update rust-bitcoin to 0.31; fix hard errors

apoelstra · apoelstra · commit 0d392dc1547a · 2024-01-11T16:21:55.000Z
Will fix warnings and deprecations in following commits.
diff --git a/Cargo.toml b/Cargo.toml
@@ -22,9 +22,8 @@ json-contract = [ "serde_json" ]
 base64 = ["bitcoin/base64"]
 
 [dependencies]
-bech32 = { version = "0.10.0-beta" }
-bitcoin = "0.30.0"
-secp256k1-zkp = { version = "0.9.2", features = [ "global-context", "bitcoin_hashes" ] }
+bitcoin = "0.31.0"
+secp256k1-zkp = { version = "0.10.0", features = [ "global-context", "hashes" ] }
 
 # Used for ContractHash::from_json_contract.
 serde_json = { version = "1.0", optional = true }
diff --git a/elementsd-tests/Cargo.toml b/elementsd-tests/Cargo.toml
@@ -7,8 +7,8 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bitcoin = "0.30.0"
+bitcoin = "0.31.0"
 elements = {path = "../", features = ["base64"]}
-elementsd = "0.8.0"
+elementsd = "0.9.0"
 rand = "0.8"
 
diff --git a/elementsd-tests/src/taproot.rs b/elementsd-tests/src/taproot.rs
@@ -5,7 +5,7 @@ extern crate rand;
 
 use crate::{Call, setup};
 
-use bitcoin::key::{XOnlyPublicKey, KeyPair};
+use bitcoin::key::{XOnlyPublicKey, Keypair};
 use bitcoin::Amount;
 use elements::hex::FromHex;
 use elements::confidential::{AssetBlindingFactor, ValueBlindingFactor};
@@ -31,8 +31,8 @@ static PARAMS: AddressParams = AddressParams::ELEMENTS;
 fn gen_keypair(
     secp: &secp256k1_zkp::Secp256k1<secp256k1_zkp::All>,
     rng: &mut rngs::ThreadRng,
-) -> (XOnlyPublicKey, KeyPair) {
-    let keypair = KeyPair::new(secp, rng);
+) -> (XOnlyPublicKey, Keypair) {
+    let keypair = Keypair::new(secp, rng);
     let (pk, _) = XOnlyPublicKey::from_keypair(&keypair);
     (pk, keypair)
 }
@@ -42,10 +42,10 @@ fn gen_keypair(
 struct TapTxOutData {
     _blind_sk: Option<secp256k1_zkp::SecretKey>,
     _blind_pk: Option<secp256k1_zkp::PublicKey>,
-    leaf1_keypair: KeyPair,
+    leaf1_keypair: Keypair,
     _leaf1_pk: XOnlyPublicKey,
     leaf1_script: Script,
-    internal_keypair: KeyPair,
+    internal_keypair: Keypair,
     internal_pk: XOnlyPublicKey,
     spend_info: TaprootSpendInfo,
     utxo: TxOut,
diff --git a/src/address.rs b/src/address.rs
@@ -33,7 +33,7 @@ use secp256k1_zkp::Verification;
 use serde;
 
 use crate::schnorr::{TapTweak, TweakedPublicKey, UntweakedPublicKey};
-use crate::taproot::TapBranchHash;
+use crate::taproot::TapNodeHash;
 
 use crate::{PubkeyHash, ScriptHash, WPubkeyHash, WScriptHash};
 use crate::{opcodes, script};
@@ -316,7 +316,7 @@ impl Address {
     pub fn p2tr<C: Verification>(
         secp: &Secp256k1<C>,
         internal_key: UntweakedPublicKey,
-        merkle_root: Option<TapBranchHash>,
+        merkle_root: Option<TapNodeHash>,
         blinder: Option<secp256k1_zkp::PublicKey>,
         params: &'static AddressParams,
     ) -> Address {
diff --git a/src/blind.rs b/src/blind.rs
@@ -794,7 +794,7 @@ pub enum UnblindError {
     /// Transaction output does not have a rangeproof.
     MissingRangeproof,
     /// Malformed asset ID.
-    MalformedAssetId(hashes::Error),
+    MalformedAssetId(hashes::FromSliceError),
     /// Error originated in `secp256k1_zkp`.
     Upstream(secp256k1_zkp::Error),
 }
@@ -829,8 +829,8 @@ impl From<secp256k1_zkp::Error> for UnblindError {
     }
 }
 
-impl From<hashes::Error> for UnblindError {
-    fn from(from: hashes::Error) -> Self {
+impl From<hashes::FromSliceError> for UnblindError {
+    fn from(from: hashes::FromSliceError) -> Self {
         UnblindError::MalformedAssetId(from)
     }
 }
diff --git a/src/issuance.rs b/src/issuance.rs
@@ -86,7 +86,7 @@ impl AssetId {
     }
 
     /// Copies a byte slice into an AssetId object
-    pub fn from_slice(sl: &[u8]) -> Result<AssetId, hashes::Error> {
+    pub fn from_slice(sl: &[u8]) -> Result<AssetId, hashes::FromSliceError> {
         sha256::Midstate::from_slice(sl).map(AssetId)
     }
 
@@ -167,7 +167,7 @@ impl ::std::fmt::LowerHex for AssetId {
 }
 
 impl FromStr for AssetId {
-    type Err = crate::hashes::hex::Error;
+    type Err = crate::hashes::hex::HexToArrayError;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         sha256::Midstate::from_str(s).map(AssetId)
     }
diff --git a/src/lib.rs b/src/lib.rs
@@ -65,8 +65,7 @@ mod serde_utils;
 // consider making upstream public
 mod endian;
 // re-export bitcoin deps which we re-use
-//pub use bitcoin::bech32;
-pub extern crate bech32; // FIXME remove this in later commit
+pub use bitcoin::bech32;
 pub use bitcoin::hashes;
 // export everything at the top level so it can be used as `elements::Transaction` etc.
 pub use crate::address::{Address, AddressParams, AddressError};
diff --git a/src/pset/error.rs b/src/pset/error.rs
@@ -67,7 +67,7 @@ pub enum Error {
     /// Unable to parse as a standard Sighash type.
     NonStandardSighashType(u32),
     /// Parsing errors from bitcoin_hashes
-    HashParseError(hashes::Error),
+    HashParseError(hashes::FromSliceError),
     /// The pre-image must hash to the correponding pset hash
     InvalidPreimageHashPair {
         /// Hash-type
@@ -214,8 +214,8 @@ impl fmt::Display for Error {
 impl error::Error for Error {}
 
 #[doc(hidden)]
-impl From<hashes::Error> for Error {
-    fn from(e: hashes::Error) -> Error {
+impl From<hashes::FromSliceError> for Error {
+    fn from(e: hashes::FromSliceError) -> Error {
         Error::HashParseError(e)
     }
 }
diff --git a/src/pset/map/global.rs b/src/pset/map/global.rs
@@ -25,7 +25,7 @@ use crate::encode::Decodable;
 use crate::endian::u32_to_array_le;
 use crate::pset::{self, map::Map, raw, Error};
 use crate::{LockTime, VarInt};
-use bitcoin::bip32::{ChildNumber, DerivationPath, ExtendedPubKey, Fingerprint, KeySource};
+use bitcoin::bip32::{ChildNumber, DerivationPath, Xpub, Fingerprint, KeySource};
 use secp256k1_zkp::Tweak;
 
 // (Not used in pset) Type: Unsigned Transaction PSET_GLOBAL_UNSIGNED_TX = 0x00
@@ -102,7 +102,7 @@ pub struct Global {
     pub version: u32,
     /// A global map from extended public keys to the used key fingerprint and
     /// derivation path as defined by BIP 32
-    pub xpub: BTreeMap<ExtendedPubKey, KeySource>,
+    pub xpub: BTreeMap<Xpub, KeySource>,
     // Global proprietary key-value pairs.
     /// Scalars used for blinding
     pub scalars: Vec<Tweak>,
@@ -369,7 +369,7 @@ impl Decodable for Global {
     fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
         let mut version: Option<u32> = None;
         let mut unknowns: BTreeMap<raw::Key, Vec<u8>> = Default::default();
-        let mut xpub_map: BTreeMap<ExtendedPubKey, (Fingerprint, DerivationPath)> =
+        let mut xpub_map: BTreeMap<Xpub, (Fingerprint, DerivationPath)> =
             Default::default();
         let mut proprietary = BTreeMap::new();
         let mut scalars = Vec::new();
@@ -416,9 +416,9 @@ impl Decodable for Global {
                         }
                         PSET_GLOBAL_XPUB => {
                             if !raw_key.key.is_empty() {
-                                let xpub = ExtendedPubKey::decode(&raw_key.key)
+                                let xpub = Xpub::decode(&raw_key.key)
                                     .map_err(|_| encode::Error::ParseFailed(
-                                        "Can't deserialize ExtendedPublicKey from global XPUB key data"
+                                        "Can't deserialize Xpub from global XPUB key data"
                                     ))?;
 
                                 if raw_value.is_empty() || raw_value.len() % 4 != 0 {
diff --git a/src/pset/map/input.rs b/src/pset/map/input.rs
@@ -20,7 +20,7 @@ use std::{
     str::FromStr,
 };
 
-use crate::taproot::{ControlBlock, LeafVersion, TapBranchHash, TapLeafHash};
+use crate::taproot::{ControlBlock, LeafVersion, TapNodeHash, TapLeafHash};
 use crate::{schnorr, AssetId, ContractHash};
 
 use crate::{confidential, locktime};
@@ -234,7 +234,7 @@ pub struct Input {
     /// Taproot Internal key
     pub tap_internal_key: Option<XOnlyPublicKey>,
     /// Taproot Merkle root
-    pub tap_merkle_root: Option<TapBranchHash>,
+    pub tap_merkle_root: Option<TapNodeHash>,
     // Proprietary key-value pairs for this input.
     /// The issuance value
     pub issuance_value_amount: Option<u64>,
@@ -646,7 +646,7 @@ impl Map for Input {
             }
             PSBT_IN_TAP_MERKLE_ROOT => {
                 impl_pset_insert_pair! {
-                    self.tap_merkle_root <= <raw_key: _>|< raw_value: TapBranchHash>
+                    self.tap_merkle_root <= <raw_key: _>|< raw_value: TapNodeHash>
                 }
             }
             PSET_IN_PROPRIETARY => {
diff --git a/src/pset/serialize.rs b/src/pset/serialize.rs
@@ -32,7 +32,7 @@ use secp256k1_zkp::{self, RangeProof, SurjectionProof, Tweak};
 
 use super::map::{PsbtSighashType, TapTree};
 use crate::schnorr;
-use crate::taproot::{ControlBlock, LeafVersion, TapBranchHash, TapLeafHash};
+use crate::taproot::{ControlBlock, LeafVersion, TapNodeHash, TapLeafHash};
 
 use crate::sighash::SchnorrSighashType;
 use crate::taproot::TaprootBuilder;
@@ -75,7 +75,7 @@ impl_pset_hash_de_serialize!(hash160::Hash);
 impl_pset_hash_de_serialize!(sha256d::Hash);
 impl_pset_hash_de_serialize!(BlockHash);
 impl_pset_hash_de_serialize!(TapLeafHash);
-impl_pset_hash_de_serialize!(TapBranchHash);
+impl_pset_hash_de_serialize!(TapNodeHash);
 
 // required for pegin bitcoin::Transactions
 impl_pset_de_serialize!(bitcoin::Transaction);
diff --git a/src/schnorr.rs b/src/schnorr.rs
@@ -19,10 +19,10 @@
 
 use std::fmt;
 
-use crate::taproot::{TapBranchHash, TapTweakHash};
+use crate::taproot::{TapNodeHash, TapTweakHash};
 use crate::SchnorrSighashType;
 use secp256k1_zkp::{self, constants::SCHNORR_SIGNATURE_SIZE, Secp256k1, Verification};
-pub use secp256k1_zkp::{KeyPair, XOnlyPublicKey};
+pub use secp256k1_zkp::{Keypair, XOnlyPublicKey};
 
 /// Untweaked Schnorr public key
 pub type UntweakedPublicKey = XOnlyPublicKey;
@@ -32,11 +32,11 @@ pub type UntweakedPublicKey = XOnlyPublicKey;
 pub struct TweakedPublicKey(XOnlyPublicKey);
 
 /// Untweaked Schnorr key pair
-pub type UntweakedKeyPair = KeyPair;
+pub type UntweakedKeypair = Keypair;
 
 /// Tweaked Schnorr key pair
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-pub struct TweakedKeyPair(KeyPair);
+pub struct TweakedKeypair(Keypair);
 
 /// A trait for tweaking Schnorr key types (x-only public keys and key pairs).
 pub trait TapTweak {
@@ -46,7 +46,7 @@ pub trait TapTweak {
     type TweakedKey;
 
     /// Tweaks an untweaked key with corresponding public key value and optional script tree merkle
-    /// root. For the [`KeyPair`] type this also tweaks the private key in the pair.
+    /// root. For the [`Keypair`] type this also tweaks the private key in the pair.
     ///
     /// This is done by using the equation Q = P + H(P|c)G, where
     ///  * Q is the tweaked public key
@@ -60,7 +60,7 @@ pub trait TapTweak {
     fn tap_tweak<C: Verification>(
         self,
         secp: &Secp256k1<C>,
-        merkle_root: Option<TapBranchHash>,
+        merkle_root: Option<TapNodeHash>,
     ) -> Self::TweakedAux;
 
     /// Directly converts to a `TweakedKey`
@@ -89,7 +89,7 @@ impl TapTweak for UntweakedPublicKey {
     fn tap_tweak<C: Verification>(
         self,
         secp: &Secp256k1<C>,
-        merkle_root: Option<TapBranchHash>,
+        merkle_root: Option<TapNodeHash>,
     ) -> (TweakedPublicKey, secp256k1_zkp::Parity) {
         let tweak = TapTweakHash::from_key_and_tweak(self, merkle_root).to_scalar();
         let (output_key, parity) = self.add_tweak(secp, &tweak).expect("Tap tweak failed");
@@ -104,11 +104,11 @@ impl TapTweak for UntweakedPublicKey {
     }
 }
 
-impl TapTweak for UntweakedKeyPair {
-    type TweakedAux = TweakedKeyPair;
-    type TweakedKey = TweakedKeyPair;
+impl TapTweak for UntweakedKeypair {
+    type TweakedAux = TweakedKeypair;
+    type TweakedKey = TweakedKeypair;
 
-    /// Tweaks private and public keys within an untweaked [`KeyPair`] with corresponding public key
+    /// Tweaks private and public keys within an untweaked [`Keypair`] with corresponding public key
     /// value and optional script tree merkle root.
     ///
     /// This is done by tweaking private key within the pair using the equation q = p + H(P|c), where
@@ -120,22 +120,22 @@ impl TapTweak for UntweakedKeyPair {
     ///
     /// # Returns
     /// The tweaked key and its parity.
-    fn tap_tweak<C: Verification>(self, secp: &Secp256k1<C>, merkle_root: Option<TapBranchHash>) -> TweakedKeyPair {
+    fn tap_tweak<C: Verification>(self, secp: &Secp256k1<C>, merkle_root: Option<TapNodeHash>) -> TweakedKeypair {
         let (pubkey, _parity) = XOnlyPublicKey::from_keypair(&self);
         let tweak = TapTweakHash::from_key_and_tweak(pubkey, merkle_root).to_scalar();
         let tweaked = self.add_xonly_tweak(secp, &tweak).expect("Tap tweak failed");
-        TweakedKeyPair(tweaked)
+        TweakedKeypair(tweaked)
     }
 
-    fn dangerous_assume_tweaked(self) -> TweakedKeyPair {
-        TweakedKeyPair(self)
+    fn dangerous_assume_tweaked(self) -> TweakedKeypair {
+        TweakedKeypair(self)
     }
 }
 
 impl TweakedPublicKey {
     /// Returns the [`TweakedPublicKey`] for `keypair`.
     #[inline]
-    pub fn from_keypair(keypair: TweakedKeyPair) -> Self {
+    pub fn from_keypair(keypair: TweakedKeypair) -> Self {
         let (xonly, _parity) = keypair.0.x_only_public_key();
         TweakedPublicKey(xonly)
     }
@@ -156,24 +156,24 @@ impl TweakedPublicKey {
     }
 }
 
-impl TweakedKeyPair {
-    /// Creates a new [`TweakedKeyPair`] from a [`KeyPair`]. No tweak is applied, consider
-    /// calling `tap_tweak` on an [`UntweakedKeyPair`] instead of using this constructor.
+impl TweakedKeypair {
+    /// Creates a new [`TweakedKeypair`] from a [`Keypair`]. No tweak is applied, consider
+    /// calling `tap_tweak` on an [`UntweakedKeypair`] instead of using this constructor.
     ///
     /// This method is dangerous and can lead to loss of funds if used incorrectly.
     /// Specifically, in multi-party protocols a peer can provide a value that allows them to steal.
     #[inline]
-    pub fn dangerous_assume_tweaked(pair: KeyPair) -> TweakedKeyPair {
-        TweakedKeyPair(pair)
+    pub fn dangerous_assume_tweaked(pair: Keypair) -> TweakedKeypair {
+        TweakedKeypair(pair)
     }
 
     /// Returns the underlying key pair.
     #[inline]
-    pub fn to_inner(self) -> KeyPair {
+    pub fn to_inner(self) -> Keypair {
         self.0
     }
 
-    /// Returns the [`TweakedPublicKey`] and its [`secp256k1_zkp::Parity`] for this [`TweakedKeyPair`].
+    /// Returns the [`TweakedPublicKey`] and its [`secp256k1_zkp::Parity`] for this [`TweakedKeypair`].
     #[inline]
     pub fn public_parts(&self) -> (TweakedPublicKey, secp256k1_zkp::Parity) {
         let (xonly, parity) = self.0.x_only_public_key();
@@ -188,16 +188,16 @@ impl From<TweakedPublicKey> for XOnlyPublicKey {
     }
 }
 
-impl From<TweakedKeyPair> for KeyPair {
+impl From<TweakedKeypair> for Keypair {
     #[inline]
-    fn from(pair: TweakedKeyPair) -> Self {
+    fn from(pair: TweakedKeypair) -> Self {
         pair.0
     }
 }
 
-impl From<TweakedKeyPair> for TweakedPublicKey {
+impl From<TweakedKeypair> for TweakedPublicKey {
     #[inline]
-    fn from(pair: TweakedKeyPair) -> Self {
+    fn from(pair: TweakedKeypair) -> Self {
         TweakedPublicKey::from_keypair(pair)
     }
 }
diff --git a/src/script.rs b/src/script.rs
@@ -37,7 +37,7 @@ use crate::{hex, opcodes, ScriptHash, WScriptHash, PubkeyHash, WPubkeyHash};
 use bitcoin::PublicKey;
 
 use crate::schnorr::{UntweakedPublicKey, TweakedPublicKey, TapTweak};
-use crate::taproot::TapBranchHash;
+use crate::taproot::TapNodeHash;
 
 const MAX_SCRIPT_SIZE : usize = 10_000;
 
@@ -271,7 +271,7 @@ impl Script {
 
     /// Generates P2TR for script spending path using an internal public key and some optional
     /// script tree merkle root.
-    pub fn new_v1_p2tr<C: Verification>(secp: &Secp256k1<C>, internal_key: UntweakedPublicKey, merkle_root: Option<TapBranchHash>) -> Script {
+    pub fn new_v1_p2tr<C: Verification>(secp: &Secp256k1<C>, internal_key: UntweakedPublicKey, merkle_root: Option<TapNodeHash>) -> Script {
         let (output_key, _) = internal_key.tap_tweak(secp, merkle_root);
         Script::new_witness_program(crate::bech32::Fe32::P, &output_key.as_inner().serialize())
     }
diff --git a/src/taproot.rs b/src/taproot.rs

Original file line number	Diff line number	Diff line change
`@@ -794,7 +794,7 @@ pub enum UnblindError {`
`794`	`794`	`/// Transaction output does not have a rangeproof.`
`795`	`795`	`MissingRangeproof,`
`796`	`796`	`/// Malformed asset ID.`
`797`		`- MalformedAssetId(hashes::Error),`
	`797`	`+ MalformedAssetId(hashes::FromSliceError),`
`798`	`798`	/// Error originated in `secp256k1_zkp`.
`799`	`799`	`Upstream(secp256k1_zkp::Error),`
`800`	`800`	`}`
`@@ -829,8 +829,8 @@ impl From<secp256k1_zkp::Error> for UnblindError {`
`829`	`829`	`}`
`830`	`830`	`}`
`831`	`831`
`832`		`-impl From<hashes::Error> for UnblindError {`
`833`		`- fn from(from: hashes::Error) -> Self {`
	`832`	`+impl From<hashes::FromSliceError> for UnblindError {`
	`833`	`+ fn from(from: hashes::FromSliceError) -> Self {`
`834`	`834`	`UnblindError::MalformedAssetId(from)`
`835`	`835`	`}`
`836`	`836`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ impl AssetId {`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`/// Copies a byte slice into an AssetId object`
`89`		`- pub fn from_slice(sl: &[u8]) -> Result<AssetId, hashes::Error> {`
	`89`	`+ pub fn from_slice(sl: &[u8]) -> Result<AssetId, hashes::FromSliceError> {`
`90`	`90`	`sha256::Midstate::from_slice(sl).map(AssetId)`
`91`	`91`	`}`
`92`	`92`
`@@ -167,7 +167,7 @@ impl ::std::fmt::LowerHex for AssetId {`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`impl FromStr for AssetId {`
`170`		`- type Err = crate::hashes::hex::Error;`
	`170`	`+ type Err = crate::hashes::hex::HexToArrayError;`
`171`	`171`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`172`	`172`	`sha256::Midstate::from_str(s).map(AssetId)`
`173`	`173`	`}`