Invoice request parsing tests

Tests for checking invoice_request message semantics when parsing bytes
as defined by BOLT 12.

Author: jkczyz

lightning/src/offers/invoice_request.rs

@@ -189,6 +189,12 @@ impl<'a> InvoiceRequestBuilder<'a> {
 		let InvoiceRequestBuilder { offer, invoice_request } = self;
 		Ok(UnsignedInvoiceRequest { offer, invoice_request })
 	}
+
+	#[cfg(test)]
+	fn build_unchecked(self) -> UnsignedInvoiceRequest<'a> {
+		let InvoiceRequestBuilder { offer, invoice_request } = self;
+		UnsignedInvoiceRequest { offer, invoice_request }
+	}
 }
 
 /// A semantically valid [`InvoiceRequest`] that hasn't been signed.
@@ -478,13 +484,13 @@ mod tests {
 
 	use bitcoin::blockdata::constants::ChainHash;
 	use bitcoin::network::constants::Network;
-	use bitcoin::secp256k1::{KeyPair, Message, PublicKey, Secp256k1, SecretKey};
+	use bitcoin::secp256k1::{KeyPair, Message, PublicKey, Secp256k1, SecretKey, self};
 	use bitcoin::secp256k1::schnorr::Signature;
 	use core::convert::TryFrom;
 	use core::num::NonZeroU64;
 	use crate::ln::features::InvoiceRequestFeatures;
 	use crate::ln::msgs::DecodeError;
-	use crate::offers::offer::{OfferBuilder, Quantity};
+	use crate::offers::offer::{Amount, Offer, OfferBuilder, Quantity};
 	use crate::offers::parse::{ParseError, SemanticError};
 	use crate::util::ser::{BigSize, Writeable};
 	use crate::util::string::PrintableString;
@@ -823,6 +829,318 @@ mod tests {
 		assert_eq!(tlv_stream.payer_note, Some(&String::from("baz")));
 	}
 
+	#[test]
+	fn parses_invoice_request_with_metadata() {
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.metadata(vec![42; 32])
+			.build().unwrap()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		if let Err(e) = InvoiceRequest::try_from(buffer) {
+			panic!("error parsing invoice_request: {:?}", e);
+		}
+	}
+
+	#[test]
+	fn parses_invoice_request_with_chain() {
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.chain(Network::Bitcoin)
+			.build().unwrap()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		if let Err(e) = InvoiceRequest::try_from(buffer) {
+			panic!("error parsing invoice_request: {:?}", e);
+		}
+
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.chain(Network::Testnet)
+			.build_unchecked()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		match InvoiceRequest::try_from(buffer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnsupportedChain)),
+		}
+	}
+
+	#[test]
+	fn parses_invoice_request_with_amount() {
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.build().unwrap()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		if let Err(e) = InvoiceRequest::try_from(buffer) {
+			panic!("error parsing invoice_request: {:?}", e);
+		}
+
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.amount_msats(1000)
+			.build().unwrap()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		if let Err(e) = InvoiceRequest::try_from(buffer) {
+			panic!("error parsing invoice_request: {:?}", e);
+		}
+
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.build_unchecked()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		match InvoiceRequest::try_from(buffer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingAmount)),
+		}
+
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.amount_msats(999)
+			.build_unchecked()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		match InvoiceRequest::try_from(buffer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::InsufficientAmount)),
+		}
+
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount(Amount::Currency { iso4217_code: *b"USD", amount: 1000 })
+			.build_unchecked()
+			.request_invoice(payer_pubkey())
+			.build_unchecked()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		match InvoiceRequest::try_from(buffer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => {
+				assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnsupportedCurrency));
+			},
+		}
+	}
+
+	#[test]
+	fn parses_invoice_request_with_quantity() {
+		let ten = NonZeroU64::new(10).unwrap();
+
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.supported_quantity(Quantity::one())
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.build().unwrap()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		if let Err(e) = InvoiceRequest::try_from(buffer) {
+			panic!("error parsing invoice_request: {:?}", e);
+		}
+
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.supported_quantity(Quantity::one())
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.amount_msats(2_000)
+			.quantity(2)
+			.build_unchecked()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		match InvoiceRequest::try_from(buffer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => {
+				assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnexpectedQuantity));
+			},
+		}
+
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.supported_quantity(Quantity::Bounded(ten))
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.amount_msats(10_000)
+			.quantity(10)
+			.build().unwrap()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		if let Err(e) = InvoiceRequest::try_from(buffer) {
+			panic!("error parsing invoice_request: {:?}", e);
+		}
+
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.supported_quantity(Quantity::Bounded(ten))
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.amount_msats(11_000)
+			.quantity(11)
+			.build_unchecked()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		match InvoiceRequest::try_from(buffer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::InvalidQuantity)),
+		}
+
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.supported_quantity(Quantity::Unbounded)
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.amount_msats(2_000)
+			.quantity(2)
+			.build().unwrap()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		if let Err(e) = InvoiceRequest::try_from(buffer) {
+			panic!("error parsing invoice_request: {:?}", e);
+		}
+
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.supported_quantity(Quantity::Unbounded)
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.build_unchecked()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		match InvoiceRequest::try_from(buffer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingQuantity)),
+		}
+	}
+
+	#[test]
+	fn parses_invoice_request_with_payer_id() {
+		let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.build().unwrap()
+			.sign(payer_sign).unwrap();
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		if let Err(e) = InvoiceRequest::try_from(buffer) {
+			panic!("error parsing invoice_request: {:?}", e);
+		}
+
+		let offer = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.build().unwrap();
+		let mut unsigned_invoice_request = offer.request_invoice(payer_pubkey()).build().unwrap();
+		let mut tlv_stream = unsigned_invoice_request.invoice_request.as_tlv_stream();
+		tlv_stream.2.payer_id = None;
+
+		let mut buffer = Vec::new();
+		tlv_stream.write(&mut buffer).unwrap();
+
+		match InvoiceRequest::try_from(buffer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingPayerId)),
+		}
+	}
+
+	#[test]
+	fn fails_parsing_invoice_request_with_missing_node_id() {
+		let offer = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.build().unwrap();
+		let mut unsigned_invoice_request = offer.request_invoice(payer_pubkey()).build().unwrap();
+		let mut tlv_stream = unsigned_invoice_request.invoice_request.as_tlv_stream();
+		tlv_stream.1.node_id = None;
+
+		let mut buffer = Vec::new();
+		tlv_stream.write(&mut buffer).unwrap();
+
+		match InvoiceRequest::try_from(buffer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => {
+				assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingSigningPubkey));
+			},
+		}
+	}
+
+	#[test]
+	fn fails_parsing_invoice_request_with_invalid_signature() {
+		let mut invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
+			.amount_msats(1000)
+			.build().unwrap()
+			.request_invoice(payer_pubkey())
+			.build().unwrap()
+			.sign(payer_sign).unwrap();
+		let last_signature_byte = invoice_request.bytes.last_mut().unwrap();
+		*last_signature_byte = last_signature_byte.wrapping_add(1);
+
+		let mut buffer = Vec::new();
+		invoice_request.write(&mut buffer).unwrap();
+
+		match InvoiceRequest::try_from(buffer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => {
+				assert_eq!(e, ParseError::InvalidSignature(secp256k1::Error::InvalidSignature));
+			},
+		}
+	}
+
 	#[test]
 	fn fails_parsing_invoice_request_with_extra_tlv_records() {
 		let secp_ctx = Secp256k1::new();

lightning/src/offers/offer.rs

@@ -145,7 +145,7 @@ impl OfferBuilder {
 	/// Sets the [`Offer::amount`].
 	///
 	/// Successive calls to this method will override the previous setting.
-	fn amount(mut self, amount: Amount) -> Self {
+	pub(crate) fn amount(mut self, amount: Amount) -> Self {
 		self.offer.amount = Some(amount);
 		self
 	}
@@ -221,6 +221,14 @@ impl OfferBuilder {
 			contents: self.offer,
 		})
 	}
+
+	#[cfg(test)]
+	pub(crate) fn build_unchecked(self) -> Offer {
+		let mut bytes = Vec::new();
+		self.offer.write(&mut bytes).unwrap();
+
+		Offer { bytes, contents: self.offer }
+	}
 }
 
 /// An `Offer` is a potentially long-lived proposal for payment of a good or service.
@@ -372,7 +380,7 @@ impl Offer {
 	}
 
 	#[cfg(test)]
-	fn as_tlv_stream(&self) -> OfferTlvStreamRef {
+	pub(crate) fn as_tlv_stream(&self) -> OfferTlvStreamRef {
 		self.contents.as_tlv_stream()
 	}
 }