Merge pull request #32 from jamesdorfman/rust-bitcoin-0.29.2

update rust-bitcoin to v0.29.2

Author: stevenroose

Cargo.lock

@@ -31,11 +31,11 @@ serde_json = "1.0.34"
 serde_yaml = "0.8.8"
 hex = "0.3.2"
 
-bitcoin = { version = "0.27.0", features = [ "use-serde" ] }
-secp256k1 = { version = "0.20.3", features = [ "recovery" ] }
+bitcoin = { version = "0.29.2", features = [ "serde" ] }
+secp256k1 = { version = "0.24.3", features = [ "recovery" ] }
 bip39 = { version = "1.0.1", features = [ "all-languages" ] }
 lightning-invoice = "0.4.0"
-miniscript = { version = "6.0.1", features = ["compiler"] }
+miniscript = { version = "9.0.0", features = ["compiler"] }
 
 # For external commands
 jobserver = "0.1.11"

Cargo.toml

@@ -1,4 +1,4 @@
-use bitcoin::{Address, Network, PublicKey, Script, PubkeyHash, ScriptHash, WPubkeyHash, WScriptHash};
+use bitcoin::{self, Address, Network, Script, PubkeyHash, ScriptHash, WPubkeyHash, WScriptHash};
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
@@ -36,7 +36,7 @@ pub struct Addresses {
 }
 
 impl Addresses {
-	pub fn from_pubkey(pubkey: &PublicKey, network: Network) -> Addresses {
+	pub fn from_pubkey(pubkey: &bitcoin::PublicKey, network: Network) -> Addresses {
 		Addresses {
 			p2pkh: Some(Address::p2pkh(pubkey, network)),
 			p2wpkh: Address::p2wpkh(pubkey, network).ok(),
@@ -47,7 +47,7 @@ impl Addresses {
 
 	pub fn from_script(script: &Script, network: Network) -> Addresses {
 		Addresses {
-			p2sh: Some(Address::p2sh(&script, network)),
+			p2sh: Address::p2sh(&script, network).ok(),
 			p2wsh: Some(Address::p2wsh(&script, network)),
 			p2shwsh: Some(Address::p2shwsh(&script, network)),
 			..Default::default()

src/address.rs

@@ -85,13 +85,13 @@ fn exec_inspect<'a>(matches: &clap::ArgMatches<'a>) {
 			version,
 			program,
 		} => {
-			let version = version.to_u8() as usize;
+			let version = version.to_num() as usize;
 			info.witness_program_version = Some(version);
 
 			if version == 0 {
 				if program.len() == 20 {
 					info.type_ = Some("p2wpkh".to_owned());
-					info.witness_pubkey_hash = 
+					info.witness_pubkey_hash =
 						Some(WPubkeyHash::from_slice(&program).expect("size 20"));
 				} else if program.len() == 32 {
 					info.type_ = Some("p2wsh".to_owned());

src/bin/hal/cmd/address.rs

@@ -40,7 +40,7 @@ fn exec_derive<'a>(matches: &clap::ArgMatches<'a>) {
 		Ok(ext_priv) => {
 			derived_xpriv = Some(ext_priv.derive_priv(&secp, &path).expect("derivation error"));
 			master_fingerprint = ext_priv.fingerprint(&secp);
-			bip32::ExtendedPubKey::from_private(&secp, derived_xpriv.as_ref().unwrap())
+			bip32::ExtendedPubKey::from_priv(&secp, derived_xpriv.as_ref().unwrap())
 		}
 		Err(_) => {
 			let ext_pub: bip32::ExtendedPubKey = key_str.parse().expect("invalid extended key");
@@ -61,7 +61,7 @@ fn exec_derive<'a>(matches: &clap::ArgMatches<'a>) {
 		public_key: derived_xpub.public_key,
 		private_key: derived_xpriv.map(|x| x.private_key),
 		addresses: hal::address::Addresses::from_pubkey(
-			&derived_xpub.public_key, derived_xpub.network,
+			&bitcoin::PublicKey::new(derived_xpub.public_key), derived_xpub.network,
 		),
 	};
 
@@ -84,7 +84,7 @@ fn exec_inspect<'a>(matches: &clap::ArgMatches<'a>) {
 	let xpub = match bip32::ExtendedPrivKey::from_str(&key_str) {
 		Ok(ext_priv) => {
 			xpriv = Some(ext_priv);
-			bip32::ExtendedPubKey::from_private(&secp, xpriv.as_ref().unwrap())
+			bip32::ExtendedPubKey::from_priv(&secp, xpriv.as_ref().unwrap())
 		}
 		Err(_) => key_str.parse().expect("invalid extended key"),
 	};
@@ -101,7 +101,7 @@ fn exec_inspect<'a>(matches: &clap::ArgMatches<'a>) {
 		public_key: xpub.public_key,
 		private_key: xpriv.map(|x| x.private_key),
 		addresses: hal::address::Addresses::from_pubkey(
-			&xpub.public_key, xpub.network,
+			&bitcoin::PublicKey::new(xpub.public_key), xpub.network,
 		),
 	};
 

src/bin/hal/cmd/bip32.rs

@@ -44,7 +44,7 @@ fn exec_generate<'a>(matches: &clap::ArgMatches<'a>) {
 	let privkey = bitcoin::PrivateKey {
 		compressed: true,
 		network: network,
-		key: secret_key,
+		inner: secret_key,
 	};
 	let pubkey = privkey.public_key(&secp);
 
@@ -76,7 +76,7 @@ fn exec_inspect<'a>(matches: &clap::ArgMatches<'a>) {
 		let pubkey = privkey.public_key(&secp256k1::Secp256k1::new());
 
 		hal::key::KeyInfo {
-			raw_private_key: (&privkey.key[..]).into(),
+			raw_private_key: (&privkey.inner[..]).into(),
 			wif_private_key: Some(privkey),
 			public_key: pubkey,
 			uncompressed_public_key: {
@@ -90,7 +90,7 @@ fn exec_inspect<'a>(matches: &clap::ArgMatches<'a>) {
 		let pubkey = secp256k1::PublicKey::from_secret_key(&secp256k1::Secp256k1::new(), &sk);
 		let btc_pubkey = PublicKey {
 			compressed: true,
-			key: pubkey.clone(),
+			inner: pubkey.clone(),
 		};
 		let network = cmd::network(matches);
 		hal::key::KeyInfo {
@@ -99,7 +99,7 @@ fn exec_inspect<'a>(matches: &clap::ArgMatches<'a>) {
 			public_key: btc_pubkey,
 			uncompressed_public_key: PublicKey {
 				compressed: false,
-				key: pubkey,
+				inner: pubkey,
 			},
 			addresses: hal::address::Addresses::from_pubkey(&btc_pubkey, network),
 		}
@@ -132,12 +132,12 @@ fn exec_sign<'a>(matches: &clap::ArgMatches<'a>) {
 		if let Ok(sk) = secp256k1::SecretKey::from_str(&pk) {
 			sk
 		} else {
-			bitcoin::PrivateKey::from_wif(&pk).expect("invalid private key provided").key
+			bitcoin::PrivateKey::from_wif(&pk).expect("invalid private key provided").inner
 		}
 	};
 
 	let secp = secp256k1::Secp256k1::signing_only();
-	let signature = secp.sign(&msg, &privkey);
+	let signature = secp.sign_ecdsa(&msg, &privkey);
 
 	let info = hal::key::SignatureInfo {
 		der: signature.serialize_der().as_ref().into(),
@@ -147,14 +147,14 @@ fn exec_sign<'a>(matches: &clap::ArgMatches<'a>) {
 }
 
 fn cmd_verify<'a>() -> clap::App<'a, 'a> {
-	cmd::subcommand("verify", "verify signatures\n\nNOTE!! For SHA-256-d hashes, the --reverse \
+	cmd::subcommand("verify", "verify ecdsa signatures\n\nNOTE!! For SHA-256-d hashes, the --reverse \
 		flag must be used because Bitcoin Core reverses the hex order for those!").args(&[
 		cmd::opt_yaml(),
 		cmd::opt("reverse", "reverse the message"),
 		cmd::opt("no-try-reverse", "don't try to verify for reversed message"),
 		cmd::arg("message", "the message to be signed in hex (must be 32 bytes)").required(true),
 		cmd::arg("pubkey", "the public key in hex").required(true),
-		cmd::arg("signature", "the signature in hex").required(true),
+		cmd::arg("signature", "the ecdsa signature in hex").required(true),
 	])
 }
 
@@ -171,20 +171,20 @@ fn exec_verify<'a>(matches: &clap::ArgMatches<'a>) {
 		let hex = matches.value_of("signature").expect("no signature provided");
 		let bytes = hex::decode(&hex).expect("invalid signature: not hex");
 		if bytes.len() == 64 {
-			secp256k1::Signature::from_compact(&bytes).expect("invalid signature")
+			secp256k1::ecdsa::Signature::from_compact(&bytes).expect("invalid signature")
 		} else {
-			secp256k1::Signature::from_der(&bytes).expect("invalid DER signature")
+			secp256k1::ecdsa::Signature::from_der(&bytes).expect("invalid DER signature")
 		}
 	};
 
 	let secp = secp256k1::Secp256k1::verification_only();
-	let valid = secp.verify(&msg, &sig, &pubkey.key).is_ok();
+	let valid = secp.verify_ecdsa(&msg, &sig, &pubkey.inner).is_ok();
 
 	// Perhaps the user should have passed --reverse.
 	if !valid && !matches.is_present("no-try-reverse") {
 		msg_bytes.reverse();
 		let msg = secp256k1::Message::from_slice(&msg_bytes[..]).expect("invalid message to be signed");
-		if secp.verify(&msg, &sig, &pubkey.key).is_ok() {
+		if secp.verify_ecdsa(&msg, &sig, &pubkey.inner).is_ok() {
 			eprintln!("Signature is valid for the reverse message.");
 			if matches.is_present("reverse") {
 				eprintln!("Try dropping the --reverse");

src/bin/hal/cmd/key.rs

@@ -60,7 +60,7 @@ fn exec_sign<'a>(matches: &clap::ArgMatches<'a>) {
 
 	let secp = secp256k1::Secp256k1::new();
 	let signature =
-		secp.sign_recoverable(&secp256k1::Message::from_slice(&hash).unwrap(), &privkey.key);
+		secp.sign_ecdsa_recoverable(&secp256k1::Message::from_slice(&hash).unwrap(), &privkey.inner);
 
 	let (recid, raw) = signature.serialize_compact();
 	let mut serialized = [0u8; 65];
@@ -115,19 +115,19 @@ fn exec_verify<'a>(matches: &clap::ArgMatches<'a>) {
 	if sig_bytes.len() != 65 {
 		panic!("Invalid signature: length is {} instead of 65 bytes", sig_bytes.len());
 	}
-	let recid = secp256k1::recovery::RecoveryId::from_i32(((sig_bytes[0] - 27) & 0x03) as i32)
+	let recid = secp256k1::ecdsa::RecoveryId::from_i32(((sig_bytes[0] - 27) & 0x03) as i32)
 		.expect("invalid recoverable signature (invalid recid)");
 	let compressed = ((sig_bytes[0] - 27) & 0x04) != 0;
-	let signature = secp256k1::recovery::RecoverableSignature::from_compact(&sig_bytes[1..], recid)
+	let signature = secp256k1::ecdsa::RecoverableSignature::from_compact(&sig_bytes[1..], recid)
 		.expect("invalid recoverable signature");
 
 	let msg = util::arg_or_stdin(matches, "message");
 	let hash = bitcoin::util::misc::signed_msg_hash(&msg);
 
 	let secp = secp256k1::Secp256k1::verification_only();
 	let pubkey = PublicKey {
-		key: secp
-			.recover(&secp256k1::Message::from_slice(&hash).unwrap(), &signature)
+		inner: secp
+			.recover_ecdsa(&secp256k1::Message::from_slice(&hash).unwrap(), &signature)
 			.expect("invalid signature"),
 		compressed: compressed,
 	};
@@ -188,22 +188,22 @@ fn exec_recover<'a>(matches: &clap::ArgMatches<'a>) {
 	if sig_bytes.len() != 65 {
 		panic!("Invalid signature: length is {} instead of 65 bytes", sig_bytes.len());
 	}
-	let recid = secp256k1::recovery::RecoveryId::from_i32((sig_bytes[0] - 27 & 0x03) as i32)
+	let recid = secp256k1::ecdsa::RecoveryId::from_i32((sig_bytes[0] - 27 & 0x03) as i32)
 		.expect("invalid recoverable signature (invalid recid)");
 	let compressed = sig_bytes[0] & 0x04 != 0x04;
-	let signature = secp256k1::recovery::RecoverableSignature::from_compact(&sig_bytes[1..], recid)
+	let signature = secp256k1::ecdsa::RecoverableSignature::from_compact(&sig_bytes[1..], recid)
 		.expect("invalid recoverable signature");
 
 	let msg = matches.value_of("message").expect("no message given");
 	let hash = bitcoin::util::misc::signed_msg_hash(&msg);
 
 	let secp = secp256k1::Secp256k1::verification_only();
 	let pubkey = secp
-		.recover(&secp256k1::Message::from_slice(&hash).unwrap(), &signature)
+		.recover_ecdsa(&secp256k1::Message::from_slice(&hash).unwrap(), &signature)
 		.expect("invalid signature");
 
 	let bitcoin_key = PublicKey {
-		key: pubkey,
+		inner: pubkey,
 		compressed: compressed,
 	};
 	let info = hal::GetInfo::get_info(&bitcoin_key, cmd::network(matches));

src/bin/hal/cmd/message.rs

@@ -4,10 +4,9 @@ use clap;
 use hal::miniscript::{
 	DescriptorInfo, MiniscriptInfo, MiniscriptKeyType, Miniscripts, PolicyInfo, ScriptContexts,
 };
-use miniscript::descriptor::Descriptor;
 use miniscript::miniscript::{BareCtx, Legacy, Miniscript, Segwitv0};
 use miniscript::policy::Liftable;
-use miniscript::{policy, DescriptorTrait, MiniscriptKey};
+use miniscript::{Descriptor, policy, MiniscriptKey};
 
 use cmd;
 use util;
@@ -49,7 +48,7 @@ fn exec_descriptor<'a>(matches: &clap::ArgMatches<'a>) {
 			address: desc.address(network).map(|a| a.to_string()).ok(),
 			script_pubkey: Some(desc.script_pubkey().into_bytes().into()),
 			unsigned_script_sig: Some(desc.unsigned_script_sig().into_bytes().into()),
-			witness_script: Some(desc.explicit_script().into_bytes().into()),
+			witness_script: desc.explicit_script().map(|s| s.into_bytes().into()).ok(),
 			max_satisfaction_weight: desc.max_satisfaction_weight().ok(),
 			policy: policy::Liftable::lift(&desc).map(|pol| pol.to_string()).ok(),
 		})
@@ -177,9 +176,15 @@ fn get_policy_info<Pk: MiniscriptKey>(
 ) -> Result<PolicyInfo, miniscript::Error>
 where
 	Pk: std::str::FromStr,
-	Pk::Hash: std::str::FromStr,
-	<<Pk as miniscript::MiniscriptKey>::Hash as ::std::str::FromStr>::Err: ::std::fmt::Display,
-	<Pk as ::std::str::FromStr>::Err: ::std::fmt::Display,
+	<Pk as std::str::FromStr>::Err: std::fmt::Display,
+	<Pk as MiniscriptKey>::Sha256: std::str::FromStr,
+	<Pk as MiniscriptKey>::Hash256: std::str::FromStr,
+	<Pk as MiniscriptKey>::Ripemd160: std::str::FromStr,
+	<Pk as MiniscriptKey>::Hash160: std::str::FromStr,
+	<<Pk as MiniscriptKey>::Sha256 as std::str::FromStr>::Err: std::fmt::Display,
+	<<Pk as MiniscriptKey>::Hash256 as std::str::FromStr>::Err: std::fmt::Display,
+	<<Pk as MiniscriptKey>::Ripemd160 as std::str::FromStr>::Err: std::fmt::Display,
+	<<Pk as MiniscriptKey>::Hash160 as std::str::FromStr>::Err: std::fmt::Display,
 {
 	let concrete_pol: Option<policy::Concrete<Pk>> = policy_str.parse().ok();
 	let policy = match concrete_pol {
@@ -193,7 +198,7 @@ where
 		is_unsatisfiable: policy.is_unsatisfiable(),
 		relative_timelocks: policy.relative_timelocks(),
 		n_keys: policy.n_keys(),
-		minimum_n_keys: policy.minimum_n_keys(),
+		minimum_n_keys: policy.minimum_n_keys().ok_or(miniscript::Error::CouldNotSatisfy)?,
 		sorted: policy.clone().sorted().to_string(),
 		normalized: policy.clone().normalized().to_string(),
 		miniscript: concrete_pol.map(|p| Miniscripts {