From a0d38d7eb9bba986447470a261978e7c73a49d76 Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Wed, 14 Dec 2022 20:49:53 +0000 Subject: [PATCH] Rename `blinded_route` variables and module to `blinded_path` Following up on the previous commit, this also renames variables and the module used to `blinded_path`. --- .../{blinded_route.rs => blinded_path.rs} | 28 +++++++-------- .../src/onion_message/functional_tests.rs | 36 +++++++++---------- lightning/src/onion_message/messenger.rs | 12 +++---- lightning/src/onion_message/mod.rs | 4 +-- lightning/src/onion_message/packet.rs | 6 ++-- lightning/src/onion_message/utils.rs | 2 +- 6 files changed, 44 insertions(+), 44 deletions(-) rename lightning/src/onion_message/{blinded_route.rs => blinded_path.rs} (88%) diff --git a/lightning/src/onion_message/blinded_route.rs b/lightning/src/onion_message/blinded_path.rs similarity index 88% rename from lightning/src/onion_message/blinded_route.rs rename to lightning/src/onion_message/blinded_path.rs index a8751acb2..31a23bc17 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 BlindedPath { - /// To send to a blinded route, the sender first finds a route to the unblinded + /// 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 BlindedPath { /// /// [`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 BlindedPath { - /// Create a blinded route to be forwarded along `node_pks`. The last node pubkey in `node_pks` + /// 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. @@ -78,7 +78,7 @@ impl BlindedPath { }) } - // 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 @@ -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 8764ed4f2..34414904d 100644 --- a/lightning/src/onion_message/functional_tests.rs +++ b/lightning/src/onion_message/functional_tests.rs @@ -136,9 +136,9 @@ fn two_unblinded_two_blinded() { let test_msg = OnionMessageContents::Custom(TestCustomMessage {}); let secp_ctx = Secp256k1::new(); - let blinded_route = BlindedPath::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::BlindedPath(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 = 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 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::BlindedPath(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); } @@ -174,36 +174,36 @@ fn we_are_intro_node() { let test_msg = TestCustomMessage {}; let secp_ctx = Secp256k1::new(); - let blinded_route = BlindedPath::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::BlindedPath(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 = 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_route), OnionMessageContents::Custom(test_msg), None).unwrap(); + 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() { +fn invalid_blinded_path_error() { // Make sure we error as expected if a provided blinded route 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 = BlindedPath::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::BlindedPath(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 = BlindedPath::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::BlindedPath(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); } @@ -223,10 +223,10 @@ fn reply_path() { format!("Received an onion message with path_id None and a reply_path").to_string(), 1); // Destination::BlindedPath - let blinded_route = 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 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::BlindedPath(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 f627f9736..1a5673a35 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::{BlindedPath, 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; @@ -92,14 +92,14 @@ use crate::prelude::*; /// // Create a blinded route 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 = BlindedPath::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. /// # 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::BlindedPath(blinded_route), message, reply_path); +/// onion_messenger.send_onion_message(&intermediate_hops, Destination::BlindedPath(blinded_path), message, reply_path); /// ``` /// /// [offers]: @@ -219,11 +219,11 @@ impl OnionMessenger // 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 intermediate_nodes.len() == 0 { - if let Destination::BlindedPath(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) + if blinded_path.introduction_node_id == our_node_id { + blinded_path.advance_by_one(&self.keys_manager, &self.secp_ctx) .map_err(|()| SendError::BlindedPathAdvanceFailed)?; } } diff --git a/lightning/src/onion_message/mod.rs b/lightning/src/onion_message/mod.rs index 289773653..f8ecf7de8 100644 --- a/lightning/src/onion_message/mod.rs +++ b/lightning/src/onion_message/mod.rs @@ -20,7 +20,7 @@ //! [offers]: //! [blinded routes]: 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::{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 434ad93d6..ea317afbf 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::{BlindedPath, 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}; @@ -146,7 +146,7 @@ pub(super) enum ForwardControlTlvs { 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), } diff --git a/lightning/src/onion_message/utils.rs b/lightning/src/onion_message/utils.rs index a95e2ea85..ae9e0a7f6 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::BlindedPath; +use super::blinded_path::BlindedPath; use super::messenger::Destination; use crate::prelude::*; -- 2.39.5