Update bdk_chain to bitcoin 0.30.0

Author: danielabrozzoni

crates/chain/Cargo.toml

@@ -14,13 +14,13 @@ readme = "README.md"
 
 [dependencies]
 # For no-std, remember to enable the bitcoin/no-std feature
-bitcoin = { version = "0.29", default-features = false }
+bitcoin = { version = "0.30.0", default-features = false }
 serde_crate = { package = "serde", version = "1", optional = true, features = ["derive"] }
 
 # Use hashbrown as a feature flag to have HashSet and HashMap from it.
 # note version 0.13 breaks outs MSRV.
 hashbrown = { version = "0.11", optional = true, features = ["serde"] }
-miniscript = { version = "9.0.0", optional = true, default-features = false }
+miniscript = { version = "10.0.0", optional = true, default-features = false }
 
 [dev-dependencies]
 rand = "0.8"

crates/chain/src/chain_data.rs

@@ -104,7 +104,7 @@ impl Default for BlockId {
     fn default() -> Self {
         Self {
             height: Default::default(),
-            hash: BlockHash::from_inner([0u8; 32]),
+            hash: BlockHash::all_zeros(),
         }
     }
 }

crates/chain/src/descriptor_ext.rs

@@ -3,12 +3,14 @@ use crate::miniscript::{Descriptor, DescriptorPublicKey};
 /// A trait to extend the functionality of a miniscript descriptor.
 pub trait DescriptorExt {
     /// Returns the minimum value (in satoshis) at which an output is broadcastable.
+    /// Panics if the descriptor wildcard is hardened.
     fn dust_value(&self) -> u64;
 }
 
 impl DescriptorExt for Descriptor<DescriptorPublicKey> {
     fn dust_value(&self) -> u64 {
         self.at_derivation_index(0)
+            .expect("descriptor can't have hardened derivation")
             .script_pubkey()
             .dust_value()
             .to_sat()

crates/chain/src/keychain/txout_index.rs

@@ -313,7 +313,7 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
         self.inner
             .all_spks()
             .range((keychain.clone(), u32::MIN)..(keychain.clone(), next_index))
-            .map(|((_, derivation_index), spk)| (*derivation_index, spk))
+            .map(|((_, derivation_index), spk)| (*derivation_index, spk.as_script()))
     }
 
     /// Get the next derivation index for `keychain`. The next index is the index after the last revealed

crates/chain/src/spk_iter.rs

@@ -1,5 +1,5 @@
 use crate::{
-    bitcoin::{secp256k1::Secp256k1, Script},
+    bitcoin::{secp256k1::Secp256k1, ScriptBuf},
     miniscript::{Descriptor, DescriptorPublicKey},
 };
 use core::{borrow::Borrow, ops::Bound, ops::RangeBounds};
@@ -22,9 +22,9 @@ pub const BIP32_MAX_INDEX: u32 = (1 << 31) - 1;
 /// # use std::str::FromStr;
 /// # let secp = bitcoin::secp256k1::Secp256k1::signing_only();
 /// # let (descriptor, _) = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, "wpkh([73c5da0a/86'/0'/0']xprv9xgqHN7yz9MwCkxsBPN5qetuNdQSUttZNKw1dcYTV4mkaAFiBVGQziHs3NRSWMkCzvgjEe3n9xV8oYywvM8at9yRqyaZVz6TYYhX98VjsUk/1/0)").unwrap();
-/// # let external_spk_0 = descriptor.at_derivation_index(0).script_pubkey();
-/// # let external_spk_3 = descriptor.at_derivation_index(3).script_pubkey();
-/// # let external_spk_4 = descriptor.at_derivation_index(4).script_pubkey();
+/// # let external_spk_0 = descriptor.at_derivation_index(0).unwrap().script_pubkey();
+/// # let external_spk_3 = descriptor.at_derivation_index(3).unwrap().script_pubkey();
+/// # let external_spk_4 = descriptor.at_derivation_index(4).unwrap().script_pubkey();
 ///
 /// // Creates a new script pubkey iterator starting at 0 from a descriptor.
 /// let mut spk_iter = SpkIterator::new(&descriptor);
@@ -84,7 +84,7 @@ impl<D> Iterator for SpkIterator<D>
 where
     D: Borrow<Descriptor<DescriptorPublicKey>>,
 {
-    type Item = (u32, Script);
+    type Item = (u32, ScriptBuf);
 
     fn next(&mut self) -> Option<Self::Item> {
         // For non-wildcard descriptors, we expect the first element to be Some((0, spk)), then None after.
@@ -96,8 +96,7 @@ where
         let script = self
             .descriptor
             .borrow()
-            .at_derivation_index(self.next_index)
-            .derived_descriptor(&self.secp)
+            .derived_descriptor(&self.secp, self.next_index)
             .expect("the descriptor cannot need hardened derivation")
             .script_pubkey();
         let output = (self.next_index, script);
@@ -149,15 +148,14 @@ mod test {
 
     #[test]
     #[allow(clippy::iter_nth_zero)]
+    #[rustfmt::skip]
     fn test_spkiterator_wildcard() {
         let (_, external_desc, _) = init_txout_index();
-        let external_spk_0 = external_desc.at_derivation_index(0).script_pubkey();
-        let external_spk_16 = external_desc.at_derivation_index(16).script_pubkey();
-        let external_spk_20 = external_desc.at_derivation_index(20).script_pubkey();
-        let external_spk_21 = external_desc.at_derivation_index(21).script_pubkey();
-        let external_spk_max = external_desc
-            .at_derivation_index(BIP32_MAX_INDEX)
-            .script_pubkey();
+        let external_spk_0 = external_desc.at_derivation_index(0).unwrap().script_pubkey();
+        let external_spk_16 = external_desc.at_derivation_index(16).unwrap().script_pubkey();
+        let external_spk_20 = external_desc.at_derivation_index(20).unwrap().script_pubkey();
+        let external_spk_21 = external_desc.at_derivation_index(21).unwrap().script_pubkey();
+        let external_spk_max = external_desc.at_derivation_index(BIP32_MAX_INDEX).unwrap().script_pubkey();
 
         let mut external_spk = SpkIterator::new(&external_desc);
         let max_index = BIP32_MAX_INDEX - 22;
@@ -187,6 +185,7 @@ mod test {
         let (no_wildcard_descriptor, _) = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, "wpkh([73c5da0a/86'/0'/0']xprv9xgqHN7yz9MwCkxsBPN5qetuNdQSUttZNKw1dcYTV4mkaAFiBVGQziHs3NRSWMkCzvgjEe3n9xV8oYywvM8at9yRqyaZVz6TYYhX98VjsUk/1/0)").unwrap();
         let external_spk_0 = no_wildcard_descriptor
             .at_derivation_index(0)
+            .unwrap()
             .script_pubkey();
 
         let mut external_spk = SpkIterator::new(&no_wildcard_descriptor);

crates/chain/src/spk_txout_index.rs

@@ -5,7 +5,7 @@ use crate::{
     indexed_tx_graph::Indexer,
     ForEachTxOut,
 };
-use bitcoin::{self, OutPoint, Script, Transaction, TxOut, Txid};
+use bitcoin::{self, OutPoint, Script, ScriptBuf, Transaction, TxOut, Txid};
 
 /// An index storing [`TxOut`]s that have a script pubkey that matches those in a list.
 ///
@@ -30,9 +30,9 @@ use bitcoin::{self, OutPoint, Script, Transaction, TxOut, Txid};
 #[derive(Clone, Debug)]
 pub struct SpkTxOutIndex<I> {
     /// script pubkeys ordered by index
-    spks: BTreeMap<I, Script>,
+    spks: BTreeMap<I, ScriptBuf>,
     /// A reverse lookup from spk to spk index
-    spk_indices: HashMap<Script, I>,
+    spk_indices: HashMap<ScriptBuf, I>,
     /// The set of unused indexes.
     unused: BTreeSet<I>,
     /// Lookup index and txout by outpoint.
@@ -152,11 +152,11 @@ impl<I: Clone + Ord> SpkTxOutIndex<I> {
         use bitcoin::hashes::Hash;
         use core::ops::Bound::*;
         let min_op = OutPoint {
-            txid: Txid::from_inner([0x00; 32]),
+            txid: Txid::all_zeros(),
             vout: u32::MIN,
         };
         let max_op = OutPoint {
-            txid: Txid::from_inner([0xff; 32]),
+            txid: Txid::from_byte_array([0xff; Txid::LEN]),
             vout: u32::MAX,
         };
 
@@ -188,18 +188,18 @@ impl<I: Clone + Ord> SpkTxOutIndex<I> {
     ///
     /// If that index hasn't been inserted yet, it will return `None`.
     pub fn spk_at_index(&self, index: &I) -> Option<&Script> {
-        self.spks.get(index)
+        self.spks.get(index).map(|s| s.as_script())
     }
 
     /// The script pubkeys that are being tracked by the index.
-    pub fn all_spks(&self) -> &BTreeMap<I, Script> {
+    pub fn all_spks(&self) -> &BTreeMap<I, ScriptBuf> {
         &self.spks
     }
 
     /// Adds a script pubkey to scan for. Returns `false` and does nothing if spk already exists in the map
     ///
     /// the index will look for outputs spending to this spk whenever it scans new data.
-    pub fn insert_spk(&mut self, index: I, spk: Script) -> bool {
+    pub fn insert_spk(&mut self, index: I, spk: ScriptBuf) -> bool {
         match self.spk_indices.entry(spk.clone()) {
             Entry::Vacant(value) => {
                 value.insert(index.clone());

crates/chain/tests/common/mod.rs

@@ -56,7 +56,7 @@ macro_rules! changeset {
 pub fn new_tx(lt: u32) -> bitcoin::Transaction {
     bitcoin::Transaction {
         version: 0x00,
-        lock_time: bitcoin::PackedLockTime(lt),
+        lock_time: bitcoin::absolute::LockTime::from_consensus(lt),
         input: vec![],
         output: vec![],
     }

crates/chain/tests/test_indexed_tx_graph.rs

@@ -10,7 +10,9 @@ use bdk_chain::{
     tx_graph::Additions,
     BlockId, ChainPosition, ConfirmationHeightAnchor,
 };
-use bitcoin::{secp256k1::Secp256k1, BlockHash, OutPoint, Script, Transaction, TxIn, TxOut};
+use bitcoin::{
+    secp256k1::Secp256k1, BlockHash, OutPoint, Script, ScriptBuf, Transaction, TxIn, TxOut,
+};
 use miniscript::Descriptor;
 
 /// Ensure [`IndexedTxGraph::insert_relevant_txs`] can successfully index transactions NOT presented
@@ -25,8 +27,8 @@ fn insert_relevant_txs() {
     const DESCRIPTOR: &str = "tr([73c5da0a/86'/0'/0']xprv9xgqHN7yz9MwCkxsBPN5qetuNdQSUttZNKw1dcYTV4mkaAFiBVGQziHs3NRSWMkCzvgjEe3n9xV8oYywvM8at9yRqyaZVz6TYYhX98VjsUk/0/*)";
     let (descriptor, _) = Descriptor::parse_descriptor(&Secp256k1::signing_only(), DESCRIPTOR)
         .expect("must be valid");
-    let spk_0 = descriptor.at_derivation_index(0).script_pubkey();
-    let spk_1 = descriptor.at_derivation_index(9).script_pubkey();
+    let spk_0 = descriptor.at_derivation_index(0).unwrap().script_pubkey();
+    let spk_1 = descriptor.at_derivation_index(9).unwrap().script_pubkey();
 
     let mut graph = IndexedTxGraph::<ConfirmationHeightAnchor, KeychainTxOutIndex<()>>::default();
     graph.index.add_keychain((), descriptor);
@@ -127,21 +129,21 @@ fn test_list_owned_txouts() {
 
     // Get trusted and untrusted addresses
 
-    let mut trusted_spks = Vec::new();
-    let mut untrusted_spks = Vec::new();
+    let mut trusted_spks: Vec<ScriptBuf> = Vec::new();
+    let mut untrusted_spks: Vec<ScriptBuf> = Vec::new();
 
     {
         // we need to scope here to take immutanble reference of the graph
         for _ in 0..10 {
             let ((_, script), _) = graph.index.reveal_next_spk(&"keychain_1".to_string());
             // TODO Assert indexes
-            trusted_spks.push(script.clone());
+            trusted_spks.push(script.to_owned());
         }
     }
     {
         for _ in 0..10 {
             let ((_, script), _) = graph.index.reveal_next_spk(&"keychain_2".to_string());
-            untrusted_spks.push(script.clone());
+            untrusted_spks.push(script.to_owned());
         }
     }
 
@@ -155,7 +157,7 @@ fn test_list_owned_txouts() {
         }],
         output: vec![TxOut {
             value: 70000,
-            script_pubkey: trusted_spks[0].clone(),
+            script_pubkey: trusted_spks[0].to_owned(),
         }],
         ..common::new_tx(0)
     };
@@ -164,7 +166,7 @@ fn test_list_owned_txouts() {
     let tx2 = Transaction {
         output: vec![TxOut {
             value: 30000,
-            script_pubkey: untrusted_spks[0].clone(),
+            script_pubkey: untrusted_spks[0].to_owned(),
         }],
         ..common::new_tx(0)
     };
@@ -177,7 +179,7 @@ fn test_list_owned_txouts() {
         }],
         output: vec![TxOut {
             value: 10000,
-            script_pubkey: trusted_spks[1].clone(),
+            script_pubkey: trusted_spks[1].to_owned(),
         }],
         ..common::new_tx(0)
     };
@@ -186,7 +188,7 @@ fn test_list_owned_txouts() {
     let tx4 = Transaction {
         output: vec![TxOut {
             value: 20000,
-            script_pubkey: untrusted_spks[1].clone(),
+            script_pubkey: untrusted_spks[1].to_owned(),
         }],
         ..common::new_tx(0)
     };
@@ -195,7 +197,7 @@ fn test_list_owned_txouts() {
     let tx5 = Transaction {
         output: vec![TxOut {
             value: 15000,
-            script_pubkey: trusted_spks[2].clone(),
+            script_pubkey: trusted_spks[2].to_owned(),
         }],
         ..common::new_tx(0)
     };
@@ -258,7 +260,7 @@ fn test_list_owned_txouts() {
                 &local_chain,
                 chain_tip,
                 graph.index.outpoints().iter().cloned(),
-                |_, spk: &Script| trusted_spks.contains(spk),
+                |_, spk: &Script| trusted_spks.contains(&spk.to_owned()),
             );
 
             assert_eq!(txouts.len(), 5);