Add baseline OnionMessenger and msgs::OnionMessage and its serialization

OnionMessenger will be a MessageSendEventsProvider, so the next commit will be
adding the boilerplate for it to send and receive messages from the PeerManager

Author: valentinewallace

lightning/src/ln/msgs.rs

@@ -31,6 +31,7 @@ use bitcoin::blockdata::script::Script;
 use bitcoin::hash_types::{Txid, BlockHash};
 
 use ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
+use onion_message;
 
 use prelude::*;
 use core::fmt;
@@ -40,7 +41,7 @@ use io_extras::read_to_end;
 
 use util::events::MessageSendEventsProvider;
 use util::logger;
-use util::ser::{Readable, Writeable, Writer, FixedLengthReader, HighZeroBytesDroppedVarInt};
+use util::ser::{LengthReadable, Readable, Writeable, Writer, FixedLengthReader, HighZeroBytesDroppedVarInt};
 
 use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
 
@@ -304,6 +305,16 @@ pub struct UpdateAddHTLC {
 	pub(crate) onion_routing_packet: OnionPacket,
 }
 
+ /// An onion message to be sent or received from a peer
+#[derive(Clone, Debug, PartialEq)]
+pub struct OnionMessage {
+	/// This blinding point is used in the shared secret that is used to decrypt the onion message
+	/// payload's `encrypted_data` field.
+	pub(crate) blinding_point: PublicKey,
+	pub(crate) len: u16,
+	pub(crate) onion_routing_packet: onion_message::Packet,
+}
+
 /// An update_fulfill_htlc message to be sent or received from a peer
 #[derive(Clone, Debug, PartialEq)]
 pub struct UpdateFulfillHTLC {
@@ -1304,6 +1315,29 @@ impl_writeable_msg!(UpdateAddHTLC, {
 	onion_routing_packet
 }, {});
 
+impl Readable for OnionMessage {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let blinding_point: PublicKey = Readable::read(r)?;
+		let len: u16 = Readable::read(r)?;
+		let mut packet_reader = FixedLengthReader::new(r, len as u64);
+		let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
+		Ok(Self {
+			blinding_point,
+			len,
+			onion_routing_packet,
+		})
+	}
+}
+
+impl Writeable for OnionMessage {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		self.blinding_point.write(w)?;
+		self.len.write(w)?;
+		self.onion_routing_packet.write(w)?;
+		Ok(())
+	}
+}
+
 impl Writeable for FinalOnionHopData {
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 		self.payment_secret.0.write(w)?;

lightning/src/onion_message.rs

@@ -14,15 +14,18 @@ use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::secp256k1::{self, PublicKey, Secp256k1, SecretKey};
 use bitcoin::secp256k1::ecdh::SharedSecret;
 
-use chain::keysinterface::{KeysInterface, Sign};
+use chain::keysinterface::{InMemorySigner, KeysInterface, KeysManager, Sign};
 use ln::msgs::DecodeError;
 use ln::onion_utils;
 use util::chacha20poly1305rfc::ChaChaPolyWriteAdapter;
+use util::events::MessageSendEvent;
+use util::logger::Logger;
 use util::ser::{IgnoringLengthReadable, LengthRead, LengthReadable, Readable, VecWriter, Writeable, Writer};
 
 use core::ops::Deref;
 use io::{self, Read};
 use prelude::*;
+use sync::{Arc, Mutex};
 
 #[derive(Clone, Debug, PartialEq)]
 pub(crate) struct Packet {
@@ -225,6 +228,41 @@ impl BlindedRoute {
 	}
 }
 
+/// A sender, receiver and forwarder of onion messages. In upcoming releases, this object will be
+/// used to retrieve invoices and fulfill invoice requests from [offers].
+///
+/// [offers]: https://github.com/lightning/bolts/pull/798
+pub struct OnionMessenger<Signer: Sign, K: Deref, L: Deref>
+	where K::Target: KeysInterface<Signer = Signer>,
+				L::Target: Logger,
+{
+	keys_manager: K,
+	logger: L,
+	pending_msg_events: Mutex<Vec<MessageSendEvent>>,
+	secp_ctx: Secp256k1<secp256k1::All>,
+	// Coming soon:
+	// invoice_handler: InvoiceHandler,
+	// custom_handler: CustomHandler, // handles custom onion messages
+}
+
+impl<Signer: Sign, K: Deref, L: Deref> OnionMessenger<Signer, K, L>
+	where K::Target: KeysInterface<Signer = Signer>,
+				L::Target: Logger,
+{
+	/// Constructs a new `OnionMessenger` to send, forward, and delegate received onion messages to
+	/// their respective handlers.
+	pub fn new(keys_manager: K, logger: L) -> Self {
+		let mut secp_ctx = Secp256k1::new();
+		secp_ctx.seeded_randomize(&keys_manager.get_secure_random_bytes());
+		OnionMessenger {
+			keys_manager,
+			pending_msg_events: Mutex::new(Vec::new()),
+			secp_ctx,
+			logger,
+		}
+	}
+}
+
 #[inline]
 fn construct_keys_callback<
 	T: secp256k1::Signing + secp256k1::Verification,
@@ -300,3 +338,16 @@ fn construct_blinded_route_keys<T: secp256k1::Signing + secp256k1::Verification>
 
 	Ok((encrypted_data_keys, blinded_node_pks))
 }
+
+/// Useful for simplifying the parameters of [`SimpleArcChannelManager`] and
+/// [`SimpleArcPeerManager`]. See their docs for more details.
+///
+///[`SimpleArcChannelManager`]: crate::ln::channelmanager::SimpleArcChannelManager
+///[`SimpleArcPeerManager`]: crate::ln::peer_handler::SimpleArcPeerManager
+pub type SimpleArcOnionMessenger<L> = OnionMessenger<InMemorySigner, Arc<KeysManager>, Arc<L>>;
+/// Useful for simplifying the parameters of [`SimpleRefChannelManager`] and
+/// [`SimpleRefPeerManager`]. See their docs for more details.
+///
+///[`SimpleRefChannelManager`]: crate::ln::channelmanager::SimpleRefChannelManager
+///[`SimpleRefPeerManager`]: crate::ln::peer_handler::SimpleRefPeerManager
+pub type SimpleRefOnionMessenger<'a, 'b, L> = OnionMessenger<InMemorySigner, &'a KeysManager, &'b L>;