Provide inbound HTLC preimages to the `EcdsaChannelSigner`

[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 006538651a8133462996a750308a13497a0427f8..3949b97e0d03019a5f79ad4f293d0d450a9d970a 100644 (file)
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -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);
        }
@@ -910,7 +922,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
                ephemeral_key_midstate.input(ephemeral_random_data);
 
                let mut secp_ctx = Secp256k1::signing_only();
-               let ephemeral_hash = Sha256::from_engine(ephemeral_key_midstate.clone()).into_inner();
+               let ephemeral_hash = Sha256::from_engine(ephemeral_key_midstate.clone()).to_byte_array();
                secp_ctx.seeded_randomize(&ephemeral_hash);
 
                PeerManager {
@@ -954,7 +966,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
                let mut ephemeral_hash = self.ephemeral_key_midstate.clone();
                let counter = self.peer_counter.get_increment();
                ephemeral_hash.input(&counter.to_le_bytes());
-               SecretKey::from_slice(&Sha256::from_engine(ephemeral_hash).into_inner()).expect("You broke SHA-256!")
+               SecretKey::from_slice(&Sha256::from_engine(ephemeral_hash).to_byte_array()).expect("You broke SHA-256!")
        }
 
        fn init_features(&self, their_node_id: &PublicKey) -> InitFeatures {
@@ -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);
@@ -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),
@@ -2624,7 +2676,7 @@ mod tests {
                for i in 0..peer_count {
                        let node_secret = SecretKey::from_slice(&[42 + i as u8; 32]).unwrap();
                        let features = InitFeatures::from_le_bytes(vec![0u8; 33]);
-                       let network = ChainHash::from(&[i as u8; 32][..]);
+                       let network = ChainHash::from(&[i as u8; 32]);
                        cfgs.push(
                                PeerManagerCfg{
                                        chan_handler: test_utils::TestChannelMessageHandler::new(network),
@@ -2737,7 +2789,7 @@ mod tests {
                                                                node_id: peers[1].node_signer.get_node_id(Recipient::Node).unwrap(),
                                                                msg: msgs::Shutdown {
                                                                        channel_id: ChannelId::new_zero(),
-                                                                       scriptpubkey: bitcoin::Script::new(),
+                                                                       scriptpubkey: bitcoin::ScriptBuf::new(),
                                                                },
                                                        });
                                                cfgs[1].chan_handler.pending_events.lock().unwrap()
@@ -2745,7 +2797,7 @@ mod tests {
                                                                node_id: peers[0].node_signer.get_node_id(Recipient::Node).unwrap(),
                                                                msg: msgs::Shutdown {
                                                                        channel_id: ChannelId::new_zero(),
-                                                                       scriptpubkey: bitcoin::Script::new(),
+                                                                       scriptpubkey: bitcoin::ScriptBuf::new(),
                                                                },
                                                        });
 
@@ -2873,7 +2925,7 @@ mod tests {
 
                let their_id = peers[1].node_signer.get_node_id(Recipient::Node).unwrap();
 
-               let msg = msgs::Shutdown { channel_id: ChannelId::from_bytes([42; 32]), scriptpubkey: bitcoin::Script::new() };
+               let msg = msgs::Shutdown { channel_id: ChannelId::from_bytes([42; 32]), scriptpubkey: bitcoin::ScriptBuf::new() };
                a_chan_handler.pending_events.lock().unwrap().push(events::MessageSendEvent::SendShutdown {
                        node_id: their_id, msg: msg.clone()
                });