diff --git a/lightning/src/onion_message/blinded_route.rs b/lightning/src/onion_message/blinded_path.rs similarity index 86% rename from lightning/src/onion_message/blinded_route.rs rename to lightning/src/onion_message/blinded_path.rs index 8a8d9924f9f..31a23bc17d0 100644 --- a/lightning/src/onion_message/blinded_route.rs +++ b/lightning/src/onion_message/blinded_path.rs @@ -7,7 +7,7 @@ // You may not use this file except in accordance with one or both of these // licenses. -//! Creating blinded routes and related utilities live here. +//! Creating blinded paths and related utilities live here. use bitcoin::hashes::{Hash, HashEngine}; use bitcoin::hashes::sha256::Hash as Sha256; @@ -26,11 +26,11 @@ use core::ops::Deref; use crate::io::{self, Cursor}; use crate::prelude::*; -/// Onion messages can be sent and received to blinded routes, which serve to hide the identity of +/// Onion messages can be sent and received to blinded paths, which serve to hide the identity of /// the recipient. #[derive(Clone, Debug, PartialEq)] -pub struct BlindedRoute { - /// To send to a blinded route, the sender first finds a route to the unblinded +pub struct BlindedPath { + /// To send to a blinded path, the sender first finds a route to the unblinded /// `introduction_node_id`, which can unblind its [`encrypted_payload`] to find out the onion /// message's next hop and forward it along. /// @@ -41,24 +41,24 @@ pub struct BlindedRoute { /// /// [`encrypted_payload`]: BlindedHop::encrypted_payload pub(crate) blinding_point: PublicKey, - /// The hops composing the blinded route. + /// The hops composing the blinded path. pub(crate) blinded_hops: Vec, } -/// Used to construct the blinded hops portion of a blinded route. These hops cannot be identified +/// Used to construct the blinded hops portion of a blinded path. These hops cannot be identified /// by outside observers and thus can be used to hide the identity of the recipient. #[derive(Clone, Debug, PartialEq)] pub struct BlindedHop { - /// The blinded node id of this hop in a blinded route. + /// The blinded node id of this hop in a blinded path. pub(crate) blinded_node_id: PublicKey, - /// The encrypted payload intended for this hop in a blinded route. - // The node sending to this blinded route will later encode this payload into the onion packet for + /// The encrypted payload intended for this hop in a blinded path. + // The node sending to this blinded path will later encode this payload into the onion packet for // this hop. pub(crate) encrypted_payload: Vec, } -impl BlindedRoute { - /// Create a blinded route to be forwarded along `node_pks`. The last node pubkey in `node_pks` +impl BlindedPath { + /// Create a blinded path to be forwarded along `node_pks`. The last node pubkey in `node_pks` /// will be the destination node. /// /// Errors if less than two hops are provided or if `node_pk`(s) are invalid. @@ -71,14 +71,14 @@ impl BlindedRoute { let blinding_secret = SecretKey::from_slice(&blinding_secret_bytes[..]).expect("RNG is busted"); let introduction_node_id = node_pks[0]; - Ok(BlindedRoute { + Ok(BlindedPath { introduction_node_id, blinding_point: PublicKey::from_secret_key(secp_ctx, &blinding_secret), blinded_hops: blinded_hops(secp_ctx, node_pks, &blinding_secret).map_err(|_| ())?, }) } - // Advance the blinded route by one hop, so make the second hop into the new introduction node. + // Advance the blinded path by one hop, so make the second hop into the new introduction node. pub(super) fn advance_by_one (&mut self, keys_manager: &K, secp_ctx: &Secp256k1) -> Result<(), ()> where K::Target: KeysInterface @@ -156,7 +156,7 @@ fn encrypt_payload(payload: P, encrypted_tlvs_ss: [u8; 32]) -> Vec writer.0 } -impl Writeable for BlindedRoute { +impl Writeable for BlindedPath { fn write(&self, w: &mut W) -> Result<(), io::Error> { self.introduction_node_id.write(w)?; self.blinding_point.write(w)?; @@ -168,7 +168,7 @@ impl Writeable for BlindedRoute { } } -impl Readable for BlindedRoute { +impl Readable for BlindedPath { fn read(r: &mut R) -> Result { let introduction_node_id = Readable::read(r)?; let blinding_point = Readable::read(r)?; @@ -178,7 +178,7 @@ impl Readable for BlindedRoute { for _ in 0..num_hops { blinded_hops.push(Readable::read(r)?); } - Ok(BlindedRoute { + Ok(BlindedPath { introduction_node_id, blinding_point, blinded_hops, @@ -196,15 +196,15 @@ impl_writeable!(BlindedHop, { pub(crate) struct ForwardTlvs { /// The node id of the next hop in the onion message's path. pub(super) next_node_id: PublicKey, - /// Senders to a blinded route use this value to concatenate the route they find to the - /// introduction node with the blinded route. + /// Senders to a blinded path use this value to concatenate the route they find to the + /// introduction node with the blinded path. pub(super) next_blinding_override: Option, } /// Similar to [`ForwardTlvs`], but these TLVs are for the final node. pub(crate) struct ReceiveTlvs { - /// If `path_id` is `Some`, it is used to identify the blinded route that this onion message is - /// sending to. This is useful for receivers to check that said blinded route is being used in + /// If `path_id` is `Some`, it is used to identify the blinded path that this onion message is + /// sending to. This is useful for receivers to check that said blinded path is being used in /// the right context. pub(super) path_id: Option<[u8; 32]>, } diff --git a/lightning/src/onion_message/functional_tests.rs b/lightning/src/onion_message/functional_tests.rs index 012e279d2a6..f65a50ee133 100644 --- a/lightning/src/onion_message/functional_tests.rs +++ b/lightning/src/onion_message/functional_tests.rs @@ -12,7 +12,7 @@ use crate::chain::keysinterface::{KeysInterface, Recipient}; use crate::ln::features::InitFeatures; use crate::ln::msgs::{self, DecodeError, OnionMessageHandler}; -use super::{BlindedRoute, CustomOnionMessageContents, CustomOnionMessageHandler, Destination, OnionMessageContents, OnionMessenger, SendError}; +use super::{BlindedPath, CustomOnionMessageContents, CustomOnionMessageHandler, Destination, OnionMessageContents, OnionMessenger, SendError}; use crate::util::ser::{Writeable, Writer}; use crate::util::test_utils; @@ -136,9 +136,9 @@ fn two_unblinded_two_blinded() { let test_msg = OnionMessageContents::Custom(TestCustomMessage {}); let secp_ctx = Secp256k1::new(); - let blinded_route = BlindedRoute::new(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap(); + let blinded_path = BlindedPath::new(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap(); - nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap(); + nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::BlindedPath(blinded_path), test_msg, None).unwrap(); pass_along_path(&nodes, None); } @@ -148,9 +148,9 @@ fn three_blinded_hops() { let test_msg = OnionMessageContents::Custom(TestCustomMessage {}); let secp_ctx = Secp256k1::new(); - let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap(); + let blinded_path = BlindedPath::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap(); - nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), test_msg, None).unwrap(); + nodes[0].messenger.send_onion_message(&[], Destination::BlindedPath(blinded_path), test_msg, None).unwrap(); pass_along_path(&nodes, None); } @@ -168,42 +168,42 @@ fn too_big_packet_error() { #[test] fn we_are_intro_node() { - // If we are sending straight to a blinded route and we are the introduction node, we need to - // advance the blinded route by 1 hop so the second hop is the new introduction node. + // 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. let mut nodes = create_nodes(3); let test_msg = TestCustomMessage {}; let secp_ctx = Secp256k1::new(); - let blinded_route = BlindedRoute::new(&[nodes[0].get_node_pk(), nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap(); + let blinded_path = BlindedPath::new(&[nodes[0].get_node_pk(), nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap(); - nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg.clone()), None).unwrap(); + nodes[0].messenger.send_onion_message(&[], Destination::BlindedPath(blinded_path), OnionMessageContents::Custom(test_msg.clone()), None).unwrap(); pass_along_path(&nodes, None); - // Try with a two-hop blinded route where we are the introduction node. - let blinded_route = BlindedRoute::new(&[nodes[0].get_node_pk(), nodes[1].get_node_pk()], &*nodes[1].keys_manager, &secp_ctx).unwrap(); - nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), None).unwrap(); + // Try with a two-hop blinded path where we are the introduction node. + let blinded_path = BlindedPath::new(&[nodes[0].get_node_pk(), nodes[1].get_node_pk()], &*nodes[1].keys_manager, &secp_ctx).unwrap(); + nodes[0].messenger.send_onion_message(&[], Destination::BlindedPath(blinded_path), OnionMessageContents::Custom(test_msg), None).unwrap(); nodes.remove(2); pass_along_path(&nodes, None); } #[test] -fn invalid_blinded_route_error() { - // Make sure we error as expected if a provided blinded route has 0 or 1 hops. +fn invalid_blinded_path_error() { + // Make sure we error as expected if a provided blinded path has 0 or 1 hops. let nodes = create_nodes(3); let test_msg = TestCustomMessage {}; // 0 hops let secp_ctx = Secp256k1::new(); - let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap(); - blinded_route.blinded_hops.clear(); - let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg.clone()), None).unwrap_err(); + let mut blinded_path = BlindedPath::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap(); + blinded_path.blinded_hops.clear(); + let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedPath(blinded_path), OnionMessageContents::Custom(test_msg.clone()), None).unwrap_err(); assert_eq!(err, SendError::TooFewBlindedHops); // 1 hop - let mut blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap(); - blinded_route.blinded_hops.remove(0); - assert_eq!(blinded_route.blinded_hops.len(), 1); - let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), None).unwrap_err(); + let mut blinded_path = BlindedPath::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap(); + blinded_path.blinded_hops.remove(0); + assert_eq!(blinded_path.blinded_hops.len(), 1); + let err = nodes[0].messenger.send_onion_message(&[], Destination::BlindedPath(blinded_path), OnionMessageContents::Custom(test_msg), None).unwrap_err(); assert_eq!(err, SendError::TooFewBlindedHops); } @@ -214,7 +214,7 @@ fn reply_path() { let secp_ctx = Secp256k1::new(); // Destination::Node - let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap(); + let reply_path = BlindedPath::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap(); nodes[0].messenger.send_onion_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], Destination::Node(nodes[3].get_node_pk()), OnionMessageContents::Custom(test_msg.clone()), Some(reply_path)).unwrap(); pass_along_path(&nodes, None); // Make sure the last node successfully decoded the reply path. @@ -222,11 +222,11 @@ fn reply_path() { "lightning::onion_message::messenger".to_string(), format!("Received an onion message with path_id None and a reply_path").to_string(), 1); - // Destination::BlindedRoute - let blinded_route = BlindedRoute::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap(); - let reply_path = BlindedRoute::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap(); + // Destination::BlindedPath + let blinded_path = BlindedPath::new(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap(); + let reply_path = BlindedPath::new(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap(); - nodes[0].messenger.send_onion_message(&[], Destination::BlindedRoute(blinded_route), OnionMessageContents::Custom(test_msg), Some(reply_path)).unwrap(); + nodes[0].messenger.send_onion_message(&[], Destination::BlindedPath(blinded_path), OnionMessageContents::Custom(test_msg), Some(reply_path)).unwrap(); pass_along_path(&nodes, None); nodes[3].logger.assert_log_contains( "lightning::onion_message::messenger".to_string(), diff --git a/lightning/src/onion_message/messenger.rs b/lightning/src/onion_message/messenger.rs index b884c2ffebd..269b5f8cb7c 100644 --- a/lightning/src/onion_message/messenger.rs +++ b/lightning/src/onion_message/messenger.rs @@ -20,7 +20,7 @@ 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}; +use super::blinded_path::{BlindedPath, ForwardTlvs, ReceiveTlvs}; pub 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; @@ -46,7 +46,7 @@ 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::{BlindedPath, CustomOnionMessageContents, Destination, OnionMessageContents, OnionMessenger}; /// # use lightning::util::logger::{Logger, Record}; /// # use lightning::util::ser::{Writeable, Writer}; /// # use lightning::io; @@ -89,17 +89,17 @@ 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]: @@ -122,15 +122,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 +145,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 +158,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`], @@ -207,8 +207,8 @@ impl OnionMessenger /// Send an onion message with contents `message` to `destination`, routing it through `intermediate_nodes`. /// See [`OnionMessenger`] for example usage. - pub fn send_onion_message(&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 +216,15 @@ impl OnionMessenger let OnionMessageContents::Custom(ref msg) = message; if msg.tlv_type() < 64 { return Err(SendError::InvalidMessage) } - // If we are sending straight to a blinded route and we are the introduction node, we need to - // advance the blinded route by 1 hop so the second hop is the new introduction node. + // 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. if intermediate_nodes.len() == 0 { - if let Destination::BlindedRoute(ref mut blinded_route) = destination { + if let Destination::BlindedPath(ref mut blinded_path) = destination { let our_node_id = self.keys_manager.get_node_id(Recipient::Node) .map_err(|()| SendError::GetNodeIdFailed)?; - if blinded_route.introduction_node_id == our_node_id { - blinded_route.advance_by_one(&self.keys_manager, &self.secp_ctx) - .map_err(|()| SendError::BlindedRouteAdvanceFailed)?; + if blinded_path.introduction_node_id == our_node_id { + blinded_path.advance_by_one(&self.keys_manager, &self.secp_ctx) + .map_err(|()| SendError::BlindedPathAdvanceFailed)?; } } } @@ -236,7 +236,7 @@ impl OnionMessenger } else { match destination { Destination::Node(pk) => (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), } }; @@ -346,7 +346,7 @@ impl OnionMessageHandler for OnionMessenger pk, @@ -476,13 +476,13 @@ pub type SimpleRefOnionMessenger<'a, 'b, L> = OnionMessenger<&'a KeysManager, &' /// `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; diff --git a/lightning/src/onion_message/mod.rs b/lightning/src/onion_message/mod.rs index 89c1545a7df..e735b428ea0 100644 --- a/lightning/src/onion_message/mod.rs +++ b/lightning/src/onion_message/mod.rs @@ -12,15 +12,15 @@ //! Onion messages are multi-purpose messages sent between peers over the lightning network. In the //! near future, they will be used to communicate invoices for [offers], unlocking use cases such as //! static invoices, refunds and proof of payer. Further, you will be able to accept payments -//! without revealing your node id through the use of [blinded routes]. +//! without revealing your node id through the use of [blinded paths]. //! //! LDK sends and receives onion messages via the [`OnionMessenger`]. See its documentation for more //! information on its usage. //! //! [offers]: -//! [blinded routes]: crate::onion_message::BlindedRoute +//! [blinded paths]: crate::onion_message::BlindedPath -mod blinded_route; +mod blinded_path; mod messenger; mod packet; mod utils; @@ -28,6 +28,6 @@ mod utils; mod functional_tests; // Re-export structs so they can be imported with just the `onion_message::` module prefix. -pub use self::blinded_route::{BlindedRoute, BlindedRoute as BlindedPath, BlindedHop}; +pub use self::blinded_path::{BlindedPath, BlindedHop}; pub use self::messenger::{CustomOnionMessageContents, CustomOnionMessageHandler, Destination, OnionMessageContents, OnionMessenger, SendError, SimpleArcOnionMessenger, SimpleRefOnionMessenger}; pub(crate) use self::packet::Packet; diff --git a/lightning/src/onion_message/packet.rs b/lightning/src/onion_message/packet.rs index 8fff53642e1..3222c08a392 100644 --- a/lightning/src/onion_message/packet.rs +++ b/lightning/src/onion_message/packet.rs @@ -14,7 +14,7 @@ use bitcoin::secp256k1::ecdh::SharedSecret; use crate::ln::msgs::DecodeError; use crate::ln::onion_utils; -use super::blinded_route::{BlindedRoute, ForwardTlvs, ReceiveTlvs}; +use super::blinded_path::{BlindedPath, ForwardTlvs, ReceiveTlvs}; use super::messenger::CustomOnionMessageHandler; use crate::util::chacha20poly1305rfc::{ChaChaPolyReadAdapter, ChaChaPolyWriteAdapter}; use crate::util::ser::{BigSize, FixedLengthReader, LengthRead, LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer}; @@ -99,7 +99,7 @@ pub(super) enum Payload { /// This payload is for the final hop. Receive { control_tlvs: ReceiveControlTlvs, - reply_path: Option, + reply_path: Option, message: OnionMessageContents, } } @@ -141,12 +141,12 @@ pub trait CustomOnionMessageContents: Writeable { /// Forward control TLVs in their blinded and unblinded form. pub(super) enum ForwardControlTlvs { - /// If we're sending to a blinded route, the node that constructed the blinded route has provided + /// If we're sending to a blinded path, the node that constructed the blinded path has provided /// this hop's control TLVs, already encrypted into bytes. Blinded(Vec), /// If we're constructing an onion message hop through an intermediate unblinded node, we'll need /// to construct the intermediate hop's control TLVs in their unblinded state to avoid encoding - /// them into an intermediate Vec. See [`super::blinded_route::ForwardTlvs`] for more info. + /// them into an intermediate Vec. See [`super::blinded_path::ForwardTlvs`] for more info. Unblinded(ForwardTlvs), } @@ -154,7 +154,7 @@ pub(super) enum ForwardControlTlvs { pub(super) enum ReceiveControlTlvs { /// See [`ForwardControlTlvs::Blinded`]. Blinded(Vec), - /// See [`ForwardControlTlvs::Unblinded`] and [`super::blinded_route::ReceiveTlvs`]. + /// See [`ForwardControlTlvs::Unblinded`] and [`super::blinded_path::ReceiveTlvs`]. Unblinded(ReceiveTlvs), } @@ -204,7 +204,7 @@ impl ReadableArgs<(SharedSecret, &H)> for Payload< let v: BigSize = Readable::read(r)?; let mut rd = FixedLengthReader::new(r, v.0); - let mut reply_path: Option = None; + let mut reply_path: Option = None; let mut read_adapter: Option> = None; let rho = onion_utils::gen_rho_from_shared_secret(&encrypted_tlvs_ss.secret_bytes()); let mut message_type: Option = None; diff --git a/lightning/src/onion_message/utils.rs b/lightning/src/onion_message/utils.rs index 00464604984..ae9e0a7f6fe 100644 --- a/lightning/src/onion_message/utils.rs +++ b/lightning/src/onion_message/utils.rs @@ -16,7 +16,7 @@ use bitcoin::secp256k1::{self, PublicKey, Secp256k1, SecretKey, Scalar}; use bitcoin::secp256k1::ecdh::SharedSecret; use crate::ln::onion_utils; -use super::blinded_route::BlindedRoute; +use super::blinded_path::BlindedPath; use super::messenger::Destination; use crate::prelude::*; @@ -87,7 +87,7 @@ pub(super) fn construct_keys_callback { build_keys!(pk, false, None); }, - Destination::BlindedRoute(BlindedRoute { blinded_hops, .. }) => { + Destination::BlindedPath(BlindedPath { blinded_hops, .. }) => { for hop in blinded_hops { build_keys_in_loop!(hop.blinded_node_id, true, Some(hop.encrypted_payload)); }