brk_mempool 0.3.0-beta.6

Bitcoin mempool monitor with fee estimation
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

use brk_types::{MempoolInfo, Transaction, Txid};

use crate::{
    steps::preparer::{Addition, Pulled},
    stores::{AddrTracker, EntryPool, TxGraveyard, TxStore},
};

/// Applies a prepared diff to in-memory mempool state.
///
/// Removals are torn down first: each tx+entry is moved into the
/// graveyard with its removal reason.
///
/// Additions then publish to live state. For `Revived` additions the
/// tx body is exhumed from the graveyard (no clone); for `Fresh` ones
/// the tx arrives inline from the Preparer.
///
/// Finally the graveyard evicts entries past its retention window.
pub struct Applier;

impl Applier {
    /// Apply `pulled` to all buckets. Returns true if anything changed.
    pub fn apply(
        pulled: Pulled,
        info: &mut MempoolInfo,
        txs: &mut TxStore,
        addrs: &mut AddrTracker,
        entries: &mut EntryPool,
        graveyard: &mut TxGraveyard,
    ) -> bool {
        let Pulled { added, removed } = pulled;
        let has_changes = !added.is_empty() || !removed.is_empty();

        for (prefix, reason) in removed {
            let Some(entry) = entries.remove(&prefix) else {
                continue;
            };
            let txid = entry.txid.clone();
            let Some(tx) = txs.remove(&txid) else {
                continue;
            };
            info.remove(&tx, entry.fee);
            addrs.remove_tx(&tx, &txid);
            graveyard.bury(txid, tx, entry, reason);
        }

        let mut to_store: Vec<(Txid, Transaction)> = Vec::with_capacity(added.len());
        for addition in added {
            let (tx, entry) = match addition {
                Addition::Fresh { tx, entry } => (tx, entry),
                Addition::Revived { entry } => {
                    let Some(tomb) = graveyard.exhume(&entry.txid) else {
                        continue;
                    };
                    (tomb.tx, entry)
                }
            };
            info.add(&tx, entry.fee);
            addrs.add_tx(&tx, &entry.txid);
            let txid = entry.txid.clone();
            entries.insert(entry);
            to_store.push((txid, tx));
        }
        txs.extend(to_store);

        graveyard.evict_old();

        has_changes
    }
}