bip157 0.5.0

A Bitcoin light-client according to the BIP-157/BIP-158 specifications
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::collections::{HashMap, HashSet};

use bitcoin::{Transaction, Txid, Wtxid};
use tokio::sync::oneshot;

use crate::Package;

#[derive(Debug)]
pub(crate) struct BroadcastQueue {
    // There are the transactions that a peer should receive first. In the case of 1p1c, these are
    // the `Wtxid` of the child transaction in the package.
    advertise: HashSet<Wtxid>,
    // Notify the user when:
    // 1. a singleton transaction was broadcast
    // 2. the final transaction in a package was broadcast
    callbacks: HashMap<Wtxid, (oneshot::Sender<Wtxid>, Wtxid)>,
    // These transactions will be fetched by the usual `Wtxid`.
    witness_data: HashMap<Wtxid, Transaction>,
    // These transactions represent missing inputs to a previously broadcast transaction. Because
    // the inputs use the legacy `Txid` in the outpoint, these transactions are indexed by `Txid`.
    legacy_data: HashMap<Txid, Transaction>,
}

impl BroadcastQueue {
    pub(crate) fn new() -> Self {
        Self {
            advertise: HashSet::new(),
            callbacks: HashMap::new(),
            witness_data: HashMap::new(),
            legacy_data: HashMap::new(),
        }
    }

    pub(crate) fn add_to_queue(&mut self, package: Package, oneshot: oneshot::Sender<Wtxid>) {
        let advertise_wtxid = package.advertise_package();
        self.advertise.insert(advertise_wtxid);
        let parent = package.parent();
        let parent_txid = parent.compute_txid();
        let parent_wtxid = parent.compute_wtxid();
        match package.child() {
            Some(child) => {
                let child_wtxid = child.compute_wtxid();
                // Only confirm once the parent is confirmed to have been requested.
                self.callbacks.insert(parent_wtxid, (oneshot, child_wtxid));
                self.witness_data.insert(child_wtxid, child);
                // The only way a peer can feasibly request this transaction is by `Txid`, as it is
                // never advertised explicitly.
                self.legacy_data.insert(parent_txid, parent);
            }
            None => {
                self.callbacks.insert(parent_wtxid, (oneshot, parent_wtxid));
                self.witness_data.insert(parent_wtxid, parent);
            }
        }
    }

    pub(crate) fn fetch_tx(&self, id: impl Into<TxIdentifier>) -> Option<Transaction> {
        let id = id.into();
        match id {
            TxIdentifier::Legacy(txid) => self.legacy_data.get(&txid).cloned(),
            TxIdentifier::Witness(wtxid) => self.witness_data.get(&wtxid).cloned(),
        }
    }

    pub(crate) fn sent_transaction_payload(&mut self, wtxid: Wtxid) {
        if let Some((callback, child)) = self.callbacks.remove(&wtxid) {
            self.advertise.remove(&child);
            let _ = callback.send(child);
        }
    }

    pub(crate) fn pending_wtxid(&self) -> Vec<Wtxid> {
        self.advertise.iter().copied().collect()
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, std::hash::Hash)]
pub(crate) enum TxIdentifier {
    Legacy(Txid),
    Witness(Wtxid),
}

impl From<Txid> for TxIdentifier {
    fn from(value: Txid) -> Self {
        Self::Legacy(value)
    }
}

impl From<Wtxid> for TxIdentifier {
    fn from(value: Wtxid) -> Self {
        Self::Witness(value)
    }
}

#[cfg(test)]
mod tests {
    use std::fs::File;

    use bitcoin::Transaction;
    use corepc_node::serde_json;

    use super::BroadcastQueue;

    #[derive(Debug, Clone)]
    struct HexTx(Transaction);
    crate::impl_deserialize!(HexTx, Transaction);

    #[derive(Debug, Clone, serde::Deserialize)]
    struct TransactionFile {
        transactions: Vec<HexTx>,
    }

    #[test]
    fn test_broadcast_queue_works() {
        // Sourced from BIP 174 test vectors
        let tx_file = File::open("./tests/data/transactions.json").unwrap();
        let tx_data: TransactionFile = serde_json::from_reader(&tx_file).unwrap();
        let transaction_1: Transaction = tx_data.transactions[0].clone().0;
        let transaction_2: Transaction = tx_data.transactions[1].clone().0;
        let mut queue = BroadcastQueue::new();
        let (tx, _) = tokio::sync::oneshot::channel();
        queue.add_to_queue(transaction_1.clone().into(), tx);
        let (tx, _) = tokio::sync::oneshot::channel();
        queue.add_to_queue(transaction_2.clone().into(), tx);
        assert_eq!(queue.pending_wtxid().len(), 2);
        queue.sent_transaction_payload(transaction_1.compute_wtxid());
        assert_eq!(queue.pending_wtxid().len(), 1);
        assert!(queue.fetch_tx(transaction_1.compute_wtxid()).is_some());
        assert!(queue.fetch_tx(transaction_2.compute_wtxid()).is_some());
        queue.sent_transaction_payload(transaction_2.compute_wtxid());
        assert_eq!(queue.pending_wtxid().len(), 0);
    }
}