WIP: Invoice encoding

Author: jkczyz

lightning/src/offers/invoice.rs

@@ -0,0 +1,230 @@
+// 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::secp256k1::schnorr::Signature;
+use bitcoin::util::address::{Address, Payload, WitnessVersion};
+use core::convert::TryFrom;
+use core::time::Duration;
+use io;
+use ln::PaymentHash;
+use ln::features::OfferFeatures;
+use offers::merkle::{SignatureTlvStream, self};
+use offers::offer::OfferTlvStream;
+use offers::parse::{ParseError, SemanticError};
+use offers::payer::PayerTlvStream;
+use offers::invoice_request::{InvoiceRequestContents, InvoiceRequestTlvStream};
+use onion_message::BlindedPath;
+use util::ser::{Readable, WithoutLength, Writeable, Writer};
+
+use prelude::*;
+
+///
+const SIGNATURE_TAG: &'static str = concat!("lightning", "invoice", "signature");
+
+///
+pub struct Invoice {
+	bytes: Vec<u8>,
+	contents: InvoiceContents,
+	signature: Option<Signature>,
+}
+
+///
+pub(crate) struct InvoiceContents {
+	invoice_request: InvoiceRequestContents,
+	paths: Option<Vec<BlindedPath>>,
+	payinfo: Option<Vec<BlindedPayInfo>>,
+	created_at: Duration,
+	relative_expiry: Option<Duration>,
+	payment_hash: PaymentHash,
+	amount_msats: u64,
+	fallbacks: Option<Vec<Address>>,
+	features: Option<OfferFeatures>,
+	code: Option<String>,
+}
+
+impl Invoice {
+	///
+	pub fn fallbacks(&self) -> Vec<&Address> {
+		let is_valid = |address: &&Address| {
+			if let Address { payload: Payload::WitnessProgram { program, .. }, .. } = address {
+				if address.is_standard() {
+					return true;
+				} else if program.len() < 2 || program.len() > 40 {
+					return false;
+				} else {
+					return true;
+				}
+			}
+
+			unreachable!()
+		};
+		self.contents.fallbacks
+			.as_ref()
+			.map(|fallbacks| fallbacks.iter().filter(is_valid).collect())
+			.unwrap_or_else(Vec::new)
+	}
+}
+
+impl Writeable for Invoice {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+		WithoutLength(&self.bytes).write(writer)
+	}
+}
+
+impl TryFrom<Vec<u8>> for Invoice {
+	type Error = ParseError;
+
+	fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
+		let tlv_stream: FullInvoiceTlvStream = Readable::read(&mut &bytes[..])?;
+		Invoice::try_from((bytes, tlv_stream))
+	}
+}
+
+tlv_stream!(InvoiceTlvStream, InvoiceTlvStreamRef, {
+	(160, paths: Vec<BlindedPath>),
+	(162, payinfo: Vec<BlindedPayInfo>),
+	(164, created_at: u64),
+	(166, relative_expiry: u32),
+	(168, payment_hash: PaymentHash),
+	(170, amount: u64),
+	(172, fallbacks: Vec<FallbackAddress>),
+	(174, features: OfferFeatures),
+	(176, code: String),
+});
+
+///
+#[derive(Debug)]
+pub struct BlindedPayInfo {
+	fee_base_msat: u32,
+	fee_proportional_millionths: u32,
+	cltv_expiry_delta: u16,
+	htlc_minimum_msat: u64,
+	htlc_maximum_msat: u64,
+	features_len: u16,
+	features: OfferFeatures,
+}
+
+impl_writeable!(BlindedPayInfo, {
+	fee_base_msat,
+	fee_proportional_millionths,
+	cltv_expiry_delta,
+	htlc_minimum_msat,
+	htlc_maximum_msat,
+	features_len,
+	features
+});
+
+///
+#[derive(Debug)]
+pub struct FallbackAddress {
+	version: WitnessVersion,
+	program: Vec<u8>,
+}
+
+impl_writeable!(FallbackAddress, { version, program });
+
+type ParsedInvoice = (Vec<u8>, FullInvoiceTlvStream);
+
+type FullInvoiceTlvStream =
+	(PayerTlvStream, OfferTlvStream, InvoiceRequestTlvStream, InvoiceTlvStream, SignatureTlvStream);
+
+type PartialInvoiceTlvStream =
+	(PayerTlvStream, OfferTlvStream, InvoiceRequestTlvStream, InvoiceTlvStream);
+
+impl TryFrom<ParsedInvoice> for Invoice {
+	type Error = ParseError;
+
+	fn try_from(invoice: ParsedInvoice) -> Result<Self, Self::Error> {
+		let (bytes, tlv_stream) = invoice;
+		let (
+			payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream,
+			SignatureTlvStream { signature },
+		) = tlv_stream;
+		let contents = InvoiceContents::try_from(
+			(payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream)
+		)?;
+
+		if let Some(signature) = &signature {
+			let pubkey = contents.invoice_request.offer.signing_pubkey();
+			merkle::verify_signature(signature, SIGNATURE_TAG, &bytes, pubkey)?;
+		}
+
+		Ok(Invoice { bytes, contents, signature })
+	}
+}
+
+impl TryFrom<PartialInvoiceTlvStream> for InvoiceContents {
+	type Error = SemanticError;
+
+	fn try_from(tlv_stream: PartialInvoiceTlvStream) -> Result<Self, Self::Error> {
+		let (
+			payer_tlv_stream,
+			offer_tlv_stream,
+			invoice_request_tlv_stream,
+			InvoiceTlvStream {
+				paths, payinfo, created_at, relative_expiry, payment_hash, amount, fallbacks,
+				features, code,
+			},
+		) = tlv_stream;
+
+		let invoice_request = InvoiceRequestContents::try_from(
+			(payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream)
+		)?;
+
+		let (paths, payinfo) = match (paths, payinfo) {
+			(None, _) => return Err(SemanticError::MissingPaths),
+			(_, None) => return Err(SemanticError::InvalidPayInfo),
+			(Some(paths), _) if paths.is_empty() => return Err(SemanticError::MissingPaths),
+			(Some(paths), Some(payinfo)) if paths.len() != payinfo.len() => {
+				return Err(SemanticError::InvalidPayInfo);
+			},
+			(paths, payinfo) => (paths, payinfo),
+		};
+
+		let created_at = match created_at {
+			None => return Err(SemanticError::MissingCreationTime),
+			Some(timestamp) => Duration::from_secs(timestamp),
+		};
+
+		let relative_expiry = relative_expiry
+			.map(Into::<u64>::into)
+			.map(Duration::from_secs);
+
+		let payment_hash = match payment_hash {
+			None => return Err(SemanticError::MissingPaymentHash),
+			Some(payment_hash) => payment_hash,
+		};
+
+		let amount_msats = match amount {
+			None => return Err(SemanticError::MissingAmount),
+			Some(amount) => amount,
+		};
+
+		let fallbacks = match fallbacks {
+			None => None,
+			Some(fallbacks) => {
+				let mut addresses = Vec::with_capacity(fallbacks.len());
+				for FallbackAddress { version, program } in fallbacks {
+					addresses.push(Address {
+						payload: Payload::WitnessProgram { version, program },
+						network: invoice_request.network(),
+					});
+				}
+				Some(addresses)
+			},
+		};
+
+		Ok(InvoiceContents {
+			invoice_request, paths, payinfo, created_at, relative_expiry, payment_hash,
+			amount_msats, fallbacks, features, code,
+		})
+	}
+}

lightning/src/offers/invoice_request.rs

@@ -235,7 +235,7 @@ pub struct InvoiceRequest {
 #[derive(Clone, Debug)]
 pub(crate) struct InvoiceRequestContents {
 	payer: PayerContents,
-	offer: OfferContents,
+	pub(super) offer: OfferContents,
 	chain: Option<ChainHash>,
 	amount_msats: Option<u64>,
 	features: Option<OfferFeatures>,
@@ -306,6 +306,21 @@ impl InvoiceRequestContents {
 		self.chain.unwrap_or_else(|| self.offer.implied_chain())
 	}
 
+	pub fn network(&self) -> Network {
+		let chain = self.chain();
+		if chain == ChainHash::using_genesis_block(Network::Bitcoin) {
+			Network::Bitcoin
+		} else if chain == ChainHash::using_genesis_block(Network::Testnet) {
+			Network::Testnet
+		} else if chain == ChainHash::using_genesis_block(Network::Signet) {
+			Network::Signet
+		} else if chain == ChainHash::using_genesis_block(Network::Regtest) {
+			Network::Regtest
+		} else {
+			unreachable!()
+		}
+	}
+
 	pub(super) fn as_tlv_stream(&self) -> PartialInvoiceRequestTlvStreamRef {
 		let payer = PayerTlvStreamRef {
 			metadata: self.payer.0.as_ref(),

lightning/src/offers/mod.rs

@@ -12,6 +12,7 @@
 //!
 //! Offers are a flexible protocol for Lightning payments.
 
+pub mod invoice;
 pub mod invoice_request;
 mod merkle;
 pub mod offer;

lightning/src/offers/offer.rs

@@ -377,7 +377,7 @@ impl Offer {
 
 	/// The public key used by the recipient to sign invoices.
 	pub fn signing_pubkey(&self) -> PublicKey {
-		self.contents.signing_pubkey.unwrap()
+		self.contents.signing_pubkey()
 	}
 
 	///
@@ -441,6 +441,10 @@ impl OfferContents {
 		self.quantity_min.is_some() || self.quantity_max.is_some()
 	}
 
+	pub fn signing_pubkey(&self) -> PublicKey {
+		self.signing_pubkey.unwrap()
+	}
+
 	pub(super) fn as_tlv_stream(&self) -> OfferTlvStreamRef {
 		let (currency, amount) = match &self.amount {
 			None => (None, None),

lightning/src/offers/parse.rs

@@ -111,6 +111,12 @@ pub enum SemanticError {
 	UnexpectedQuantity,
 	/// A payer id was expected but was missing.
 	MissingPayerId,
+	///
+	InvalidPayInfo,
+	///
+	MissingCreationTime,
+	///
+	MissingPaymentHash,
 }
 
 impl From<bech32::Error> for ParseError {

lightning/src/util/ser.rs

@@ -30,6 +30,7 @@ use bitcoin::consensus;
 use bitcoin::consensus::Encodable;
 use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 use bitcoin::hash_types::{Txid, BlockHash};
+use bitcoin::util::address::WitnessVersion;
 use core::marker::Sized;
 use core::time::Duration;
 use ln::msgs::DecodeError;
@@ -966,6 +967,22 @@ macro_rules! impl_consensus_ser {
 impl_consensus_ser!(Transaction);
 impl_consensus_ser!(TxOut);
 
+impl Writeable for WitnessVersion {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		self.to_num().write(w)
+	}
+}
+
+impl Readable for WitnessVersion {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let num: u8 = Readable::read(r)?;
+		match WitnessVersion::try_from(num) {
+			Ok(version) => Ok(version),
+			Err(_) => Err(DecodeError::InvalidValue),
+		}
+	}
+}
+
 impl<T: Readable> Readable for Mutex<T> {
 	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let t: T = Readable::read(r)?;
@@ -1026,6 +1043,26 @@ impl<A: Writeable, B: Writeable, C: Writeable, D: Writeable> Writeable for (A, B
 	}
 }
 
+impl<A: Readable, B: Readable, C: Readable, D: Readable, E: Readable> Readable for (A, B, C, D, E) {
+	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)?;
+		let e: E = Readable::read(r)?;
+		Ok((a, b, c, d, e))
+	}
+}
+impl<A: Writeable, B: Writeable, C: Writeable, D: Writeable, E: Writeable> Writeable for (A, B, C, D, E) {
+	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)?;
+		self.4.write(w)
+	}
+}
+
 impl Writeable for () {
 	fn write<W: Writer>(&self, _: &mut W) -> Result<(), io::Error> {
 		Ok(())