Limit OnionMessenger event buffer size.

[rust-lightning] / lightning / src / events / mod.rs

diff --git a/lightning/src/events/mod.rs b/lightning/src/events/mod.rs
index b43f2f9370d4370a70510af93c4828e2d3b93b92..09c52bd2a3f6fe0e29e61664bf76bc39868f8eac 100644 (file)
--- a/lightning/src/events/mod.rs
+++ b/lightning/src/events/mod.rs
@@ -38,11 +38,13 @@ use bitcoin::hashes::Hash;
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::secp256k1::PublicKey;
 use crate::io;
-use crate::prelude::*;
 use core::time::Duration;
 use core::ops::Deref;
 use crate::sync::Arc;
 
+#[allow(unused_imports)]
+use crate::prelude::*;
+
 /// Some information provided on receipt of payment depends on whether the payment received is a
 /// spontaneous payment or a "conventional" lightning payment that's paying an invoice.
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -1039,6 +1041,30 @@ pub enum Event {
        ///
        /// [`ChannelHandshakeConfig::negotiate_anchors_zero_fee_htlc_tx`]: crate::util::config::ChannelHandshakeConfig::negotiate_anchors_zero_fee_htlc_tx
        BumpTransaction(BumpTransactionEvent),
+       /// We received an onion message that is intended to be forwarded to a peer
+       /// that is currently offline. This event will only be generated if the
+       /// `OnionMessenger` was initialized with
+       /// [`OnionMessenger::new_with_offline_peer_interception`], see its docs.
+       ///
+       /// [`OnionMessenger::new_with_offline_peer_interception`]: crate::onion_message::messenger::OnionMessenger::new_with_offline_peer_interception
+       OnionMessageIntercepted {
+               /// The node id of the offline peer.
+               peer_node_id: PublicKey,
+               /// The onion message intended to be forwarded to `peer_node_id`.
+               message: msgs::OnionMessage,
+       },
+       /// Indicates that an onion message supporting peer has come online and it may
+       /// be time to forward any onion messages that were previously intercepted for
+       /// them. This event will only be generated if the `OnionMessenger` was
+       /// initialized with
+       /// [`OnionMessenger::new_with_offline_peer_interception`], see its docs.
+       ///
+       /// [`OnionMessenger::new_with_offline_peer_interception`]: crate::onion_message::messenger::OnionMessenger::new_with_offline_peer_interception
+       OnionMessagePeerConnected {
+               /// The node id of the peer we just connected to, who advertises support for
+               /// onion messages.
+               peer_node_id: PublicKey,
+       }
 }
 
 impl Writeable for Event {
@@ -1284,6 +1310,19 @@ impl Writeable for Event {
                                35u8.write(writer)?;
                                // Never write ConnectionNeeded events as buffered onion messages aren't serialized.
                        },
+                       &Event::OnionMessageIntercepted { ref peer_node_id, ref message } => {
+                               37u8.write(writer)?;
+                               write_tlv_fields!(writer, {
+                                       (0, peer_node_id, required),
+                                       (2, message, required),
+                               });
+                       },
+                       &Event::OnionMessagePeerConnected { ref peer_node_id } => {
+                               39u8.write(writer)?;
+                               write_tlv_fields!(writer, {
+                                       (0, peer_node_id, required),
+                               });
+                       }
                        // Note that, going forward, all new events must only write data inside of
                        // `write_tlv_fields`. Versions 0.0.101+ will ignore odd-numbered events that write
                        // data via `write_tlv_fields`.
@@ -1695,6 +1734,29 @@ impl MaybeReadable for Event {
                        },
                        // Note that we do not write a length-prefixed TLV for ConnectionNeeded events.
                        35u8 => Ok(None),
+                       37u8 => {
+                               let mut f = || {
+                                       _init_and_read_len_prefixed_tlv_fields!(reader, {
+                                               (0, peer_node_id, required),
+                                               (2, message, required),
+                                       });
+                                       Ok(Some(Event::OnionMessageIntercepted {
+                                               peer_node_id: peer_node_id.0.unwrap(), message: message.0.unwrap()
+                                       }))
+                               };
+                               f()
+                       },
+                       39u8 => {
+                               let mut f = || {
+                                       _init_and_read_len_prefixed_tlv_fields!(reader, {
+                                               (0, peer_node_id, required),
+                                       });
+                                       Ok(Some(Event::OnionMessagePeerConnected {
+                                               peer_node_id: peer_node_id.0.unwrap()
+                                       }))
+                               };
+                               f()
+                       },
                        // Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue.
                        // Version 0.0.100 failed to properly ignore odd types, possibly resulting in corrupt
                        // reads.