X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fonion_message%2Fmessenger.rs;h=3ee9d8fc4fabe81b9438367ac96bfcd903c97638;hb=3194d833b609e72b0b3cf0bcf988d37eadc75c74;hp=a09c942be61fbfcb75da606e6b440bfffa37bdbc;hpb=3ba91cea59fc2a9c4edb6b06ba54244a640d659d;p=rust-lightning diff --git a/lightning/src/onion_message/messenger.rs b/lightning/src/onion_message/messenger.rs index a09c942b..3ee9d8fc 100644 --- a/lightning/src/onion_message/messenger.rs +++ b/lightning/src/onion_message/messenger.rs @@ -15,13 +15,13 @@ use bitcoin::hashes::hmac::{Hmac, HmacEngine}; use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::secp256k1::{self, PublicKey, Scalar, Secp256k1, SecretKey}; -use crate::chain::keysinterface::{InMemorySigner, KeysInterface, KeysManager, Recipient, Sign}; +use crate::chain::keysinterface::{KeysInterface, KeysManager, Recipient}; use crate::ln::features::{InitFeatures, NodeFeatures}; use crate::ln::msgs::{self, OnionMessageHandler}; use crate::ln::onion_utils; use crate::ln::peer_handler::IgnoringMessageHandler; -use super::blinded_route::{BlindedRoute, ForwardTlvs, ReceiveTlvs}; -pub use super::packet::{CustomOnionMessageContents, OnionMessageContents}; +use super::blinded_path::{BlindedPath, ForwardTlvs, ReceiveTlvs}; +use super::packet::{CustomOnionMessageContents, OnionMessageContents}; use super::packet::{BIG_PACKET_HOP_DATA_LEN, ForwardControlTlvs, Packet, Payload, ReceiveControlTlvs, SMALL_PACKET_HOP_DATA_LEN}; use super::utils; use crate::util::events::OnionMessageProvider; @@ -46,7 +46,8 @@ use crate::prelude::*; /// # use lightning::chain::keysinterface::{InMemorySigner, KeysManager, KeysInterface}; /// # use lightning::ln::msgs::DecodeError; /// # use lightning::ln::peer_handler::IgnoringMessageHandler; -/// # use lightning::onion_message::{BlindedRoute, CustomOnionMessageContents, Destination, OnionMessageContents, OnionMessenger}; +/// # use lightning::onion_message::blinded_path::BlindedPath; +/// # use lightning::onion_message::messenger::{CustomOnionMessageContents, Destination, OnionMessageContents, OnionMessenger}; /// # use lightning::util::logger::{Logger, Record}; /// # use lightning::util::ser::{Writeable, Writer}; /// # use lightning::io; @@ -89,23 +90,23 @@ use crate::prelude::*; /// let message = OnionMessageContents::Custom(your_custom_message); /// onion_messenger.send_onion_message(&intermediate_hops, Destination::Node(destination_node_id), message, reply_path); /// -/// // Create a blinded route to yourself, for someone to send an onion message to. +/// // Create a blinded path to yourself, for someone to send an onion message to. /// # let your_node_id = hop_node_id1; /// let hops = [hop_node_id3, hop_node_id4, your_node_id]; -/// let blinded_route = BlindedRoute::new(&hops, &keys_manager, &secp_ctx).unwrap(); +/// let blinded_path = BlindedPath::new(&hops, &keys_manager, &secp_ctx).unwrap(); /// -/// // Send a custom onion message to a blinded route. +/// // Send a custom onion message to a blinded path. /// # let intermediate_hops = [hop_node_id1, hop_node_id2]; /// let reply_path = None; /// # let your_custom_message = YourCustomMessage {}; /// let message = OnionMessageContents::Custom(your_custom_message); -/// onion_messenger.send_onion_message(&intermediate_hops, Destination::BlindedRoute(blinded_route), message, reply_path); +/// onion_messenger.send_onion_message(&intermediate_hops, Destination::BlindedPath(blinded_path), message, reply_path); /// ``` /// /// [offers]: /// [`OnionMessenger`]: crate::onion_message::OnionMessenger -pub struct OnionMessenger - where K::Target: KeysInterface, +pub struct OnionMessenger + where K::Target: KeysInterface, L::Target: Logger, CMH:: Target: CustomOnionMessageHandler, { @@ -122,15 +123,15 @@ pub struct OnionMessenger pub enum Destination { /// We're sending this onion message to a node. Node(PublicKey), - /// We're sending this onion message to a blinded route. - BlindedRoute(BlindedRoute), + /// We're sending this onion message to a blinded path. + BlindedPath(BlindedPath), } impl Destination { pub(super) fn num_hops(&self) -> usize { match self { Destination::Node(_) => 1, - Destination::BlindedRoute(BlindedRoute { blinded_hops, .. }) => blinded_hops.len(), + Destination::BlindedPath(BlindedPath { blinded_hops, .. }) => blinded_hops.len(), } } } @@ -145,7 +146,7 @@ pub enum SendError { /// Because implementations such as Eclair will drop onion messages where the message packet /// exceeds 32834 bytes, we refuse to send messages where the packet exceeds this size. TooBigPacket, - /// The provided [`Destination`] was an invalid [`BlindedRoute`], due to having fewer than two + /// The provided [`Destination`] was an invalid [`BlindedPath`], due to having fewer than two /// blinded hops. TooFewBlindedHops, /// Our next-hop peer was offline or does not support onion message forwarding. @@ -158,11 +159,11 @@ pub enum SendError { /// /// [`KeysInterface`]: crate::chain::keysinterface::KeysInterface GetNodeIdFailed, - /// We attempted to send to a blinded route where we are the introduction node, and failed to - /// advance the blinded route to make the second hop the new introduction node. Either + /// We attempted to send to a blinded path where we are the introduction node, and failed to + /// advance the blinded path to make the second hop the new introduction node. Either /// [`KeysInterface::ecdh`] failed, we failed to tweak the current blinding point to get the /// new blinding point, or we were attempting to send to ourselves. - BlindedRouteAdvanceFailed, + BlindedPathAdvanceFailed, } /// Handler for custom onion messages. If you are using [`SimpleArcOnionMessenger`], @@ -186,8 +187,8 @@ pub trait CustomOnionMessageHandler { fn read_custom_message(&self, message_type: u64, buffer: &mut R) -> Result, msgs::DecodeError>; } -impl OnionMessenger - where K::Target: KeysInterface, +impl OnionMessenger + where K::Target: KeysInterface, L::Target: Logger, CMH::Target: CustomOnionMessageHandler, { @@ -207,8 +208,8 @@ impl OnionMessenger(&self, intermediate_nodes: &[PublicKey], mut destination: Destination, message: OnionMessageContents, reply_path: Option) -> Result<(), SendError> { - if let Destination::BlindedRoute(BlindedRoute { ref blinded_hops, .. }) = destination { + pub fn send_onion_message(&self, intermediate_nodes: &[PublicKey], mut destination: Destination, message: OnionMessageContents, reply_path: Option) -> Result<(), SendError> { + if let Destination::BlindedPath(BlindedPath { ref blinded_hops, .. }) = destination { if blinded_hops.len() < 2 { return Err(SendError::TooFewBlindedHops); } @@ -216,15 +217,15 @@ impl OnionMessenger OnionMessenger (pk, PublicKey::from_secret_key(&self.secp_ctx, &blinding_secret)), - Destination::BlindedRoute(BlindedRoute { introduction_node_id, blinding_point, .. }) => + Destination::BlindedPath(BlindedPath { introduction_node_id, blinding_point, .. }) => (introduction_node_id, blinding_point), } }; @@ -295,8 +296,8 @@ fn outbound_buffer_full(peer_node_id: &PublicKey, buffer: &HashMap OnionMessageHandler for OnionMessenger - where K::Target: KeysInterface, +impl OnionMessageHandler for OnionMessenger + where K::Target: KeysInterface, L::Target: Logger, CMH::Target: CustomOnionMessageHandler + Sized, { @@ -346,7 +347,7 @@ impl OnionMessageHandler for Onion // TODO: we need to check whether `next_node_id` is our node, in which case this is a dummy // blinded hop and this onion message is destined for us. In this situation, we should keep // unwrapping the onion layers to get to the final payload. Since we don't have the option - // of creating blinded routes with dummy hops currently, we should be ok to not handle this + // of creating blinded paths with dummy hops currently, we should be ok to not handle this // for now. let new_pubkey = match onion_utils::next_hop_packet_pubkey(&self.secp_ctx, msg.onion_routing_packet.public_key, &onion_decode_ss) { Ok(pk) => pk, @@ -439,8 +440,8 @@ impl OnionMessageHandler for Onion } } -impl OnionMessageProvider for OnionMessenger - where K::Target: KeysInterface, +impl OnionMessageProvider for OnionMessenger + where K::Target: KeysInterface, L::Target: Logger, CMH::Target: CustomOnionMessageHandler, { @@ -462,7 +463,7 @@ impl OnionMessageProvider for Onio /// /// [`SimpleArcChannelManager`]: crate::ln::channelmanager::SimpleArcChannelManager /// [`SimpleArcPeerManager`]: crate::ln::peer_handler::SimpleArcPeerManager -pub type SimpleArcOnionMessenger = OnionMessenger, Arc, IgnoringMessageHandler>; +pub type SimpleArcOnionMessenger = OnionMessenger, Arc, IgnoringMessageHandler>; /// Useful for simplifying the parameters of [`SimpleRefChannelManager`] and /// [`SimpleRefPeerManager`]. See their docs for more details. /// @@ -470,19 +471,19 @@ pub type SimpleArcOnionMessenger = OnionMessenger = OnionMessenger; +pub type SimpleRefOnionMessenger<'a, 'b, L> = OnionMessenger<&'a KeysManager, &'b L, IgnoringMessageHandler>; /// Construct onion packet payloads and keys for sending an onion message along the given /// `unblinded_path` to the given `destination`. fn packet_payloads_and_keys( secp_ctx: &Secp256k1, unblinded_path: &[PublicKey], destination: Destination, - message: OnionMessageContents, mut reply_path: Option, session_priv: &SecretKey + message: OnionMessageContents, mut reply_path: Option, session_priv: &SecretKey ) -> Result<(Vec<(Payload, [u8; 32])>, Vec), secp256k1::Error> { let num_hops = unblinded_path.len() + destination.num_hops(); let mut payloads = Vec::with_capacity(num_hops); let mut onion_packet_keys = Vec::with_capacity(num_hops); - let (mut intro_node_id_blinding_pt, num_blinded_hops) = if let Destination::BlindedRoute(BlindedRoute { + let (mut intro_node_id_blinding_pt, num_blinded_hops) = if let Destination::BlindedPath(BlindedPath { introduction_node_id, blinding_point, blinded_hops }) = &destination { (Some((*introduction_node_id, *blinding_point)), blinded_hops.len()) } else { (None, 0) }; let num_unblinded_hops = num_hops - num_blinded_hops;