Merge pull request #2727 from TheBlueMatt/2023-11-better-bolt11-utils

[rust-lightning] / lightning / src / ln / peer_handler.rs

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index 34110a73a4c66a2e6cde0c66b15d0a224624f5b4..4c2e68d9a43993a021c5a0bc796b548aed1a649e 100644 (file)
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -27,7 +27,7 @@ use crate::ln::msgs::{ChannelMessageHandler, LightningError, SocketAddress, Onio
 #[cfg(not(c_bindings))]
 use crate::ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
 use crate::util::ser::{VecWriter, Writeable, Writer};
-use crate::ln::peer_channel_encryptor::{PeerChannelEncryptor, NextNoiseStep, MSG_BUF_ALLOC_SIZE};
+use crate::ln::peer_channel_encryptor::{PeerChannelEncryptor, NextNoiseStep, MessageBuf, MSG_BUF_ALLOC_SIZE};
 use crate::ln::wire;
 use crate::ln::wire::{Encode, Type};
 #[cfg(not(c_bindings))]
@@ -231,6 +231,18 @@ impl ChannelMessageHandler for ErroringMessageHandler {
        fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &msgs::ClosingSigned) {
                ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
        }
+       fn handle_stfu(&self, their_node_id: &PublicKey, msg: &msgs::Stfu) {
+               ErroringMessageHandler::push_error(&self, their_node_id, msg.channel_id);
+       }
+       fn handle_splice(&self, their_node_id: &PublicKey, msg: &msgs::Splice) {
+               ErroringMessageHandler::push_error(&self, their_node_id, msg.channel_id);
+       }
+       fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &msgs::SpliceAck) {
+               ErroringMessageHandler::push_error(&self, their_node_id, msg.channel_id);
+       }
+       fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &msgs::SpliceLocked) {
+               ErroringMessageHandler::push_error(&self, their_node_id, msg.channel_id);
+       }
        fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateAddHTLC) {
                ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
        }
@@ -495,7 +507,7 @@ struct Peer {
        /// prioritize channel messages over them.
        ///
        /// Note that these messages are *not* encrypted/MAC'd, and are only serialized.
-       gossip_broadcast_buffer: VecDeque<Vec<u8>>,
+       gossip_broadcast_buffer: VecDeque<MessageBuf>,
        awaiting_write_event: bool,
 
        pending_read_buffer: Vec<u8>,
@@ -1102,7 +1114,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
                        }
                        if peer.should_buffer_gossip_broadcast() {
                                if let Some(msg) = peer.gossip_broadcast_buffer.pop_front() {
-                                       peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_buffer(&msg[..]));
+                                       peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_buffer(msg));
                                }
                        }
                        if peer.should_buffer_gossip_backfill() {
@@ -1251,7 +1263,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
        }
 
        /// Append a message to a peer's pending outbound/write gossip broadcast buffer
-       fn enqueue_encoded_gossip_broadcast(&self, peer: &mut Peer, encoded_message: Vec<u8>) {
+       fn enqueue_encoded_gossip_broadcast(&self, peer: &mut Peer, encoded_message: MessageBuf) {
                peer.msgs_sent_since_pong += 1;
                debug_assert!(peer.gossip_broadcast_buffer.len() <= OUTBOUND_BUFFER_LIMIT_DROP_GOSSIP);
                peer.gossip_broadcast_buffer.push_back(encoded_message);
@@ -1652,6 +1664,22 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
                                self.message_handler.chan_handler.handle_channel_ready(&their_node_id, &msg);
                        },
 
+                       // Quiescence messages:
+                       wire::Message::Stfu(msg) => {
+                               self.message_handler.chan_handler.handle_stfu(&their_node_id, &msg);
+                       }
+
+                       // Splicing messages:
+                       wire::Message::Splice(msg) => {
+                               self.message_handler.chan_handler.handle_splice(&their_node_id, &msg);
+                       }
+                       wire::Message::SpliceAck(msg) => {
+                               self.message_handler.chan_handler.handle_splice_ack(&their_node_id, &msg);
+                       }
+                       wire::Message::SpliceLocked(msg) => {
+                               self.message_handler.chan_handler.handle_splice_locked(&their_node_id, &msg);
+                       }
+
                        // Interactive transaction construction messages:
                        wire::Message::TxAddInput(msg) => {
                                self.message_handler.chan_handler.handle_tx_add_input(&their_node_id, &msg);
@@ -1800,7 +1828,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
                                        if except_node.is_some() && peer.their_node_id.as_ref().map(|(pk, _)| pk) == except_node {
                                                continue;
                                        }
-                                       self.enqueue_encoded_gossip_broadcast(&mut *peer, encoded_msg.clone());
+                                       self.enqueue_encoded_gossip_broadcast(&mut *peer, MessageBuf::from_encoded(&encoded_msg));
                                }
                        },
                        wire::Message::NodeAnnouncement(ref msg) => {
@@ -1827,7 +1855,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
                                        if except_node.is_some() && peer.their_node_id.as_ref().map(|(pk, _)| pk) == except_node {
                                                continue;
                                        }
-                                       self.enqueue_encoded_gossip_broadcast(&mut *peer, encoded_msg.clone());
+                                       self.enqueue_encoded_gossip_broadcast(&mut *peer, MessageBuf::from_encoded(&encoded_msg));
                                }
                        },
                        wire::Message::ChannelUpdate(ref msg) => {
@@ -1849,7 +1877,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
                                        if except_node.is_some() && peer.their_node_id.as_ref().map(|(pk, _)| pk) == except_node {
                                                continue;
                                        }
-                                       self.enqueue_encoded_gossip_broadcast(&mut *peer, encoded_msg.clone());
+                                       self.enqueue_encoded_gossip_broadcast(&mut *peer, MessageBuf::from_encoded(&encoded_msg));
                                }
                        },
                        _ => debug_assert!(false, "We shouldn't attempt to forward anything but gossip messages"),
@@ -1969,6 +1997,30 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
                                                                        &msg.channel_id);
                                                        self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
                                                },
+                                               MessageSendEvent::SendStfu { ref node_id, ref msg} => {
+                                                       log_debug!(self.logger, "Handling SendStfu event in peer_handler for node {} for channel {}",
+                                                                       log_pubkey!(node_id),
+                                                                       &msg.channel_id);
+                                                       self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+                                               }
+                                               MessageSendEvent::SendSplice { ref node_id, ref msg} => {
+                                                       log_debug!(self.logger, "Handling SendSplice event in peer_handler for node {} for channel {}",
+                                                                       log_pubkey!(node_id),
+                                                                       &msg.channel_id);
+                                                       self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+                                               }
+                                               MessageSendEvent::SendSpliceAck { ref node_id, ref msg} => {
+                                                       log_debug!(self.logger, "Handling SendSpliceAck event in peer_handler for node {} for channel {}",
+                                                                       log_pubkey!(node_id),
+                                                                       &msg.channel_id);
+                                                       self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+                                               }
+                                               MessageSendEvent::SendSpliceLocked { ref node_id, ref msg} => {
+                                                       log_debug!(self.logger, "Handling SendSpliceLocked event in peer_handler for node {} for channel {}",
+                                                                       log_pubkey!(node_id),
+                                                                       &msg.channel_id);
+                                                       self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+                                               }
                                                MessageSendEvent::SendTxAddInput { ref node_id, ref msg } => {
                                                        log_debug!(self.logger, "Handling SendTxAddInput event in peer_handler for node {} for channel {}",
                                                                        log_pubkey!(node_id),