Add Features feature to invoices.

Author: valentinewallace

lightning-invoice/Cargo.toml

@@ -10,6 +10,7 @@ readme = "README.md"
 
 [dependencies]
 bech32 = "0.7"
+lightning = { version = "0.0.13", path = "../lightning" }
 secp256k1 = { version = "0.20", features = ["recovery"] }
 num-traits = "0.2.8"
 bitcoin_hashes = "0.9.4"

lightning-invoice/src/de.rs

@@ -431,6 +431,8 @@ impl FromBase32 for TaggedField {
 				Ok(TaggedField::Route(Route::from_base32(field_data)?)),
 			constants::TAG_PAYMENT_SECRET =>
 				Ok(TaggedField::PaymentSecret(PaymentSecret::from_base32(field_data)?)),
+			constants::TAG_FEATURES =>
+				Ok(TaggedField::Features(InvoiceFeatures::from_base32(field_data)?)),
 			_ => {
 				// "A reader MUST skip over unknown fields"
 				Err(ParseError::Skip)
@@ -977,16 +979,17 @@ mod test {
 	}
 
 	#[test]
-	fn test_payment_secret_deserialization() {
-		use bech32::CheckBase32;
+	fn test_payment_secret_and_features_de_and_ser() {
+		use lightning::ln::features::InvoiceFeatures;
 		use secp256k1::recovery::{RecoveryId, RecoverableSignature};
 		use TaggedField::*;
-		use {SiPrefix, SignedRawInvoice, Signature, RawInvoice, RawTaggedField, RawHrp, RawDataPart,
+		use {SiPrefix, SignedRawInvoice, Signature, RawInvoice, RawHrp, RawDataPart,
 				 Currency, Sha256, PositiveTimestamp};
 
-		assert_eq!( // BOLT 11 payment secret invoice. The unknown fields are invoice features.
-			"lnbc25m1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdq5vdhkven9v5sxyetpdeessp5zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zygs9q5sqqqqqqqqqqqqqqqpqsq67gye39hfg3zd8rgc80k32tvy9xk2xunwm5lzexnvpx6fd77en8qaq424dxgt56cag2dpt359k3ssyhetktkpqh24jqnjyw6uqd08sgptq44qu".parse(),
-			Ok(SignedRawInvoice {
+		// Feature bits 9, 15, and 99 are set.
+		let expected_features = InvoiceFeatures::from_le_bytes(vec![0, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8]);
+		let invoice_str = "lnbc25m1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdq5vdhkven9v5sxyetpdeessp5zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zygs9q5sqqqqqqqqqqqqqqqpqsq67gye39hfg3zd8rgc80k32tvy9xk2xunwm5lzexnvpx6fd77en8qaq424dxgt56cag2dpt359k3ssyhetktkpqh24jqnjyw6uqd08sgptq44qu";
+		let invoice = SignedRawInvoice {
 					raw_invoice: RawInvoice {
 						hrp: RawHrp {
 							currency: Currency::Bitcoin,
@@ -1001,10 +1004,7 @@ mod test {
 								).unwrap())).into(),
 								Description(::Description::new("coffee beans".to_owned()).unwrap()).into(),
 								PaymentSecret(::PaymentSecret([17; 32])).into(),
-								RawTaggedField::UnknownSemantics(vec![5, 0, 20, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-																											0, 0, 0, 0, 1, 0, 16,
-																											0].check_base32().unwrap())],
-									}
+								Features(expected_features).into()]}
 								},
 					hash: [0xb1, 0x96, 0x46, 0xc3, 0xbc, 0x56, 0x76, 0x1d, 0x20, 0x65, 0x6e, 0x0e, 0x32,
 									0xec, 0xd2, 0x69, 0x27, 0xb7, 0x62, 0x6e, 0x2a, 0x8b, 0xe6, 0x97, 0x71, 0x9f,
@@ -1017,8 +1017,12 @@ mod test {
 											0x60, 0x82, 0xea, 0xac, 0x81, 0x39, 0x11, 0xda, 0xe0, 0x1a, 0xf3, 0xc1],
 										RecoveryId::from_i32(1).unwrap()
 								).unwrap()),
-			})
-		)
+			};
+		assert_eq!(invoice_str, invoice.to_string());
+		assert_eq!(
+			invoice_str.parse(),
+			Ok(invoice)
+		);
 	}
 
 	#[test]

lightning-invoice/src/lib.rs

@@ -17,12 +17,14 @@
 
 extern crate bech32;
 extern crate bitcoin_hashes;
+extern crate lightning;
 extern crate num_traits;
 extern crate secp256k1;
 
 use bech32::u5;
 use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256;
+use lightning::ln::features::InvoiceFeatures;
 
 use secp256k1::key::PublicKey;
 use secp256k1::{Message, Secp256k1};
@@ -325,6 +327,7 @@ pub enum TaggedField {
 	Fallback(Fallback),
 	Route(Route),
 	PaymentSecret(PaymentSecret),
+	Features(InvoiceFeatures),
 }
 
 /// SHA-256 hash
@@ -416,6 +419,7 @@ pub mod constants {
 	pub const TAG_FALLBACK: u8 = 9;
 	pub const TAG_ROUTE: u8 = 3;
 	pub const TAG_PAYMENT_SECRET: u8 = 16;
+	pub const TAG_FEATURES: u8 = 5;
 }
 
 impl InvoiceBuilder<tb::False, tb::False, tb::False> {
@@ -506,6 +510,13 @@ impl<D: tb::Bool, H: tb::Bool, T: tb::Bool> InvoiceBuilder<D, H, T> {
 		}
 		self
 	}
+
+	/// Adds a features field which indicates the set of supported protocol extensions which the
+	/// invoice generator supports.
+	pub fn features(mut self, features: InvoiceFeatures) -> Self {
+		self.tagged_fields.push(TaggedField::Features(features));
+		self
+	}
 }
 
 impl<D: tb::Bool, H: tb::Bool> InvoiceBuilder<D, H, tb::True> {
@@ -825,6 +836,10 @@ impl RawInvoice {
 		find_extract!(self.known_tagged_fields(), TaggedField::PaymentSecret(ref x), x)
 	}
 
+	pub fn features(&self) -> Option<&InvoiceFeatures> {
+		find_extract!(self.known_tagged_fields(), TaggedField::Features(ref x), x)
+	}
+
 	pub fn fallbacks(&self) -> Vec<&Fallback> {
 		self.known_tagged_fields().filter_map(|tf| match tf {
 			&TaggedField::Fallback(ref f) => Some(f),
@@ -1012,6 +1027,11 @@ impl Invoice {
 		self.signed_invoice.payment_secret()
 	}
 
+	/// Get the invoice features if they were included in the invoice
+	pub fn features(&self) -> Option<&InvoiceFeatures> {
+		self.signed_invoice.features()
+	}
+
 	/// Recover the payee's public key (only to be used if none was included in the invoice)
 	pub fn recover_payee_pub_key(&self) -> PublicKey {
 		self.signed_invoice.recover_payee_pub_key().expect("was checked by constructor").0
@@ -1069,6 +1089,7 @@ impl TaggedField {
 			TaggedField::Fallback(_) => constants::TAG_FALLBACK,
 			TaggedField::Route(_) => constants::TAG_ROUTE,
 			TaggedField::PaymentSecret(_) => constants::TAG_PAYMENT_SECRET,
+			TaggedField::Features(_) => constants::TAG_FEATURES,
 		};
 
 		u5::try_from_u8(tag).expect("all tags defined are <32")

lightning-invoice/src/ser.rs

@@ -450,7 +450,9 @@ impl ToBase32 for TaggedField {
 			TaggedField::PaymentSecret(ref payment_secret) => {
 				  write_tagged_field(writer, constants::TAG_PAYMENT_SECRET, payment_secret)
 			},
-
+			TaggedField::Features(ref features) => {
+				write_tagged_field(writer, constants::TAG_FEATURES, features)
+			},
 		}
 	}
 }

lightning/src/ln/features.rs

@@ -25,6 +25,8 @@
 use std::{cmp, fmt};
 use std::marker::PhantomData;
 
+use bitcoin::bech32;
+use bitcoin::bech32::{Base32Len, FromBase32, ToBase32, u5, WriteBase32};
 use ln::msgs::DecodeError;
 use util::ser::{Readable, Writeable, Writer};
 
@@ -51,6 +53,7 @@ mod sealed {
 			required_features: [$( $( $required_feature: ident )|*, )*],
 			optional_features: [$( $( $optional_feature: ident )|*, )*],
 		}) => {
+			#[derive(Eq, PartialEq)]
 			pub struct $context {}
 
 			impl Context for $context {
@@ -318,6 +321,7 @@ mod sealed {
 /// appears.
 ///
 /// (C-not exported) as we map the concrete feature types below directly instead
+#[derive(Eq)]
 pub struct Features<T: sealed::Context> {
 	/// Note that, for convenience, flags is LITTLE endian (despite being big-endian on the wire)
 	flags: Vec<u8>,
@@ -395,6 +399,68 @@ impl InvoiceFeatures {
 	}
 }
 
+impl ToBase32 for InvoiceFeatures {
+	fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
+		// Explanation for the "4": the normal way to round up when dividing is to add the divisor
+		// minus one before dividing
+		let total_u5s = (self.flags.len() * 8 + 4) / 5 as usize;
+		let mut be_u5s: Vec<u5> = vec![u5::try_from_u8(0).unwrap(); total_u5s];
+		for (u8_idx, byte) in self.flags.iter().enumerate() {
+			for bit_pos in 0..8 {
+				if 1 << bit_pos & byte != 0 {
+					let bit_pos_from_left_0_indexed = u8_idx * 8 + (bit_pos);
+					let new_u5_idx = total_u5s - (bit_pos_from_left_0_indexed as f64 / 5 as f64).floor() as usize - 1;
+					let new_bit_pos = bit_pos_from_left_0_indexed % 5;
+					be_u5s[new_u5_idx] = u5::try_from_u8(be_u5s[new_u5_idx].to_u8() | 1 << new_bit_pos).unwrap();
+				}
+			}
+		}
+
+		// Trim the starting 0s (they're are the highest feature bits, so if they're unset they should
+		// be dropped)
+		while be_u5s.len() > 0 && be_u5s[0].to_u8() == 0 {
+			be_u5s.remove(0);
+		}
+		writer.write(&be_u5s)
+	}
+}
+
+impl Base32Len for InvoiceFeatures {
+	fn base32_len(&self) -> usize {
+		self.to_base32().len()
+	}
+}
+
+impl FromBase32 for InvoiceFeatures {
+	type Err = bech32::Error;
+
+	fn from_base32(field_data: &[u5]) -> Result<InvoiceFeatures, bech32::Error> {
+		// Explanation for the "7": the normal way to round up when dividing is to add the divisor
+		// minus one before dividing
+		let total_bytes = (field_data.len() * 5 + 7) / 8 as usize;
+		let mut le_bytes: Vec<u8> = vec![0; total_bytes];
+		for (u5_idx, chunk) in field_data.iter().enumerate() {
+			let chunk_as_u8 = chunk.to_u8();
+			for bit_pos in 0..5 {
+				if 1 << bit_pos & chunk_as_u8 != 0 {
+					let bit_pos_from_right_0_indexed = (field_data.len() - u5_idx - 1) * 5 + bit_pos;
+					let new_byte_idx = (bit_pos_from_right_0_indexed as f64 / 8 as f64).floor() as usize;
+					let new_bit_pos = bit_pos_from_right_0_indexed % 8;
+					le_bytes[new_byte_idx] = le_bytes[new_byte_idx] | 1 << new_bit_pos;
+				}
+			}
+		}
+		// Trim the tailing 0s (they're the highest feature bits, so if they're unset they should be
+		// dropped).
+		let mut len = le_bytes.len();
+		while len > 0 && le_bytes[len - 1] == 0 {
+			le_bytes.remove(len - 1);
+			len = le_bytes.len();
+		}
+		Ok(InvoiceFeatures::from_le_bytes(le_bytes))
+	}
+}
+
 impl<T: sealed::Context> Features<T> {
 	/// Create a blank Features with no features set
 	pub fn empty() -> Self {