chore: trim leftover test helpers and formatting drift

jjyr · jjyr · commit 0ea9d76029de · 2026-03-19T00:52:14.000+08:00
diff --git a/crates/fiber-lib/src/fiber/channel.rs b/crates/fiber-lib/src/fiber/channel.rs
@@ -2200,10 +2200,7 @@ where
                 ));
             }
             ChannelState::NegotiatingFunding(_) => {
-                debug!(
-                    "Beginning processing tx collaboration command, and transitioning from {:?} to CollaboratingFundingTx state",
-                    state.state
-                );
+                debug!("Beginning processing tx collaboration command, and transitioning from {:?} to CollaboratingFundingTx state", state.state);
                 state.state =
                     ChannelState::CollaboratingFundingTx(CollaboratingFundingTxFlags::empty());
                 CollaboratingFundingTxFlags::empty()
@@ -2294,10 +2291,7 @@ where
                     state.funding_tx = Some(tx);
                     state.update_state(ChannelState::AwaitingTxSignatures(flags));
                 } else {
-                    error!(
-                        "Invalid state. Expect channel state to be AwaitingTxSignatures, but bot {:?}",
-                        state.state
-                    );
+                    error!("Invalid state. Expect channel state to be AwaitingTxSignatures, but bot {:?}", state.state);
                 }
                 Ok(())
             }
@@ -3933,6 +3927,7 @@ impl ChannelActorState {
     fn on_peer_reconnected(&mut self) {
         if self.reestablishing {
             self.connectivity_state = ChannelConnectivityState::Syncing;
+            self.send_reestablish_message();
         }
     }
 
@@ -4857,10 +4852,8 @@ impl ChannelActorState {
             self.to_local_amount = to_local_amount;
             self.to_remote_amount = to_remote_amount;
 
-            debug!(
-                "Updated local balance to {} and remote balance to {} by removing tlc {:?} with reason {:?}",
-                to_local_amount, to_remote_amount, tlc_id, reason
-            );
+            debug!("Updated local balance to {} and remote balance to {} by removing tlc {:?} with reason {:?}",
+                            to_local_amount, to_remote_amount, tlc_id, reason);
             self.apply_remove_tlc(tlc_id);
         }
         debug!(
@@ -5626,9 +5619,7 @@ impl ChannelActorState {
                 debug!("We have sent our shutdown signature, waiting for counterparty's signature");
             }
         } else {
-            debug!(
-                "Not ready to shutdown the channel, waiting for both parties to send the Shutdown message"
-            );
+            debug!("Not ready to shutdown the channel, waiting for both parties to send the Shutdown message");
         }
 
         Ok(())
@@ -5681,8 +5672,7 @@ impl ChannelActorState {
             _ => {
                 return Err(ProcessingChannelError::InvalidParameter(format!(
                     "Must/Mustn't send announcement nonce if channel is public/private, nonce {:?}, channel is public: {}",
-                    &accept_channel.channel_announcement_nonce,
-                    self.is_public()
+                    &accept_channel.channel_announcement_nonce, self.is_public()
                 )));
             }
         }
@@ -5719,10 +5709,7 @@ impl ChannelActorState {
                 ));
             }
             ChannelState::NegotiatingFunding(_) => {
-                debug!(
-                    "Started negotiating funding tx collaboration, and transitioning from {:?} to CollaboratingFundingTx state",
-                    self.state
-                );
+                debug!("Started negotiating funding tx collaboration, and transitioning from {:?} to CollaboratingFundingTx state", self.state);
                 self.state =
                     ChannelState::CollaboratingFundingTx(CollaboratingFundingTxFlags::empty());
                 CollaboratingFundingTxFlags::empty()
@@ -5925,9 +5912,7 @@ impl ChannelActorState {
         flags: SigningCommitmentFlags,
     ) -> ProcessingChannelResult {
         if flags.contains(SigningCommitmentFlags::COMMITMENT_SIGNED_SENT) {
-            debug!(
-                "Commitment signed message sent by both sides, transitioning to AwaitingTxSignatures state"
-            );
+            debug!("Commitment signed message sent by both sides, transitioning to AwaitingTxSignatures state");
             self.update_state(ChannelState::AwaitingTxSignatures(
                 AwaitingTxSignaturesFlags::empty(),
             ));
@@ -6719,10 +6704,8 @@ impl ChannelActorState {
                 "udt_amount: {}, to_remote_amount: {}, to_local_amount: {}",
                 udt_amount, self.to_remote_amount, self.to_local_amount
             );
-            debug!(
-                "current_capacity: {}, remote_reserved_ckb_amount: {}, local_reserved_ckb_amount: {}",
-                current_capacity, self.remote_reserved_ckb_amount, self.local_reserved_ckb_amount
-            );
+            debug!("current_capacity: {}, remote_reserved_ckb_amount: {}, local_reserved_ckb_amount: {}",
+                current_capacity, self.remote_reserved_ckb_amount, self.local_reserved_ckb_amount);
             let is_udt_amount_ok = udt_amount == self.get_liquid_capacity();
             return Ok(is_udt_amount_ok);
         } else {
@@ -7014,10 +6997,8 @@ impl ChannelActorState {
         } else {
             debug!(
                 "Final balance partition before shutting down: local {} (fee {}), remote {} (fee {})",
-                self.to_local_amount,
-                local_shutdown_fee,
-                self.to_remote_amount,
-                remote_shutdown_fee
+                self.to_local_amount, local_shutdown_fee,
+                self.to_remote_amount, remote_shutdown_fee
             );
             let local_value =
                 self.to_local_amount as u64 + self.local_reserved_ckb_amount - local_shutdown_fee;
diff --git a/crates/fiber-lib/src/fiber/graph.rs b/crates/fiber-lib/src/fiber/graph.rs
@@ -1077,34 +1077,6 @@ where
         self.source
     }
 
-    #[cfg(any(test, feature = "bench"))]
-    pub fn debug_history_result(
-        &self,
-        channel_outpoint: &OutPoint,
-        from: Pubkey,
-        to: Pubkey,
-    ) -> Option<TimedResult> {
-        let (direction, _) = super::history::output_direction(from, to);
-        self.history
-            .get_result(channel_outpoint, direction)
-            .copied()
-    }
-
-    #[cfg(any(test, feature = "bench"))]
-    pub fn debug_history_probability(
-        &self,
-        channel_outpoint: &OutPoint,
-        from: Pubkey,
-        to: Pubkey,
-        amount: u128,
-    ) -> Option<f64> {
-        let channel = self.get_channel(channel_outpoint)?;
-        Some(
-            self.history
-                .eval_probability(from, to, channel_outpoint, amount, channel.capacity()),
-        )
-    }
-
     pub(crate) fn mark_channel_failed(&mut self, channel_outpoint: &OutPoint) {
         if let Some(channel) = self.channels.get_mut(channel_outpoint) {
             if let Some(info) = channel.update_of_node2.as_mut() {
diff --git a/crates/fiber-lib/src/fiber/network.rs b/crates/fiber-lib/src/fiber/network.rs
@@ -58,8 +58,7 @@ use super::channel::{
 use super::gossip::{GossipActorMessage, GossipMessageStore, GossipMessageUpdates};
 use super::graph::{NetworkGraph, NetworkGraphStateStore, OwnedChannelUpdateEvent};
 use super::types::{
-    BroadcastMessageWithTimestamp, FiberMessage, ForwardTlcResult, GossipMessage, Init,
-    OpenChannel, ReestablishChannel,
+    BroadcastMessageWithTimestamp, FiberMessage, ForwardTlcResult, GossipMessage, Init, OpenChannel,
 };
 use super::{
     FiberConfig, InFlightCkbTxActor, InFlightCkbTxActorArguments, InFlightCkbTxKind,
@@ -1273,18 +1272,17 @@ where
 
                 if num_inbound_peers > state.max_inbound_peers {
                     debug!(
-                        "Already connected to {} inbound peers, only wants {} peers, disconnecting some",
-                        num_inbound_peers, state.max_inbound_peers
-                    );
+                                "Already connected to {} inbound peers, only wants {} peers, disconnecting some",
+                                num_inbound_peers, state.max_inbound_peers
+                            );
                     inbound_peer_sessions.retain(|k| !state.session_channels_map.contains_key(k));
                     let sessions_to_disconnect = if inbound_peer_sessions.len()
                         < num_inbound_peers - state.max_inbound_peers
                     {
                         warn!(
-                            "Wants to disconnect more {} inbound peers, but all peers except {:?} have channels, will not disconnect any peer with channels",
-                            num_inbound_peers - state.max_inbound_peers,
-                            &inbound_peer_sessions
-                        );
+                                    "Wants to disconnect more {} inbound peers, but all peers except {:?} have channels, will not disconnect any peer with channels",
+                                    num_inbound_peers - state.max_inbound_peers, &inbound_peer_sessions
+                                );
                         &inbound_peer_sessions[..]
                     } else {
                         &inbound_peer_sessions[..num_inbound_peers - state.max_inbound_peers]
@@ -1302,9 +1300,9 @@ where
 
                 if num_outbound_peers >= state.min_outbound_peers {
                     debug!(
-                        "Already connected to {} outbound peers, wants a minimal of {} peers, skipping connecting to more peers",
-                        num_outbound_peers, state.min_outbound_peers
-                    );
+                                "Already connected to {} outbound peers, wants a minimal of {} peers, skipping connecting to more peers",
+                                num_outbound_peers, state.min_outbound_peers
+                            );
                     return Ok(());
                 }
 
@@ -1342,9 +1340,9 @@ where
                     debug!("Peer to connect: {:?}, {:?}", pubkey, addresses);
                     if let Some(peer) = state.peer_session_map.get(&pubkey) {
                         debug!(
-                            "Randomly selected peer {:?} already connected with session id {:?}, skipping connection",
-                            pubkey, peer.session_id
-                        );
+                                    "Randomly selected peer {:?} already connected with session id {:?}, skipping connection",
+                                    pubkey, peer.session_id
+                                );
                         continue;
                     }
 
@@ -3998,8 +3996,6 @@ where
             );
             self.attach_channel_to_session(remote_pubkey, channel_id);
             let _ = actor.send_message(ChannelActorMessage::Event(ChannelEvent::PeerReconnected));
-            self.send_reestablish_message(remote_pubkey, channel_id)
-                .await?;
             return Ok(actor);
         }
 
@@ -4041,28 +4037,6 @@ where
 
         Ok(channel)
     }
-
-    async fn send_reestablish_message(
-        &self,
-        remote_pubkey: Pubkey,
-        channel_id: Hash256,
-    ) -> Result<(), Error> {
-        let channel_actor_state = self
-            .store
-            .get_channel_actor_state(&channel_id)
-            .ok_or(Error::ChannelNotFound(channel_id))?;
-        let reestablish_channel = ReestablishChannel {
-            channel_id,
-            local_commitment_number: channel_actor_state.get_local_commitment_number(),
-            remote_commitment_number: channel_actor_state.get_remote_commitment_number(),
-        };
-        self.send_fiber_message_to_pubkey(
-            &remote_pubkey,
-            FiberMessage::reestablish_channel(reestablish_channel),
-        )
-        .await
-    }
-
     async fn on_peer_connected(&mut self, remote_pubkey: Pubkey, session: &SessionContext) {
         debug!("Peer {:?} connected", remote_pubkey);
         self.peer_session_map.insert(
