chore: resolve rebase conflicts and fix reconnect tests

Author: jjyr

crates/fiber-lib/src/fiber/network.rs

@@ -1150,7 +1150,10 @@ where
             }
             NetworkActorCommand::DisconnectPeer(pubkey, reason) => {
                 let peer_id = PeerId::from_public_key(&tentacle::secio::PublicKey::from(pubkey));
-                let session = state.peer_session_map.get(&pubkey).map(|peer| peer.session_id);
+                let session = state
+                    .peer_session_map
+                    .get(&pubkey)
+                    .map(|peer| peer.session_id);
                 if matches!(reason, PeerDisconnectReason::Requested) {
                     state.peer_reconnect_backoff_attempts.remove(&peer_id);
                     if session.is_some() {
@@ -3767,7 +3770,12 @@ where
 
     fn has_direct_active_channel(&self, peer_id: &PeerId) -> bool {
         self.resolve_peer_pubkey(peer_id)
-            .map(|pubkey| !self.store.get_active_channel_ids_by_pubkey(&pubkey).is_empty())
+            .map(|pubkey| {
+                !self
+                    .store
+                    .get_active_channel_ids_by_pubkey(&pubkey)
+                    .is_empty()
+            })
             .unwrap_or(false)
     }
 
@@ -3807,7 +3815,8 @@ where
             return;
         }
 
-        self.peer_reconnect_backoff_attempts.insert(peer_id.clone(), 0);
+        self.peer_reconnect_backoff_attempts
+            .insert(peer_id.clone(), 0);
         match trigger {
             PeerReconnectTrigger::Disconnected => {
                 debug_event!(self.network, "PeerReconnectBackoffSeededByDisconnect");
@@ -5140,10 +5149,12 @@ impl ServiceHandle for NetworkServiceHandle {
                 );
                 try_send_actor_message(
                     &self.actor,
-                    NetworkActorMessage::new_command(NetworkActorCommand::SeedPeerReconnectBackoff(
-                        peer_id,
-                        PeerReconnectTrigger::DialError,
-                    )),
+                    NetworkActorMessage::new_command(
+                        NetworkActorCommand::SeedPeerReconnectBackoff(
+                            peer_id,
+                            PeerReconnectTrigger::DialError,
+                        ),
+                    ),
                 );
             } else {
                 debug!(

crates/fiber-lib/src/fiber/tests/channel.rs

@@ -1,8 +1,8 @@
 use crate::ckb::tests::test_utils::complete_commitment_tx;
 use crate::fiber::channel::{
-    AddTlcResponse, ChannelState, CloseFlags, MAX_COMMITMENT_DELAY_EPOCHS,
-    MIN_COMMITMENT_DELAY_EPOCHS, NegotiatingFundingFlags, OutboundTlcStatus, ReplayOrderHint,
-    TLCId, TlcStatus, UpdateCommand, XUDT_COMPATIBLE_WITNESS,
+    AddTlcResponse, ChannelState, CloseFlags, NegotiatingFundingFlags, OutboundTlcStatus,
+    ReplayOrderHint, TLCId, TlcStatus, UpdateCommand, MAX_COMMITMENT_DELAY_EPOCHS,
+    MIN_COMMITMENT_DELAY_EPOCHS, XUDT_COMPATIBLE_WITNESS,
 };
 use crate::fiber::config::{
     DEFAULT_COMMITMENT_DELAY_EPOCHS, DEFAULT_FINAL_TLC_EXPIRY_DELTA, DEFAULT_TLC_EXPIRY_DELTA,
@@ -13,38 +13,37 @@ use crate::fiber::graph::ChannelInfo;
 use crate::fiber::network::{DebugEvent, FiberMessageWithTarget, PeerDisconnectReason};
 use crate::fiber::payment::{AttemptStatus, PaymentStatus, SendPaymentCommand};
 use crate::fiber::types::{
-    AddTlc, FiberMessage, Hash256, Init, NO_SHARED_SECRET, PaymentHopData,
-    PeeledPaymentOnionPacket, Pubkey, TlcErr, TlcErrorCode,
+    AddTlc, FiberMessage, Hash256, Init, PaymentHopData, PeeledPaymentOnionPacket, Pubkey, TlcErr,
+    TlcErrorCode, NO_SHARED_SECRET,
 };
 use crate::invoice::{CkbInvoiceStatus, Currency, InvoiceBuilder};
-use crate::test_utils::{NetworkNode, init_tracing};
+use crate::test_utils::{init_tracing, NetworkNode};
 use crate::tests::test_utils::*;
 use crate::{
-    NetworkServiceEvent,
-    ckb::contracts::{Contract, get_cell_deps},
+    ckb::contracts::{get_cell_deps, Contract},
     fiber::{
-        NetworkActorCommand, NetworkActorMessage,
         channel::{
-            AddTlcCommand, ChannelActorStateStore, ChannelCommand, ChannelCommandWithId,
-            DEFAULT_COMMITMENT_FEE_RATE, InMemorySigner, RemoveTlcCommand, ShutdownCommand,
-            derive_private_key, derive_tlc_pubkey,
+            derive_private_key, derive_tlc_pubkey, AddTlcCommand, ChannelActorStateStore,
+            ChannelCommand, ChannelCommandWithId, InMemorySigner, RemoveTlcCommand,
+            ShutdownCommand, DEFAULT_COMMITMENT_FEE_RATE,
         },
         config::DEFAULT_AUTO_ACCEPT_CHANNEL_CKB_FUNDING_AMOUNT,
         hash_algorithm::HashAlgorithm,
         network::{AcceptChannelCommand, OpenChannelCommand},
         types::{Privkey, RemoveTlcFulfill, RemoveTlcReason},
+        NetworkActorCommand, NetworkActorMessage,
     },
     gen_rand_fiber_private_key, gen_rand_fiber_public_key, gen_rand_sha256_hash,
-    now_timestamp_as_millis_u64,
+    now_timestamp_as_millis_u64, NetworkServiceEvent,
 };
 use ckb_types::core::EpochNumberWithFraction;
 use ckb_types::{
-    core::{FeeRate, tx_pool::TxStatus},
+    core::{tx_pool::TxStatus, FeeRate},
     packed::{CellInput, Script, Transaction},
     prelude::{AsTransactionBuilder, Builder, Entity, Pack, Unpack},
 };
-use musig2::KeyAggContext;
 use musig2::secp::Point;
+use musig2::KeyAggContext;
 use ractor::call;
 use secp256k1::SECP256K1;
 use std::collections::{HashMap, HashSet};
@@ -369,11 +368,10 @@ async fn test_create_channel_with_too_large_amounts() {
     };
     let res = create_channel_with_nodes(&mut node_a, &mut node_b, params).await;
     assert!(res.is_err(), "Create channel failed: {:?}", res);
-    assert!(
-        res.unwrap_err()
-            .to_string()
-            .contains("The total UDT funding amount should be less")
-    );
+    assert!(res
+        .unwrap_err()
+        .to_string()
+        .contains("The total UDT funding amount should be less"));
 }
 
 #[tokio::test]
@@ -1159,11 +1157,10 @@ async fn test_network_send_payment_keysend_with_payment_hash() {
             ..Default::default()
         })
         .await;
-    assert!(
-        res.err()
-            .unwrap()
-            .contains("keysend payment should not have payment_hash")
-    );
+    assert!(res
+        .err()
+        .unwrap()
+        .contains("keysend payment should not have payment_hash"));
 }
 
 #[tokio::test]
@@ -1672,11 +1669,10 @@ async fn test_network_send_payment_dry_run_can_still_query() {
             ..Default::default()
         })
         .await;
-    assert!(
-        res.unwrap_err()
-            .to_string()
-            .contains("Payment session already exists")
-    );
+    assert!(res
+        .unwrap_err()
+        .to_string()
+        .contains("Payment session already exists"));
 
     // now use a different payment hash
     let payment_hash = gen_rand_sha256_hash();
@@ -3211,12 +3207,10 @@ async fn test_channel_update_tlc_expiry() {
     })
     .unwrap();
     assert!(update_result.is_err());
-    assert!(
-        update_result
-            .unwrap_err()
-            .to_string()
-            .contains("TLC expiry delta is too small")
-    );
+    assert!(update_result
+        .unwrap_err()
+        .to_string()
+        .contains("TLC expiry delta is too small"));
 
     // update channel with new tlc_expiry_delta which is too large
     let update_result = call!(node_b.network_actor, |rpc_reply| {
@@ -3237,12 +3231,10 @@ async fn test_channel_update_tlc_expiry() {
     })
     .unwrap();
     assert!(update_result.is_err());
-    assert!(
-        update_result
-            .unwrap_err()
-            .to_string()
-            .contains("TLC expiry delta is too large")
-    );
+    assert!(update_result
+        .unwrap_err()
+        .to_string()
+        .contains("TLC expiry delta is too large"));
 
     let epoch_delay_milliseconds =
         (DEFAULT_COMMITMENT_DELAY_EPOCHS as f64 * MILLI_SECONDS_PER_EPOCH as f64 * 2.0 / 3.0)
@@ -3512,11 +3504,10 @@ async fn test_forward_payment_tlc_minimum_value() {
         .send_payment_keysend(&node_c, tlc_amount - 1, false)
         .await;
     assert!(res.is_err());
-    assert!(
-        res.unwrap_err()
-            .to_string()
-            .contains("Failed to build route, PathFind error: no path found")
-    );
+    assert!(res
+        .unwrap_err()
+        .to_string()
+        .contains("Failed to build route, PathFind error: no path found"));
 }
 
 #[tokio::test]
@@ -4452,7 +4443,7 @@ async fn test_peer_disconnect_with_active_channel_enters_backoff_reconnect() {
         .await;
     node_a
         .expect_event(|event| {
-            matches!(event, NetworkServiceEvent::PeerDisConnected(id, _) if id == &node_b.peer_id)
+            matches!(event, NetworkServiceEvent::PeerDisConnected(id, _) if id == &node_b.pubkey)
         })
         .await;
 }
@@ -4758,12 +4749,10 @@ async fn test_shutdown_channel_with_large_size_shutdown_script_should_fail() {
     };
 
     let shutdown_channel_result = call!(node_b.network_actor, message).expect("node_b alive");
-    assert!(
-        shutdown_channel_result
-            .err()
-            .unwrap()
-            .contains("Local balance is not enough to pay the fee")
-    );
+    assert!(shutdown_channel_result
+        .err()
+        .unwrap()
+        .contains("Local balance is not enough to pay the fee"));
 
     let message = |rpc_reply| {
         NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
@@ -4782,12 +4771,10 @@ async fn test_shutdown_channel_with_large_size_shutdown_script_should_fail() {
     };
 
     let shutdown_channel_result = call!(node_a.network_actor, message).expect("node_b alive");
-    assert!(
-        shutdown_channel_result
-            .err()
-            .unwrap()
-            .contains("Local balance is not enough to pay the fee")
-    );
+    assert!(shutdown_channel_result
+        .err()
+        .unwrap()
+        .contains("Local balance is not enough to pay the fee"));
 }
 
 #[tokio::test]
@@ -5633,11 +5620,9 @@ async fn test_send_payment_will_succeed_with_valid_invoice() {
         node_3.get_invoice_status(ckb_invoice.payment_hash()),
         Some(CkbInvoiceStatus::Paid)
     );
-    assert!(
-        node_3
-            .get_payment_preimage(ckb_invoice.payment_hash())
-            .is_none()
-    );
+    assert!(node_3
+        .get_payment_preimage(ckb_invoice.payment_hash())
+        .is_none());
 }
 
 #[tokio::test]
@@ -5768,11 +5753,9 @@ async fn test_send_payment_will_fail_with_cancelled_invoice() {
         node_3.get_invoice_status(ckb_invoice.payment_hash()),
         Some(CkbInvoiceStatus::Cancelled)
     );
-    assert!(
-        node_3
-            .get_payment_preimage(ckb_invoice.payment_hash())
-            .is_some()
-    );
+    assert!(node_3
+        .get_payment_preimage(ckb_invoice.payment_hash())
+        .is_some());
 }
 
 #[tokio::test]
@@ -5960,11 +5943,8 @@ async fn test_open_channel_tlc_expiry_is_smaller_than_commitment_delay() {
 
     eprintln!("open_channel_result: {:?}", open_channel_result);
     let error = open_channel_result.unwrap_err().to_string();
-    assert!(
-        error.contains(
-            "TLC expiry delta 13332 is smaller than 2/3 commitment_delay_epoch delay 13333"
-        )
-    );
+    assert!(error
+        .contains("TLC expiry delta 13332 is smaller than 2/3 commitment_delay_epoch delay 13333"));
 
     let message = |rpc_reply| {
         NetworkActorMessage::Command(NetworkActorCommand::OpenChannel(

crates/fiber-lib/src/fiber/tests/network.rs

@@ -754,7 +754,7 @@ async fn test_peer_disconnect_without_active_channel_skips_backoff_reconnect() {
         .await;
     node1
         .expect_event(|event| {
-            matches!(event, NetworkServiceEvent::PeerDisConnected(id, _) if id == &node2.peer_id)
+            matches!(event, NetworkServiceEvent::PeerDisConnected(id, _) if id == &node2.pubkey)
         })
         .await;
 }