use bitcoin types in Fallback

Author: futurepaul

lightning-invoice/src/de.rs

@@ -5,10 +5,13 @@ use core::fmt::{Display, Formatter};
 use core::num::ParseIntError;
 use core::str;
 use core::str::FromStr;
+use core::convert::TryFrom;
 
 use bech32;
 use bech32::{u5, FromBase32};
 
+use bitcoin::{PubkeyHash, ScriptHash};
+use bitcoin::util::address::WitnessVersion;
 use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256;
 use crate::prelude::*;
@@ -553,6 +556,11 @@ impl FromBase32 for Fallback {
 					return Err(ParseError::InvalidSegWitProgramLength);
 				}
 
+				let version = match WitnessVersion::try_from(version) {
+					Ok(version) => version,
+					Err(_) => return Err(ParseError::InvalidSegWitVersion),
+				};
+
 				Ok(Fallback::SegWitProgram {
 					version: version,
 					program: bytes
@@ -562,17 +570,22 @@ impl FromBase32 for Fallback {
 				if bytes.len() != 20 {
 					return Err(ParseError::InvalidPubKeyHashLength);
 				}
-				//TODO: refactor once const generics are available
-				let mut pkh = [0u8; 20];
-				pkh.copy_from_slice(&bytes);
+				let pkh = match PubkeyHash::from_slice(&bytes) {
+					Ok(pkh) => pkh,
+					Err(_) => return Err(ParseError::InvalidPubKeyHash),
+				};
+
 				Ok(Fallback::PubKeyHash(pkh))
 			}
 			18 => {
 				if bytes.len() != 20 {
 					return Err(ParseError::InvalidScriptHashLength);
 				}
-				let mut sh = [0u8; 20];
-				sh.copy_from_slice(&bytes);
+				let sh = match ScriptHash::from_slice(&bytes) {
+					Ok(sh) => sh,
+					Err(_) => return Err(ParseError::InvalidScriptHash),
+				};
+				
 				Ok(Fallback::ScriptHash(sh))
 			}
 			_ => Err(ParseError::Skip)
@@ -655,12 +668,21 @@ impl Display for ParseError {
 			ParseError::InvalidSegWitProgramLength => {
 				f.write_str("fallback SegWit program is too long or too short")
 			},
+			ParseError::InvalidSegWitVersion => {
+				f.write_str("fallback SegWit version is not valid")
+			},
 			ParseError::InvalidPubKeyHashLength => {
 				f.write_str("fallback public key hash has a length unequal 20 bytes")
 			},
+			ParseError::InvalidPubKeyHash => {
+				f.write_str("fallback public key hash is not a valid")
+			},
 			ParseError::InvalidScriptHashLength => {
 				f.write_str("fallback script hash has a length unequal 32 bytes")
 			},
+			ParseError::InvalidScriptHash => {
+				f.write_str("fallback script hash is not a valid")
+			},
 			ParseError::InvalidRecoveryId => {
 				f.write_str("recovery id is out of range (should be in [0,3])")
 			},
@@ -854,26 +876,29 @@ mod test {
 	fn test_parse_fallback() {
 		use crate::Fallback;
 		use bech32::FromBase32;
+		use bitcoin::{PubkeyHash, ScriptHash};
+		use bitcoin::util::address::WitnessVersion;
+		use bitcoin_hashes::Hash;
 
 		let cases = vec![
 			(
 				from_bech32("3x9et2e20v6pu37c5d9vax37wxq72un98".as_bytes()),
-				Ok(Fallback::PubKeyHash([
+				Ok(Fallback::PubKeyHash(PubkeyHash::from_slice(&[
 					0x31, 0x72, 0xb5, 0x65, 0x4f, 0x66, 0x83, 0xc8, 0xfb, 0x14, 0x69, 0x59, 0xd3,
 					0x47, 0xce, 0x30, 0x3c, 0xae, 0x4c, 0xa7
-				]))
+				]).unwrap()))
 			),
 			(
 				from_bech32("j3a24vwu6r8ejrss3axul8rxldph2q7z9".as_bytes()),
-				Ok(Fallback::ScriptHash([
+				Ok(Fallback::ScriptHash(ScriptHash::from_slice(&[
 					0x8f, 0x55, 0x56, 0x3b, 0x9a, 0x19, 0xf3, 0x21, 0xc2, 0x11, 0xe9, 0xb9, 0xf3,
 					0x8c, 0xdf, 0x68, 0x6e, 0xa0, 0x78, 0x45
-				]))
+				]).unwrap()))
 			),
 			(
 				from_bech32("qw508d6qejxtdg4y5r3zarvary0c5xw7k".as_bytes()),
 				Ok(Fallback::SegWitProgram {
-					version: u5::try_from_u8(0).unwrap(),
+					version: WitnessVersion::V0,
 					program: Vec::from(&[
 						0x75u8, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54, 0x94, 0x1c, 0x45,
 						0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6
@@ -907,36 +932,6 @@ mod test {
 		}
 	}
 
-	#[test]
-	fn test_fallback_to_address() {
-		use crate::Fallback;
-		use crate::Currency;
-		use crate::utils::address_from_fallback;
-		use bech32::FromBase32;
-		use bitcoin::Address;
-		use core::str::FromStr;
-
-		let cases = vec![
-			(
-				from_bech32("3x9et2e20v6pu37c5d9vax37wxq72un98".as_bytes()),
-				Address::from_str("15WTXVVv4JHN992HjbRxMwmekcppRpzJrK").unwrap()
-			),
-			(
-				from_bech32("j3a24vwu6r8ejrss3axul8rxldph2q7z9".as_bytes()),
-				Address::from_str("3EktnHQD7RiAE6uzMj2ZifT9YgRrkSgzQX").unwrap()
-			),
-			(
-				from_bech32("qw508d6qejxtdg4y5r3zarvary0c5xw7k".as_bytes()),
-				Address::from_str("bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4").unwrap()
-			),
-		];
-
-		for (input, expected) in cases.into_iter() {
-			let address = address_from_fallback(&Fallback::from_base32(&input).unwrap(), Currency::Bitcoin);
-			assert_eq!(address, expected);
-		}
-	}
-
 	#[test]
 	fn test_parse_route() {
 		use lightning::routing::gossip::RoutingFees;

lightning-invoice/src/lib.rs

@@ -46,6 +46,11 @@ use std::time::SystemTime;
 
 use bech32::u5;
 use bitcoin::Address;
+use bitcoin::Network;
+use bitcoin::PubkeyHash;
+use bitcoin::Script;
+use bitcoin::ScriptHash;
+use bitcoin::util::address::WitnessVersion;
 use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256;
 use lightning::ln::PaymentSecret;
@@ -117,8 +122,11 @@ pub enum ParseError {
 	PaddingError,
 	IntegerOverflowError,
 	InvalidSegWitProgramLength,
+	InvalidSegWitVersion,
 	InvalidPubKeyHashLength,
+	InvalidPubKeyHash,
 	InvalidScriptHashLength,
+	InvalidScriptHash,
 	InvalidRecoveryId,
 	InvalidSliceLength(String),
 
@@ -443,17 +451,16 @@ pub struct ExpiryTime(Duration);
 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 pub struct MinFinalCltvExpiryDelta(pub u64);
 
-// TODO: better types instead onf byte arrays
 /// Fallback address in case no LN payment is possible
 #[allow(missing_docs)]
 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 pub enum Fallback {
 	SegWitProgram {
-		version: u5,
+		version: WitnessVersion,
 		program: Vec<u8>,
 	},
-	PubKeyHash([u8; 20]),
-	ScriptHash([u8; 20]),
+	PubKeyHash(PubkeyHash),
+	ScriptHash(ScriptHash),
 }
 
 /// Recoverable signature
@@ -1256,13 +1263,35 @@ impl Invoice {
 	///
 	/// (C-not exported) as we don't support Vec<&NonOpaqueType>
 	pub fn fallbacks(&self) -> Vec<&Fallback> {
+
+
 		self.signed_invoice.fallbacks()
 	}
 
-	/// Returns a list of all fallback addresses as `bitcoin::Address`es
+	/// Returns a list of all fallback addresses as [`Address`]es
 	pub fn fallback_addresses(&self) -> Vec<Address> {
 		self.fallbacks().iter().map(|fallback| {
-			utils::address_from_fallback(fallback, self.currency())
+			let network = match self.currency() {
+				Currency::Bitcoin => Network::Bitcoin,
+				Currency::BitcoinTestnet => Network::Testnet,
+				Currency::Regtest => Network::Regtest,
+				Currency::Simnet => Network::Regtest,
+				Currency::Signet => Network::Signet,
+			};
+		
+			let script = match fallback {
+				Fallback::SegWitProgram { version, program } => {
+					Script::new_witness_program(*version, program.as_slice())
+				}
+				Fallback::PubKeyHash(pkh) => {
+					Script::new_p2pkh(&pkh)
+				}
+				Fallback::ScriptHash(sh) => {
+					Script::new_p2sh(&sh)
+				}
+			};
+		
+			Address::from_script(&script, network).unwrap()
 		}).collect()
 	}
 
@@ -1938,7 +1967,7 @@ mod test {
 			.payee_pub_key(public_key.clone())
 			.expiry_time(Duration::from_secs(54321))
 			.min_final_cltv_expiry_delta(144)
-			.fallback(Fallback::PubKeyHash([0;20]))
+			.fallback(Fallback::PubKeyHash(PubkeyHash::from_slice(&[0;20]).unwrap()))
 			.private_route(route_1.clone())
 			.private_route(route_2.clone())
 			.description_hash(sha256::Hash::from_slice(&[3;32][..]).unwrap())
@@ -1964,7 +1993,10 @@ mod test {
 		assert_eq!(invoice.payee_pub_key(), Some(&public_key));
 		assert_eq!(invoice.expiry_time(), Duration::from_secs(54321));
 		assert_eq!(invoice.min_final_cltv_expiry_delta(), 144);
-		assert_eq!(invoice.fallbacks(), vec![&Fallback::PubKeyHash([0;20])]);
+		assert_eq!(invoice.fallbacks(), vec![&Fallback::PubKeyHash(PubkeyHash::from_slice(&[0;20]).unwrap())]);
+		let address = Address::from_script(&Script::new_p2pkh(&PubkeyHash::from_slice(&[0;20]).unwrap()), Network::Testnet).unwrap();
+		assert_eq!(invoice.fallback_addresses(), vec![address]);
+
 		assert_eq!(invoice.private_routes(), vec![&PrivateRoute(route_1), &PrivateRoute(route_2)]);
 		assert_eq!(
 			invoice.description(),

lightning-invoice/src/ser.rs

@@ -329,7 +329,7 @@ impl ToBase32 for Fallback {
 	fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
 		match *self {
 			Fallback::SegWitProgram {version: v, program: ref p} => {
-				writer.write_u5(v)?;
+				writer.write_u5(u5::try_from_u8(v.to_num()).expect("0-16 < 32"))?;
 				p.write_base32(writer)
 			},
 			Fallback::PubKeyHash(ref hash) => {

lightning-invoice/src/utils.rs

@@ -1,11 +1,9 @@
 //! Convenient utilities to create an invoice.
 
-use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError, Fallback};
+use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError};
 
 use crate::{prelude::*, Description, InvoiceDescription, Sha256};
 use bech32::ToBase32;
-use bitcoin::util::address::WitnessVersion;
-use bitcoin::{Network, Address, Script, PubkeyHash, ScriptHash};
 use bitcoin_hashes::Hash;
 use lightning::chain;
 use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
@@ -18,7 +16,6 @@ use lightning::routing::gossip::RoutingFees;
 use lightning::routing::router::{RouteHint, RouteHintHop, Router};
 use lightning::util::logger::Logger;
 use secp256k1::PublicKey;
-use core::convert::TryFrom;
 use core::ops::Deref;
 use core::time::Duration;
 
@@ -636,33 +633,6 @@ fn filter_channels<L: Deref>(
 		.collect::<Vec<RouteHint>>()
 }
 
-pub(crate) fn address_from_fallback(fallback: &Fallback, currency: Currency) -> Address {
-	let network = match currency {
-		Currency::Bitcoin => Network::Bitcoin,
-		Currency::BitcoinTestnet => Network::Testnet,
-		Currency::Regtest => Network::Regtest,
-		Currency::Simnet => Network::Regtest,
-		Currency::Signet => Network::Signet,
-	};
-
-	let script = match fallback {
-		Fallback::SegWitProgram { version, program } => {
-			let version = WitnessVersion::try_from(*version).unwrap();
-			Script::new_witness_program(version, program.as_slice())
-		}
-		Fallback::PubKeyHash(pkh) => {
-			let pkh = PubkeyHash::from_slice(pkh).unwrap();
-			Script::new_p2pkh(&pkh)
-		}
-		Fallback::ScriptHash(sh) => {
-			let sh = ScriptHash::from_slice(sh).unwrap();
-			Script::new_p2sh(&sh)
-		}
-	};
-
-	Address::from_script(&script, network).unwrap()
-}
-
 #[cfg(test)]
 mod test {
 	use core::time::Duration;

lightning-invoice/tests/ser_de.rs

@@ -5,9 +5,10 @@ extern crate lightning_invoice;
 extern crate secp256k1;
 extern crate hex;
 
+use bitcoin::util::address::WitnessVersion;
+use bitcoin::{PubkeyHash, ScriptHash};
 use bitcoin_hashes::hex::FromHex;
 use bitcoin_hashes::{sha256, Hash};
-use bech32::u5;
 use lightning::ln::PaymentSecret;
 use lightning::routing::gossip::RoutingFees;
 use lightning::routing::router::{RouteHint, RouteHintHop};
@@ -115,7 +116,7 @@ fn get_test_tuples() -> Vec<(String, SignedRawInvoice, bool, bool)> {
 				.payment_hash(sha256::Hash::from_hex(
 					"0001020304050607080900010203040506070809000102030405060708090102"
 				).unwrap())
-				.fallback(Fallback::PubKeyHash([49, 114, 181, 101, 79, 102, 131, 200, 251, 20, 105, 89, 211, 71, 206, 48, 60, 174, 76, 167]))
+				.fallback(Fallback::PubKeyHash(PubkeyHash::from_slice(&[49, 114, 181, 101, 79, 102, 131, 200, 251, 20, 105, 89, 211, 71, 206, 48, 60, 174, 76, 167]).unwrap()))
 				.build_raw()
 				.unwrap()
 				.sign(|_| {
@@ -137,7 +138,7 @@ fn get_test_tuples() -> Vec<(String, SignedRawInvoice, bool, bool)> {
 				.payment_hash(sha256::Hash::from_hex(
 					"0001020304050607080900010203040506070809000102030405060708090102"
 				).unwrap())
-				.fallback(Fallback::PubKeyHash([4, 182, 31, 125, 193, 234, 13, 201, 148, 36, 70, 76, 196, 6, 77, 197, 100, 217, 30, 137]))
+				.fallback(Fallback::PubKeyHash(PubkeyHash::from_slice(&[4, 182, 31, 125, 193, 234, 13, 201, 148, 36, 70, 76, 196, 6, 77, 197, 100, 217, 30, 137]).unwrap()))
 				.private_route(RouteHint(vec![RouteHintHop {
 					src_node_id: PublicKey::from_slice(&hex::decode(
 							"029e03a901b85534ff1e92c43c74431f7ce72046060fcf7a95c37e148f78c77255"
@@ -176,7 +177,7 @@ fn get_test_tuples() -> Vec<(String, SignedRawInvoice, bool, bool)> {
 				.payment_hash(sha256::Hash::from_hex(
 					"0001020304050607080900010203040506070809000102030405060708090102"
 				).unwrap())
-				.fallback(Fallback::ScriptHash([143, 85, 86, 59, 154, 25, 243, 33, 194, 17, 233, 185, 243, 140, 223, 104, 110, 160, 120, 69]))
+				.fallback(Fallback::ScriptHash(ScriptHash::from_slice(&[143, 85, 86, 59, 154, 25, 243, 33, 194, 17, 233, 185, 243, 140, 223, 104, 110, 160, 120, 69]).unwrap()))
 				.build_raw()
 				.unwrap()
 				.sign(|_| {
@@ -198,7 +199,7 @@ fn get_test_tuples() -> Vec<(String, SignedRawInvoice, bool, bool)> {
 				.payment_hash(sha256::Hash::from_hex(
 					"0001020304050607080900010203040506070809000102030405060708090102"
 				).unwrap())
-				.fallback(Fallback::SegWitProgram { version: u5::try_from_u8(0).unwrap(),
+				.fallback(Fallback::SegWitProgram { version: WitnessVersion::V0,
 					program: vec![117, 30, 118, 232, 25, 145, 150, 212, 84, 148, 28, 69, 209, 179, 163, 35, 241, 67, 59, 214]
 				})
 				.build_raw()
@@ -222,7 +223,7 @@ fn get_test_tuples() -> Vec<(String, SignedRawInvoice, bool, bool)> {
 				.payment_hash(sha256::Hash::from_hex(
 					"0001020304050607080900010203040506070809000102030405060708090102"
 				).unwrap())
-				.fallback(Fallback::SegWitProgram { version: u5::try_from_u8(0).unwrap(),
+				.fallback(Fallback::SegWitProgram { version: WitnessVersion::V0,
 					program: vec![24, 99, 20, 60, 20, 197, 22, 104, 4, 189, 25, 32, 51, 86, 218, 19, 108, 152, 86, 120, 205, 77, 39, 161, 184, 198, 50, 150, 4, 144, 50, 98]
 				})
 				.build_raw()