acceptxmr 0.14.0

Accept monero in your application.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::collections::HashMap;

use log::trace;
use monero::cryptonote::hash::Hashable;
use thiserror::Error;
use tokio::join;

use crate::{
    invoice::Transfer,
    monerod_client::{
        Client as MonerodClient, RpcClient as MonerodRpcClient, RpcError as MonerodRpcError,
    },
    SubIndex,
};

pub(crate) struct TxpoolCache<M: MonerodClient = MonerodRpcClient> {
    monerod_client: M,
    transactions: HashMap<monero::Hash, monero::Transaction>,
    discovered_transfers: HashMap<monero::Hash, Vec<(SubIndex, Transfer)>>,
}

impl<M: MonerodClient> TxpoolCache<M> {
    pub(crate) async fn init(monerod_client: M) -> Result<TxpoolCache<M>, TxpoolCacheError> {
        let txs = monerod_client.txpool().await?;
        let transactions = txs.iter().map(|tx| (tx.hash(), tx.clone())).collect();

        Ok(TxpoolCache {
            monerod_client,
            transactions,
            discovered_transfers: HashMap::new(),
        })
    }

    /// Update the txpool cache with newest [transactions](monero::Transaction)
    /// from daemon txpool. Returns transactions received.
    pub(crate) async fn update(&mut self) -> Result<Vec<monero::Transaction>, TxpoolCacheError> {
        trace!("Checking for new transactions in txpool");

        let txpool_hashes = self.monerod_client.txpool_hashes().await?;
        trace!("Transactions in txpool: {}", txpool_hashes.len());
        let mut new_hashes = Vec::new();
        for hash in &txpool_hashes {
            if !self.transactions.contains_key(hash) {
                new_hashes.push(*hash);
            }
        }

        // Cloning RPC client because async block below requires unique access to
        // `self`.
        //
        // TODO: Find a way to do this without cloning.
        let monerod_client = self.monerod_client.clone();
        let (new_transactions, ()) =
            join!(monerod_client.transactions_by_hashes(&new_hashes), async {
                self.transactions.retain(|k, _| txpool_hashes.contains(k));
                self.discovered_transfers
                    .retain(|k, _| txpool_hashes.contains(k));
            });
        let new_transactions = new_transactions?;

        self.transactions
            .extend(new_transactions.iter().map(|tx| (tx.hash(), tx.clone())));

        Ok(new_transactions)
    }

    pub(crate) fn discovered_transfers(&self) -> &HashMap<monero::Hash, Vec<(SubIndex, Transfer)>> {
        &self.discovered_transfers
    }

    pub(crate) fn insert_transfers(
        &mut self,
        transfers: &HashMap<monero::Hash, Vec<(SubIndex, Transfer)>>,
    ) {
        self.discovered_transfers.extend(transfers.clone());
        trace!(
            "Txpool contains {} transfers for tracked invoices",
            self.discovered_transfers.len(),
        );
    }
}

/// Errors specific to the block cache.
#[derive(Error, Debug)]
pub enum TxpoolCacheError {
    /// An error originating from a daemon RPC call.
    #[error("RPC error: {0}")]
    Rpc(#[from] MonerodRpcError),
}