Bump bitcoin version to v0.25.0

Author: stevenroose

Cargo.toml

@@ -14,13 +14,13 @@ readme = "README.md"
 use-serde = ["serde", "bitcoin/use-serde"]
 
 [dependencies]
-bitcoin = "0.23"
+bitcoin = "0.25"
 rand = "0.7"
 rust-crypto = "0.2"
 
 serde = { version = "1", optional = true, features = ["derive"] }
 
 [dev-dependencies]
-bitcoin = { version = "0.23", features = ["use-serde", "bitcoinconsensus"] }
+bitcoin = { version = "0.25", features = ["use-serde", "bitcoinconsensus"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

src/account.rs

@@ -641,8 +641,9 @@ impl Account {
         R: Fn(&OutPoint) -> Option<TxOut>,
     {
         let mut signed = 0;
+        //TODO(stevenroose) try to prevent this clone here
         let txclone = transaction.clone();
-        let mut bip143hasher: Option<bip143::SighashComponents> = None;
+        let mut bip143hasher = bip143::SigHashCache::new(&txclone);
         for (ix, input) in transaction.input.iter_mut().enumerate() {
             if let Some(spend) = resolver(&input.previous_output) {
                 if let Some((kix, instantiated)) = self
@@ -680,14 +681,12 @@ impl Account {
                                 return Err(Error::Unsupported("can only sign all inputs for now"));
                             }
                             input.script_sig = Script::new();
-                            let hasher =
-                                bip143hasher.unwrap_or(bip143::SighashComponents::new(&txclone));
-                            let sighash = hasher.sighash_all(
-                                &txclone.input[ix],
+                            let sighash = bip143hasher.signature_hash(
+                                ix,
                                 &instantiated.script_code,
                                 spend.value,
+                                hash_type,
                             );
-                            bip143hasher = Some(hasher);
                             let signature = self.context.sign(&sighash[..], &pk)?.serialize_der();
                             let mut with_hashtype = signature.to_vec();
                             with_hashtype.push(hash_type.as_u32() as u8);
@@ -712,14 +711,12 @@ impl Account {
                                         .into_script()[..],
                                 )
                                 .into_script();
-                            let hasher =
-                                bip143hasher.unwrap_or(bip143::SighashComponents::new(&txclone));
-                            let sighash = hasher.sighash_all(
-                                &txclone.input[ix],
+                            let sighash = bip143hasher.signature_hash(
+                                ix,
                                 &instantiated.script_code,
                                 spend.value,
+                                hash_type,
                             );
-                            bip143hasher = Some(hasher);
                             let signature = self.context.sign(&sighash[..], &pk)?.serialize_der();
                             let mut with_hashtype = signature.to_vec();
                             with_hashtype.push(hash_type.as_u32() as u8);
@@ -733,14 +730,12 @@ impl Account {
                                 return Err(Error::Unsupported("can only sign all inputs for now"));
                             }
                             input.script_sig = Script::new();
-                            let hasher =
-                                bip143hasher.unwrap_or(bip143::SighashComponents::new(&txclone));
-                            let sighash = hasher.sighash_all(
-                                &txclone.input[ix],
+                            let sighash = bip143hasher.signature_hash(
+                                ix,
                                 &instantiated.script_code,
                                 spend.value,
+                                hash_type,
                             );
-                            bip143hasher = Some(hasher);
                             let signature = self.context.sign(&sighash[..], &pk)?.serialize_der();
                             let mut with_hashtype = signature.to_vec();
                             with_hashtype.push(hash_type.as_u32() as u8);
@@ -789,10 +784,15 @@ impl InstantiatedKey {
             context.tweak_exp_add(&mut public, tweak)?;
         }
         let script_code = scripter(&public, csv);
+        assert!(public.compressed);
         let address = match address_type {
             AccountAddressType::P2PKH => Address::p2pkh(&public, network),
-            AccountAddressType::P2SHWPKH => Address::p2shwpkh(&public, network),
-            AccountAddressType::P2WPKH => Address::p2wpkh(&public, network),
+            AccountAddressType::P2SHWPKH => {
+                Address::p2shwpkh(&public, network).expect("compressed pubkey")
+            }
+            AccountAddressType::P2WPKH => {
+                Address::p2wpkh(&public, network).expect("compressed pubkey")
+            }
             AccountAddressType::P2WSH(_) => Address::p2wsh(&script_code, network),
         };
         Ok(InstantiatedKey {

src/coins.rs

@@ -325,7 +325,7 @@ use bitcoin::hashes::hex::FromHex;
     use bitcoin::blockdata::script::Builder;
     use bitcoin::util::bip32::ExtendedPubKey;
     use bitcoin::{
-        network::constants::Network, Address, BitcoinHash, Block, BlockHeader, OutPoint,
+        network::constants::Network, Address, Block, BlockHeader, OutPoint,
         Transaction, TxIn, TxOut,
     };
 
@@ -406,10 +406,10 @@ use bitcoin::hashes::hex::FromHex;
             .address
             .clone();
         let genesis = genesis_block(Network::Testnet);
-        let next = mine(&genesis.bitcoin_hash(), 1, miner);
+        let next = mine(&genesis.block_hash(), 1, miner);
         coins.process(&mut master, &next);
         assert_eq!(coins.confirmed_balance(), NEW_COINS);
-        coins.unwind_tip(&next.bitcoin_hash());
+        coins.unwind_tip(&next.block_hash());
         assert_eq!(coins.confirmed_balance(), 0);
     }
 }

src/proved.rs

@@ -19,7 +19,7 @@
 //!
 
 use bitcoin::hashes::{sha256d, Hash, HashEngine};
-use bitcoin::{BitcoinHash, Block, Transaction};
+use bitcoin::{Block, Transaction};
 
 /// A confirmed transaction with its SPV proof
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -34,7 +34,7 @@ impl ProvedTransaction {
     pub fn new(block: &Block, txnr: usize) -> ProvedTransaction {
         let transaction = block.txdata[txnr].clone();
         ProvedTransaction {
-            block_hash: block.header.bitcoin_hash(),
+            block_hash: block.header.block_hash(),
             merkle_path: Self::compute_proof(txnr, block),
             transaction,
         }
@@ -136,7 +136,7 @@ mod test {
             let pt = ProvedTransaction {
                 transaction: tx.clone(),
                 merkle_path: proof,
-                block_hash: block.header.bitcoin_hash(),
+                block_hash: block.header.block_hash(),
             };
             assert_eq!(pt.merkle_root(), block.header.merkle_root);
         }