Remove code fragments with no effect

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

diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs
index 6275713b589043142626fd2cbd582b0a3e456cee..b1d81695b40d8d2cf13dcb39a037f44783a2c7a9 100644 (file)
--- a/src/ln/channelmanager.rs
+++ b/src/ln/channelmanager.rs
@@ -478,7 +478,6 @@ impl ChannelManager {
        fn construct_onion_keys_callback<T: secp256k1::Signing, FType: FnMut(SharedSecret, [u8; 32], PublicKey, &RouteHop)> (secp_ctx: &Secp256k1<T>, route: &Route, session_priv: &SecretKey, mut callback: FType) -> Result<(), HandleError> {
                let mut blinded_priv = session_priv.clone();
                let mut blinded_pub = PublicKey::from_secret_key(secp_ctx, &blinded_priv);
-               let mut first_iteration = true;
 
                for hop in route.hops.iter() {
                        let shared_secret = SharedSecret::new(secp_ctx, &hop.pubkey, &blinded_priv);
@@ -489,10 +488,6 @@ impl ChannelManager {
                        let mut blinding_factor = [0u8; 32];
                        sha.result(&mut blinding_factor);
 
-                       if first_iteration {
-                               blinded_pub = PublicKey::from_secret_key(secp_ctx, &blinded_priv);
-                               first_iteration = false;
-                       }
                        let ephemeral_pubkey = blinded_pub;
 
                        secp_call!(blinded_priv.mul_assign(secp_ctx, &secp_call!(SecretKey::from_slice(secp_ctx, &blinding_factor))));
@@ -876,6 +871,7 @@ impl ChannelManager {
                        htlc_minimum_msat: chan.get_our_htlc_minimum_msat(),
                        fee_base_msat: chan.get_our_fee_base_msat(&*self.fee_estimator),
                        fee_proportional_millionths: self.fee_proportional_millionths,
+                       excess_data: Vec::new(),
                };
 
                let msg_hash = Sha256dHash::from_data(&unsigned.encode()[..]);
@@ -1030,19 +1026,22 @@ impl ChannelManager {
                }
        }
 
-       fn get_announcement_sigs(&self, chan: &Channel) -> Result<Option<msgs::AnnouncementSignatures>, HandleError> {
-               if !chan.is_usable() || !chan.should_announce() { return Ok(None) }
+       fn get_announcement_sigs(&self, chan: &Channel) -> Option<msgs::AnnouncementSignatures> {
+               if !chan.should_announce() { return None }
 
-               let (announcement, our_bitcoin_sig) = chan.get_channel_announcement(self.get_our_node_id(), self.genesis_hash.clone())?;
+               let (announcement, our_bitcoin_sig) = match chan.get_channel_announcement(self.get_our_node_id(), self.genesis_hash.clone()) {
+                       Ok(res) => res,
+                       Err(_) => return None, // Only in case of state precondition violations eg channel is closing
+               };
                let msghash = Message::from_slice(&Sha256dHash::from_data(&announcement.encode()[..])[..]).unwrap();
                let our_node_sig = self.secp_ctx.sign(&msghash, &self.our_network_key);
 
-               Ok(Some(msgs::AnnouncementSignatures {
+               Some(msgs::AnnouncementSignatures {
                        channel_id: chan.channel_id(),
                        short_channel_id: chan.get_short_channel_id().unwrap(),
                        node_signature: our_node_sig,
                        bitcoin_signature: our_bitcoin_sig,
-               }))
+               })
        }
 
        /// Processes HTLCs which are pending waiting on random forward delay.
@@ -1379,14 +1378,7 @@ impl ChainListener for ChannelManager {
                        channel_state.by_id.retain(|_, channel| {
                                let chan_res = channel.block_connected(header, height, txn_matched, indexes_of_txn_matched);
                                if let Ok(Some(funding_locked)) = chan_res {
-                                       let announcement_sigs = match self.get_announcement_sigs(channel) {
-                                               Ok(res) => res,
-                                               Err(e) => {
-                                                       log_error!(self, "Got error handling message: {}!", e.err);
-                                                       //TODO: push e on events and blow up the channel (it has bad keys)
-                                                       return true;
-                                               }
-                                       };
+                                       let announcement_sigs = self.get_announcement_sigs(channel);
                                        new_events.push(events::Event::SendFundingLocked {
                                                node_id: channel.get_their_node_id(),
                                                msg: funding_locked,
@@ -1626,7 +1618,7 @@ impl ChannelMessageHandler for ChannelManager {
                                        return Err(HandleError{err: "Got a message for a channel from the wrong node!", action: None})
                                }
                                chan.funding_locked(&msg)?;
-                               return Ok(self.get_announcement_sigs(chan)?);
+                               return Ok(self.get_announcement_sigs(chan));
                        },
                        None => return Err(HandleError{err: "Failed to find corresponding channel", action: None})
                };
@@ -2277,7 +2269,6 @@ mod tests {
        }
 
        struct Node {
-               feeest: Arc<test_utils::TestFeeEstimator>,
                chain_monitor: Arc<chaininterface::ChainWatchInterfaceUtil>,
                tx_broadcaster: Arc<test_utils::TestBroadcaster>,
                chan_monitor: Arc<test_utils::TestChannelMonitor>,
@@ -2830,7 +2821,7 @@ mod tests {
                        };
                        let node = ChannelManager::new(node_id.clone(), 0, true, Network::Testnet, feeest.clone(), chan_monitor.clone(), chain_monitor.clone(), tx_broadcaster.clone(), Arc::clone(&logger)).unwrap();
                        let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id), Arc::clone(&logger));
-                       nodes.push(Node { feeest, chain_monitor, tx_broadcaster, chan_monitor, node, router });
+                       nodes.push(Node { chain_monitor, tx_broadcaster, chan_monitor, node, router });
                }
 
                nodes