chore: bump bitcoin version to 0.32.4

Cargo.toml

@@ -27,7 +27,7 @@ resolver = "2"
 
 [workspace.dependencies]
 assert_matches = "1.5.0"
-bitcoin = "0.28.1"
+bitcoin = "0.32.4"
 byteorder = "1.4.3"
 canbench-rs = "0.1.8"
 candid = "0.10.6"
@@ -48,6 +48,7 @@ ic-metrics-encoder = "1.0.0"
 ic-stable-structures = "0.6.7"
 lazy_static = "1.4.0"
 pocket-ic = "6.0.0"
+secp256k1 = "0.29.1"
 serde = "1.0.171"
 serde_bytes = "0.11"
 serde_json = "1.0.94"

benchmarks/Cargo.toml

@@ -9,7 +9,7 @@ path = "src/main.rs"
 bench = false
 
 [dependencies]
-bitcoin = { workspace = true, features = ["use-serde"]}
+bitcoin = { workspace = true, features = ["serde"] }
 canbench-rs = { workspace = true }
 candid = { workspace = true }
 hex = { workspace = true }

benchmarks/src/main.rs

@@ -1,5 +1,5 @@
 use bitcoin::consensus::Decodable;
-use bitcoin::{consensus::Encodable, Block as BitcoinBlock, BlockHeader as Header};
+use bitcoin::{block::Header, consensus::Encodable, Block as BitcoinBlock};
 use canbench_rs::{bench, bench_fn, BenchResult};
 use ic_btc_canister::{types::BlockHeaderBlob, with_state_mut};
 use ic_btc_interface::{InitConfig, Network};
@@ -22,7 +22,7 @@ fn init() {
                 .split('\n')
                 .map(|block_hex| {
                     let block_bytes = hex::decode(block_hex).unwrap();
-                    Block::new(BitcoinBlock::consensus_decode(block_bytes.as_slice()).unwrap())
+                    Block::new(BitcoinBlock::consensus_decode(&mut block_bytes.as_slice()).unwrap())
                 })
                 .collect(),
         );

bootstrap/state-builder/src/build_address_utxos.rs

@@ -6,7 +6,7 @@
 //!   --network testnet \
 //!   --output balances.bin \
 //!   --utxos-dump-path utxos-dump.csv
-use bitcoin::{Address as BitcoinAddress, Script, Txid as BitcoinTxid};
+use bitcoin::{hashes::Hash, Address as BitcoinAddress, Script, Txid as BitcoinTxid};
 use clap::Parser;
 use ic_btc_canister::types::{into_bitcoin_network, Address, AddressUtxo};
 use ic_btc_interface::Network;
@@ -49,7 +49,13 @@ fn main() {
         let line = line.unwrap();
         let parts: Vec<_> = line.split(',').collect();
 
-        let txid = Txid::from(BitcoinTxid::from_str(parts[1]).unwrap().to_vec());
+        let txid = Txid::from(
+            BitcoinTxid::from_str(parts[1])
+                .unwrap()
+                .as_raw_hash()
+                .as_byte_array()
+                .to_vec(),
+        );
         let vout: u32 = parts[2].parse().unwrap();
         let address_str = parts[5];
         let height: u32 = parts[0].parse().unwrap();
@@ -61,13 +67,15 @@ fn main() {
 
         // Load the address. The UTXO dump tool we use doesn't output all the addresses
         // we support, so if parsing the address itself fails, we try parsing the script directly.
+        let bitcoin_newtork = into_bitcoin_network(args.network);
         let address = if let Ok(address) = BitcoinAddress::from_str(address_str) {
-            Some(address)
+            let checked_address = address
+                .require_network(bitcoin_newtork)
+                .expect("Address must be valid for network");
+            Some(checked_address)
         } else {
-            BitcoinAddress::from_script(
-                &Script::from(hex::decode(script).expect("script must be valid hex")),
-                into_bitcoin_network(args.network),
-            )
+            let bytes = hex::decode(script).expect("script must be valid hex");
+            BitcoinAddress::from_script(Script::from_bytes(&bytes), bitcoin_newtork).ok()
         };
 
         if let Some(address) = address {

bootstrap/state-builder/src/build_balances.rs

@@ -59,13 +59,15 @@ fn main() {
 
         // Load the address. The UTXO dump tool we use doesn't output all the addresses
         // we support, so if parsing the address itself fails, we try parsing the script directly.
+        let bitcoin_newtork = into_bitcoin_network(args.network);
         let address = if let Ok(address) = BitcoinAddress::from_str(address_str) {
-            Some(address)
+            let checked_address = address
+                .require_network(bitcoin_newtork)
+                .expect("Address must be valid for network");
+            Some(checked_address)
         } else {
-            BitcoinAddress::from_script(
-                &Script::from(hex::decode(script).expect("script must be valid hex")),
-                into_bitcoin_network(args.network),
-            )
+            let bytes = hex::decode(script).expect("script must be valid hex");
+            BitcoinAddress::from_script(Script::from_bytes(&bytes), bitcoin_newtork).ok()
         };
 
         if let Some(address) = address {

bootstrap/state-builder/src/build_utxos.rs

@@ -6,8 +6,9 @@
 //!   --network testnet \
 //!   --output output-dir \
 //!   --utxos-dump-path utxos-dump.csv
-use bitcoin::{Address, Txid as BitcoinTxid};
+use bitcoin::{hashes::Hash, Address, Txid as BitcoinTxid};
 use clap::Parser;
+use ic_btc_canister::types::into_bitcoin_network;
 use ic_btc_canister::{types::TxOut, with_state, with_state_mut};
 use ic_btc_interface::{Flag, InitConfig, Network};
 use ic_btc_types::{OutPoint, Txid};
@@ -86,7 +87,13 @@ fn main() {
             let line = line.unwrap();
             let parts: Vec<_> = line.split(',').collect();
 
-            let txid = Txid::from(BitcoinTxid::from_str(parts[1]).unwrap().to_vec());
+            let txid = Txid::from(
+                BitcoinTxid::from_str(parts[1])
+                    .unwrap()
+                    .as_raw_hash()
+                    .as_byte_array()
+                    .to_vec(),
+            );
             let vout: u32 = parts[2].parse().unwrap();
             let amount: u64 = parts[3].parse().unwrap();
             let script = parts[6];
@@ -101,13 +108,18 @@ fn main() {
             // Instead of using the scripts from the database, we can infer the script from the
             // address. Otherwise, we use the script in the chainstate database as-is.
             let script = match Address::from_str(address_str) {
-                Ok(address) => address.script_pubkey().as_bytes().to_vec(),
+                Ok(address) => address
+                    .require_network(into_bitcoin_network(args.network))
+                    .unwrap()
+                    .script_pubkey()
+                    .as_bytes()
+                    .to_vec(),
                 Err(_) => hex::decode(script).unwrap(),
             };
 
             // Insert the UTXO
             let outpoint = OutPoint { txid, vout };
-            if !bitcoin::Script::from(script.clone()).is_provably_unspendable() {
+            if !bitcoin::Script::from_bytes(&script).is_provably_unspendable() {
                 let txout = TxOut {
                     value: amount,
                     script_pubkey: script,

bootstrap/state-builder/src/main_state_builder.rs

@@ -61,7 +61,7 @@ fn read_block(reader: &mut BufReader<File>) -> Block {
     let mut block = String::new();
     reader.read_line(&mut block).unwrap();
     let block = hex::decode(block.replace('\n', "")).unwrap();
-    Block::new(BitcoinBlock::consensus_decode(block.as_slice()).unwrap())
+    Block::new(BitcoinBlock::consensus_decode(&mut block.as_slice()).unwrap())
 }
 
 fn main() {

canister/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bitcoin = { workspace = true, features = ["use-serde"] }
+bitcoin = { workspace = true, features = ["serde"] }
 # An optional dependency to benchmark parts of the code.
 canbench-rs = { workspace = true, optional = true }
 candid = { workspace = true }
@@ -35,7 +35,7 @@ bench = false
 [dev-dependencies]
 assert_matches = { workspace = true }
 async-std = { version = "1.12.0", features = ["attributes"] }
-bitcoin = { workspace = true, features = ["rand"] } # needed for generating secp256k1 keys.
+bitcoin = { workspace = true }
 byteorder = { workspace = true }
 candid_parser = { workspace = true }
 ic-btc-test-utils = { workspace = true }

canister/proptest-regressions/blocktree.txt

@@ -4,4 +4,4 @@
 #
 # It is recommended to check this file in to source control so that
 # everyone who runs the test benefits from these saved cases.
-cc f9ce64e7b8f2ec6d8dd535b56e1aad46443a3e6589852a73a6b2d9778e4e9870 # shrinks to input = _SerializeDeserializeArgs { tree: BlockTree { root: Block { block: Block { header: BlockHeader { version: 1, prev_blockhash: 0000000000000000000000000000000000000000000000000000000000000000, merkle_root: 91ee09dd76d9df4a91913067f13fd47dca48420335cd64ed5ca6262bfe3ecbeb, time: 0, bits: 545259519, nonce: 2 }, txdata: [Transaction { version: 1, lock_time: 0, input: [TxIn { previous_output: OutPoint { txid: 0000000000000000000000000000000000000000000000000000000000000000, vout: 4294967295 }, script_sig: Script(), sequence: 4294967295, witness: Witness { content: [], witness_elements: 0, last: 0, second_to_last: 0 } }], output: [TxOut { value: 5000000000, script_pubkey: Script(OP_DUP OP_HASH160 OP_PUSHBYTES_20 1c06d2ab6d4557646aeda8477edc4143bb728b7f OP_EQUALVERIFY OP_CHECKSIG) }] }] }, transactions: [Transaction { tx: Transaction { version: 1, lock_time: 0, input: [TxIn { previous_output: OutPoint { txid: 0000000000000000000000000000000000000000000000000000000000000000, vout: 4294967295 }, script_sig: Script(), sequence: 4294967295, witness: Witness { content: [], witness_elements: 0, last: 0, second_to_last: 0 } }], output: [TxOut { value: 5000000000, script_pubkey: Script(OP_DUP OP_HASH160 OP_PUSHBYTES_20 1c06d2ab6d4557646aeda8477edc4143bb728b7f OP_EQUALVERIFY OP_CHECKSIG) }] }, txid: RefCell { value: None } }], block_hash: RefCell { value: None }, mock_difficulty: None }, children: [] } }
+cc f9ce64e7b8f2ec6d8dd535b56e1aad46443a3e6589852a73a6b2d9778e4e9870 # shrinks to input = _SerializeDeserializeArgs { tree: BlockTree { root: Block { block: Block { header: Header { version: 1, prev_blockhash: 0000000000000000000000000000000000000000000000000000000000000000, merkle_root: 91ee09dd76d9df4a91913067f13fd47dca48420335cd64ed5ca6262bfe3ecbeb, time: 0, bits: 545259519, nonce: 2 }, txdata: [Transaction { version: 1, lock_time: 0, input: [TxIn { previous_output: OutPoint { txid: 0000000000000000000000000000000000000000000000000000000000000000, vout: 4294967295 }, script_sig: Script(), sequence: 4294967295, witness: Witness { content: [], witness_elements: 0, last: 0, second_to_last: 0 } }], output: [TxOut { value: 5000000000, script_pubkey: Script(OP_DUP OP_HASH160 OP_PUSHBYTES_20 1c06d2ab6d4557646aeda8477edc4143bb728b7f OP_EQUALVERIFY OP_CHECKSIG) }] }] }, transactions: [Transaction { tx: Transaction { version: 1, lock_time: 0, input: [TxIn { previous_output: OutPoint { txid: 0000000000000000000000000000000000000000000000000000000000000000, vout: 4294967295 }, script_sig: Script(), sequence: 4294967295, witness: Witness { content: [], witness_elements: 0, last: 0, second_to_last: 0 } }], output: [TxOut { value: 5000000000, script_pubkey: Script(OP_DUP OP_HASH160 OP_PUSHBYTES_20 1c06d2ab6d4557646aeda8477edc4143bb728b7f OP_EQUALVERIFY OP_CHECKSIG) }] }, txid: RefCell { value: None } }], block_hash: RefCell { value: None }, mock_difficulty: None }, children: [] } }