]> git.bitcoin.ninja Git - rust-lightning/blob - lightning/src/onion_message/messenger.rs
Persist scorer upon update based on event handling
[rust-lightning] / lightning / src / onion_message / messenger.rs
1 // This file is Copyright its original authors, visible in version control
2 // history.
3 //
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
8 // licenses.
9
10 //! LDK sends, receives, and forwards onion messages via the [`OnionMessenger`]. See its docs for
11 //! more information.
12
13 use bitcoin::hashes::{Hash, HashEngine};
14 use bitcoin::hashes::hmac::{Hmac, HmacEngine};
15 use bitcoin::hashes::sha256::Hash as Sha256;
16 use bitcoin::secp256k1::{self, PublicKey, Scalar, Secp256k1, SecretKey};
17
18 use crate::blinded_path::{BlindedPath, ForwardTlvs, ReceiveTlvs, utils};
19 use crate::chain::keysinterface::{EntropySource, KeysManager, NodeSigner, Recipient};
20 use crate::events::OnionMessageProvider;
21 use crate::ln::features::{InitFeatures, NodeFeatures};
22 use crate::ln::msgs::{self, OnionMessageHandler};
23 use crate::ln::onion_utils;
24 use crate::ln::peer_handler::IgnoringMessageHandler;
25 pub use super::packet::{CustomOnionMessageContents, OnionMessageContents};
26 use super::packet::{BIG_PACKET_HOP_DATA_LEN, ForwardControlTlvs, Packet, Payload, ReceiveControlTlvs, SMALL_PACKET_HOP_DATA_LEN};
27 use crate::util::logger::Logger;
28 use crate::util::ser::Writeable;
29
30 use core::ops::Deref;
31 use crate::io;
32 use crate::sync::{Arc, Mutex};
33 use crate::prelude::*;
34
35 /// A sender, receiver and forwarder of onion messages. In upcoming releases, this object will be
36 /// used to retrieve invoices and fulfill invoice requests from [offers]. Currently, only sending
37 /// and receiving custom onion messages is supported.
38 ///
39 /// # Example
40 ///
41 /// ```
42 /// # extern crate bitcoin;
43 /// # use bitcoin::hashes::_export::_core::time::Duration;
44 /// # use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
45 /// # use lightning::blinded_path::BlindedPath;
46 /// # use lightning::chain::keysinterface::KeysManager;
47 /// # use lightning::ln::peer_handler::IgnoringMessageHandler;
48 /// # use lightning::onion_message::{CustomOnionMessageContents, Destination, OnionMessageContents, OnionMessenger};
49 /// # use lightning::util::logger::{Logger, Record};
50 /// # use lightning::util::ser::{Writeable, Writer};
51 /// # use lightning::io;
52 /// # use std::sync::Arc;
53 /// # struct FakeLogger;
54 /// # impl Logger for FakeLogger {
55 /// #     fn log(&self, record: &Record) { unimplemented!() }
56 /// # }
57 /// # let seed = [42u8; 32];
58 /// # let time = Duration::from_secs(123456);
59 /// # let keys_manager = KeysManager::new(&seed, time.as_secs(), time.subsec_nanos());
60 /// # let logger = Arc::new(FakeLogger {});
61 /// # let node_secret = SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap();
62 /// # let secp_ctx = Secp256k1::new();
63 /// # let hop_node_id1 = PublicKey::from_secret_key(&secp_ctx, &node_secret);
64 /// # let (hop_node_id2, hop_node_id3, hop_node_id4) = (hop_node_id1, hop_node_id1, hop_node_id1);
65 /// # let destination_node_id = hop_node_id1;
66 /// # let your_custom_message_handler = IgnoringMessageHandler {};
67 /// // Create the onion messenger. This must use the same `keys_manager` as is passed to your
68 /// // ChannelManager.
69 /// let onion_messenger = OnionMessenger::new(&keys_manager, &keys_manager, logger, &your_custom_message_handler);
70 ///
71 /// # struct YourCustomMessage {}
72 /// impl Writeable for YourCustomMessage {
73 ///     fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
74 ///             # Ok(())
75 ///             // Write your custom onion message to `w`
76 ///     }
77 /// }
78 /// impl CustomOnionMessageContents for YourCustomMessage {
79 ///     fn tlv_type(&self) -> u64 {
80 ///             # let your_custom_message_type = 42;
81 ///             your_custom_message_type
82 ///     }
83 /// }
84 /// // Send a custom onion message to a node id.
85 /// let intermediate_hops = [hop_node_id1, hop_node_id2];
86 /// let reply_path = None;
87 /// # let your_custom_message = YourCustomMessage {};
88 /// let message = OnionMessageContents::Custom(your_custom_message);
89 /// onion_messenger.send_onion_message(&intermediate_hops, Destination::Node(destination_node_id), message, reply_path);
90 ///
91 /// // Create a blinded path to yourself, for someone to send an onion message to.
92 /// # let your_node_id = hop_node_id1;
93 /// let hops = [hop_node_id3, hop_node_id4, your_node_id];
94 /// let blinded_path = BlindedPath::new_for_message(&hops, &keys_manager, &secp_ctx).unwrap();
95 ///
96 /// // Send a custom onion message to a blinded path.
97 /// # let intermediate_hops = [hop_node_id1, hop_node_id2];
98 /// let reply_path = None;
99 /// # let your_custom_message = YourCustomMessage {};
100 /// let message = OnionMessageContents::Custom(your_custom_message);
101 /// onion_messenger.send_onion_message(&intermediate_hops, Destination::BlindedPath(blinded_path), message, reply_path);
102 /// ```
103 ///
104 /// [offers]: <https://github.com/lightning/bolts/pull/798>
105 /// [`OnionMessenger`]: crate::onion_message::OnionMessenger
106 pub struct OnionMessenger<ES: Deref, NS: Deref, L: Deref, CMH: Deref>
107         where ES::Target: EntropySource,
108                   NS::Target: NodeSigner,
109                   L::Target: Logger,
110                   CMH:: Target: CustomOnionMessageHandler,
111 {
112         entropy_source: ES,
113         node_signer: NS,
114         logger: L,
115         pending_messages: Mutex<HashMap<PublicKey, VecDeque<msgs::OnionMessage>>>,
116         secp_ctx: Secp256k1<secp256k1::All>,
117         custom_handler: CMH,
118         // Coming soon:
119         // invoice_handler: InvoiceHandler,
120 }
121
122 /// The destination of an onion message.
123 pub enum Destination {
124         /// We're sending this onion message to a node.
125         Node(PublicKey),
126         /// We're sending this onion message to a blinded path.
127         BlindedPath(BlindedPath),
128 }
129
130 impl Destination {
131         pub(super) fn num_hops(&self) -> usize {
132                 match self {
133                         Destination::Node(_) => 1,
134                         Destination::BlindedPath(BlindedPath { blinded_hops, .. }) => blinded_hops.len(),
135                 }
136         }
137 }
138
139 /// Errors that may occur when [sending an onion message].
140 ///
141 /// [sending an onion message]: OnionMessenger::send_onion_message
142 #[derive(Debug, PartialEq, Eq)]
143 pub enum SendError {
144         /// Errored computing onion message packet keys.
145         Secp256k1(secp256k1::Error),
146         /// Because implementations such as Eclair will drop onion messages where the message packet
147         /// exceeds 32834 bytes, we refuse to send messages where the packet exceeds this size.
148         TooBigPacket,
149         /// The provided [`Destination`] was an invalid [`BlindedPath`], due to having fewer than two
150         /// blinded hops.
151         TooFewBlindedHops,
152         /// Our next-hop peer was offline or does not support onion message forwarding.
153         InvalidFirstHop,
154         /// Onion message contents must have a TLV type >= 64.
155         InvalidMessage,
156         /// Our next-hop peer's buffer was full or our total outbound buffer was full.
157         BufferFull,
158         /// Failed to retrieve our node id from the provided [`NodeSigner`].
159         ///
160         /// [`NodeSigner`]: crate::chain::keysinterface::NodeSigner
161         GetNodeIdFailed,
162         /// We attempted to send to a blinded path where we are the introduction node, and failed to
163         /// advance the blinded path to make the second hop the new introduction node. Either
164         /// [`NodeSigner::ecdh`] failed, we failed to tweak the current blinding point to get the
165         /// new blinding point, or we were attempting to send to ourselves.
166         BlindedPathAdvanceFailed,
167 }
168
169 /// Handler for custom onion messages. If you are using [`SimpleArcOnionMessenger`],
170 /// [`SimpleRefOnionMessenger`], or prefer to ignore inbound custom onion messages,
171 /// [`IgnoringMessageHandler`] must be provided to [`OnionMessenger::new`]. Otherwise, a custom
172 /// implementation of this trait must be provided, with [`CustomMessage`] specifying the supported
173 /// message types.
174 ///
175 /// See [`OnionMessenger`] for example usage.
176 ///
177 /// [`IgnoringMessageHandler`]: crate::ln::peer_handler::IgnoringMessageHandler
178 /// [`CustomMessage`]: Self::CustomMessage
179 pub trait CustomOnionMessageHandler {
180         /// The message known to the handler. To support multiple message types, you may want to make this
181         /// an enum with a variant for each supported message.
182         type CustomMessage: CustomOnionMessageContents;
183         /// Called with the custom message that was received.
184         fn handle_custom_message(&self, msg: Self::CustomMessage);
185         /// Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
186         /// message type is unknown.
187         fn read_custom_message<R: io::Read>(&self, message_type: u64, buffer: &mut R) -> Result<Option<Self::CustomMessage>, msgs::DecodeError>;
188 }
189
190 impl<ES: Deref, NS: Deref, L: Deref, CMH: Deref> OnionMessenger<ES, NS, L, CMH>
191         where ES::Target: EntropySource,
192                   NS::Target: NodeSigner,
193                   L::Target: Logger,
194                   CMH::Target: CustomOnionMessageHandler,
195 {
196         /// Constructs a new `OnionMessenger` to send, forward, and delegate received onion messages to
197         /// their respective handlers.
198         pub fn new(entropy_source: ES, node_signer: NS, logger: L, custom_handler: CMH) -> Self {
199                 let mut secp_ctx = Secp256k1::new();
200                 secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
201                 OnionMessenger {
202                         entropy_source,
203                         node_signer,
204                         pending_messages: Mutex::new(HashMap::new()),
205                         secp_ctx,
206                         logger,
207                         custom_handler,
208                 }
209         }
210
211         /// Send an onion message with contents `message` to `destination`, routing it through `intermediate_nodes`.
212         /// See [`OnionMessenger`] for example usage.
213         pub fn send_onion_message<T: CustomOnionMessageContents>(&self, intermediate_nodes: &[PublicKey], mut destination: Destination, message: OnionMessageContents<T>, reply_path: Option<BlindedPath>) -> Result<(), SendError> {
214                 if let Destination::BlindedPath(BlindedPath { ref blinded_hops, .. }) = destination {
215                         if blinded_hops.len() < 2 {
216                                 return Err(SendError::TooFewBlindedHops);
217                         }
218                 }
219                 let OnionMessageContents::Custom(ref msg) = message;
220                 if msg.tlv_type() < 64 { return Err(SendError::InvalidMessage) }
221
222                 // If we are sending straight to a blinded path and we are the introduction node, we need to
223                 // advance the blinded path by 1 hop so the second hop is the new introduction node.
224                 if intermediate_nodes.len() == 0 {
225                         if let Destination::BlindedPath(ref mut blinded_path) = destination {
226                                 let our_node_id = self.node_signer.get_node_id(Recipient::Node)
227                                         .map_err(|()| SendError::GetNodeIdFailed)?;
228                                 if blinded_path.introduction_node_id == our_node_id {
229                                         blinded_path.advance_message_path_by_one(&self.node_signer, &self.secp_ctx)
230                                                 .map_err(|()| SendError::BlindedPathAdvanceFailed)?;
231                                 }
232                         }
233                 }
234
235                 let blinding_secret_bytes = self.entropy_source.get_secure_random_bytes();
236                 let blinding_secret = SecretKey::from_slice(&blinding_secret_bytes[..]).expect("RNG is busted");
237                 let (introduction_node_id, blinding_point) = if intermediate_nodes.len() != 0 {
238                         (intermediate_nodes[0], PublicKey::from_secret_key(&self.secp_ctx, &blinding_secret))
239                 } else {
240                         match destination {
241                                 Destination::Node(pk) => (pk, PublicKey::from_secret_key(&self.secp_ctx, &blinding_secret)),
242                                 Destination::BlindedPath(BlindedPath { introduction_node_id, blinding_point, .. }) =>
243                                         (introduction_node_id, blinding_point),
244                         }
245                 };
246                 let (packet_payloads, packet_keys) = packet_payloads_and_keys(
247                         &self.secp_ctx, intermediate_nodes, destination, message, reply_path, &blinding_secret)
248                         .map_err(|e| SendError::Secp256k1(e))?;
249
250                 let prng_seed = self.entropy_source.get_secure_random_bytes();
251                 let onion_routing_packet = construct_onion_message_packet(
252                         packet_payloads, packet_keys, prng_seed).map_err(|()| SendError::TooBigPacket)?;
253
254                 let mut pending_per_peer_msgs = self.pending_messages.lock().unwrap();
255                 if outbound_buffer_full(&introduction_node_id, &pending_per_peer_msgs) { return Err(SendError::BufferFull) }
256                 match pending_per_peer_msgs.entry(introduction_node_id) {
257                         hash_map::Entry::Vacant(_) => Err(SendError::InvalidFirstHop),
258                         hash_map::Entry::Occupied(mut e) => {
259                                 e.get_mut().push_back(msgs::OnionMessage { blinding_point, onion_routing_packet });
260                                 Ok(())
261                         }
262                 }
263         }
264
265         #[cfg(test)]
266         pub(super) fn release_pending_msgs(&self) -> HashMap<PublicKey, VecDeque<msgs::OnionMessage>> {
267                 let mut pending_msgs = self.pending_messages.lock().unwrap();
268                 let mut msgs = HashMap::new();
269                 // We don't want to disconnect the peers by removing them entirely from the original map, so we
270                 // swap the pending message buffers individually.
271                 for (peer_node_id, pending_messages) in &mut *pending_msgs {
272                         msgs.insert(*peer_node_id, core::mem::take(pending_messages));
273                 }
274                 msgs
275         }
276 }
277
278 fn outbound_buffer_full(peer_node_id: &PublicKey, buffer: &HashMap<PublicKey, VecDeque<msgs::OnionMessage>>) -> bool {
279         const MAX_TOTAL_BUFFER_SIZE: usize = (1 << 20) * 128;
280         const MAX_PER_PEER_BUFFER_SIZE: usize = (1 << 10) * 256;
281         let mut total_buffered_bytes = 0;
282         let mut peer_buffered_bytes = 0;
283         for (pk, peer_buf) in buffer {
284                 for om in peer_buf {
285                         let om_len = om.serialized_length();
286                         if pk == peer_node_id {
287                                 peer_buffered_bytes += om_len;
288                         }
289                         total_buffered_bytes += om_len;
290
291                         if total_buffered_bytes >= MAX_TOTAL_BUFFER_SIZE ||
292                                 peer_buffered_bytes >= MAX_PER_PEER_BUFFER_SIZE
293                         {
294                                 return true
295                         }
296                 }
297         }
298         false
299 }
300
301 impl<ES: Deref, NS: Deref, L: Deref, CMH: Deref> OnionMessageHandler for OnionMessenger<ES, NS, L, CMH>
302         where ES::Target: EntropySource,
303                   NS::Target: NodeSigner,
304                   L::Target: Logger,
305                   CMH::Target: CustomOnionMessageHandler + Sized,
306 {
307         /// Handle an incoming onion message. Currently, if a message was destined for us we will log, but
308         /// soon we'll delegate the onion message to a handler that can generate invoices or send
309         /// payments.
310         fn handle_onion_message(&self, _peer_node_id: &PublicKey, msg: &msgs::OnionMessage) {
311                 let control_tlvs_ss = match self.node_signer.ecdh(Recipient::Node, &msg.blinding_point, None) {
312                         Ok(ss) => ss,
313                         Err(e) =>  {
314                                 log_error!(self.logger, "Failed to retrieve node secret: {:?}", e);
315                                 return
316                         }
317                 };
318                 let onion_decode_ss = {
319                         let blinding_factor = {
320                                 let mut hmac = HmacEngine::<Sha256>::new(b"blinded_node_id");
321                                 hmac.input(control_tlvs_ss.as_ref());
322                                 Hmac::from_engine(hmac).into_inner()
323                         };
324                         match self.node_signer.ecdh(Recipient::Node, &msg.onion_routing_packet.public_key,
325                                 Some(&Scalar::from_be_bytes(blinding_factor).unwrap()))
326                         {
327                                 Ok(ss) => ss.secret_bytes(),
328                                 Err(()) => {
329                                         log_trace!(self.logger, "Failed to compute onion packet shared secret");
330                                         return
331                                 }
332                         }
333                 };
334                 match onion_utils::decode_next_untagged_hop(onion_decode_ss, &msg.onion_routing_packet.hop_data[..],
335                         msg.onion_routing_packet.hmac, (control_tlvs_ss, &*self.custom_handler))
336                 {
337                         Ok((Payload::Receive::<<<CMH as Deref>::Target as CustomOnionMessageHandler>::CustomMessage> {
338                                 message, control_tlvs: ReceiveControlTlvs::Unblinded(ReceiveTlvs { path_id }), reply_path,
339                         }, None)) => {
340                                 log_info!(self.logger,
341                                         "Received an onion message with path_id {:02x?} and {} reply_path",
342                                                 path_id, if reply_path.is_some() { "a" } else { "no" });
343                                 match message {
344                                         OnionMessageContents::Custom(msg) => self.custom_handler.handle_custom_message(msg),
345                                 }
346                         },
347                         Ok((Payload::Forward(ForwardControlTlvs::Unblinded(ForwardTlvs {
348                                 next_node_id, next_blinding_override
349                         })), Some((next_hop_hmac, new_packet_bytes)))) => {
350                                 // TODO: we need to check whether `next_node_id` is our node, in which case this is a dummy
351                                 // blinded hop and this onion message is destined for us. In this situation, we should keep
352                                 // unwrapping the onion layers to get to the final payload. Since we don't have the option
353                                 // of creating blinded paths with dummy hops currently, we should be ok to not handle this
354                                 // for now.
355                                 let new_pubkey = match onion_utils::next_hop_packet_pubkey(&self.secp_ctx, msg.onion_routing_packet.public_key, &onion_decode_ss) {
356                                         Ok(pk) => pk,
357                                         Err(e) => {
358                                                 log_trace!(self.logger, "Failed to compute next hop packet pubkey: {}", e);
359                                                 return
360                                         }
361                                 };
362                                 let outgoing_packet = Packet {
363                                         version: 0,
364                                         public_key: new_pubkey,
365                                         hop_data: new_packet_bytes,
366                                         hmac: next_hop_hmac,
367                                 };
368                                 let onion_message = msgs::OnionMessage {
369                                         blinding_point: match next_blinding_override {
370                                                 Some(blinding_point) => blinding_point,
371                                                 None => {
372                                                         let blinding_factor = {
373                                                                 let mut sha = Sha256::engine();
374                                                                 sha.input(&msg.blinding_point.serialize()[..]);
375                                                                 sha.input(control_tlvs_ss.as_ref());
376                                                                 Sha256::from_engine(sha).into_inner()
377                                                         };
378                                                         let next_blinding_point = msg.blinding_point;
379                                                         match next_blinding_point.mul_tweak(&self.secp_ctx, &Scalar::from_be_bytes(blinding_factor).unwrap()) {
380                                                                 Ok(bp) => bp,
381                                                                 Err(e) => {
382                                                                         log_trace!(self.logger, "Failed to compute next blinding point: {}", e);
383                                                                         return
384                                                                 }
385                                                         }
386                                                 },
387                                         },
388                                         onion_routing_packet: outgoing_packet,
389                                 };
390
391                                 let mut pending_per_peer_msgs = self.pending_messages.lock().unwrap();
392                                 if outbound_buffer_full(&next_node_id, &pending_per_peer_msgs) {
393                                         log_trace!(self.logger, "Dropping forwarded onion message to peer {:?}: outbound buffer full", next_node_id);
394                                         return
395                                 }
396
397                                 #[cfg(fuzzing)]
398                                 pending_per_peer_msgs.entry(next_node_id).or_insert_with(VecDeque::new);
399
400                                 match pending_per_peer_msgs.entry(next_node_id) {
401                                         hash_map::Entry::Vacant(_) => {
402                                                 log_trace!(self.logger, "Dropping forwarded onion message to disconnected peer {:?}", next_node_id);
403                                                 return
404                                         },
405                                         hash_map::Entry::Occupied(mut e) => {
406                                                 e.get_mut().push_back(onion_message);
407                                                 log_trace!(self.logger, "Forwarding an onion message to peer {}", next_node_id);
408                                         }
409                                 };
410                         },
411                         Err(e) => {
412                                 log_trace!(self.logger, "Errored decoding onion message packet: {:?}", e);
413                         },
414                         _ => {
415                                 log_trace!(self.logger, "Received bogus onion message packet, either the sender encoded a final hop as a forwarding hop or vice versa");
416                         },
417                 };
418         }
419
420         fn peer_connected(&self, their_node_id: &PublicKey, init: &msgs::Init, _inbound: bool) -> Result<(), ()> {
421                 if init.features.supports_onion_messages() {
422                         let mut peers = self.pending_messages.lock().unwrap();
423                         peers.insert(their_node_id.clone(), VecDeque::new());
424                 }
425                 Ok(())
426         }
427
428         fn peer_disconnected(&self, their_node_id: &PublicKey) {
429                 let mut pending_msgs = self.pending_messages.lock().unwrap();
430                 pending_msgs.remove(their_node_id);
431         }
432
433         fn provided_node_features(&self) -> NodeFeatures {
434                 let mut features = NodeFeatures::empty();
435                 features.set_onion_messages_optional();
436                 features
437         }
438
439         fn provided_init_features(&self, _their_node_id: &PublicKey) -> InitFeatures {
440                 let mut features = InitFeatures::empty();
441                 features.set_onion_messages_optional();
442                 features
443         }
444 }
445
446 impl<ES: Deref, NS: Deref, L: Deref, CMH: Deref> OnionMessageProvider for OnionMessenger<ES, NS, L, CMH>
447         where ES::Target: EntropySource,
448                   NS::Target: NodeSigner,
449                   L::Target: Logger,
450                   CMH::Target: CustomOnionMessageHandler,
451 {
452         fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<msgs::OnionMessage> {
453                 let mut pending_msgs = self.pending_messages.lock().unwrap();
454                 if let Some(msgs) = pending_msgs.get_mut(&peer_node_id) {
455                         return msgs.pop_front()
456                 }
457                 None
458         }
459 }
460
461 // TODO: parameterize the below Simple* types with OnionMessenger and handle the messages it
462 // produces
463 /// Useful for simplifying the parameters of [`SimpleArcChannelManager`] and
464 /// [`SimpleArcPeerManager`]. See their docs for more details.
465 ///
466 /// This is not exported to bindings users as `Arc`s don't make sense in bindings.
467 ///
468 /// [`SimpleArcChannelManager`]: crate::ln::channelmanager::SimpleArcChannelManager
469 /// [`SimpleArcPeerManager`]: crate::ln::peer_handler::SimpleArcPeerManager
470 pub type SimpleArcOnionMessenger<L> = OnionMessenger<Arc<KeysManager>, Arc<KeysManager>, Arc<L>, IgnoringMessageHandler>;
471 /// Useful for simplifying the parameters of [`SimpleRefChannelManager`] and
472 /// [`SimpleRefPeerManager`]. See their docs for more details.
473 ///
474 /// This is not exported to bindings users as general type aliases don't make sense in bindings.
475 ///
476 /// [`SimpleRefChannelManager`]: crate::ln::channelmanager::SimpleRefChannelManager
477 /// [`SimpleRefPeerManager`]: crate::ln::peer_handler::SimpleRefPeerManager
478 pub type SimpleRefOnionMessenger<'a, 'b, L> = OnionMessenger<&'a KeysManager, &'a KeysManager, &'b L, IgnoringMessageHandler>;
479
480 /// Construct onion packet payloads and keys for sending an onion message along the given
481 /// `unblinded_path` to the given `destination`.
482 fn packet_payloads_and_keys<T: CustomOnionMessageContents, S: secp256k1::Signing + secp256k1::Verification>(
483         secp_ctx: &Secp256k1<S>, unblinded_path: &[PublicKey], destination: Destination,
484         message: OnionMessageContents<T>, mut reply_path: Option<BlindedPath>, session_priv: &SecretKey
485 ) -> Result<(Vec<(Payload<T>, [u8; 32])>, Vec<onion_utils::OnionKeys>), secp256k1::Error> {
486         let num_hops = unblinded_path.len() + destination.num_hops();
487         let mut payloads = Vec::with_capacity(num_hops);
488         let mut onion_packet_keys = Vec::with_capacity(num_hops);
489
490         let (mut intro_node_id_blinding_pt, num_blinded_hops) = if let Destination::BlindedPath(BlindedPath {
491                 introduction_node_id, blinding_point, blinded_hops }) = &destination {
492                 (Some((*introduction_node_id, *blinding_point)), blinded_hops.len()) } else { (None, 0) };
493         let num_unblinded_hops = num_hops - num_blinded_hops;
494
495         let mut unblinded_path_idx = 0;
496         let mut blinded_path_idx = 0;
497         let mut prev_control_tlvs_ss = None;
498         let mut final_control_tlvs = None;
499         utils::construct_keys_callback(secp_ctx, unblinded_path, Some(destination), session_priv, |_, onion_packet_ss, ephemeral_pubkey, control_tlvs_ss, unblinded_pk_opt, enc_payload_opt| {
500                 if num_unblinded_hops != 0 && unblinded_path_idx < num_unblinded_hops {
501                         if let Some(ss) = prev_control_tlvs_ss.take() {
502                                 payloads.push((Payload::Forward(ForwardControlTlvs::Unblinded(
503                                         ForwardTlvs {
504                                                 next_node_id: unblinded_pk_opt.unwrap(),
505                                                 next_blinding_override: None,
506                                         }
507                                 )), ss));
508                         }
509                         prev_control_tlvs_ss = Some(control_tlvs_ss);
510                         unblinded_path_idx += 1;
511                 } else if let Some((intro_node_id, blinding_pt)) = intro_node_id_blinding_pt.take() {
512                         if let Some(control_tlvs_ss) = prev_control_tlvs_ss.take() {
513                                 payloads.push((Payload::Forward(ForwardControlTlvs::Unblinded(ForwardTlvs {
514                                         next_node_id: intro_node_id,
515                                         next_blinding_override: Some(blinding_pt),
516                                 })), control_tlvs_ss));
517                         }
518                 }
519                 if blinded_path_idx < num_blinded_hops.saturating_sub(1) && enc_payload_opt.is_some() {
520                         payloads.push((Payload::Forward(ForwardControlTlvs::Blinded(enc_payload_opt.unwrap())),
521                                 control_tlvs_ss));
522                         blinded_path_idx += 1;
523                 } else if let Some(encrypted_payload) = enc_payload_opt {
524                         final_control_tlvs = Some(ReceiveControlTlvs::Blinded(encrypted_payload));
525                         prev_control_tlvs_ss = Some(control_tlvs_ss);
526                 }
527
528                 let (rho, mu) = onion_utils::gen_rho_mu_from_shared_secret(onion_packet_ss.as_ref());
529                 onion_packet_keys.push(onion_utils::OnionKeys {
530                         #[cfg(test)]
531                         shared_secret: onion_packet_ss,
532                         #[cfg(test)]
533                         blinding_factor: [0; 32],
534                         ephemeral_pubkey,
535                         rho,
536                         mu,
537                 });
538         })?;
539
540         if let Some(control_tlvs) = final_control_tlvs {
541                 payloads.push((Payload::Receive {
542                         control_tlvs,
543                         reply_path: reply_path.take(),
544                         message,
545                 }, prev_control_tlvs_ss.unwrap()));
546         } else {
547                 payloads.push((Payload::Receive {
548                         control_tlvs: ReceiveControlTlvs::Unblinded(ReceiveTlvs { path_id: None, }),
549                         reply_path: reply_path.take(),
550                         message,
551                 }, prev_control_tlvs_ss.unwrap()));
552         }
553
554         Ok((payloads, onion_packet_keys))
555 }
556
557 /// Errors if the serialized payload size exceeds onion_message::BIG_PACKET_HOP_DATA_LEN
558 fn construct_onion_message_packet<T: CustomOnionMessageContents>(payloads: Vec<(Payload<T>, [u8; 32])>, onion_keys: Vec<onion_utils::OnionKeys>, prng_seed: [u8; 32]) -> Result<Packet, ()> {
559         // Spec rationale:
560         // "`len` allows larger messages to be sent than the standard 1300 bytes allowed for an HTLC
561         // onion, but this should be used sparingly as it is reduces anonymity set, hence the
562         // recommendation that it either look like an HTLC onion, or if larger, be a fixed size."
563         let payloads_ser_len = onion_utils::payloads_serialized_length(&payloads);
564         let hop_data_len = if payloads_ser_len <= SMALL_PACKET_HOP_DATA_LEN {
565                 SMALL_PACKET_HOP_DATA_LEN
566         } else if payloads_ser_len <= BIG_PACKET_HOP_DATA_LEN {
567                 BIG_PACKET_HOP_DATA_LEN
568         } else { return Err(()) };
569
570         Ok(onion_utils::construct_onion_message_packet::<_, _>(
571                 payloads, onion_keys, prng_seed, hop_data_len))
572 }