Merge pull request #2441 from arik-so/2023-07-taproot-signer-wrapped

[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 7c259113934ca797ec211dd1bb33b8bd2f0f0d74..7d5f4a22ec8573e17764c31017f5804083161b21 100644 (file)
--- a/lightning/src/onion_message/messenger.rs
+++ b/lightning/src/onion_message/messenger.rs
@@ -152,6 +152,17 @@ pub trait MessageRouter {
        ) -> Result<OnionMessagePath, ()>;
 }
 
+/// A [`MessageRouter`] that always fails.
+pub struct DefaultMessageRouter;
+
+impl MessageRouter for DefaultMessageRouter {
+       fn find_path(
+               &self, _sender: PublicKey, _peers: Vec<PublicKey>, _destination: Destination
+       ) -> Result<OnionMessagePath, ()> {
+               Err(())
+       }
+}
+
 /// A path for sending an [`msgs::OnionMessage`].
 #[derive(Clone)]
 pub struct OnionMessagePath {
@@ -416,7 +427,7 @@ where
        L::Target: Logger,
        MR::Target: MessageRouter,
        OMH::Target: OffersMessageHandler,
-       CMH::Target: CustomOnionMessageHandler + Sized,
+       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
@@ -452,7 +463,7 @@ where
                        Ok((Payload::Receive::<<<CMH as Deref>::Target as CustomOnionMessageHandler>::CustomMessage> {
                                message, control_tlvs: ReceiveControlTlvs::Unblinded(ReceiveTlvs { path_id }), reply_path,
                        }, None)) => {
-                               log_info!(self.logger,
+                               log_trace!(self.logger,
                                        "Received an onion message with path_id {:02x?} and {} reply_path",
                                                path_id, if reply_path.is_some() { "a" } else { "no" });
 
@@ -479,7 +490,7 @@ where
                                // unwrapping the onion layers to get to the final payload. Since we don't have the option
                                // 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) {
+                               let new_pubkey = match onion_utils::next_hop_pubkey(&self.secp_ctx, msg.onion_routing_packet.public_key, &onion_decode_ss) {
                                        Ok(pk) => pk,
                                        Err(e) => {
                                                log_trace!(self.logger, "Failed to compute next hop packet pubkey: {}", e);
@@ -496,21 +507,16 @@ where
                                        blinding_point: match next_blinding_override {
                                                Some(blinding_point) => blinding_point,
                                                None => {
-                                                       let blinding_factor = {
-                                                               let mut sha = Sha256::engine();
-                                                               sha.input(&msg.blinding_point.serialize()[..]);
-                                                               sha.input(control_tlvs_ss.as_ref());
-                                                               Sha256::from_engine(sha).into_inner()
-                                                       };
-                                                       let next_blinding_point = msg.blinding_point;
-                                                       match next_blinding_point.mul_tweak(&self.secp_ctx, &Scalar::from_be_bytes(blinding_factor).unwrap()) {
+                                                       match onion_utils::next_hop_pubkey(
+                                                               &self.secp_ctx, msg.blinding_point, control_tlvs_ss.as_ref()
+                                                       ) {
                                                                Ok(bp) => bp,
                                                                Err(e) => {
                                                                        log_trace!(self.logger, "Failed to compute next blinding point: {}", e);
                                                                        return
                                                                }
                                                        }
-                                               },
+                                               }
                                        },
                                        onion_routing_packet: outgoing_packet,
                                };
@@ -598,11 +604,11 @@ where
 ///
 /// [`SimpleArcChannelManager`]: crate::ln::channelmanager::SimpleArcChannelManager
 /// [`SimpleArcPeerManager`]: crate::ln::peer_handler::SimpleArcPeerManager
-pub type SimpleArcOnionMessenger<L, R> = OnionMessenger<
+pub type SimpleArcOnionMessenger<L> = OnionMessenger<
        Arc<KeysManager>,
        Arc<KeysManager>,
        Arc<L>,
-       Arc<R>,
+       Arc<DefaultMessageRouter>,
        IgnoringMessageHandler,
        IgnoringMessageHandler
 >;
@@ -614,11 +620,11 @@ pub type SimpleArcOnionMessenger<L, R> = OnionMessenger<
 ///
 /// [`SimpleRefChannelManager`]: crate::ln::channelmanager::SimpleRefChannelManager
 /// [`SimpleRefPeerManager`]: crate::ln::peer_handler::SimpleRefPeerManager
-pub type SimpleRefOnionMessenger<'a, 'b, 'c, L, R> = OnionMessenger<
+pub type SimpleRefOnionMessenger<'a, 'b, 'c, L> = OnionMessenger<
        &'a KeysManager,
        &'a KeysManager,
        &'b L,
-       &'c R,
+       &'c DefaultMessageRouter,
        IgnoringMessageHandler,
        IgnoringMessageHandler
 >;