WIP

Author: evanlinjin

examples/example_wallet_electrum/Cargo.toml

@@ -6,5 +6,5 @@ edition = "2021"
 [dependencies]
 bdk_wallet = { path = "../../wallet", features = ["file_store"] }
 #bdk_electrum = { version = "0.21" }
-bdk_electrum = { git = "https://github.com/bitcoindevkit/bdk", rev = "b70758652d1c819c88d92765905d09e26b951ee2" }
+bdk_electrum = { git = "https://github.com/evanlinjin/bdk", branch = "superimposed_canonicalization" }
 anyhow = "1"

examples/example_wallet_esplora_async/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 [dependencies]
 bdk_wallet = { path = "../../wallet", features = ["rusqlite"] }
 #bdk_esplora = { version = "0.20", features = ["async-https", "tokio"] }
-bdk_esplora = { git = "https://github.com/bitcoindevkit/bdk", rev = "b70758652d1c819c88d92765905d09e26b951ee2", features = ["async-https", "tokio"] }
-bdk_testenv = { git = "https://github.com/bitcoindevkit/bdk", rev = "b70758652d1c819c88d92765905d09e26b951ee2" }
+bdk_esplora = { git = "https://github.com/evanlinjin/bdk", branch = "superimposed_canonicalization", features = ["async-https", "tokio"] }
+bdk_testenv = { git = "https://github.com/evanlinjin/bdk", branch = "superimposed_canonicalization" }
 tokio = { version = "1", features = ["rt", "rt-multi-thread", "macros"] }
 anyhow = "1"

examples/example_wallet_esplora_blocking/Cargo.toml

@@ -9,5 +9,5 @@ publish = false
 [dependencies]
 bdk_wallet = { path = "../../wallet", features = ["file_store"] }
 #bdk_esplora = { version = "0.20", features = ["blocking"] }
-bdk_esplora = { git = "https://github.com/bitcoindevkit/bdk", rev = "b70758652d1c819c88d92765905d09e26b951ee2", features = ["blocking"] }
+bdk_esplora = { git = "https://github.com/evanlinjin/bdk", branch = "superimposed_canonicalization", features = ["blocking"] }
 anyhow = "1"

examples/example_wallet_rpc/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 [dependencies]
 bdk_wallet = { path = "../../wallet", features = ["file_store"] }
 #bdk_bitcoind_rpc = { version = "0.18" }
-bdk_bitcoind_rpc = { git = "https://github.com/bitcoindevkit/bdk", rev = "b70758652d1c819c88d92765905d09e26b951ee2" }
+bdk_bitcoind_rpc = { git = "https://github.com/evanlinjin/bdk", branch = "superimposed_canonicalization" }
 
 anyhow = "1"
 clap = { version = "4.5.17", features = ["derive", "env"] }

wallet/Cargo.toml

@@ -28,14 +28,14 @@ serde_json = { version = "^1.0" }
 bip39 = { version = "2.0", optional = true }
 
 [dependencies.bdk_chain]
-git = "https://github.com/bitcoindevkit/bdk"
-rev = "b70758652d1c819c88d92765905d09e26b951ee2"
+git = "https://github.com/evanlinjin/bdk"
+branch = "superimposed_canonicalization"
 default-features = false
 features = ["miniscript", "serde"]
 
 [dependencies.bdk_file_store]
-git = "https://github.com/bitcoindevkit/bdk"
-rev = "b70758652d1c819c88d92765905d09e26b951ee2"
+git = "https://github.com/evanlinjin/bdk"
+branch = "superimposed_canonicalization"
 optional = true
 
 [features]
@@ -59,8 +59,8 @@ anyhow = "1"
 rand = "^0.8"
 
 [dev-dependencies.bdk_chain]
-git = "https://github.com/bitcoindevkit/bdk"
-rev = "b70758652d1c819c88d92765905d09e26b951ee2"
+git = "https://github.com/evanlinjin/bdk"
+branch = "superimposed_canonicalization"
 features = ["rusqlite"]
 
 [package.metadata.docs.rs]

wallet/src/wallet/changeset.rs

@@ -3,6 +3,8 @@ use bdk_chain::{
 };
 use miniscript::{Descriptor, DescriptorPublicKey};
 
+use super::unbroadcasted;
+
 type IndexedTxGraphChangeSet =
     indexed_tx_graph::ChangeSet<ConfirmationBlockTime, keychain_txout::ChangeSet>;
 
@@ -21,6 +23,8 @@ pub struct ChangeSet {
     pub tx_graph: tx_graph::ChangeSet<ConfirmationBlockTime>,
     /// Changes to [`KeychainTxOutIndex`](keychain_txout::KeychainTxOutIndex).
     pub indexer: keychain_txout::ChangeSet,
+    /// Changes to [`Unbroadcasted`](crate::unbroadcasted::Unbroadcasted).
+    pub unbroadcasted: unbroadcasted::ChangeSet,
 }
 
 impl Merge for ChangeSet {

wallet/src/wallet/mod.rs

@@ -19,6 +19,7 @@ use alloc::{
     sync::Arc,
     vec::Vec,
 };
+use chain::CanonicalizationParams;
 use core::{cmp::Ordering, fmt, mem, ops::Deref};
 
 use bdk_chain::{
@@ -57,6 +58,7 @@ mod params;
 mod persisted;
 pub mod signer;
 pub mod tx_builder;
+pub mod unbroadcasted;
 pub(crate) mod utils;
 
 use crate::collections::{BTreeMap, HashMap, HashSet};
@@ -80,6 +82,7 @@ pub use bdk_chain::Balance;
 pub use changeset::ChangeSet;
 pub use params::*;
 pub use persisted::*;
+pub use unbroadcasted::Unbroadcasted;
 pub use utils::IsDust;
 
 /// A Bitcoin wallet
@@ -105,6 +108,7 @@ pub struct Wallet {
     change_signers: Arc<SignersContainer>,
     chain: LocalChain,
     indexed_graph: IndexedTxGraph<ConfirmationBlockTime, KeychainTxOutIndex<KeychainKind>>,
+    unbroadcasted: Unbroadcasted,
     stage: ChangeSet,
     network: Network,
     secp: SecpCtx,
@@ -405,13 +409,15 @@ impl Wallet {
         let change_descriptor = index.get_descriptor(KeychainKind::Internal).cloned();
         let indexed_graph = IndexedTxGraph::new(index);
         let indexed_graph_changeset = indexed_graph.initial_changeset();
+        let unbroadcasted = Unbroadcasted::default();
 
         let stage = ChangeSet {
             descriptor,
             change_descriptor,
             local_chain: chain_changeset,
             tx_graph: indexed_graph_changeset.tx_graph,
             indexer: indexed_graph_changeset.indexer,
+            unbroadcasted: Default::default(),
             network: Some(network),
         };
 
@@ -421,6 +427,7 @@ impl Wallet {
             network,
             chain,
             indexed_graph,
+            unbroadcasted,
             stage,
             secp,
         })
@@ -605,13 +612,16 @@ impl Wallet {
         indexed_graph.apply_changeset(changeset.indexer.into());
         indexed_graph.apply_changeset(changeset.tx_graph.into());
 
+        let unbroadcasted = Unbroadcasted::from_changeset(changeset.unbroadcasted);
+
         let stage = ChangeSet::default();
 
         Ok(Some(Wallet {
             signers,
             change_signers,
             chain,
             indexed_graph,
+            unbroadcasted,
             stage,
             network,
             secp,
@@ -809,13 +819,31 @@ impl Wallet {
         self.indexed_graph.index.index_of_spk(spk).cloned()
     }
 
+    /// Modifies canonicalization by assuming that all unbroadcasted transactions are canonical.
+    pub fn include_unbroadcasted_canonicalization_params(&self) -> CanonicalizationParams {
+        CanonicalizationParams {
+            assume_canonical: self.unbroadcasted.txids().collect(),
+        }
+    }
+
+    /// TODO: Return this in the order in which it needs to be broadcasted.
+    pub fn unbroadcasted(&self) -> impl Iterator<Item = (Txid, Arc<Transaction>)> + '_ {
+        self.unbroadcasted
+            .txids()
+            .filter_map(|txid| self.tx_graph().get_tx(txid).map(|tx| (txid, tx)))
+    }
+
     /// Return the list of unspent outputs of this wallet
-    pub fn list_unspent(&self) -> impl Iterator<Item = LocalOutput> + '_ {
+    pub fn list_unspent(
+        &self,
+        params: CanonicalizationParams,
+    ) -> impl Iterator<Item = LocalOutput> + '_ {
         self.indexed_graph
             .graph()
             .filter_chain_unspents(
                 &self.chain,
                 self.chain.tip().block_id(),
+                params,
                 self.indexed_graph.index.outpoints().iter().cloned(),
             )
             .map(|((k, i), full_txo)| new_local_utxo(k, i, full_txo))
@@ -824,12 +852,16 @@ impl Wallet {
     /// List all relevant outputs (includes both spent and unspent, confirmed and unconfirmed).
     ///
     /// To list only unspent outputs (UTXOs), use [`Wallet::list_unspent`] instead.
-    pub fn list_output(&self) -> impl Iterator<Item = LocalOutput> + '_ {
+    pub fn list_output(
+        &self,
+        params: CanonicalizationParams,
+    ) -> impl Iterator<Item = LocalOutput> + '_ {
         self.indexed_graph
             .graph()
             .filter_chain_txouts(
                 &self.chain,
                 self.chain.tip().block_id(),
+                params,
                 self.indexed_graph.index.outpoints().iter().cloned(),
             )
             .map(|((k, i), full_txo)| new_local_utxo(k, i, full_txo))
@@ -876,13 +908,14 @@ impl Wallet {
 
     /// Returns the utxo owned by this wallet corresponding to `outpoint` if it exists in the
     /// wallet's database.
-    pub fn get_utxo(&self, op: OutPoint) -> Option<LocalOutput> {
+    pub fn get_utxo(&self, params: CanonicalizationParams, op: OutPoint) -> Option<LocalOutput> {
         let ((keychain, index), _) = self.indexed_graph.index.txout(op)?;
         self.indexed_graph
             .graph()
             .filter_chain_unspents(
                 &self.chain,
                 self.chain.tip().block_id(),
+                params,
                 core::iter::once(((), op)),
             )
             .map(|(_, full_txo)| new_local_utxo(keychain, index, full_txo))
@@ -1055,10 +1088,10 @@ impl Wallet {
     /// ```
     ///
     /// [`Anchor`]: bdk_chain::Anchor
-    pub fn get_tx(&self, txid: Txid) -> Option<WalletTx> {
+    pub fn get_tx(&self, params: CanonicalizationParams, txid: Txid) -> Option<WalletTx> {
         let graph = self.indexed_graph.graph();
         graph
-            .list_canonical_txs(&self.chain, self.chain.tip().block_id())
+            .list_canonical_txs(&self.chain, self.chain.tip().block_id(), params)
             .find(|tx| tx.tx_node.txid == txid)
     }
 
@@ -1073,11 +1106,14 @@ impl Wallet {
     ///
     /// To iterate over all canonical transactions, including those that are irrelevant, use
     /// [`TxGraph::list_canonical_txs`].
-    pub fn transactions(&self) -> impl Iterator<Item = WalletTx> + '_ {
+    pub fn transactions(
+        &self,
+        params: CanonicalizationParams,
+    ) -> impl Iterator<Item = WalletTx> + '_ {
         let tx_graph = self.indexed_graph.graph();
         let tx_index = &self.indexed_graph.index;
         tx_graph
-            .list_canonical_txs(&self.chain, self.chain.tip().block_id())
+            .list_canonical_txs(&self.chain, self.chain.tip().block_id(), params)
             .filter(|c_tx| tx_index.is_tx_relevant(&c_tx.tx_node.tx))
     }
 
@@ -1097,21 +1133,26 @@ impl Wallet {
     ///     wallet.transactions_sort_by(|tx1, tx2| tx2.chain_position.cmp(&tx1.chain_position));
     /// # Ok::<(), anyhow::Error>(())
     /// ```
-    pub fn transactions_sort_by<F>(&self, compare: F) -> Vec<WalletTx>
+    pub fn transactions_sort_by<F>(
+        &self,
+        params: CanonicalizationParams,
+        compare: F,
+    ) -> Vec<WalletTx>
     where
         F: FnMut(&WalletTx, &WalletTx) -> Ordering,
     {
-        let mut txs: Vec<WalletTx> = self.transactions().collect();
+        let mut txs: Vec<WalletTx> = self.transactions(params).collect();
         txs.sort_unstable_by(compare);
         txs
     }
 
     /// Return the balance, separated into available, trusted-pending, untrusted-pending and immature
     /// values.
-    pub fn balance(&self) -> Balance {
+    pub fn balance(&self, params: CanonicalizationParams) -> Balance {
         self.indexed_graph.graph().balance(
             &self.chain,
             self.chain.tip().block_id(),
+            params,
             self.indexed_graph.index.outpoints().iter().cloned(),
             |&(k, _), _| k == KeychainKind::Internal,
         )
@@ -1590,7 +1631,7 @@ impl Wallet {
         let txout_index = &self.indexed_graph.index;
         let chain_tip = self.chain.tip().block_id();
         let chain_positions = graph
-            .list_canonical_txs(&self.chain, chain_tip)
+            .list_canonical_txs(&self.chain, chain_tip, CanonicalizationParams::default())
             .map(|canon_tx| (canon_tx.tx_node.txid, canon_tx.chain_position))
             .collect::<HashMap<Txid, _>>();
 

wallet/src/wallet/unbroadcasted.rs

@@ -0,0 +1,99 @@
+use crate::collections::BTreeMap;
+
+use crate::collections::HashSet;
+
+use crate::collections::hash_map;
+use crate::collections::HashMap;
+
+use bitcoin::Txid;
+use chain::CanonicalizationParams;
+use chain::Merge;
+
+/// An ordered unbroadcasted list.
+///
+/// It is ordered in case of RBF txs.
+#[derive(Debug, Clone, Default)]
+pub struct Unbroadcasted {
+    txs: HashMap<Txid, u64>,
+    order: HashSet<(u64, Txid)>,
+    next_seq: u64,
+}
+
+#[must_use]
+#[derive(Debug, Clone, Default, PartialEq, serde::Deserialize, serde::Serialize)]
+pub struct ChangeSet {
+    /// Add or remove?
+    pub txs: BTreeMap<(u64, Txid), bool>,
+}
+
+impl Merge for ChangeSet {
+    fn merge(&mut self, other: Self) {
+        self.txs.merge(other.txs);
+    }
+
+    fn is_empty(&self) -> bool {
+        self.txs.is_empty()
+    }
+}
+
+impl Unbroadcasted {
+    pub fn from_changeset(changeset: ChangeSet) -> Self {
+        let mut out = Unbroadcasted::default();
+        out.apply_changeset(changeset);
+        out
+    }
+
+    pub fn apply_changeset(&mut self, changeset: ChangeSet) {
+        for ((_, txid), is_add) in changeset.txs {
+            if is_add {
+                let _ = self.insert(txid);
+            } else {
+                let _ = self.remove(txid);
+            }
+        }
+    }
+
+    /// Reinserting will bump the tx's seq to `next_seq`.
+    pub fn insert(&mut self, txid: Txid) -> ChangeSet {
+        let seq = self.next_seq;
+        self.next_seq += 1;
+
+        match self.txs.entry(txid) {
+            hash_map::Entry::Occupied(mut entry) => {
+                // remove stuff
+                let entry_seq = entry.get_mut();
+                self.order.remove(&(*entry_seq, txid));
+                self.order.insert((seq, txid));
+                *entry_seq = seq;
+            }
+            hash_map::Entry::Vacant(entry) => {
+                entry.insert(seq);
+                self.order.insert((seq, txid));
+            }
+        }
+
+        let mut changeset = ChangeSet::default();
+        changeset.txs.insert((seq, txid), true);
+        changeset
+    }
+
+    pub fn remove(&mut self, txid: Txid) -> ChangeSet {
+        let mut changeset = ChangeSet::default();
+        if let Some(seq) = self.txs.remove(&txid) {
+            self.order.remove(&(seq, txid));
+
+            let seq = self.next_seq;
+            self.next_seq += 1;
+
+            changeset.txs.insert((seq, txid), false);
+        }
+        changeset
+    }
+
+    /// Txids ordered by precedence.
+    ///
+    /// Transactions with greater precedence will appear later in this list.
+    pub fn txids(&self) -> impl ExactSizeIterator<Item = Txid> + '_ {
+        self.order.iter().map(|&(_, txid)| txid)
+    }
+}