brk_rpc 0.12.2

A thin wrapper around Bitcoin Core's JSON-RPC
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

use brk_types::{Bitcoin, MempoolEntryInfo, Sats, Timestamp, Txid, VSize, Weight};
use serde::Deserialize;

/// The subset of a `getmempoolentry` response that BRK consumes.
#[derive(Deserialize)]
pub struct MempoolEntry {
    vsize: VSize,
    weight: Weight,
    time: Timestamp,
    fees: MempoolFees,
    depends: Vec<Txid>,
}

impl MempoolEntry {
    pub fn into_info(self, txid: Txid) -> MempoolEntryInfo {
        MempoolEntryInfo {
            txid,
            vsize: self.vsize,
            weight: self.weight,
            fee: Sats::from(self.fees.base),
            first_seen: self.time,
            depends: self.depends,
        }
    }
}

#[derive(Deserialize)]
struct MempoolFees {
    base: Bitcoin,
}

#[cfg(test)]
mod tests {
    use serde_json::from_str;

    use super::*;

    #[test]
    fn ignores_unused_core_fields() {
        let txid = "0000000000000000000000000000000000000000000000000000000000000001";
        let json = format!(
            r#"{{"vsize":250,"weight":1000,"time":1700000000,"fees":{{"base":0.00001,"modified":0.00001}},"depends":["{txid}"],"spentby":["{txid}"]}}"#
        );
        let entry: MempoolEntry = from_str(&json).unwrap();
        let info = entry.into_info(Txid::COINBASE);

        assert_eq!(u64::from(info.vsize), 250);
        assert_eq!(u64::from(info.weight), 1000);
        assert_eq!(info.depends.len(), 1);
        assert_eq!(info.depends[0].to_string(), txid);
    }

    #[test]
    fn rejects_negative_numeric_fields() {
        let json =
            r#"{"vsize":250,"weight":-1,"time":1700000000,"fees":{"base":0.00001},"depends":[]}"#;
        assert!(from_str::<MempoolEntry>(json).is_err());
    }
}