Avoid a redundant allocation in `InvoiceError` handling in one case

[rust-lightning] / lightning / src / onion_message / messenger.rs

diff --git a/lightning/src/onion_message/messenger.rs b/lightning/src/onion_message/messenger.rs
index d526ba9e3a2dfb1c226a7cdf5adef4276d69e24f..723e105d044cf549cfd8f392e206782b38a479af 100644 (file)
--- a/lightning/src/onion_message/messenger.rs
+++ b/lightning/src/onion_message/messenger.rs
@@ -19,6 +19,7 @@ use crate::blinded_path::BlindedPath;
 use crate::blinded_path::message::{advance_path_by_one, ForwardTlvs, ReceiveTlvs};
 use crate::blinded_path::utils;
 use crate::sign::{EntropySource, KeysManager, NodeSigner, Recipient};
+use crate::ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
 use crate::ln::features::{InitFeatures, NodeFeatures};
 use crate::ln::msgs::{self, OnionMessage, OnionMessageHandler};
 use crate::ln::onion_utils;
@@ -176,14 +177,18 @@ pub trait MessageRouter {
        ) -> Result<OnionMessagePath, ()>;
 }
 
-/// A [`MessageRouter`] that always fails.
+/// A [`MessageRouter`] that can only route to a directly connected [`Destination`].
 pub struct DefaultMessageRouter;
 
 impl MessageRouter for DefaultMessageRouter {
        fn find_path(
-               &self, _sender: PublicKey, _peers: Vec<PublicKey>, _destination: Destination
+               &self, _sender: PublicKey, peers: Vec<PublicKey>, destination: Destination
        ) -> Result<OnionMessagePath, ()> {
-               Err(())
+               if peers.contains(&destination.first_node()) {
+                       Ok(OnionMessagePath { intermediate_nodes: vec![], destination })
+               } else {
+                       Err(())
+               }
        }
 }
 
@@ -213,6 +218,13 @@ impl Destination {
                        Destination::BlindedPath(BlindedPath { blinded_hops, .. }) => blinded_hops.len(),
                }
        }
+
+       fn first_node(&self) -> PublicKey {
+               match self {
+                       Destination::Node(node_id) => *node_id,
+                       Destination::BlindedPath(BlindedPath { introduction_node_id: node_id, .. }) => *node_id,
+               }
+       }
 }
 
 /// Errors that may occur when [sending an onion message].
@@ -225,8 +237,8 @@ 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 [`BlindedPath`], due to having fewer than two
-       /// blinded hops.
+       /// The provided [`Destination`] was an invalid [`BlindedPath`] due to not having any blinded
+       /// hops.
        TooFewBlindedHops,
        /// Our next-hop peer was offline or does not support onion message forwarding.
        InvalidFirstHop,
@@ -299,7 +311,7 @@ where
 {
        let OnionMessagePath { intermediate_nodes, mut destination } = path;
        if let Destination::BlindedPath(BlindedPath { ref blinded_hops, .. }) = destination {
-               if blinded_hops.len() < 2 {
+               if blinded_hops.is_empty() {
                        return Err(SendError::TooFewBlindedHops);
                }
        }
@@ -344,11 +356,13 @@ where
        }))
 }
 
-/// Decode one layer of an incoming onion message
-/// Returns either a Forward (another onion message), or Receive (decrypted content)
-pub fn peel_onion<NS: Deref, L: Deref, CMH: Deref>(
-       node_signer: NS, secp_ctx: &Secp256k1<secp256k1::All>, logger: L, custom_handler: CMH,
-       msg: &OnionMessage,
+/// Decode one layer of an incoming [`OnionMessage`].
+///
+/// Returns either the next layer of the onion for forwarding or the decrypted content for the
+/// receiver.
+pub fn peel_onion_message<NS: Deref, L: Deref, CMH: Deref>(
+       msg: &OnionMessage, secp_ctx: &Secp256k1<secp256k1::All>, node_signer: NS, logger: L,
+       custom_handler: CMH,
 ) -> Result<PeeledOnion<<<CMH>::Target as CustomOnionMessageHandler>::CustomMessage>, ()>
 where
        NS::Target: NodeSigner,
@@ -583,12 +597,9 @@ where
        OMH::Target: OffersMessageHandler,
        CMH::Target: CustomOnionMessageHandler,
 {
-       /// Handle an incoming onion message. Currently, if a message was destined for us we will log, but
-       /// soon we'll delegate the onion message to a handler that can generate invoices or send
-       /// payments.
        fn handle_onion_message(&self, _peer_node_id: &PublicKey, msg: &OnionMessage) {
-               match peel_onion(
-                       &*self.node_signer, &self.secp_ctx, &*self.logger, &*self.custom_handler, msg
+               match peel_onion_message(
+                       msg, &self.secp_ctx, &*self.node_signer, &*self.logger, &*self.custom_handler
                ) {
                        Ok(PeeledOnion::Receive(message, path_id, reply_path)) => {
                                log_trace!(self.logger,
@@ -705,12 +716,12 @@ where
 ///
 /// [`SimpleArcChannelManager`]: crate::ln::channelmanager::SimpleArcChannelManager
 /// [`SimpleArcPeerManager`]: crate::ln::peer_handler::SimpleArcPeerManager
-pub type SimpleArcOnionMessenger<L> = OnionMessenger<
+pub type SimpleArcOnionMessenger<M, T, F, L> = OnionMessenger<
        Arc<KeysManager>,
        Arc<KeysManager>,
        Arc<L>,
        Arc<DefaultMessageRouter>,
-       IgnoringMessageHandler,
+       Arc<SimpleArcChannelManager<M, T, F, L>>,
        IgnoringMessageHandler
 >;
 
@@ -721,12 +732,14 @@ pub type SimpleArcOnionMessenger<L> = OnionMessenger<
 ///
 /// [`SimpleRefChannelManager`]: crate::ln::channelmanager::SimpleRefChannelManager
 /// [`SimpleRefPeerManager`]: crate::ln::peer_handler::SimpleRefPeerManager
-pub type SimpleRefOnionMessenger<'a, 'b, 'c, L> = OnionMessenger<
+pub type SimpleRefOnionMessenger<
+       'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, M, T, F, L
+> = OnionMessenger<
        &'a KeysManager,
        &'a KeysManager,
        &'b L,
-       &'c DefaultMessageRouter,
-       IgnoringMessageHandler,
+       &'i DefaultMessageRouter,
+       &'j SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, M, T, F, L>,
        IgnoringMessageHandler
 >;