upgrade to bitcoin 0.32

Author: RCasatta

Cargo.toml

@@ -22,8 +22,9 @@ json-contract = [ "serde_json" ]
 base64 = ["bitcoin/base64"]
 
 [dependencies]
-bitcoin = "0.31.0"
-secp256k1-zkp = { version = "0.10.0", features = [ "global-context", "hashes" ] }
+bech32 = "0.11.0"
+bitcoin = "0.32.2"
+secp256k1-zkp = { version = "0.11.0", features = [ "global-context", "hashes" ] }
 
 # Used for ContractHash::from_json_contract.
 serde_json = { version = "1.0", optional = true }

src/address.rs

@@ -21,11 +21,11 @@ use std::fmt;
 use std::fmt::Write as _;
 use std::str::FromStr;
 
-use bitcoin::base58;
-use bitcoin::PublicKey;
-use crate::bech32::{Bech32, Bech32m, ByteIterExt, Fe32, Hrp, Fe32IterExt};
+use crate::bech32::{Bech32, Bech32m, ByteIterExt, Fe32, Fe32IterExt, Hrp};
 use crate::blech32::{Blech32, Blech32m};
 use crate::hashes::Hash;
+use bitcoin::base58;
+use bitcoin::PublicKey;
 use secp256k1_zkp;
 use secp256k1_zkp::Secp256k1;
 use secp256k1_zkp::Verification;
@@ -35,8 +35,8 @@ use serde;
 use crate::schnorr::{TapTweak, TweakedPublicKey, UntweakedPublicKey};
 use crate::taproot::TapNodeHash;
 
-use crate::{PubkeyHash, ScriptHash, WPubkeyHash, WScriptHash};
 use crate::{opcodes, script};
+use crate::{PubkeyHash, ScriptHash, WPubkeyHash, WScriptHash};
 
 /// Encoding error
 #[derive(Debug, PartialEq)]
@@ -62,6 +62,8 @@ pub enum AddressError {
 
     /// An invalid blinding pubkey was encountered.
     InvalidBlindingPubKey(secp256k1_zkp::UpstreamError),
+
+    TodoInvalid,
 }
 
 impl From<crate::bech32::primitives::decode::SegwitHrpstringError> for AddressError {
@@ -89,10 +91,18 @@ impl fmt::Display for AddressError {
                 write!(f, "invalid witness script version: {}", wver)
             }
             AddressError::InvalidWitnessProgramLength(ref len) => {
-                write!(f, "the witness program must be between 2 and 40 bytes in length, not {}", len)
+                write!(
+                    f,
+                    "the witness program must be between 2 and 40 bytes in length, not {}",
+                    len
+                )
             }
             AddressError::InvalidSegwitV0ProgramLength(ref len) => {
-                write!(f, "a v0 witness program must be length 20 or 32, not {}", len)
+                write!(
+                    f,
+                    "a v0 witness program must be length 20 or 32, not {}",
+                    len
+                )
             }
             AddressError::InvalidBlindingPubKey(ref e) => {
                 write!(f, "an invalid blinding pubkey was encountered: {}", e)
@@ -103,6 +113,7 @@ impl fmt::Display for AddressError {
             AddressError::InvalidSegwitV0Encoding => {
                 write!(f, "v0 witness program must use b(l)ech32 not b(l)ech32m")
             }
+            AddressError::TodoInvalid => todo!(),
         }
     }
 }
@@ -212,7 +223,8 @@ impl Address {
         params: &'static AddressParams,
     ) -> Address {
         let mut hash_engine = PubkeyHash::engine();
-        pk.write_into(&mut hash_engine).expect("engines don't error");
+        pk.write_into(&mut hash_engine)
+            .expect("engines don't error");
 
         Address {
             params,
@@ -244,7 +256,8 @@ impl Address {
         params: &'static AddressParams,
     ) -> Address {
         let mut hash_engine = WPubkeyHash::engine();
-        pk.write_into(&mut hash_engine).expect("engines don't error");
+        pk.write_into(&mut hash_engine)
+            .expect("engines don't error");
 
         Address {
             params,
@@ -264,7 +277,8 @@ impl Address {
         params: &'static AddressParams,
     ) -> Address {
         let mut hash_engine = ScriptHash::engine();
-        pk.write_into(&mut hash_engine).expect("engines don't error");
+        pk.write_into(&mut hash_engine)
+            .expect("engines don't error");
 
         let builder = script::Builder::new()
             .push_int(0)
@@ -401,7 +415,9 @@ impl Address {
             Payload::WitnessProgram {
                 version: witver,
                 program: ref witprog,
-            } => script::Builder::new().push_int(witver.to_u8() as i64).push_slice(witprog),
+            } => script::Builder::new()
+                .push_int(witver.to_u8() as i64)
+                .push_slice(witprog),
         }
         .into_script()
     }
@@ -450,10 +466,7 @@ impl Address {
 
         Ok(Address {
             params,
-            payload: Payload::WitnessProgram {
-                version,
-                program,
-            },
+            payload: Payload::WitnessProgram { version, program },
             blinding_pubkey,
         })
     }
@@ -468,13 +481,15 @@ impl Address {
         let (blinded, prefix) = match data[0] == params.blinded_prefix {
             true => {
                 if data.len() != 55 {
-                    return Err(base58::Error::InvalidLength(data.len()).into());
+                    // return Err(base58::Error::InvalidLength(data.len()).into());
+                    return Err(AddressError::TodoInvalid);
                 }
                 (true, data[1])
             }
             false => {
                 if data.len() != 21 {
-                    return Err(base58::Error::InvalidLength(data.len()).into());
+                    // return Err(base58::Error::InvalidLength(data.len()).into());
+                    return Err(AddressError::TodoInvalid);
                 }
                 (false, data[0])
             }
@@ -496,7 +511,8 @@ impl Address {
         } else if prefix == params.p2sh_prefix {
             Payload::ScriptHash(ScriptHash::from_slice(payload_data).unwrap())
         } else {
-            return Err(base58::Error::InvalidAddressVersion(prefix).into());
+            // return Err(base58::Error::InvalidAddressVersion(prefix).into());
+            return Err(AddressError::TodoInvalid);
         };
 
         Ok(Address {
@@ -522,7 +538,8 @@ impl Address {
 
         // Base58.
         if s.len() > 150 {
-            return Err(base58::Error::InvalidLength(s.len() * 11 / 15).into());
+            // return Err(base58::Error::InvalidLength(s.len() * 11 / 15).into());
+            return Err(AddressError::TodoInvalid);
         }
         let data = base58::decode_check(s)?;
         Address::from_base58(&data, params)
@@ -574,14 +591,23 @@ impl fmt::Display for Address {
                 // FIXME: surely we can fix this logic to not be so repetitive.
                 if self.is_blinded() {
                     if let Some(ref blinder) = self.blinding_pubkey {
-                        let byte_iter = IntoIterator::into_iter(blinder.serialize()).chain(witprog.iter().copied());
+                        let byte_iter = IntoIterator::into_iter(blinder.serialize())
+                            .chain(witprog.iter().copied());
                         let fe_iter = byte_iter.bytes_to_fes();
                         if witver.to_u8() == 0 {
-                            for c in fe_iter.with_checksum::<Blech32>(&hrp).with_witness_version(witver).chars() {
+                            for c in fe_iter
+                                .with_checksum::<Blech32>(&hrp)
+                                .with_witness_version(witver)
+                                .chars()
+                            {
                                 fmt.write_char(c)?;
                             }
                         } else {
-                            for c in fe_iter.with_checksum::<Blech32m>(&hrp).with_witness_version(witver).chars() {
+                            for c in fe_iter
+                                .with_checksum::<Blech32m>(&hrp)
+                                .with_witness_version(witver)
+                                .chars()
+                            {
                                 fmt.write_char(c)?;
                             }
                         }
@@ -592,11 +618,19 @@ impl fmt::Display for Address {
                 let byte_iter = witprog.iter().copied();
                 let fe_iter = byte_iter.bytes_to_fes();
                 if witver.to_u8() == 0 {
-                    for c in fe_iter.with_checksum::<Bech32>(&hrp).with_witness_version(witver).chars() {
+                    for c in fe_iter
+                        .with_checksum::<Bech32>(&hrp)
+                        .with_witness_version(witver)
+                        .chars()
+                    {
                         fmt.write_char(c)?;
                     }
                 } else {
-                    for c in fe_iter.with_checksum::<Bech32m>(&hrp).with_witness_version(witver).chars() {
+                    for c in fe_iter
+                        .with_checksum::<Bech32m>(&hrp)
+                        .with_witness_version(witver)
+                        .chars()
+                    {
                         fmt.write_char(c)?;
                     }
                 }
@@ -660,11 +694,13 @@ impl FromStr for Address {
 
         // Base58.
         if s.len() > 150 {
-            return Err(base58::Error::InvalidLength(s.len() * 11 / 15).into());
+            // return Err(base58::Error::InvalidLength(s.len() * 11 / 15).into());
+            return Err(AddressError::TodoInvalid);
         }
         let data = base58::decode_check(s)?;
         if data.is_empty() {
-            return Err(base58::Error::InvalidLength(data.len()).into());
+            // return Err(base58::Error::InvalidLength(data.len()).into());
+            return Err(AddressError::TodoInvalid);
         }
 
         let p = data[0];
@@ -734,9 +770,9 @@ impl serde::Serialize for Address {
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::Script;
     use bitcoin::key;
     use secp256k1_zkp::{PublicKey, Secp256k1};
-    use crate::Script;
     #[cfg(feature = "serde")]
     use serde_json;
 
@@ -755,7 +791,9 @@ mod test {
         );
         #[cfg(feature = "serde")]
         assert_eq!(
-            serde_json::from_value::<Address>(serde_json::to_value(addr).unwrap()).ok().as_ref(),
+            serde_json::from_value::<Address>(serde_json::to_value(addr).unwrap())
+                .ok()
+                .as_ref(),
             Some(addr)
         );
     }
@@ -831,7 +869,12 @@ mod test {
 
         for &(a, blinded, ref params) in &addresses {
             let result = a.parse();
-            assert!(result.is_ok(), "vector: {}, err: \"{}\"", a, result.unwrap_err());
+            assert!(
+                result.is_ok(),
+                "vector: {}, err: \"{}\"",
+                a,
+                result.unwrap_err()
+            );
             let addr: Address = result.unwrap();
             assert_eq!(a, &addr.to_string(), "vector: {}", a);
             assert_eq!(blinded, addr.is_blinded());
@@ -858,7 +901,8 @@ mod test {
             "blech32 error: invalid checksum", // is valid blech32m, but should be blech32
         );
 
-        let address: Result<Address, _> = "ert130xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqqu2tys".parse();
+        let address: Result<Address, _> =
+            "ert130xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqqu2tys".parse();
         assert_eq!(
             address.err().unwrap().to_string(),
             "bech32 error: invalid segwit witness version: 3", // FIXME https://github.com/rust-bitcoin/rust-bech32/issues/162 should be 17
@@ -879,14 +923,18 @@ mod test {
         );
     }
 
-
     #[test]
     fn test_fixed_addresses() {
-        let pk = bitcoin::PublicKey::from_str("0212bf0ea45b733dfde8ecb5e896306c4165c666c99fc5d1ab887f71393a975cea")
-            .unwrap();
+        let pk = bitcoin::PublicKey::from_str(
+            "0212bf0ea45b733dfde8ecb5e896306c4165c666c99fc5d1ab887f71393a975cea",
+        )
+        .unwrap();
         let script = Script::default();
         let secp = Secp256k1::verification_only();
-        let internal_key = UntweakedPublicKey::from_str("93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51").unwrap();
+        let internal_key = UntweakedPublicKey::from_str(
+            "93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51",
+        )
+        .unwrap();
         let tap_node_hash = TapNodeHash::all_zeros();
 
         let mut expected = IntoIterator::into_iter([
@@ -934,9 +982,12 @@ mod test {
             "tlq1pqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww5vx8c8vs0ywzejta7jjcc5f4asnacdtu0wlaas0upmsq90enaz2lekytucqf82vs",
         ]);
 
-        for params in [&AddressParams::ELEMENTS, &AddressParams::LIQUID, &AddressParams::LIQUID_TESTNET] {
+        for params in [
+            &AddressParams::ELEMENTS,
+            &AddressParams::LIQUID,
+            &AddressParams::LIQUID_TESTNET,
+        ] {
             for blinder in [None, Some(pk.inner)] {
-
                 let addr = Address::p2pkh(&pk, blinder, params);
                 assert_eq!(&addr.to_string(), expected.next().unwrap());
 
@@ -959,6 +1010,5 @@ mod test {
                 assert_eq!(&addr.to_string(), expected.next().unwrap());
             }
         }
-
     }
 }

src/blech32/decode.rs

@@ -150,7 +150,7 @@ impl<'s> UncheckedHrpstring<'s> {
         }
 
         let mut checksum_eng = checksum::Engine::<Ck>::new();
-        checksum_eng.input_hrp(&self.hrp());
+        checksum_eng.input_hrp(self.hrp());
 
         // Unwrap ok since we checked all characters in our constructor.
         for fe in self.data.iter().map(|&b| Fe32::from_char(b.into()).unwrap()) {

src/blech32/mod.rs

@@ -37,6 +37,8 @@ impl crate::bech32::Checksum for Blech32 {
         0x7093e5a608865b,
     ];
     const TARGET_RESIDUE: u64 = 1;
+
+    const CODE_LENGTH: usize = 9999; // TODO
 }
 
 /// The blech32m checksum algorithm.
@@ -54,5 +56,6 @@ impl crate::bech32::Checksum for Blech32m {
         0x7093e5a608865b,
     ];
     const TARGET_RESIDUE: u64 = 0x455972a3350f7a1;
-}
 
+    const CODE_LENGTH: usize = 9999; // TODO
+}

src/blind.rs

@@ -26,11 +26,11 @@ use secp256k1_zkp::{Generator, RangeProof, Secp256k1, Signing, SurjectionProof};
 
 use crate::{AddressParams, Script, TxIn};
 
+use crate::hashes;
 use crate::{
     confidential::{Asset, AssetBlindingFactor, Nonce, Value, ValueBlindingFactor},
     Address, AssetId, Transaction, TxOut, TxOutWitness,
 };
-use crate::hashes;
 
 /// Transaction Output related errors
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -229,7 +229,11 @@ impl RangeProofMessage {
 }
 
 /// Information about Transaction Input Asset
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(
+    feature = "serde",
+    derive(Serialize, Deserialize),
+    serde(crate = "actual_serde")
+)]
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct TxOutSecrets {
     /// Asset
@@ -1462,7 +1466,7 @@ mod tests {
                 SECP256K1,
                 &PrivateKey {
                     compressed: true,
-                    network: Network::Regtest,
+                    network: bitcoin::NetworkKind::Test,
                     inner: sk,
                 },
             );
@@ -1471,7 +1475,7 @@ mod tests {
                 SECP256K1,
                 &PrivateKey {
                     compressed: true,
-                    network: Network::Regtest,
+                    network: bitcoin::NetworkKind::Test,
                     inner: blinding_sk,
                 },
             );