Use concrete WitnessProgram type

Author: wpaulino

lightning-invoice/src/lib.rs

@@ -46,7 +46,7 @@ use std::time::SystemTime;
 
 use bech32::u5;
 use bitcoin::{Address, Network, PubkeyHash, ScriptHash};
-use bitcoin::address::{Payload, WitnessVersion};
+use bitcoin::address::{Payload, WitnessProgram, WitnessVersion};
 use bitcoin_hashes::{Hash, sha256};
 use lightning::ln::features::Bolt11InvoiceFeatures;
 use lightning::util::invoice::construct_invoice_preimage;
@@ -413,6 +413,7 @@ impl From<Network> for Currency {
 			Network::Testnet => Currency::BitcoinTestnet,
 			Network::Regtest => Currency::Regtest,
 			Network::Signet => Currency::Signet,
+			_ => unreachable!(),
 		}
 	}
 }
@@ -1429,10 +1430,13 @@ impl Bolt11Invoice {
 
 	/// Returns a list of all fallback addresses as [`Address`]es
 	pub fn fallback_addresses(&self) -> Vec<Address> {
-		self.fallbacks().iter().map(|fallback| {
+		self.fallbacks().iter().filter_map(|fallback| {
 			let payload = match fallback {
 				Fallback::SegWitProgram { version, program } => {
-					Payload::WitnessProgram { version: *version, program: program.to_vec() }
+					match WitnessProgram::new(*version, program.clone()) {
+						Ok(witness_program) => Payload::WitnessProgram(witness_program),
+						Err(_) => return None,
+					}
 				}
 				Fallback::PubKeyHash(pkh) => {
 					Payload::PubkeyHash(*pkh)
@@ -1442,7 +1446,7 @@ impl Bolt11Invoice {
 				}
 			};
 
-			Address { payload, network: self.network() }
+			Some(Address::new(self.network(), payload))
 		}).collect()
 	}
 

lightning/src/ln/channel.rs

@@ -7823,7 +7823,7 @@ mod tests {
 	use bitcoin::hashes::Hash;
 	use bitcoin::hash_types::WPubkeyHash;
 	use bitcoin::blockdata::locktime::absolute::LockTime;
-	use bitcoin::address::WitnessVersion;
+	use bitcoin::address::{WitnessProgram, WitnessVersion};
 	use crate::prelude::*;
 
 	struct TestFeeEstimator {
@@ -7885,8 +7885,9 @@ mod tests {
 	#[test]
 	fn upfront_shutdown_script_incompatibility() {
 		let features = channelmanager::provided_init_features(&UserConfig::default()).clear_shutdown_anysegwit();
-		let non_v0_segwit_shutdown_script =
-			ShutdownScript::new_witness_program(WitnessVersion::V16, &[0, 40]).unwrap();
+		let non_v0_segwit_shutdown_script = ShutdownScript::new_witness_program(
+			&WitnessProgram::new(WitnessVersion::V16, &[0, 40]).unwrap(),
+		).unwrap();
 
 		let seed = [42; 32];
 		let network = Network::Testnet;

lightning/src/ln/script.rs

@@ -1,11 +1,11 @@
 //! Abstractions for scripts used in the Lightning Network.
 
 use bitcoin::blockdata::opcodes::all::OP_PUSHBYTES_0 as SEGWIT_V0;
-use bitcoin::blockdata::script::{Builder, Script, ScriptBuf};
+use bitcoin::blockdata::script::{Script, ScriptBuf};
 use bitcoin::hashes::Hash;
 use bitcoin::hash_types::{WPubkeyHash, WScriptHash};
 use bitcoin::secp256k1::PublicKey;
-use bitcoin::address::WitnessVersion;
+use bitcoin::address::WitnessProgram;
 
 use crate::ln::channelmanager;
 use crate::ln::features::InitFeatures;
@@ -81,12 +81,8 @@ impl ShutdownScript {
 	/// # Errors
 	///
 	/// This function may return an error if `program` is invalid for the segwit `version`.
-	pub fn new_witness_program(version: WitnessVersion, program: &[u8]) -> Result<Self, InvalidShutdownScript> {
-		let script = Builder::new()
-			.push_int(version as i64)
-			.push_slice(&program)
-			.into_script();
-		Self::try_from(script)
+	pub fn new_witness_program(witness_program: &WitnessProgram) -> Result<Self, InvalidShutdownScript> {
+		Self::try_from(ScriptBuf::new_witness_program(witness_program))
 	}
 
 	/// Converts the shutdown script into the underlying [`ScriptBuf`].
@@ -177,7 +173,7 @@ mod shutdown_script_tests {
 	use bitcoin::secp256k1::{PublicKey, SecretKey};
 	use crate::ln::features::InitFeatures;
 	use core::convert::TryFrom;
-	use bitcoin::address::WitnessVersion;
+	use bitcoin::address::{WitnessProgram, WitnessVersion};
 
 	fn pubkey() -> bitcoin::key::PublicKey {
 		let secp_ctx = Secp256k1::signing_only();
@@ -240,30 +236,17 @@ mod shutdown_script_tests {
 
 	#[test]
 	fn generates_segwit_from_non_v0_witness_program() {
-		let witness_program = ScriptBuf::new_witness_program(WitnessVersion::V16, &[0; 40]);
-		let shutdown_script = ShutdownScript::new_witness_program(WitnessVersion::V16, &[0; 40]).unwrap();
+		let witness_program = WitnessProgram::new(WitnessVersion::V16, &[0; 40]).unwrap();
+		let script = ScriptBuf::new_witness_program(&witness_program);
+		let shutdown_script = ShutdownScript::new_witness_program(&witness_program).unwrap();
 		assert!(shutdown_script.is_compatible(&any_segwit_features()));
 		assert!(!shutdown_script.is_compatible(&InitFeatures::empty()));
-		assert_eq!(shutdown_script.into_inner(), witness_program);
+		assert_eq!(shutdown_script.into_inner(), script);
 	}
 
 	#[test]
 	fn fails_from_unsupported_script() {
 		let op_return = ScriptBuf::new_op_return(&[0; 42]);
 		assert!(ShutdownScript::try_from(op_return).is_err());
 	}
-
-	#[test]
-	fn fails_from_invalid_segwit_v0_witness_program() {
-		let witness_program = ScriptBuf::new_witness_program(WitnessVersion::V0, &[0; 2]);
-		assert!(ShutdownScript::try_from(witness_program).is_err());
-	}
-
-	#[test]
-	fn fails_from_invalid_segwit_non_v0_witness_program() {
-		let witness_program = ScriptBuf::new_witness_program(WitnessVersion::V16, &[0; 42]);
-		assert!(ShutdownScript::try_from(witness_program).is_err());
-
-		assert!(ShutdownScript::new_witness_program(WitnessVersion::V16, &[0; 42]).is_err());
-	}
 }

lightning/src/ln/shutdown_tests.rs

@@ -27,7 +27,7 @@ use crate::util::string::UntrustedString;
 use bitcoin::blockdata::script::Builder;
 use bitcoin::blockdata::opcodes;
 use bitcoin::network::constants::Network;
-use bitcoin::address::WitnessVersion;
+use bitcoin::address::{WitnessProgram, WitnessVersion};
 
 use regex;
 
@@ -927,8 +927,9 @@ fn test_unsupported_anysegwit_shutdown_script() {
 
 	// Check that using an unsupported shutdown script fails and a supported one succeeds.
 	let supported_shutdown_script = chanmon_cfgs[1].keys_manager.get_shutdown_scriptpubkey().unwrap();
+	let unsupported_witness_program = WitnessProgram::new(WitnessVersion::V16, &[0, 40]).unwrap();
 	let unsupported_shutdown_script =
-		ShutdownScript::new_witness_program(WitnessVersion::V16, &[0, 40]).unwrap();
+		ShutdownScript::new_witness_program(&unsupported_witness_program).unwrap();
 	chanmon_cfgs[1].keys_manager
 		.expect(OnGetShutdownScriptpubkey { returns: unsupported_shutdown_script.clone() })
 		.expect(OnGetShutdownScriptpubkey { returns: supported_shutdown_script });

lightning/src/offers/invoice.rs

@@ -103,7 +103,7 @@ use bitcoin::hashes::Hash;
 use bitcoin::network::constants::Network;
 use bitcoin::secp256k1::{KeyPair, PublicKey, Secp256k1, self};
 use bitcoin::secp256k1::schnorr::Signature;
-use bitcoin::address::{Address, Payload, WitnessVersion};
+use bitcoin::address::{Address, Payload, WitnessProgram, WitnessVersion};
 use bitcoin::key::TweakedPublicKey;
 use core::convert::{AsRef, Infallible, TryFrom};
 use core::time::Duration;
@@ -930,15 +930,12 @@ impl InvoiceContents {
 				return None;
 			}
 
-			let address = Address {
-				payload: Payload::WitnessProgram {
-					version,
-					program: program.clone(),
-				},
-				network,
+			let witness_program = match WitnessProgram::new(version, program.clone()) {
+				Ok(witness_program) => witness_program,
+				Err(_) => return None,
 			};
-
-			if !address.is_standard() && version == WitnessVersion::V0 {
+			let address = Address::new(network, Payload::WitnessProgram(witness_program));
+			if !address.is_spend_standard() && version == WitnessVersion::V0 {
 				return None;
 			}
 
@@ -1309,7 +1306,7 @@ mod tests {
 	use bitcoin::hashes::Hash;
 	use bitcoin::network::constants::Network;
 	use bitcoin::secp256k1::{Message, Secp256k1, XOnlyPublicKey, self};
-	use bitcoin::address::{Address, Payload, WitnessVersion};
+	use bitcoin::address::{Address, Payload, WitnessProgram, WitnessVersion};
 	use bitcoin::key::TweakedPublicKey;
 	use core::convert::TryFrom;
 	use core::time::Duration;
@@ -1837,7 +1834,7 @@ mod tests {
 			Some(&vec![
 				FallbackAddress {
 					version: WitnessVersion::V0.to_num(),
-					program: Vec::from(script.wscript_hash()),
+					program: Vec::from(script.wscript_hash().to_byte_array()),
 				},
 				FallbackAddress {
 					version: WitnessVersion::V0.to_num(),
@@ -2129,26 +2126,16 @@ mod tests {
 
 		match Bolt12Invoice::try_from(buffer) {
 			Ok(invoice) => {
+				let v1_witness_program = WitnessProgram::new(WitnessVersion::V1, vec![0u8; 33]).unwrap();
+				let v2_witness_program = WitnessProgram::new(WitnessVersion::V2, vec![0u8; 40]).unwrap();
 				assert_eq!(
 					invoice.fallbacks(),
 					vec![
 						Address::p2wsh(&script, Network::Bitcoin),
 						Address::p2wpkh(&pubkey, Network::Bitcoin).unwrap(),
 						Address::p2tr_tweaked(tweaked_pubkey, Network::Bitcoin),
-						Address {
-							payload: Payload::WitnessProgram {
-								version: WitnessVersion::V1,
-								program: vec![0u8; 33],
-							},
-							network: Network::Bitcoin,
-						},
-						Address {
-							payload: Payload::WitnessProgram {
-								version: WitnessVersion::V2,
-								program: vec![0u8; 40],
-							},
-							network: Network::Bitcoin,
-						},
+						Address::new(Network::Bitcoin, Payload::WitnessProgram(v1_witness_program)),
+						Address::new(Network::Bitcoin, Payload::WitnessProgram(v2_witness_program)),
 					],
 				);
 			},