Onion message payload for Offers

TODO: Include details

Author: jkczyz

lightning/src/onion_message/messenger.rs

@@ -217,8 +217,8 @@ impl<ES: Deref, NS: Deref, L: Deref, CMH: Deref> OnionMessenger<ES, NS, L, CMH>
 				return Err(SendError::TooFewBlindedHops);
 			}
 		}
-		let OnionMessageContents::Custom(ref msg) = message;
-		if msg.tlv_type() < 64 { return Err(SendError::InvalidMessage) }
+
+		if message.tlv_type() < 64 { return Err(SendError::InvalidMessage) }
 
 		// If we are sending straight to a blinded path and we are the introduction node, we need to
 		// advance the blinded path by 1 hop so the second hop is the new introduction node.
@@ -342,6 +342,7 @@ impl<ES: Deref, NS: Deref, L: Deref, CMH: Deref> OnionMessageHandler for OnionMe
 					"Received an onion message with path_id {:02x?} and {} reply_path",
 						path_id, if reply_path.is_some() { "a" } else { "no" });
 				match message {
+					OnionMessageContents::Offers(_msg) => todo!(),
 					OnionMessageContents::Custom(msg) => self.custom_handler.handle_custom_message(msg),
 				}
 			},

lightning/src/onion_message/mod.rs

@@ -22,6 +22,7 @@
 
 mod blinded_path;
 mod messenger;
+mod offers;
 mod packet;
 mod utils;
 #[cfg(test)]

lightning/src/onion_message/offers.rs

@@ -0,0 +1,95 @@
+// 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.
+
+//! Message handling for BOLT 12 Offers.
+
+use core::convert::TryFrom;
+use crate::io::{self, Read};
+use crate::ln::msgs::DecodeError;
+use crate::offers::invoice_request::InvoiceRequest;
+use crate::offers::invoice::Invoice;
+use crate::offers::parse::ParseError;
+use crate::util::ser::{ReadableArgs, Writeable, Writer};
+
+use crate::prelude::*;
+
+// TLV record types for the `onionmsg_tlv` TLV stream as defined in BOLT 4.
+const INVOICE_REQUEST_TLV_TYPE: u64 = 64;
+const INVOICE_TLV_TYPE: u64 = 66;
+const INVOICE_ERROR_TLV_TYPE: u64 = 68;
+
+/// Possible BOLT 12 Offers messages sent and received via an [`OnionMessage`].
+///
+/// [`OnionMessage`]: crate::ln::msgs::OnionMessage
+#[derive(Debug)]
+pub enum OffersMessage {
+	/// A request for an [`Invoice`] for a particular [`Offer`].
+	///
+	/// [`Offer`]: crate::offers::offer::Offer
+	InvoiceRequest(InvoiceRequest),
+
+	/// An [`Invoice`] sent in response to an [`InvoiceRequest`] or a [`Refund`].
+	///
+	/// [`Refund`]: crate::offers::refund::Refund
+	Invoice(Invoice),
+
+	/// An error from handling an [`OffersMessage`].
+	InvoiceError,
+}
+
+impl OffersMessage {
+	/// Returns whether `tlv_type` corresponds to a TLV record for Offers.
+	pub fn is_known_type(tlv_type: u64) -> bool {
+		match tlv_type {
+			INVOICE_REQUEST_TLV_TYPE | INVOICE_TLV_TYPE | INVOICE_ERROR_TLV_TYPE => true,
+			_ => false,
+		}
+	}
+
+	/// The TLV record type for the message as used in an `onionmsg_tlv` TLV stream.
+	pub fn tlv_type(&self) -> u64 {
+		match self {
+			OffersMessage::InvoiceRequest(_) => INVOICE_REQUEST_TLV_TYPE,
+			OffersMessage::Invoice(_) => INVOICE_TLV_TYPE,
+			OffersMessage::InvoiceError => INVOICE_ERROR_TLV_TYPE,
+		}
+	}
+
+	fn parse(tlv_type: u64, bytes: Vec<u8>) -> Result<Self, ParseError> {
+		match tlv_type {
+			INVOICE_REQUEST_TLV_TYPE => Ok(Self::InvoiceRequest(InvoiceRequest::try_from(bytes)?)),
+			INVOICE_TLV_TYPE => Ok(Self::Invoice(Invoice::try_from(bytes)?)),
+			INVOICE_ERROR_TLV_TYPE => Ok(Self::InvoiceError),
+			_ => unreachable!(),
+		}
+	}
+}
+
+impl Writeable for OffersMessage {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		match self {
+			OffersMessage::InvoiceRequest(message) => message.write(w),
+			OffersMessage::Invoice(message) => message.write(w),
+			OffersMessage::InvoiceError => Ok(()),
+		}
+	}
+}
+
+impl ReadableArgs<u64> for OffersMessage {
+	fn read<R: Read>(r: &mut R, tlv_type: u64) -> Result<Self, DecodeError> {
+		let mut bytes = Vec::new();
+		r.read_to_end(&mut bytes).unwrap();
+
+		match Self::parse(tlv_type, bytes) {
+			Ok(message) => Ok(message),
+			Err(ParseError::Decode(e)) => Err(e),
+			Err(_) => Err(DecodeError::InvalidValue), // TODO: log ParseError?
+		}
+	}
+}

lightning/src/onion_message/packet.rs

@@ -16,6 +16,7 @@ use crate::ln::msgs::DecodeError;
 use crate::ln::onion_utils;
 use super::blinded_path::{BlindedPath, ForwardTlvs, ReceiveTlvs};
 use super::messenger::CustomOnionMessageHandler;
+use super::offers::OffersMessage;
 use crate::util::chacha20poly1305rfc::{ChaChaPolyReadAdapter, ChaChaPolyWriteAdapter};
 use crate::util::ser::{BigSize, FixedLengthReader, LengthRead, LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer};
 
@@ -108,10 +109,8 @@ pub(super) enum Payload<T: CustomOnionMessageContents> {
 /// The contents of an onion message. In the context of offers, this would be the invoice, invoice
 /// request, or invoice error.
 pub enum OnionMessageContents<T: CustomOnionMessageContents> {
-	// Coming soon:
-	// Invoice,
-	// InvoiceRequest,
-	// InvoiceError,
+	/// A message related to BOLT 12 Offers.
+	Offers(OffersMessage),
 	/// A custom onion message specified by the user.
 	Custom(T),
 }
@@ -122,6 +121,7 @@ impl<T: CustomOnionMessageContents> OnionMessageContents<T> {
 	/// (C-not exported) as methods on non-cloneable enums are not currently exportable
 	pub fn tlv_type(&self) -> u64 {
 		match self {
+			&OnionMessageContents::Offers(ref msg) => msg.tlv_type(),
 			&OnionMessageContents::Custom(ref msg) => msg.tlv_type(),
 		}
 	}
@@ -131,6 +131,7 @@ impl<T: CustomOnionMessageContents> OnionMessageContents<T> {
 impl<T: CustomOnionMessageContents> Writeable for OnionMessageContents<T> {
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 		match self {
+			OnionMessageContents::Offers(msg) => Ok(msg.write(w)?),
 			OnionMessageContents::Custom(msg) => Ok(msg.write(w)?),
 		}
 	}
@@ -215,19 +216,30 @@ impl<H: CustomOnionMessageHandler> ReadableArgs<(SharedSecret, &H)> for Payload<
 		decode_tlv_stream_with_custom_tlv_decode!(&mut rd, {
 			(2, reply_path, option),
 			(4, read_adapter, (option: LengthReadableArgs, rho)),
-		}, |msg_type, msg_reader| {
+		}, |msg_type, msg_reader: &mut FixedLengthReader<_>| {
 			if msg_type < 64 { return Ok(false) }
 			// Don't allow reading more than one data TLV from an onion message.
 			if message_type.is_some() { return Err(DecodeError::InvalidValue) }
 
 			message_type = Some(msg_type);
-			match handler.read_custom_message(msg_type, msg_reader) {
-				Ok(Some(msg)) => {
-					message = Some(msg);
-					Ok(true)
+			match msg_type {
+				tlv_type if OffersMessage::is_known_type(tlv_type) => {
+					match OffersMessage::read(msg_reader, tlv_type) {
+						Ok(msg) => {
+							message = Some(OnionMessageContents::Offers(msg));
+							Ok(true)
+						},
+						Err(e) => Err(e),
+					}
+				},
+				_ => match handler.read_custom_message(msg_type, msg_reader) {
+					Ok(Some(msg)) => {
+						message = Some(OnionMessageContents::Custom(msg));
+						Ok(true)
+					},
+					Ok(None) => Ok(false),
+					Err(e) => Err(e),
 				},
-				Ok(None) => Ok(false),
-				Err(e) => Err(e),
 			}
 		});
 		rd.eat_remaining().map_err(|_| DecodeError::ShortRead)?;
@@ -245,7 +257,7 @@ impl<H: CustomOnionMessageHandler> ReadableArgs<(SharedSecret, &H)> for Payload<
 				Ok(Payload::Receive {
 					control_tlvs: ReceiveControlTlvs::Unblinded(tlvs),
 					reply_path,
-					message: OnionMessageContents::Custom(message.unwrap()),
+					message: message.unwrap(),
 				})
 			}
 		}