refactor(tx_graph): add pub changeset module

- The original `tx_graph::ChangeSet` is moved to `changeset` module.

- The indexed changeset (formerly `indexed_tx_graph::ChangeSet`) is
now defined in `changeset::indexed` module. This is the type used by
`TxGraph`.

Author: ValuedMammal

crates/bitcoind_rpc/tests/test_emitter.rs

@@ -189,7 +189,7 @@ fn test_into_tx_graph() -> anyhow::Result<()> {
         assert!(emitter.next_block()?.is_none());
 
         let mempool_txs = emitter.mempool()?;
-        let tx_graph_changeset = tx_graph.batch_insert_unconfirmed(mempool_txs);
+        let tx_graph_changeset = tx_graph.batch_insert_unconfirmed(mempool_txs).tx_graph;
         assert_eq!(
             tx_graph_changeset
                 .txs
@@ -221,7 +221,9 @@ fn test_into_tx_graph() -> anyhow::Result<()> {
         let emission = emitter.next_block()?.expect("must get mined block");
         let height = emission.block_height();
         let _ = chain.apply_update(emission.checkpoint)?;
-        let tx_graph_changeset = tx_graph.apply_block_relevant(&emission.block, height);
+        let tx_graph_changeset = tx_graph
+            .apply_block_relevant(&emission.block, height)
+            .tx_graph;
         assert!(tx_graph_changeset.txs.is_empty());
         assert!(tx_graph_changeset.txouts.is_empty());
         assert_eq!(tx_graph_changeset.anchors, exp_anchors);

crates/chain/src/rusqlite_impl.rs

@@ -16,6 +16,7 @@ use rusqlite::named_params;
 use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
 use rusqlite::OptionalExtension;
 use rusqlite::Transaction;
+use tx_graph::changeset as tx;
 
 /// Table name for schemas.
 pub const SCHEMAS_TABLE_NAME: &str = "bdk_schemas";
@@ -199,8 +200,8 @@ fn to_sql_error<E: std::error::Error + Send + Sync + 'static>(err: E) -> rusqlit
     rusqlite::Error::ToSqlConversionFailure(Box::new(err))
 }
 
-impl tx_graph::ChangeSet<ConfirmationBlockTime> {
-    /// Schema name for [`tx_graph::ChangeSet`].
+impl tx::ChangeSet<ConfirmationBlockTime> {
+    /// Schema name for [`tx::ChangeSet`].
     pub const SCHEMA_NAME: &'static str = "bdk_txgraph";
     /// Name of table that stores full transactions and `last_seen` timestamps.
     pub const TXS_TABLE_NAME: &'static str = "bdk_txs";
@@ -209,7 +210,7 @@ impl tx_graph::ChangeSet<ConfirmationBlockTime> {
     /// Name of table that stores [`Anchor`]s.
     pub const ANCHORS_TABLE_NAME: &'static str = "bdk_anchors";
 
-    /// Get v0 of sqlite [tx_graph::ChangeSet] schema
+    /// Get v0 of sqlite [`tx::ChangeSet`] schema
     pub fn schema_v0() -> String {
         // full transactions
         let create_txs_table = format!(
@@ -247,7 +248,7 @@ impl tx_graph::ChangeSet<ConfirmationBlockTime> {
         format!("{create_txs_table}; {create_txouts_table}; {create_anchors_table}")
     }
 
-    /// Get v1 of sqlite [tx_graph::ChangeSet] schema
+    /// Get v1 of sqlite [`tx::ChangeSet`] schema
     pub fn schema_v1() -> String {
         let add_confirmation_time_column = format!(
             "ALTER TABLE {} ADD COLUMN confirmation_time INTEGER DEFAULT -1 NOT NULL",
@@ -567,7 +568,7 @@ mod test {
 
     #[test]
     fn can_persist_anchors_and_txs_independently() -> anyhow::Result<()> {
-        type ChangeSet = tx_graph::ChangeSet<ConfirmationBlockTime>;
+        type ChangeSet = tx::ChangeSet<ConfirmationBlockTime>;
         let mut conn = rusqlite::Connection::open_in_memory()?;
 
         // init tables
@@ -629,7 +630,7 @@ mod test {
 
     #[test]
     fn v0_to_v1_schema_migration_is_backward_compatible() -> anyhow::Result<()> {
-        type ChangeSet = tx_graph::ChangeSet<ConfirmationBlockTime>;
+        type ChangeSet = tx::ChangeSet<ConfirmationBlockTime>;
         let mut conn = rusqlite::Connection::open_in_memory()?;
 
         // Create initial database with v0 sqlite schema

crates/chain/src/tx_graph.rs

@@ -113,12 +113,15 @@ use alloc::vec::Vec;
 use bdk_core::ConfirmationBlockTime;
 pub use bdk_core::TxUpdate;
 use bitcoin::{Amount, Block, OutPoint, ScriptBuf, SignedAmount, Transaction, TxOut, Txid};
+use changeset::{self as tx, indexed::ChangeSet};
 use core::fmt::{self, Formatter};
 use core::{
     convert::Infallible,
     ops::{Deref, RangeInclusive},
 };
 
+pub mod changeset;
+
 impl<A: Ord, X> From<TxGraph<A, X>> for TxUpdate<A> {
     fn from(graph: TxGraph<A, X>) -> Self {
         Self {
@@ -631,7 +634,7 @@ impl<A: Anchor, X: Indexer> TxGraph<A, X> {
                         );
                     }
                     None => {
-                        changeset.txouts.insert(outpoint, txout);
+                        changeset.tx_graph.txouts.insert(outpoint, txout);
                     }
                 }
             }
@@ -669,7 +672,7 @@ impl<A: Anchor, X: Indexer> TxGraph<A, X> {
                         .insert(txid);
                 }
                 *partial_tx = TxNodeInternal::Whole(tx.clone());
-                changeset.txs.insert(tx);
+                changeset.tx_graph.txs.insert(tx);
             }
         }
 
@@ -830,7 +833,7 @@ impl<A: Anchor, X: Indexer> TxGraph<A, X> {
                 }
                 self.txs_by_highest_conf_heights.insert((new_top_h, txid));
             }
-            changeset.anchors.insert((anchor, txid));
+            changeset.tx_graph.anchors.insert((anchor, txid));
         }
         changeset
     }
@@ -862,7 +865,7 @@ impl<A: Anchor, X: Indexer> TxGraph<A, X> {
                 self.txs_by_last_seen.remove(&(old_last_seen, txid));
             }
             self.txs_by_last_seen.insert((seen_at, txid));
-            changeset.last_seen.insert(txid, seen_at);
+            changeset.tx_graph.last_seen.insert(txid, seen_at);
         }
         changeset
     }
@@ -970,25 +973,28 @@ impl<A: Anchor, X: Indexer> TxGraph<A, X> {
 
     /// Determines the [`ChangeSet`] between `self` and an empty [`TxGraph`].
     pub fn initial_changeset(&self) -> ChangeSet<A, X::ChangeSet> {
-        ChangeSet {
+        let tx_graph = tx::ChangeSet {
             txs: self.full_txs().map(|tx_node| tx_node.tx).collect(),
             txouts: self
                 .floating_txouts()
                 .map(|(op, txout)| (op, txout.clone()))
                 .collect(),
             anchors: self.rev_anchors(),
             last_seen: self.last_seen.clone().into_iter().collect(),
+        };
+        ChangeSet {
+            tx_graph,
             indexer: self.index.initial_changeset(),
         }
     }
 
     /// Indexes the txs and txouts of `changeset` and merges the resulting changes.
     fn index_changeset(&mut self, changeset: &mut ChangeSet<A, X::ChangeSet>) {
         let indexer = &mut changeset.indexer;
-        for tx in &changeset.txs {
+        for tx in &changeset.tx_graph.txs {
             indexer.merge(self.index.index_tx(tx));
         }
-        for (&outpoint, txout) in &changeset.txouts {
+        for (&outpoint, txout) in &changeset.tx_graph.txouts {
             indexer.merge(self.index.index_txout(outpoint, txout));
         }
     }
@@ -999,6 +1005,7 @@ impl<A: Anchor, X: Indexer> TxGraph<A, X> {
         // transactions so we do that first.
         self.index.apply_changeset(changeset.indexer);
 
+        let changeset = changeset.tx_graph;
         for tx in &changeset.txs {
             self.index.index_tx(tx);
         }
@@ -1397,142 +1404,6 @@ where
     }
 }
 
-/// The [`ChangeSet`] represents changes to a [`TxGraph`].
-///
-/// Since [`TxGraph`] is monotone, the "changeset" can only contain transactions to be added and
-/// not removed.
-///
-/// Refer to [module-level documentation](self) for more.
-#[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Deserialize, serde::Serialize),
-    serde(bound(
-        deserialize = "A: Ord + serde::Deserialize<'de>, X: serde::Deserialize<'de>",
-        serialize = "A: Ord + serde::Serialize, X: serde::Serialize",
-    ))
-)]
-#[must_use]
-pub struct ChangeSet<A = (), X = ()> {
-    /// Added transactions.
-    pub txs: BTreeSet<Arc<Transaction>>,
-    /// Added txouts.
-    pub txouts: BTreeMap<OutPoint, TxOut>,
-    /// Added anchors.
-    pub anchors: BTreeSet<(A, Txid)>,
-    /// Added last-seen unix timestamps of transactions.
-    pub last_seen: BTreeMap<Txid, u64>,
-    /// [`Indexer`] changes
-    pub indexer: X,
-}
-
-impl<A, X: Default> Default for ChangeSet<A, X> {
-    fn default() -> Self {
-        Self {
-            txs: Default::default(),
-            txouts: Default::default(),
-            anchors: Default::default(),
-            last_seen: Default::default(),
-            indexer: Default::default(),
-        }
-    }
-}
-
-impl<A, X> From<X> for ChangeSet<A, X> {
-    fn from(indexer: X) -> Self {
-        Self {
-            indexer,
-            txs: Default::default(),
-            txouts: Default::default(),
-            anchors: Default::default(),
-            last_seen: Default::default(),
-        }
-    }
-}
-
-impl<A, X> ChangeSet<A, X> {
-    /// Iterates over all outpoints contained within [`ChangeSet`].
-    pub fn txouts(&self) -> impl Iterator<Item = (OutPoint, &TxOut)> {
-        self.txs
-            .iter()
-            .flat_map(|tx| {
-                tx.output
-                    .iter()
-                    .enumerate()
-                    .map(move |(vout, txout)| (OutPoint::new(tx.compute_txid(), vout as _), txout))
-            })
-            .chain(self.txouts.iter().map(|(op, txout)| (*op, txout)))
-    }
-
-    /// Iterates over the heights of that the new transaction anchors in this changeset.
-    ///
-    /// This is useful if you want to find which heights you need to fetch data about in order to
-    /// confirm or exclude these anchors.
-    pub fn anchor_heights(&self) -> impl Iterator<Item = u32> + '_
-    where
-        A: Anchor,
-    {
-        let mut dedup = None;
-        self.anchors
-            .iter()
-            .map(|(a, _)| a.anchor_block().height)
-            .filter(move |height| {
-                let duplicate = dedup == Some(*height);
-                dedup = Some(*height);
-                !duplicate
-            })
-    }
-}
-
-impl<A: Ord, X: Merge> Merge for ChangeSet<A, X> {
-    fn merge(&mut self, other: Self) {
-        // We use `extend` instead of `BTreeMap::append` due to performance issues with `append`.
-        // Refer to https://github.com/rust-lang/rust/issues/34666#issuecomment-675658420
-        self.txs.extend(other.txs);
-        self.txouts.extend(other.txouts);
-        self.anchors.extend(other.anchors);
-
-        // last_seen timestamps should only increase
-        self.last_seen.extend(
-            other
-                .last_seen
-                .into_iter()
-                .filter(|(txid, update_ls)| self.last_seen.get(txid) < Some(update_ls))
-                .collect::<Vec<_>>(),
-        );
-        self.indexer.merge(other.indexer);
-    }
-
-    fn is_empty(&self) -> bool {
-        self.txs.is_empty()
-            && self.txouts.is_empty()
-            && self.anchors.is_empty()
-            && self.last_seen.is_empty()
-            && self.indexer.is_empty()
-    }
-}
-
-impl<A: Ord, X> ChangeSet<A, X> {
-    /// Transform the [`ChangeSet`] to have [`Anchor`]s of another type.
-    ///
-    /// This takes in a closure of signature `FnMut(A) -> A2` which is called for each [`Anchor`] to
-    /// transform it.
-    pub fn map_anchors<A2: Ord, F>(self, mut f: F) -> ChangeSet<A2, X>
-    where
-        F: FnMut(A) -> A2,
-    {
-        ChangeSet {
-            txs: self.txs,
-            txouts: self.txouts,
-            anchors: BTreeSet::<(A2, Txid)>::from_iter(
-                self.anchors.into_iter().map(|(a, txid)| (f(a), txid)),
-            ),
-            last_seen: self.last_seen,
-            indexer: self.indexer,
-        }
-    }
-}
-
 impl<A, X> AsRef<TxGraph<A, X>> for TxGraph<A, X> {
     fn as_ref(&self) -> &TxGraph<A, X> {
         self