titan_types/
mempool_entry.rs

1use {
2    bitcoin::{hashes::Hash, Txid},
3    bitcoincore_rpc::json::GetMempoolEntryResult,
4    borsh::{BorshDeserialize, BorshSerialize},
5    serde::{Deserialize, Serialize},
6    std::io::{Read, Result, Write},
7};
8
9#[derive(Debug, Clone, PartialEq, Eq, Hash, BorshSerialize, BorshDeserialize, Serialize, Deserialize)]
10pub struct MempoolEntryFee {
11    pub base: u64,
12    pub descendant: u64,
13    pub ancestor: u64,
14}
15
16#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
17pub struct MempoolEntry {
18    pub vsize: u64,
19    pub weight: Option<u64>,
20    pub descendant_count: u64,
21    pub descendant_size: u64,
22    pub ancestor_count: u64,
23    pub ancestor_size: u64,
24    pub fees: MempoolEntryFee,
25    pub depends: Vec<Txid>,
26    #[serde(rename = "spentby")]
27    pub spent_by: Vec<Txid>,
28}
29
30impl From<&GetMempoolEntryResult> for MempoolEntry {
31    fn from(value: &GetMempoolEntryResult) -> Self {
32        Self {
33            vsize: value.vsize,
34            weight: value.weight,
35            descendant_count: value.descendant_count,
36            descendant_size: value.descendant_size,
37            ancestor_count: value.ancestor_count,
38            ancestor_size: value.ancestor_size,
39            fees: MempoolEntryFee {
40                base: value.fees.base.to_sat(),
41                descendant: value.fees.descendant.to_sat(),
42                ancestor: value.fees.ancestor.to_sat(),
43            },
44            depends: value.depends.clone(),
45            spent_by: value.spent_by.clone(),
46        }
47    }
48}
49
50impl BorshSerialize for MempoolEntry {
51    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
52        BorshSerialize::serialize(&self.vsize, writer)?;
53
54        if let Some(weight) = self.weight {
55            BorshSerialize::serialize(&true, writer)?;
56            BorshSerialize::serialize(&weight, writer)?;
57        } else {
58            BorshSerialize::serialize(&false, writer)?;
59        }
60
61        BorshSerialize::serialize(&self.descendant_count, writer)?;
62        BorshSerialize::serialize(&self.descendant_size, writer)?;
63        BorshSerialize::serialize(&self.ancestor_count, writer)?;
64        BorshSerialize::serialize(&self.ancestor_size, writer)?;
65        BorshSerialize::serialize(&self.fees, writer)?;
66
67        BorshSerialize::serialize(&self.depends.len(), writer)?;
68        for txid in &self.depends {
69            BorshSerialize::serialize(&txid.as_raw_hash().to_byte_array(), writer)?;
70        }
71
72        BorshSerialize::serialize(&self.spent_by.len(), writer)?;
73        for txid in &self.spent_by {
74            BorshSerialize::serialize(&txid.as_raw_hash().to_byte_array(), writer)?;
75        }
76        Ok(())
77    }
78}
79
80impl BorshDeserialize for MempoolEntry {
81    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
82        let vsize = u64::deserialize_reader(reader)?;
83
84        let weight_exists = bool::deserialize_reader(reader)?;
85        let weight = if weight_exists {
86            Some(u64::deserialize_reader(reader)?)
87        } else {
88            None
89        };
90
91        let descendant_count = u64::deserialize_reader(reader)?;
92        let descendant_size = u64::deserialize_reader(reader)?;
93        let ancestor_count = u64::deserialize_reader(reader)?;
94        let ancestor_size = u64::deserialize_reader(reader)?;
95        let fees = MempoolEntryFee::deserialize_reader(reader)?;
96
97        let depends_len = u64::deserialize_reader(reader)?;
98        let mut depends = Vec::new();
99        for _ in 0..depends_len {
100            let txid_bytes = <[u8; 32]>::deserialize_reader(reader)?;
101            let txid = bitcoin::Txid::from_byte_array(txid_bytes);
102            depends.push(txid);
103        }
104
105        let spent_by_len = u64::deserialize_reader(reader)?;
106        let mut spent_by = Vec::new();
107        for _ in 0..spent_by_len {
108            let txid_bytes = <[u8; 32]>::deserialize_reader(reader)?;
109            let txid = bitcoin::Txid::from_byte_array(txid_bytes);
110            spent_by.push(txid);
111        }
112
113        Ok(Self {
114            vsize,
115            weight,
116            descendant_count,
117            descendant_size,
118            ancestor_count,
119            ancestor_size,
120            fees,
121            depends,
122            spent_by,
123        })
124    }
125}
titan_types/mempool_entry.rs

titan_types/
mempool_entry.rs
