bitcoin 0.32

coins/bitcoin/Cargo.toml

@@ -23,7 +23,7 @@ thiserror = { version = "1", default-features = false, optional = true }
 zeroize = { version = "^1.5", default-features = false }
 rand_core = { version = "0.6", default-features = false }
 
-bitcoin = { version = "0.31", default-features = false, features = ["no-std"] }
+bitcoin = { version = "0.32", default-features = false }
 
 k256 = { version = "^0.13.1", default-features = false, features = ["arithmetic", "bits"] }
 
@@ -36,7 +36,7 @@ serde_json = { version = "1", default-features = false, optional = true }
 simple-request = { path = "../../common/request", version = "0.1", default-features = false, features = ["tls", "basic-auth"], optional = true }
 
 [dev-dependencies]
-secp256k1 = { version = "0.28", default-features = false, features = ["std"] }
+secp256k1 = { version = "0.29", default-features = false, features = ["std"] }
 
 frost = { package = "modular-frost", path = "../../crypto/frost", features = ["tests"] }
 

coins/bitcoin/src/rpc.rs

@@ -195,13 +195,13 @@ impl Rpc {
         // If this was already successfully published, consider this having succeeded
         if let RpcError::RequestError(Error { code, .. }) = e {
           if code == RPC_VERIFY_ALREADY_IN_CHAIN {
-            return Ok(tx.txid());
+            return Ok(tx.compute_txid());
           }
         }
         Err(e)?
       }
     };
-    if txid != tx.txid() {
+    if txid != tx.compute_txid() {
       Err(RpcError::InvalidResponse("returned TX ID inequals calculated TX ID"))?;
     }
     Ok(txid)
@@ -215,7 +215,7 @@ impl Rpc {
     let tx: Transaction = encode::deserialize(&bytes)
       .map_err(|_| RpcError::InvalidResponse("node sent an improperly serialized transaction"))?;
 
-    let mut tx_hash = *tx.txid().as_raw_hash().as_byte_array();
+    let mut tx_hash = *tx.compute_txid().as_raw_hash().as_byte_array();
     tx_hash.reverse();
     if hash != &tx_hash {
       Err(RpcError::InvalidResponse("node replied with a different transaction"))?;

coins/bitcoin/src/tests/crypto.rs

@@ -39,7 +39,7 @@ fn test_algorithm() {
     .verify_schnorr(
       &Signature::from_slice(&sig)
         .expect("couldn't convert produced signature to secp256k1::Signature"),
-      &Message::from(Hash::hash(MESSAGE)),
+      &Message::from_digest_slice(Hash::hash(MESSAGE).as_ref()).unwrap(),
       &x_only(&keys[&Participant::new(1).unwrap()].group_key()),
     )
     .unwrap()

coins/bitcoin/src/wallet/mod.rs

@@ -4,7 +4,7 @@ use std_shims::{
   io::{self, Write},
 };
 #[cfg(feature = "std")]
-use std_shims::io::Read;
+use std::io::{Read, BufReader};
 
 use k256::{
   elliptic_curve::sec1::{Tag, ToEncodedPoint},
@@ -18,8 +18,8 @@ use frost::{
 };
 
 use bitcoin::{
-  consensus::encode::serialize, key::TweakedPublicKey, address::Payload, OutPoint, ScriptBuf,
-  TxOut, Transaction, Block,
+  consensus::encode::serialize, key::TweakedPublicKey, OutPoint, ScriptBuf, TxOut, Transaction,
+  Block,
 };
 #[cfg(feature = "std")]
 use bitcoin::consensus::encode::Decodable;
@@ -46,12 +46,12 @@ pub fn tweak_keys(keys: &ThresholdKeys<Secp256k1>) -> ThresholdKeys<Secp256k1> {
 /// Return the Taproot address payload for a public key.
 ///
 /// If the key is odd, this will return None.
-pub fn address_payload(key: ProjectivePoint) -> Option<Payload> {
+pub fn p2tr_script_buf(key: ProjectivePoint) -> Option<ScriptBuf> {
   if key.to_encoded_point(true).tag() != Tag::CompressedEvenY {
     return None;
   }
 
-  Some(Payload::p2tr_tweaked(TweakedPublicKey::dangerous_assume_tweaked(x_only(&key))))
+  Some(ScriptBuf::new_p2tr_tweaked(TweakedPublicKey::dangerous_assume_tweaked(x_only(&key))))
 }
 
 /// A spendable output.
@@ -89,11 +89,17 @@ impl ReceivedOutput {
   /// Read a ReceivedOutput from a generic satisfying Read.
   #[cfg(feature = "std")]
   pub fn read<R: Read>(r: &mut R) -> io::Result<ReceivedOutput> {
-    Ok(ReceivedOutput {
-      offset: Secp256k1::read_F(r)?,
-      output: TxOut::consensus_decode(r).map_err(|_| io::Error::other("invalid TxOut"))?,
-      outpoint: OutPoint::consensus_decode(r).map_err(|_| io::Error::other("invalid OutPoint"))?,
-    })
+    let offset = Secp256k1::read_F(r)?;
+    let output;
+    let outpoint;
+    {
+      let mut buf_r = BufReader::new(r);
+      output =
+        TxOut::consensus_decode(&mut buf_r).map_err(|_| io::Error::other("invalid TxOut"))?;
+      outpoint =
+        OutPoint::consensus_decode(&mut buf_r).map_err(|_| io::Error::other("invalid OutPoint"))?;
+    }
+    Ok(ReceivedOutput { offset, output, outpoint })
   }
 
   /// Write a ReceivedOutput to a generic satisfying Write.
@@ -124,7 +130,7 @@ impl Scanner {
   /// Returns None if this key can't be scanned for.
   pub fn new(key: ProjectivePoint) -> Option<Scanner> {
     let mut scripts = HashMap::new();
-    scripts.insert(address_payload(key)?.script_pubkey(), Scalar::ZERO);
+    scripts.insert(p2tr_script_buf(key)?, Scalar::ZERO);
     Some(Scanner { key, scripts })
   }
 
@@ -141,9 +147,8 @@ impl Scanner {
     // chance of being even
     // That means this should terminate within a very small amount of iterations
     loop {
-      match address_payload(self.key + (ProjectivePoint::GENERATOR * offset)) {
-        Some(address) => {
-          let script = address.script_pubkey();
+      match p2tr_script_buf(self.key + (ProjectivePoint::GENERATOR * offset)) {
+        Some(script) => {
           if self.scripts.contains_key(&script) {
             None?;
           }
@@ -166,7 +171,7 @@ impl Scanner {
         res.push(ReceivedOutput {
           offset: *offset,
           output: output.clone(),
-          outpoint: OutPoint::new(tx.txid(), vout),
+          outpoint: OutPoint::new(tx.compute_txid(), vout),
         });
       }
     }

coins/bitcoin/src/wallet/send.rs

@@ -23,7 +23,7 @@ use bitcoin::{
 
 use crate::{
   crypto::Schnorr,
-  wallet::{ReceivedOutput, address_payload},
+  wallet::{ReceivedOutput, p2tr_script_buf},
 };
 
 #[rustfmt::skip]
@@ -248,7 +248,7 @@ impl SignableTransaction {
 
   /// Returns the TX ID of the transaction this will create.
   pub fn txid(&self) -> [u8; 32] {
-    let mut res = self.tx.txid().to_byte_array();
+    let mut res = self.tx.compute_txid().to_byte_array();
     res.reverse();
     res
   }
@@ -288,7 +288,7 @@ impl SignableTransaction {
       transcript.append_message(b"signing_input", u32::try_from(i).unwrap().to_le_bytes());
 
       let offset = keys.clone().offset(self.offsets[i]);
-      if address_payload(offset.group_key())?.script_pubkey() != self.prevouts[i].script_pubkey {
+      if p2tr_script_buf(offset.group_key())? != self.prevouts[i].script_pubkey {
         None?;
       }