10033071784

Committed 22 Jul 2024 01:26AM UTC coverage: 81.876% (-1.6%) from 83.434%

Build # 10033071784

Build Type

push

github

Committed by

notmandatory

Commit Message

Merge bitcoindevkit/bdk#1514: refactor(wallet)!: rework persistence, changeset, and construction

64eb57634 chore(wallet): Fix ChangeSet::merge (LLFourn)
8875c92ec chore(wallet): Fix descriptor mismatch error keychain (LLFourn)
2cf07d686 refactor(chain,wallet)!: move rusqlite things into it's own file (志宇)
93f9b83e2 chore(chain): rm unused `sqlite` types (志宇)
892b97d44 feat(chain,wallet)!: Change persist-traits to be "safer" (志宇)
3aed4cf17 test(wallet): ensure checks work when loading wallet (志宇)
af4ee0fa4 refactor(wallet)!: Make `bdk_wallet::ChangeSet` non-exhaustive (志宇)
22d02ed3d feat!: improve wallet building methods (志宇)
eb73f0659 refactor!: move `WalletChangeSet` to `bdk_wallet` and fix import paths (志宇)
6b4300195 feat!: Rework sqlite, changesets, persistence and wallet-construction (志宇)

Pull request description:

  Closes #1496
  Closes #1498
  Closes #1500

  ### Description

  Rework sqlite: Instead of only supported one schema (defined in `bdk_sqlite`), we have a schema per changeset type for more flexiblity.

  * rm `bdk_sqlite` crate (as we don't need `bdk_sqlite::Store` anymore).
  * add `sqlite` feature on `bdk_chain` which adds methods on each changeset type for initializing tables, loading the changeset and writing.

  Rework changesets: Some callers may want to use `KeychainTxOutIndex` where `K` may change per descriptor on every run. So we only want to persist the last revealed indices by `DescriptorId` (which uniquely-ish identifies the descriptor).

  * rm `keychain_added` field from `keychain_txout`'s changeset.
  * Add `keychain_added` to `CombinedChangeSet` (which is renamed to `WalletChangeSet`).

  Rework persistence: add... (continued)

Run Details

817 of 1088 new or added lines in 12 files covered. (75.09%)

33 existing lines in 7 files now uncovered.

10946 of 13369 relevant lines covered (81.88%)

16192.73 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.51

/crates/chain/src/indexed_tx_graph.rs

//! Contains the [`IndexedTxGraph`] and associated types. Refer to the
//! [`IndexedTxGraph`] documentation for more.
use core::fmt::Debug;

use alloc::vec::Vec;
use bitcoin::{Block, OutPoint, Transaction, TxOut, Txid};

use crate::{
    tx_graph::{self, TxGraph},
    Anchor, AnchorFromBlockPosition, BlockId, Indexer, Merge,
};

/// The [`IndexedTxGraph`] combines a [`TxGraph`] and an [`Indexer`] implementation.
///
/// It ensures that [`TxGraph`] and [`Indexer`] are updated atomically.
#[derive(Debug)]
pub struct IndexedTxGraph<A, I> {
    /// Transaction index.
    pub index: I,
    graph: TxGraph<A>,
}

impl<A, I: Default> Default for IndexedTxGraph<A, I> {
    fn default() -> Self {
        Self {
            graph: Default::default(),
            index: Default::default(),
        }
    }
}

impl<A, I> IndexedTxGraph<A, I> {
    /// Construct a new [`IndexedTxGraph`] with a given `index`.
    pub fn new(index: I) -> Self {
        Self {
            index,
            graph: TxGraph::default(),
        }
    }

    /// Get a reference of the internal transaction graph.
    pub fn graph(&self) -> &TxGraph<A> {
        &self.graph
    }
}

impl<A: Anchor, I: Indexer> IndexedTxGraph<A, I> {
    /// Applies the [`ChangeSet`] to the [`IndexedTxGraph`].
    pub fn apply_changeset(&mut self, changeset: ChangeSet<A, I::ChangeSet>) {
        self.index.apply_changeset(changeset.indexer);

        for tx in &changeset.tx_graph.txs {
            self.index.index_tx(tx);
        }
        for (&outpoint, txout) in &changeset.tx_graph.txouts {
            self.index.index_txout(outpoint, txout);
        }

        self.graph.apply_changeset(changeset.tx_graph);
    }

    /// Determines the [`ChangeSet`] between `self` and an empty [`IndexedTxGraph`].
    pub fn initial_changeset(&self) -> ChangeSet<A, I::ChangeSet> {
        let graph = self.graph.initial_changeset();
        let indexer = self.index.initial_changeset();
        ChangeSet {
            tx_graph: graph,
            indexer,
        }
    }
}

impl<A: Anchor, I: Indexer> IndexedTxGraph<A, I>
where
    I::ChangeSet: Default + Merge,
{
    fn index_tx_graph_changeset(
        &mut self,
        tx_graph_changeset: &tx_graph::ChangeSet<A>,
    ) -> I::ChangeSet {
        let mut changeset = I::ChangeSet::default();
        for added_tx in &tx_graph_changeset.txs {
            changeset.merge(self.index.index_tx(added_tx));
        }
        for (&added_outpoint, added_txout) in &tx_graph_changeset.txouts {
            changeset.merge(self.index.index_txout(added_outpoint, added_txout));
        }
        changeset
    }

    /// Apply an `update` directly.
    ///
    /// `update` is a [`TxGraph<A>`] and the resultant changes is returned as [`ChangeSet`].
    pub fn apply_update(&mut self, update: TxGraph<A>) -> ChangeSet<A, I::ChangeSet> {
        let graph = self.graph.apply_update(update);
        let indexer = self.index_tx_graph_changeset(&graph);
        ChangeSet {
            tx_graph: graph,
            indexer,
        }
    }

    /// Insert a floating `txout` of given `outpoint`.
    pub fn insert_txout(&mut self, outpoint: OutPoint, txout: TxOut) -> ChangeSet<A, I::ChangeSet> {
        let graph = self.graph.insert_txout(outpoint, txout);
        let indexer = self.index_tx_graph_changeset(&graph);
        ChangeSet {
            tx_graph: graph,
            indexer,
        }
    }

    /// Insert and index a transaction into the graph.
    pub fn insert_tx(&mut self, tx: Transaction) -> ChangeSet<A, I::ChangeSet> {
        let graph = self.graph.insert_tx(tx);
        let indexer = self.index_tx_graph_changeset(&graph);
        ChangeSet {
            tx_graph: graph,
            indexer,
        }
    }

    /// Insert an `anchor` for a given transaction.
    pub fn insert_anchor(&mut self, txid: Txid, anchor: A) -> ChangeSet<A, I::ChangeSet> {
        self.graph.insert_anchor(txid, anchor).into()
    }

    /// Insert a unix timestamp of when a transaction is seen in the mempool.
    ///
    /// This is used for transaction conflict resolution in [`TxGraph`] where the transaction with
    /// the later last-seen is prioritized.
    pub fn insert_seen_at(&mut self, txid: Txid, seen_at: u64) -> ChangeSet<A, I::ChangeSet> {
        self.graph.insert_seen_at(txid, seen_at).into()
    }

    /// Batch insert transactions, filtering out those that are irrelevant.
    ///
    /// Relevancy is determined by the [`Indexer::is_tx_relevant`] implementation of `I`. Irrelevant
    /// transactions in `txs` will be ignored. `txs` do not need to be in topological order.
    pub fn batch_insert_relevant<'t>(
        &mut self,
        txs: impl IntoIterator<Item = (&'t Transaction, impl IntoIterator<Item = A>)>,
    ) -> ChangeSet<A, I::ChangeSet> {
        // The algorithm below allows for non-topologically ordered transactions by using two loops.
        // This is achieved by:
        // 1. insert all txs into the index. If they are irrelevant then that's fine it will just
        //    not store anything about them.
        // 2. decide whether to insert them into the graph depending on whether `is_tx_relevant`
        //    returns true or not. (in a second loop).
        let txs = txs.into_iter().collect::<Vec<_>>();

        let mut indexer = I::ChangeSet::default();
        for (tx, _) in &txs {
            indexer.merge(self.index.index_tx(tx));
        }

        let mut graph = tx_graph::ChangeSet::default();
        for (tx, anchors) in txs {
            if self.index.is_tx_relevant(tx) {
                let txid = tx.compute_txid();
                graph.merge(self.graph.insert_tx(tx.clone()));
                for anchor in anchors {
                    graph.merge(self.graph.insert_anchor(txid, anchor));
                }
            }
        }

        ChangeSet {
            tx_graph: graph,
            indexer,
        }
    }

    /// Batch insert unconfirmed transactions, filtering out those that are irrelevant.
    ///
    /// Relevancy is determined by the internal [`Indexer::is_tx_relevant`] implementation of `I`.
    /// Irrelevant transactions in `txs` will be ignored.
    ///
    /// Items of `txs` are tuples containing the transaction and a *last seen* timestamp. The
    /// *last seen* communicates when the transaction is last seen in the mempool which is used for
    /// conflict-resolution in [`TxGraph`] (refer to [`TxGraph::insert_seen_at`] for details).
    pub fn batch_insert_relevant_unconfirmed<'t>(
        &mut self,
        unconfirmed_txs: impl IntoIterator<Item = (&'t Transaction, u64)>,
    ) -> ChangeSet<A, I::ChangeSet> {
        // The algorithm below allows for non-topologically ordered transactions by using two loops.
        // This is achieved by:
        // 1. insert all txs into the index. If they are irrelevant then that's fine it will just
        //    not store anything about them.
        // 2. decide whether to insert them into the graph depending on whether `is_tx_relevant`
        //    returns true or not. (in a second loop).
        let txs = unconfirmed_txs.into_iter().collect::<Vec<_>>();

        let mut indexer = I::ChangeSet::default();
        for (tx, _) in &txs {
            indexer.merge(self.index.index_tx(tx));
        }

        let graph = self.graph.batch_insert_unconfirmed(
            txs.into_iter()
                .filter(|(tx, _)| self.index.is_tx_relevant(tx))
                .map(|(tx, seen_at)| (tx.clone(), seen_at)),
        );

        ChangeSet {
            tx_graph: graph,
            indexer,
        }
    }

    /// Batch insert unconfirmed transactions.
    ///
    /// Items of `txs` are tuples containing the transaction and a *last seen* timestamp. The
    /// *last seen* communicates when the transaction is last seen in the mempool which is used for
    /// conflict-resolution in [`TxGraph`] (refer to [`TxGraph::insert_seen_at`] for details).
    ///
    /// To filter out irrelevant transactions, use [`batch_insert_relevant_unconfirmed`] instead.
    ///
    /// [`batch_insert_relevant_unconfirmed`]: IndexedTxGraph::batch_insert_relevant_unconfirmed
    pub fn batch_insert_unconfirmed(
        &mut self,
        txs: impl IntoIterator<Item = (Transaction, u64)>,
    ) -> ChangeSet<A, I::ChangeSet> {
        let graph = self.graph.batch_insert_unconfirmed(txs);
        let indexer = self.index_tx_graph_changeset(&graph);
        ChangeSet {
            tx_graph: graph,
            indexer,
        }
    }
}

/// Methods are available if the anchor (`A`) implements [`AnchorFromBlockPosition`].
impl<A: Anchor, I: Indexer> IndexedTxGraph<A, I>
where
    I::ChangeSet: Default + Merge,
    A: AnchorFromBlockPosition,
{
    /// Batch insert all transactions of the given `block` of `height`, filtering out those that are
    /// irrelevant.
    ///
    /// Each inserted transaction's anchor will be constructed from
    /// [`AnchorFromBlockPosition::from_block_position`].
    ///
    /// Relevancy is determined by the internal [`Indexer::is_tx_relevant`] implementation of `I`.
    /// Irrelevant transactions in `txs` will be ignored.
    pub fn apply_block_relevant(
        &mut self,
        block: &Block,
        height: u32,
    ) -> ChangeSet<A, I::ChangeSet> {
        let block_id = BlockId {
            hash: block.block_hash(),
            height,
        };
        let mut changeset = ChangeSet::<A, I::ChangeSet>::default();
        for (tx_pos, tx) in block.txdata.iter().enumerate() {
            changeset.indexer.merge(self.index.index_tx(tx));
            if self.index.is_tx_relevant(tx) {
                let txid = tx.compute_txid();
                let anchor = A::from_block_position(block, block_id, tx_pos);
                changeset.tx_graph.merge(self.graph.insert_tx(tx.clone()));
                changeset
                    .tx_graph
                    .merge(self.graph.insert_anchor(txid, anchor));
            }
        }
        changeset
    }

    /// Batch insert all transactions of the given `block` of `height`.
    ///
    /// Each inserted transaction's anchor will be constructed from
    /// [`AnchorFromBlockPosition::from_block_position`].
    ///
    /// To only insert relevant transactions, use [`apply_block_relevant`] instead.
    ///
    /// [`apply_block_relevant`]: IndexedTxGraph::apply_block_relevant
    pub fn apply_block(&mut self, block: Block, height: u32) -> ChangeSet<A, I::ChangeSet> {
        let block_id = BlockId {
            hash: block.block_hash(),
            height,
        };
        let mut graph = tx_graph::ChangeSet::default();
        for (tx_pos, tx) in block.txdata.iter().enumerate() {
            let anchor = A::from_block_position(&block, block_id, tx_pos);
            graph.merge(self.graph.insert_anchor(tx.compute_txid(), anchor));
            graph.merge(self.graph.insert_tx(tx.clone()));
        }
        let indexer = self.index_tx_graph_changeset(&graph);
        ChangeSet {
            tx_graph: graph,
            indexer,
        }
    }
}

impl<A, I> AsRef<TxGraph<A>> for IndexedTxGraph<A, I> {
    fn as_ref(&self) -> &TxGraph<A> {
        &self.graph
    }
}

/// Represents changes to an [`IndexedTxGraph`].
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(
    feature = "serde",
    derive(serde::Deserialize, serde::Serialize),
    serde(
        crate = "serde_crate",
        bound(
            deserialize = "A: Ord + serde::Deserialize<'de>, IA: serde::Deserialize<'de>",
            serialize = "A: Ord + serde::Serialize, IA: serde::Serialize"
        )
    )
)]
#[must_use]
pub struct ChangeSet<A, IA> {
    /// [`TxGraph`] changeset.
    pub tx_graph: tx_graph::ChangeSet<A>,
    /// [`Indexer`] changeset.
    pub indexer: IA,
}

impl<A, IA: Default> Default for ChangeSet<A, IA> {
    fn default() -> Self {
        Self {
            tx_graph: Default::default(),
            indexer: Default::default(),
        }
    }
}

impl<A: Anchor, IA: Merge> Merge for ChangeSet<A, IA> {
    fn merge(&mut self, other: Self) {
        self.tx_graph.merge(other.tx_graph);
        self.indexer.merge(other.indexer);
    }

    fn is_empty(&self) -> bool {
        self.tx_graph.is_empty() && self.indexer.is_empty()
    }
}

impl<A, IA: Default> From<tx_graph::ChangeSet<A>> for ChangeSet<A, IA> {
    fn from(graph: tx_graph::ChangeSet<A>) -> Self {
        Self {
            tx_graph: graph,
            ..Default::default()
        }
    }
}

#[cfg(feature = "miniscript")]
impl<A> From<crate::keychain_txout::ChangeSet> for ChangeSet<A, crate::keychain_txout::ChangeSet> {
    fn from(indexer: crate::keychain_txout::ChangeSet) -> Self {
        Self {
            tx_graph: Default::default(),
            indexer,
        }
    }
}

1	//! Contains the [`IndexedTxGraph`] and associated types. Refer to the
2	//! [`IndexedTxGraph`] documentation for more.
3	use core::fmt::Debug;
4
5	use alloc::vec::Vec;
6	use bitcoin::{Block, OutPoint, Transaction, TxOut, Txid};
7
8	use crate::{
9	tx_graph::{self, TxGraph},
10	Anchor, AnchorFromBlockPosition, BlockId, Indexer, Merge,
11	};
12
13	/// The [`IndexedTxGraph`] combines a [`TxGraph`] and an [`Indexer`] implementation.
14	///
15	/// It ensures that [`TxGraph`] and [`Indexer`] are updated atomically.
16	#[derive(Debug)]
17	pub struct IndexedTxGraph<A, I> {
18	/// Transaction index.
19	pub index: I,
20	graph: TxGraph<A>,
21	}
22
23	impl<A, I: Default> Default for IndexedTxGraph<A, I> {
24	fn default() -> Self {	×
25	Self {	×
26	graph: Default::default(),	×
27	index: Default::default(),	×
28	}	×
29	}	×
30	}
31
32	impl<A, I> IndexedTxGraph<A, I> {
33	/// Construct a new [`IndexedTxGraph`] with a given `index`.
34	pub fn new(index: I) -> Self {	1,389✔
35	Self {	1,389✔
36	index,	1,389✔
37	graph: TxGraph::default(),	1,389✔
38	}	1,389✔
39	}	1,389✔
40
41	/// Get a reference of the internal transaction graph.
42	pub fn graph(&self) -> &TxGraph<A> {	5,986✔
43	&self.graph	5,986✔
44	}	5,986✔
45	}
46
47	impl<A: Anchor, I: Indexer> IndexedTxGraph<A, I> {
48	/// Applies the [`ChangeSet`] to the [`IndexedTxGraph`].
49	pub fn apply_changeset(&mut self, changeset: ChangeSet<A, I::ChangeSet>) {	32✔
50	self.index.apply_changeset(changeset.indexer);	32✔
51
52	for tx in &changeset.tx_graph.txs {	32✔
53	self.index.index_tx(tx);	×
54	}	×
55	for (&outpoint, txout) in &changeset.tx_graph.txouts {	32✔
56	self.index.index_txout(outpoint, txout);	×
57	}	×
58
59	self.graph.apply_changeset(changeset.tx_graph);	32✔
60	}	32✔
61
62	/// Determines the [`ChangeSet`] between `self` and an empty [`IndexedTxGraph`].
63	pub fn initial_changeset(&self) -> ChangeSet<A, I::ChangeSet> {	1,367✔
64	let graph = self.graph.initial_changeset();	1,367✔
65	let indexer = self.index.initial_changeset();	1,367✔
66	ChangeSet {	1,367✔
67	tx_graph: graph,	1,367✔
68	indexer,	1,367✔
69	}	1,367✔
70	}	1,367✔
71	}
72
73	impl<A: Anchor, I: Indexer> IndexedTxGraph<A, I>
74	where
75	I::ChangeSet: Default + Merge,
76	{
77	fn index_tx_graph_changeset(	5,079✔
78	&mut self,	5,079✔
79	tx_graph_changeset: &tx_graph::ChangeSet<A>,	5,079✔
80	) -> I::ChangeSet {	5,079✔
81	let mut changeset = I::ChangeSet::default();	5,079✔
82	for added_tx in &tx_graph_changeset.txs {	7,716✔
83	changeset.merge(self.index.index_tx(added_tx));	2,637✔
84	}	2,637✔
85	for (&added_outpoint, added_txout) in &tx_graph_changeset.txouts {	5,096✔
86	changeset.merge(self.index.index_txout(added_outpoint, added_txout));	17✔
87	}	17✔
88	changeset	5,079✔
89	}	5,079✔
90
91	/// Apply an `update` directly.
92	///
93	/// `update` is a [`TxGraph<A>`] and the resultant changes is returned as [`ChangeSet`].
94	pub fn apply_update(&mut self, update: TxGraph<A>) -> ChangeSet<A, I::ChangeSet> {	311✔
95	let graph = self.graph.apply_update(update);	311✔
96	let indexer = self.index_tx_graph_changeset(&graph);	311✔
97	ChangeSet {	311✔
98	tx_graph: graph,	311✔
99	indexer,	311✔
100	}	311✔
101	}	311✔
102
103	/// Insert a floating `txout` of given `outpoint`.
104	pub fn insert_txout(&mut self, outpoint: OutPoint, txout: TxOut) -> ChangeSet<A, I::ChangeSet> {	16✔
105	let graph = self.graph.insert_txout(outpoint, txout);	16✔
106	let indexer = self.index_tx_graph_changeset(&graph);	16✔
107	ChangeSet {	16✔
108	tx_graph: graph,	16✔
109	indexer,	16✔
110	}	16✔
111	}	16✔
112
113	/// Insert and index a transaction into the graph.
114	pub fn insert_tx(&mut self, tx: Transaction) -> ChangeSet<A, I::ChangeSet> {	2,451✔
115	let graph = self.graph.insert_tx(tx);	2,451✔
116	let indexer = self.index_tx_graph_changeset(&graph);	2,451✔
117	ChangeSet {	2,451✔
118	tx_graph: graph,	2,451✔
119	indexer,	2,451✔
120	}	2,451✔
121	}	2,451✔
122
123	/// Insert an `anchor` for a given transaction.
124	pub fn insert_anchor(&mut self, txid: Txid, anchor: A) -> ChangeSet<A, I::ChangeSet> {	3✔
125	self.graph.insert_anchor(txid, anchor).into()	3✔
126	}	3✔
127
128	/// Insert a unix timestamp of when a transaction is seen in the mempool.
129	///
130	/// This is used for transaction conflict resolution in [`TxGraph`] where the transaction with
131	/// the later last-seen is prioritized.
132	pub fn insert_seen_at(&mut self, txid: Txid, seen_at: u64) -> ChangeSet<A, I::ChangeSet> {	2✔
133	self.graph.insert_seen_at(txid, seen_at).into()	2✔
134	}	2✔
135
136	/// Batch insert transactions, filtering out those that are irrelevant.
137	///
138	/// Relevancy is determined by the [`Indexer::is_tx_relevant`] implementation of `I`. Irrelevant
139	/// transactions in `txs` will be ignored. `txs` do not need to be in topological order.
140	pub fn batch_insert_relevant<'t>(	2✔
141	&mut self,	2✔
142	txs: impl IntoIterator<Item = (&'t Transaction, impl IntoIterator<Item = A>)>,	2✔
143	) -> ChangeSet<A, I::ChangeSet> {	2✔
144	// The algorithm below allows for non-topologically ordered transactions by using two loops.	2✔
145	// This is achieved by:	2✔
146	// 1. insert all txs into the index. If they are irrelevant then that's fine it will just	2✔
147	// not store anything about them.	2✔
148	// 2. decide whether to insert them into the graph depending on whether `is_tx_relevant`	2✔
149	// returns true or not. (in a second loop).	2✔
150	let txs = txs.into_iter().collect::<Vec<_>>();	2✔
151		2✔
152	let mut indexer = I::ChangeSet::default();	2✔
153	for (tx, _) in &txs {	9✔
154	indexer.merge(self.index.index_tx(tx));	7✔
155	}	7✔
156
157	let mut graph = tx_graph::ChangeSet::default();	2✔
158	for (tx, anchors) in txs {	9✔
159	if self.index.is_tx_relevant(tx) {	7✔
160	let txid = tx.compute_txid();	6✔
161	graph.merge(self.graph.insert_tx(tx.clone()));	6✔
162	for anchor in anchors {	9✔
163	graph.merge(self.graph.insert_anchor(txid, anchor));	3✔
164	}	3✔
165	}	1✔
166	}
167
168	ChangeSet {	2✔
169	tx_graph: graph,	2✔
170	indexer,	2✔
171	}	2✔
172	}	2✔
173
174	/// Batch insert unconfirmed transactions, filtering out those that are irrelevant.
175	///
176	/// Relevancy is determined by the internal [`Indexer::is_tx_relevant`] implementation of `I`.
177	/// Irrelevant transactions in `txs` will be ignored.
178	///
179	/// Items of `txs` are tuples containing the transaction and a last seen timestamp. The
180	/// last seen communicates when the transaction is last seen in the mempool which is used for
181	/// conflict-resolution in [`TxGraph`] (refer to [`TxGraph::insert_seen_at`] for details).
182	pub fn batch_insert_relevant_unconfirmed<'t>(	1✔
183	&mut self,	1✔
184	unconfirmed_txs: impl IntoIterator<Item = (&'t Transaction, u64)>,	1✔
185	) -> ChangeSet<A, I::ChangeSet> {	1✔
186	// The algorithm below allows for non-topologically ordered transactions by using two loops.	1✔
187	// This is achieved by:	1✔
188	// 1. insert all txs into the index. If they are irrelevant then that's fine it will just	1✔
189	// not store anything about them.	1✔
190	// 2. decide whether to insert them into the graph depending on whether `is_tx_relevant`	1✔
191	// returns true or not. (in a second loop).	1✔
192	let txs = unconfirmed_txs.into_iter().collect::<Vec<_>>();	1✔
193		1✔
194	let mut indexer = I::ChangeSet::default();	1✔
195	for (tx, _) in &txs {	3✔
196	indexer.merge(self.index.index_tx(tx));	2✔
197	}	2✔
198
199	let graph = self.graph.batch_insert_unconfirmed(	1✔
200	txs.into_iter()	1✔
201	.filter(\|(tx, _)\| self.index.is_tx_relevant(tx))	2✔
202	.map(\|(tx, seen_at)\| (tx.clone(), seen_at)),	2✔
203	);	1✔
204		1✔
205	ChangeSet {	1✔
206	tx_graph: graph,	1✔
207	indexer,	1✔
208	}	1✔
209	}	1✔
210
211	/// Batch insert unconfirmed transactions.
212	///
213	/// Items of `txs` are tuples containing the transaction and a last seen timestamp. The
214	/// last seen communicates when the transaction is last seen in the mempool which is used for
215	/// conflict-resolution in [`TxGraph`] (refer to [`TxGraph::insert_seen_at`] for details).
216	///
217	/// To filter out irrelevant transactions, use [`batch_insert_relevant_unconfirmed`] instead.
218	///
219	/// [`batch_insert_relevant_unconfirmed`]: IndexedTxGraph::batch_insert_relevant_unconfirmed
220	pub fn batch_insert_unconfirmed(	1✔
221	&mut self,	1✔
222	txs: impl IntoIterator<Item = (Transaction, u64)>,	1✔
223	) -> ChangeSet<A, I::ChangeSet> {	1✔
224	let graph = self.graph.batch_insert_unconfirmed(txs);	1✔
225	let indexer = self.index_tx_graph_changeset(&graph);	1✔
226	ChangeSet {	1✔
227	tx_graph: graph,	1✔
228	indexer,	1✔
229	}	1✔
230	}	1✔
231	}
232
233	/// Methods are available if the anchor (`A`) implements [`AnchorFromBlockPosition`].
234	impl<A: Anchor, I: Indexer> IndexedTxGraph<A, I>
235	where
236	I::ChangeSet: Default + Merge,
237	A: AnchorFromBlockPosition,
238	{
239	/// Batch insert all transactions of the given `block` of `height`, filtering out those that are
240	/// irrelevant.
241	///
242	/// Each inserted transaction's anchor will be constructed from
243	/// [`AnchorFromBlockPosition::from_block_position`].
244	///
245	/// Relevancy is determined by the internal [`Indexer::is_tx_relevant`] implementation of `I`.
246	/// Irrelevant transactions in `txs` will be ignored.
247	pub fn apply_block_relevant(	103✔
248	&mut self,	103✔
249	block: &Block,	103✔
250	height: u32,	103✔
251	) -> ChangeSet<A, I::ChangeSet> {	103✔
252	let block_id = BlockId {	103✔
253	hash: block.block_hash(),	103✔
254	height,	103✔
255	};	103✔
256	let mut changeset = ChangeSet::<A, I::ChangeSet>::default();	103✔
257	for (tx_pos, tx) in block.txdata.iter().enumerate() {	106✔
258	changeset.indexer.merge(self.index.index_tx(tx));	106✔
259	if self.index.is_tx_relevant(tx) {	106✔
260	let txid = tx.compute_txid();	3✔
261	let anchor = A::from_block_position(block, block_id, tx_pos);	3✔
262	changeset.tx_graph.merge(self.graph.insert_tx(tx.clone()));	3✔
263	changeset	3✔
264	.tx_graph	3✔
265	.merge(self.graph.insert_anchor(txid, anchor));	3✔
266	}	103✔
267	}
268	changeset	103✔
269	}	103✔
270
271	/// Batch insert all transactions of the given `block` of `height`.
272	///
273	/// Each inserted transaction's anchor will be constructed from
274	/// [`AnchorFromBlockPosition::from_block_position`].
275	///
276	/// To only insert relevant transactions, use [`apply_block_relevant`] instead.
277	///
278	/// [`apply_block_relevant`]: IndexedTxGraph::apply_block_relevant
279	pub fn apply_block(&mut self, block: Block, height: u32) -> ChangeSet<A, I::ChangeSet> {	179✔
280	let block_id = BlockId {	179✔
281	hash: block.block_hash(),	179✔
282	height,	179✔
283	};	179✔
284	let mut graph = tx_graph::ChangeSet::default();	179✔
285	for (tx_pos, tx) in block.txdata.iter().enumerate() {	190✔
286	let anchor = A::from_block_position(&block, block_id, tx_pos);	190✔
287	graph.merge(self.graph.insert_anchor(tx.compute_txid(), anchor));	190✔
288	graph.merge(self.graph.insert_tx(tx.clone()));	190✔
289	}	190✔
290	let indexer = self.index_tx_graph_changeset(&graph);	179✔
291	ChangeSet {	179✔
292	tx_graph: graph,	179✔
293	indexer,	179✔
294	}	179✔
295	}	179✔
296	}
297
298	impl<A, I> AsRef<TxGraph<A>> for IndexedTxGraph<A, I> {
NEW 299	fn as_ref(&self) -> &TxGraph<A> {	×
NEW 300	&self.graph	×
UNCOV 301	}	×
302	}
303
304	/// Represents changes to an [`IndexedTxGraph`].
305	#[derive(Clone, Debug, PartialEq)]
306	#[cfg_attr(
307	feature = "serde",
UNCOV 308	derive(serde::Deserialize, serde::Serialize),	×
309	serde(
310	crate = "serde_crate",
311	bound(
312	deserialize = "A: Ord + serde::Deserialize<'de>, IA: serde::Deserialize<'de>",
313	serialize = "A: Ord + serde::Serialize, IA: serde::Serialize"
314	)
315	)
316	)]
317	#[must_use]
318	pub struct ChangeSet<A, IA> {
319	/// [`TxGraph`] changeset.
320	pub tx_graph: tx_graph::ChangeSet<A>,
321	/// [`Indexer`] changeset.
322	pub indexer: IA,
323	}
324
325	impl<A, IA: Default> Default for ChangeSet<A, IA> {
326	fn default() -> Self {	124✔
327	Self {	124✔
328	tx_graph: Default::default(),	124✔
329	indexer: Default::default(),	124✔
330	}	124✔
331	}	124✔
332	}
333
334	impl<A: Anchor, IA: Merge> Merge for ChangeSet<A, IA> {
UNCOV 335	fn merge(&mut self, other: Self) {	×
NEW 336	self.tx_graph.merge(other.tx_graph);	×
UNCOV 337	self.indexer.merge(other.indexer);	×
UNCOV 338	}	×
339
340	fn is_empty(&self) -> bool {	102✔
341	self.tx_graph.is_empty() && self.indexer.is_empty()	102✔
342	}	102✔
343	}
344
345	impl<A, IA: Default> From<tx_graph::ChangeSet<A>> for ChangeSet<A, IA> {
346	fn from(graph: tx_graph::ChangeSet<A>) -> Self {	21✔
347	Self {	21✔
348	tx_graph: graph,	21✔
349	..Default::default()	21✔
350	}	21✔
351	}	21✔
352	}
353
354	#[cfg(feature = "miniscript")]
355	impl<A> From<crate::keychain_txout::ChangeSet> for ChangeSet<A, crate::keychain_txout::ChangeSet> {
356	fn from(indexer: crate::keychain_txout::ChangeSet) -> Self {	904✔
357	Self {	904✔
358	tx_graph: Default::default(),	904✔
359	indexer,	904✔
360	}	904✔
361	}	904✔
362	}

bitcoindevkit / bdk / 10033071784

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous