WIP: invoice_request with reflected offer

Author: jkczyz

lightning/src/offers/invoice_request.rs

@@ -0,0 +1,111 @@
+// This file is Copyright its original authors, visible in version control
+// history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
+//! Data structures and encoding for `invoice_request` messages.
+
+use bitcoin::hash_types::BlockHash;
+use bitcoin::secp256k1::PublicKey;
+use bitcoin::secp256k1::schnorr::Signature;
+use core::convert::TryFrom;
+use core::str::FromStr;
+use ln::features::OfferFeatures;
+use offers::{Offer, PayerTlvStream};
+use offers::merkle::SignatureTlvStream;
+use offers::offer::{OfferTlvStream, ParsedOffer};
+use offers::parse::{Bech32Encode, ParseError, SemanticError};
+
+///
+pub struct InvoiceRequest {
+	bytes: Vec<u8>,
+	offer: Offer,
+	chain: Option<BlockHash>,
+	amount_msat: Option<u64>,
+	features: Option<OfferFeatures>,
+	quantity: Option<u64>,
+	payer_id: Option<PublicKey>,
+	payer_note: Option<String>,
+	payer_info: Option<Vec<u8>>,
+	signature: Option<Signature>,
+}
+
+impl AsRef<[u8]> for InvoiceRequest {
+	fn as_ref(&self) -> &[u8] {
+		&self.bytes
+	}
+}
+
+tlv_stream!(struct InvoiceRequestTlvStream {
+	(80, chain: BlockHash),
+	(82, amount: u64),
+	(84, features: OfferFeatures),
+	(86, quantity: u64),
+	(88, payer_id: PublicKey),
+	(89, payer_note: String),
+});
+
+impl Bech32Encode for InvoiceRequest {
+	type TlvStream = FullInvoiceRequestTlvStream;
+
+	const BECH32_HRP: &'static str = "lnr";
+}
+
+type FullInvoiceRequestTlvStream =
+	(PayerTlvStream, OfferTlvStream, InvoiceRequestTlvStream, SignatureTlvStream);
+
+impl FromStr for InvoiceRequest {
+	type Err = ParseError;
+
+	fn from_str(s: &str) -> Result<Self, <Self as FromStr>::Err> {
+		let (tlv_stream, bytes) = InvoiceRequest::from_bech32_str(s)?;
+		Ok(InvoiceRequest::try_from((tlv_stream, bytes))?)
+	}
+}
+
+type ParsedInvoiceRequest = (FullInvoiceRequestTlvStream, Vec<u8>);
+
+impl TryFrom<ParsedInvoiceRequest> for InvoiceRequest {
+	type Error = SemanticError;
+
+	fn try_from(invoice_request: ParsedInvoiceRequest) -> Result<Self, Self::Error> {
+		let ((
+				PayerTlvStream { payer_info },
+				offer_tlv_stream,
+				InvoiceRequestTlvStream { chain, amount, features, quantity, payer_id, payer_note },
+				SignatureTlvStream { signature },
+		), bytes) = invoice_request;
+
+		let offer = Offer::try_from(ParsedOffer(offer_tlv_stream, vec![]))?;
+
+		let chain = match chain {
+			None => None,
+			Some(chain) if chain == offer.chain() => Some(chain),
+			Some(_) => return Err(SemanticError::UnsupportedChain),
+		};
+
+		// TODO: Check remaining fields against the reflected offer
+		let amount_msat = amount.map(Into::into);
+
+		let quantity = quantity.map(Into::into);
+
+		let payer_note = payer_note.map(Into::into);
+
+		let payer_info = payer_info.map(Into::into);
+
+		Ok(InvoiceRequest {
+			bytes, offer, chain, amount_msat, features, quantity, payer_id, payer_note, payer_info,
+			signature,
+		})
+	}
+}
+
+impl core::fmt::Display for InvoiceRequest {
+	fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
+		self.fmt_bech32_str(f)
+	}
+}

lightning/src/offers/merkle.rs

@@ -10,10 +10,15 @@
 //! Tagged hashes for use in signature calculation and verification.
 
 use bitcoin::hashes::{Hash, HashEngine, sha256};
+use bitcoin::secp256k1::schnorr::Signature;
 use util::ser::{BigSize, Readable};
 
 const SIGNATURE_TYPES: core::ops::RangeInclusive<u64> = 240..=1000;
 
+tlv_stream!(struct SignatureTlvStream {
+	(240, signature: Signature),
+});
+
 pub(super) fn root_hash(data: &[u8]) -> sha256::Hash {
 	let mut tlv_stream = TlvStream::new(&data[..]).peekable();
 	let nonce_tag = tagged_hash_engine(sha256::Hash::from_engine({

lightning/src/offers/mod.rs

@@ -10,6 +10,7 @@
 //! Implementation of Lightning Offers
 //! ([BOLT 12](https://github.com/lightning/bolts/blob/master/12-offer-encoding.md)).
 
+mod invoice_request;
 mod merkle;
 mod offer;
 mod parse;

lightning/src/util/ser.rs

@@ -1043,6 +1043,24 @@ impl<A: Writeable, B: Writeable, C: Writeable> Writeable for (A, B, C) {
 	}
 }
 
+impl<A: Readable, B: Readable, C: Readable, D: Readable> Readable for (A, B, C, D) {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let a: A = Readable::read(r)?;
+		let b: B = Readable::read(r)?;
+		let c: C = Readable::read(r)?;
+		let d: D = Readable::read(r)?;
+		Ok((a, b, c, d))
+	}
+}
+impl<A: Writeable, B: Writeable, C: Writeable, D: Writeable> Writeable for (A, B, C, D) {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		self.0.write(w)?;
+		self.1.write(w)?;
+		self.2.write(w)?;
+		self.3.write(w)
+	}
+}
+
 impl Writeable for () {
 	fn write<W: Writer>(&self, _: &mut W) -> Result<(), io::Error> {
 		Ok(())

lightning/src/util/ser_macros.rs

@@ -437,7 +437,7 @@ macro_rules! tlv_stream {
 		#[derive(Debug)]
 		pub(crate) struct $name {
 			$(
-				$field: Option<tlv_record_type!($fieldty$(<$gen>)?)>,
+				pub(crate) $field: Option<tlv_record_type!($fieldty$(<$gen>)?)>,
 			)*
 		}