feat: add wallet changeset primitives

rustaceanrob · rustaceanrob · commit d676afad1fe1 · 2025-05-13T16:00:51.000+01:00
diff --git a/bdk-ffi/src/bitcoin.rs b/bdk-ffi/src/bitcoin.rs
@@ -37,32 +37,54 @@ use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 
 /// A reference to an unspent output by TXID and output index.
-#[derive(Debug, Clone, Eq, PartialEq, uniffi:: Record)]
+#[derive(Debug, Clone, Eq, PartialEq, std::hash::Hash, uniffi:: Record)]
 pub struct OutPoint {
     /// The transaction.
-    pub txid: String,
+    pub txid: Arc<Txid>,
     /// The index of the output in the transaction.
     pub vout: u32,
 }
 
 impl From<&BdkOutPoint> for OutPoint {
     fn from(outpoint: &BdkOutPoint) -> Self {
         OutPoint {
-            txid: outpoint.txid.to_string(),
+            txid: Arc::new(Txid(outpoint.txid)),
             vout: outpoint.vout,
         }
     }
 }
 
+impl From<BdkOutPoint> for OutPoint {
+    fn from(value: BdkOutPoint) -> Self {
+        Self {
+            txid: Arc::new(Txid(value.txid)),
+            vout: value.vout,
+        }
+    }
+}
+
 impl From<OutPoint> for BdkOutPoint {
     fn from(outpoint: OutPoint) -> Self {
         BdkOutPoint {
-            txid: BitcoinTxid::from_str(&outpoint.txid).unwrap(),
+            txid: BitcoinTxid::from_raw_hash(outpoint.txid.0.into()),
             vout: outpoint.vout,
         }
     }
 }
 
+/// An [`OutPoint`] suitable as a key in a hash map.
+#[derive(Debug, PartialEq, Eq, std::hash::Hash, uniffi::Object)]
+#[uniffi::export(Debug, Eq, Hash)]
+pub struct HashableOutPoint(pub(crate) OutPoint);
+
+#[uniffi::export]
+impl HashableOutPoint {
+    /// Get the internal [`OutPoint`]
+    pub fn outpoint(&self) -> OutPoint {
+        self.0.clone()
+    }
+}
+
 /// Represents fee rate.
 ///
 /// This is an integer type representing fee rate in sat/kwu. It provides protection against mixing
@@ -549,7 +571,7 @@ impl From<&BdkTxIn> for TxIn {
     fn from(tx_in: &BdkTxIn) -> Self {
         TxIn {
             previous_output: OutPoint {
-                txid: tx_in.previous_output.txid.to_string(),
+                txid: Arc::new(Txid(tx_in.previous_output.txid)),
                 vout: tx_in.previous_output.vout,
             },
             script_sig: Arc::new(Script(tx_in.script_sig.clone())),
@@ -583,6 +605,24 @@ impl From<&BdkTxOut> for TxOut {
     }
 }
 
+impl From<BdkTxOut> for TxOut {
+    fn from(tx_out: BdkTxOut) -> Self {
+        Self {
+            value: tx_out.value.to_sat(),
+            script_pubkey: Arc::new(Script(tx_out.script_pubkey)),
+        }
+    }
+}
+
+impl From<TxOut> for BdkTxOut {
+    fn from(tx_out: TxOut) -> Self {
+        Self {
+            value: BdkAmount::from_sat(tx_out.value),
+            script_pubkey: tx_out.script_pubkey.0.clone(),
+        }
+    }
+}
+
 /// A bitcoin Block hash
 #[derive(Debug, Clone, Copy, PartialEq, Eq, std::hash::Hash, uniffi::Object)]
 #[uniffi::export(Display, Eq, Hash)]
diff --git a/bdk-ffi/src/types.rs b/bdk-ffi/src/types.rs
@@ -1,4 +1,6 @@
-use crate::bitcoin::{Address, Amount, OutPoint, Script, Transaction, TxOut};
+use crate::bitcoin::{
+    Address, Amount, BlockHash, DescriptorId, HashableOutPoint, OutPoint, Script, Transaction, TxOut, Txid
+};
 use crate::error::{CreateTxError, RequestBuilderError};
 
 use bdk_core::bitcoin::absolute::LockTime as BdkLockTime;
@@ -23,7 +25,7 @@ use bdk_wallet::Balance as BdkBalance;
 use bdk_wallet::LocalOutput as BdkLocalOutput;
 use bdk_wallet::Update as BdkUpdate;
 
-use std::collections::HashMap;
+use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::convert::TryFrom;
 use std::sync::{Arc, Mutex};
 
@@ -66,7 +68,7 @@ impl From<BdkChainPosition<BdkConfirmationBlockTime>> for ChainPosition {
             } => {
                 let block_id = BlockId {
                     height: anchor.block_id.height,
-                    hash: anchor.block_id.hash.to_string(),
+                    hash: Arc::new(BlockHash(anchor.block_id.hash)),
                 };
                 ChainPosition::Confirmed {
                     confirmation_block_time: ConfirmationBlockTime {
@@ -84,21 +86,57 @@ impl From<BdkChainPosition<BdkConfirmationBlockTime>> for ChainPosition {
 }
 
 /// Represents the confirmation block and time of a transaction.
-#[derive(Debug, uniffi::Record)]
+#[derive(Debug, Clone, PartialEq, Eq, std::hash::Hash, uniffi::Record)]
 pub struct ConfirmationBlockTime {
     /// The anchor block.
     pub block_id: BlockId,
     /// The confirmation time of the transaction being anchored.
     pub confirmation_time: u64,
 }
 
+impl From<BdkConfirmationBlockTime> for ConfirmationBlockTime {
+    fn from(value: BdkConfirmationBlockTime) -> Self {
+        Self {
+            block_id: value.block_id.into(),
+            confirmation_time: value.confirmation_time,
+        }
+    }
+}
+
+impl From<ConfirmationBlockTime> for BdkConfirmationBlockTime {
+    fn from(value: ConfirmationBlockTime) -> Self {
+        Self {
+            block_id: value.block_id.into(),
+            confirmation_time: value.confirmation_time,
+        }
+    }
+}
+
 /// A reference to a block in the canonical chain.
-#[derive(Debug, uniffi::Record)]
+#[derive(Debug, Clone, PartialEq, Eq, std::hash::Hash, uniffi::Record)]
 pub struct BlockId {
     /// The height of the block.
     pub height: u32,
     /// The hash of the block.
-    pub hash: String,
+    pub hash: Arc<BlockHash>,
+}
+
+impl From<bdk_wallet::chain::BlockId> for BlockId {
+    fn from(value: bdk_wallet::chain::BlockId) -> Self {
+        Self {
+            height: value.height,
+            hash: Arc::new(BlockHash(value.hash)),
+        }
+    }
+}
+
+impl From<BlockId> for bdk_wallet::chain::BlockId {
+    fn from(value: BlockId) -> Self {
+        Self {
+            height: value.height,
+            hash: value.hash.0,
+        }
+    }
 }
 
 /// A transaction that is deemed to be part of the canonical history.
@@ -203,7 +241,7 @@ impl From<BdkLocalOutput> for LocalOutput {
     fn from(local_utxo: BdkLocalOutput) -> Self {
         LocalOutput {
             outpoint: OutPoint {
-                txid: local_utxo.outpoint.txid.to_string(),
+                txid: Arc::new(Txid(local_utxo.outpoint.txid)),
                 vout: local_utxo.outpoint.vout,
             },
             txout: TxOut {
@@ -714,3 +752,150 @@ pub struct UnconfirmedTx {
     pub tx: Arc<Transaction>,
     pub last_seen: u64,
 }
+
+/// Mapping of descriptors to their last revealed index.
+#[derive(Debug, Clone, uniffi::Record)]
+pub struct IndexerChangeSet {
+    pub last_revealed: HashMap<Arc<DescriptorId>, u32>,
+}
+
+impl From<bdk_wallet::chain::indexer::keychain_txout::ChangeSet> for IndexerChangeSet {
+    fn from(mut value: bdk_wallet::chain::indexer::keychain_txout::ChangeSet) -> Self {
+        let mut changes = HashMap::new();
+        for (id, index) in core::mem::take(&mut value.last_revealed) {
+            changes.insert(Arc::new(DescriptorId(id.0)), index);
+        }
+        Self {
+            last_revealed: changes,
+        }
+    }
+}
+
+impl From<IndexerChangeSet> for bdk_wallet::chain::indexer::keychain_txout::ChangeSet {
+    fn from(mut value: IndexerChangeSet) -> Self {
+        let mut changes = BTreeMap::new();
+        for (id, index) in core::mem::take(&mut value.last_revealed) {
+            let descriptor_id = bdk_wallet::chain::DescriptorId(id.0);
+            changes.insert(descriptor_id, index);
+        }
+        Self {
+            last_revealed: changes,
+        }
+    }
+}
+
+/// The hash added or removed at the given height.
+#[derive(Debug, Clone, uniffi::Record)]
+pub struct ChainChange {
+    /// Effected height
+    pub height: u32,
+    /// A hash was added or must be removed.
+    pub hash: Option<Arc<BlockHash>>,
+}
+
+/// Changes to the local chain
+#[derive(Debug, Clone, uniffi::Record)]
+pub struct LocalChainChangeSet {
+    pub changes: Vec<ChainChange>,
+}
+
+impl From<bdk_wallet::chain::local_chain::ChangeSet> for LocalChainChangeSet {
+    fn from(mut value: bdk_wallet::chain::local_chain::ChangeSet) -> Self {
+        let mut changes = Vec::with_capacity(value.blocks.len());
+        for (height, hash) in core::mem::take(&mut value.blocks) {
+            let hash = hash.map(|h| Arc::new(BlockHash(h)));
+            let change = ChainChange { height, hash };
+            changes.push(change);
+        }
+        Self { changes }
+    }
+}
+
+impl From<LocalChainChangeSet> for bdk_wallet::chain::local_chain::ChangeSet {
+    fn from(mut value: LocalChainChangeSet) -> Self {
+        let mut changes = BTreeMap::new();
+        for change in core::mem::take(&mut value.changes) {
+            let height = change.height;
+            let hash = change.hash.map(|h| h.0);
+            changes.insert(height, hash);
+        }
+        Self { blocks: changes }
+    }
+}
+
+#[derive(Debug, Clone, uniffi::Record)]
+pub struct Anchor {
+    pub confirmation_block_time: ConfirmationBlockTime,
+    pub txid: Arc<Txid>,
+}
+
+#[derive(Debug, Clone, uniffi::Record)]
+pub struct TxGraphChangeSet {
+    pub txs: Vec<Arc<Transaction>>,
+    pub txouts: HashMap<Arc<HashableOutPoint>, TxOut>,
+    pub anchors: Vec<Anchor>,
+    pub last_seen: HashMap<Arc<Txid>, u64>,
+}
+
+impl From<bdk_wallet::chain::tx_graph::ChangeSet<BdkConfirmationBlockTime>> for TxGraphChangeSet {
+    fn from(mut value: bdk_wallet::chain::tx_graph::ChangeSet<BdkConfirmationBlockTime>) -> Self {
+        let btree_txs = core::mem::take(&mut value.txs);
+        let txs = btree_txs
+            .into_iter()
+            .map(|tx| Arc::new(tx.as_ref().into()))
+            .collect::<Vec<Arc<Transaction>>>();
+        let mut txouts = HashMap::new();
+        for (outpoint, txout) in core::mem::take(&mut value.txouts) {
+            txouts.insert(Arc::new(HashableOutPoint(outpoint.into())), txout.into());
+        }
+        let mut anchors = Vec::new();
+        for anchor in core::mem::take(&mut value.anchors) {
+            let confirmation_block_time = anchor.0.into();
+            let txid = Arc::new(Txid(anchor.1));
+            let anchor = Anchor {
+                confirmation_block_time,
+                txid,
+            };
+            anchors.push(anchor);
+        }
+        let mut last_seens = HashMap::new();
+        for (txid, time) in core::mem::take(&mut value.last_seen) {
+            last_seens.insert(Arc::new(Txid(txid)), time);
+        }
+        TxGraphChangeSet {
+            txs,
+            txouts,
+            anchors,
+            last_seen: last_seens,
+        }
+    }
+}
+
+impl From<TxGraphChangeSet> for bdk_wallet::chain::tx_graph::ChangeSet<BdkConfirmationBlockTime> {
+    fn from(mut value: TxGraphChangeSet) -> Self {
+        let mut txs = BTreeSet::new();
+        for tx in core::mem::take(&mut value.txs) {
+            let tx = Arc::new(tx.as_ref().into());
+            txs.insert(tx);
+        }
+        let mut txouts = BTreeMap::new();
+        for txout in core::mem::take(&mut value.txouts) {
+            txouts.insert(txout.0.outpoint().into(), txout.1.into());
+        }
+        let mut anchors = BTreeSet::new();
+        for anchor in core::mem::take(&mut value.anchors) {
+            let txid = anchor.txid.0;
+            anchors.insert((anchor.confirmation_block_time.into(), txid));
+        }
+        let mut last_seen = BTreeMap::new();
+        for (txid, time) in core::mem::take(&mut value.last_seen) {
+            last_seen.insert(txid.0, time);
+        }
+        Self {
+            txs,
+            txouts,
+            anchors,
+            last_seen,
+        }
+    }
+}
diff --git a/bdk-ffi/tests/bindings/test.kts b/bdk-ffi/tests/bindings/test.kts
@@ -4,10 +4,10 @@
  */
 
 import org.bitcoindevkit.bitcoin.Network
-import org.bitcoindevkit.BlockId
+import org.bitcoindevkit.Condition
 
 // A type from bitcoin-ffi
 val network = Network.TESTNET
 
 // A type from bdk-ffi
-val blockId = BlockId(0uL, "abcd")
+val condition = Condition(null, null)
diff --git a/bdk-ffi/tests/bindings/test.py b/bdk-ffi/tests/bindings/test.py
@@ -1,4 +1,4 @@
-from bdkpython import BlockId
+from bdkpython import Condition
 from bdkpython.bitcoin import Network
 
 import unittest
@@ -11,7 +11,7 @@ def test_some_enum(self):
 
     # A type from the bdk-ffi library
     def test_some_dict(self):
-        block_id = BlockId(height=0, hash="abcd")
+        condition = Condition(csv = None, timelock = None)
 
 if __name__=='__main__':
     unittest.main()
diff --git a/bdk-ffi/tests/bindings/test.swift b/bdk-ffi/tests/bindings/test.swift
@@ -10,4 +10,4 @@ import BitcoinDevKit
 let network = Network.testnet
 
 // A type from the bdk-ffi library
-let blockId = BlockId(height: 32, hash: "abcd")
+let condition = Condition(csv: nil, timelock: nil)
