Upgrade to secp256k1 v12, bitcoin v16, and crates bitcoin_hashes

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

diff --git a/src/ln/peer_handler.rs b/src/ln/peer_handler.rs
index 87a2e6d1c242b64f6e9b15fb0e9de9ef7cb8f74e..78a5896f2ce993899d3a0fd1b2b1c3450d4c26a8 100644 (file)
--- a/src/ln/peer_handler.rs
+++ b/src/ln/peer_handler.rs
@@ -234,7 +234,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                if peers.peers.insert(descriptor, Peer {
                        channel_encryptor: peer_encryptor,
                        outbound: true,
-                       their_node_id: Some(their_node_id),
+                       their_node_id: None,
                        their_global_features: None,
                        their_local_features: None,
 
@@ -438,9 +438,6 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
 
                                                        macro_rules! try_potential_handleerror {
                                                                ($thing: expr) => {
-                                                                       try_potential_handleerror!($thing, false);
-                                                               };
-                                                               ($thing: expr, $pre_noise: expr) => {
                                                                        match $thing {
                                                                                Ok(x) => x,
                                                                                Err(e) => {
@@ -449,9 +446,6 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                                                        msgs::ErrorAction::DisconnectPeer { msg: _ } => {
                                                                                                                //TODO: Try to push msg
                                                                                                                log_trace!(self, "Got Err handling message, disconnecting peer because {}", e.err);
-                                                                                                               if $pre_noise {
-                                                                                                                       peer.their_node_id = None; // Unset so that we don't generate a peer_disconnected event
-                                                                                                               }
                                                                                                                return Err(PeerHandleError{ no_connection_possible: false });
                                                                                                        },
                                                                                                        msgs::ErrorAction::IgnoreError => {
@@ -517,16 +511,17 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                        let next_step = peer.channel_encryptor.get_noise_step();
                                                        match next_step {
                                                                NextNoiseStep::ActOne => {
-                                                                       let act_two = try_potential_handleerror!(peer.channel_encryptor.process_act_one_with_key(&peer.pending_read_buffer[..], &self.our_node_secret), true).to_vec();
+                                                                       let act_two = try_potential_handleerror!(peer.channel_encryptor.process_act_one_with_key(&peer.pending_read_buffer[..], &self.our_node_secret)).to_vec();
                                                                        peer.pending_outbound_buffer.push_back(act_two);
                                                                        peer.pending_read_buffer = [0; 66].to_vec(); // act three is 66 bytes long
                                                                },
                                                                NextNoiseStep::ActTwo => {
-                                                                       let act_three = try_potential_handleerror!(peer.channel_encryptor.process_act_two(&peer.pending_read_buffer[..], &self.our_node_secret), true).to_vec();
-                                                                       peer.pending_outbound_buffer.push_back(act_three);
+                                                                       let (act_three, their_node_id) = try_potential_handleerror!(peer.channel_encryptor.process_act_two(&peer.pending_read_buffer[..], &self.our_node_secret));
+                                                                       peer.pending_outbound_buffer.push_back(act_three.to_vec());
                                                                        peer.pending_read_buffer = [0; 18].to_vec(); // Message length header is 18 bytes
                                                                        peer.pending_read_is_header = true;
 
+                                                                       peer.their_node_id = Some(their_node_id);
                                                                        insert_node_id!();
                                                                        let mut local_features = msgs::LocalFeatures::new();
                                                                        if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
@@ -539,7 +534,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
                                                                        }, 16);
                                                                },
                                                                NextNoiseStep::ActThree => {
-                                                                       let their_node_id = try_potential_handleerror!(peer.channel_encryptor.process_act_three(&peer.pending_read_buffer[..]), true);
+                                                                       let their_node_id = try_potential_handleerror!(peer.channel_encryptor.process_act_three(&peer.pending_read_buffer[..]));
                                                                        peer.pending_read_buffer = [0; 18].to_vec(); // Message length header is 18 bytes
                                                                        peer.pending_read_is_header = true;
                                                                        peer.their_node_id = Some(their_node_id);
@@ -1096,7 +1091,6 @@ mod tests {
        }
 
        fn create_network(peer_count: usize) -> Vec<PeerManager<FileDescriptor>> {
-               let secp_ctx = Secp256k1::new();
                let mut peers = Vec::new();
                let mut rng = thread_rng();
                let logger : Arc<Logger> = Arc::new(test_utils::TestLogger::new());
@@ -1107,7 +1101,7 @@ mod tests {
                        let node_id = {
                                let mut key_slice = [0;32];
                                rng.fill_bytes(&mut key_slice);
-                               SecretKey::from_slice(&secp_ctx, &key_slice).unwrap()
+                               SecretKey::from_slice(&key_slice).unwrap()
                        };
                        let msg_handler = MessageHandler { chan_handler: Arc::new(chan_handler), route_handler: Arc::new(router) };
                        let peer = PeerManager::new(msg_handler, node_id, Arc::clone(&logger));