[WIP] Performance test for path finding and payment actor

crates/fiber-lib/src/cch/actor.rs

@@ -16,8 +16,8 @@ use tokio_util::{sync::CancellationToken, task::TaskTracker};
 
 use crate::ckb::contracts::{get_script_by_contract, Contract};
 use crate::fiber::hash_algorithm::HashAlgorithm;
-use crate::fiber::network::SendPaymentCommand;
 use crate::fiber::payment::PaymentStatus;
+use crate::fiber::payment::SendPaymentCommand;
 use crate::fiber::types::{Hash256, Privkey};
 use crate::fiber::ASSUME_NETWORK_ACTOR_ALIVE;
 use crate::fiber::{NetworkActorCommand, NetworkActorMessage};

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

@@ -9,7 +9,7 @@ use crate::fiber::config::MILLI_SECONDS_PER_EPOCH;
 use crate::fiber::fee::{check_open_channel_parameters, check_tlc_delta_with_epochs};
 #[cfg(any(debug_assertions, feature = "bench"))]
 use crate::fiber::network::DebugEvent;
-use crate::fiber::network::PaymentCustomRecords;
+use crate::fiber::payment::PaymentCustomRecords;
 use crate::fiber::types::TxSignatures;
 use crate::utils::actor::ActorHandleLogGuard;
 use crate::{debug_event, fiber::types::TxAbort, utils::tx::compute_tx_message};
@@ -43,9 +43,8 @@ use crate::{
         },
         hash_algorithm::HashAlgorithm,
         key::blake2b_hash_with_salt,
-        network::{
-            get_chain_hash, sign_network_message, FiberMessageWithPeerId, SendOnionPacketCommand,
-        },
+        network::SendOnionPacketCommand,
+        network::{get_chain_hash, sign_network_message, FiberMessageWithPeerId},
         serde_utils::{CompactSignatureAsBytes, EntityHex, PubNonceAsBytes},
         types::{
             AcceptChannel, AddTlc, AnnouncementSignatures, BroadcastMessageWithTimestamp,
@@ -1750,18 +1749,23 @@ where
         peeled_onion_packet: PeeledPaymentOnionPacket,
         forward_fee: u128,
     ) {
+        let (send, _recv) = oneshot::channel::<Result<(), TlcErr>>();
+        let port = RpcReplyPort::from(send);
         match self.network.send_message(NetworkActorMessage::Command(
-            NetworkActorCommand::SendPaymentOnionPacket(SendOnionPacketCommand {
-                peeled_onion_packet: peeled_onion_packet.clone(),
-                previous_tlc: Some(PrevTlcInfo::new(
-                    state.get_id(),
-                    u64::from(tlc_id),
-                    forward_fee,
-                )),
-                payment_hash,
-                // forward tlc always set attempt_id to None
-                attempt_id: None,
-            }),
+            NetworkActorCommand::SendPaymentOnionPacket(
+                SendOnionPacketCommand {
+                    peeled_onion_packet: peeled_onion_packet.clone(),
+                    previous_tlc: Some(PrevTlcInfo::new(
+                        state.get_id(),
+                        u64::from(tlc_id),
+                        forward_fee,
+                    )),
+                    payment_hash,
+                    // forward tlc always set attempt_id to None
+                    attempt_id: None,
+                },
+                port,
+            ),
         )) {
             Ok(_) => {
                 // we successfully sent the forward tlc, we will wait for the result
@@ -1826,12 +1830,25 @@ where
         state: &mut ChannelActorState,
         trigger_next: bool,
     ) {
+        debug!(
+            "apply_retryable_tlc_operations start: remained_ops={} waiting_tlc_ack={} reestablishing={}",
+            state.retryable_tlc_operations.len(),
+            state.is_waiting_tlc_ack(),
+            state.reestablishing
+        );
+        state.log_ack_state("[ack] retryable_ops_start");
         loop {
             if state.is_waiting_tlc_ack() {
+                state.log_ack_state("[ack] retryable_ops_blocked");
+                debug!(
+                    "apply_retryable_tlc_operations blocked remained_ops={}",
+                    state.retryable_tlc_operations.len()
+                );
                 break;
             }
 
             let Some(operation) = state.retryable_tlc_operations.pop_front() else {
+                debug!("apply_retryable_tlc_operations empty queue, exiting",);
                 return;
             };
 
@@ -1873,6 +1890,12 @@ where
         if trigger_next {
             state.schedule_next_retry_task(myself);
         }
+        debug!(
+            "apply_retryable_tlc_operations finished: remained_ops={} trigger_next={} waiting_tlc_ack={}",
+            state.retryable_tlc_operations.len(),
+            trigger_next,
+            state.is_waiting_tlc_ack()
+        );
     }
 
     fn handle_forward_tlc_result(
@@ -4176,6 +4199,11 @@ impl ChannelActorState {
 
     pub fn set_waiting_ack(&mut self, myself: &ActorRef<ChannelActorMessage>, waiting_ack: bool) {
         self.tlc_state.set_waiting_ack(waiting_ack);
+        self.log_ack_state(if waiting_ack {
+            "[ack] set_waiting_ack(true)"
+        } else {
+            "[ack] set_waiting_ack(false)"
+        });
         if waiting_ack {
             self.set_waiting_peer_response();
             myself.send_after(Duration::from_millis(PEER_CHANNEL_RESPONSE_TIMEOUT), || {
@@ -4186,6 +4214,18 @@ impl ChannelActorState {
         }
     }
 
+    fn log_ack_state(&self, context: &str) {
+        debug!(
+            channel = ?self.get_id(),
+            "{} waiting_ack={} send_present={} verify_present={} next_present={}",
+            context,
+            self.tlc_state.waiting_ack,
+            self.remote_revocation_nonce_for_send.is_some(),
+            self.remote_revocation_nonce_for_verify.is_some(),
+            self.remote_revocation_nonce_for_next.is_some()
+        );
+    }
+
     pub fn try_create_channel_messages(&mut self) -> Option<(ChannelAnnouncement, ChannelUpdate)> {
         let channel_announcement = self.try_create_channel_announcement_message()?;
         let channel_update = self.try_create_channel_update_message()?;
@@ -4597,6 +4637,7 @@ impl ChannelActorState {
         if let Some(nonce) = remote_channel_announcement_nonce {
             state.update_remote_channel_announcement_nonce(&nonce);
         }
+        state.log_ack_state("[ack] new_inbound_channel");
         state
     }
 
@@ -4622,7 +4663,7 @@ impl ChannelActorState {
         let signer = InMemorySigner::generate_from_seed(seed);
         let local_pubkeys = signer.get_base_public_keys();
         let temp_channel_id = derive_temp_channel_id_from_tlc_key(&local_pubkeys.tlc_base_key);
-        Self {
+        let state = Self {
             state: ChannelState::NegotiatingFunding(NegotiatingFundingFlags::empty()),
             public_channel_info,
             local_tlc_info,
@@ -4674,7 +4715,9 @@ impl ChannelActorState {
             pending_notify_settle_tlcs: vec![],
             ephemeral_config: Default::default(),
             private_key: Some(private_key),
-        }
+        };
+        state.log_ack_state("[ack] new_outbound_channel");
+        state
     }
 
     fn check_accept_channel_parameters(&self) -> ProcessingChannelResult {
@@ -4961,6 +5004,7 @@ impl ChannelActorState {
                             )),
                         ))
                         .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+                    self.log_ack_state("[ack] send_revoke_and_ack_message(resend_cached)");
                     return Ok(());
                 }
                 None => {
@@ -5048,6 +5092,7 @@ impl ChannelActorState {
         } else {
             self.remote_revocation_nonce_for_send = None;
         }
+        self.log_ack_state("[ack] send_revoke_and_ack_message");
 
         self.network()
             .send_message(NetworkActorMessage::new_command(
@@ -6018,6 +6063,7 @@ impl ChannelActorState {
         self.remote_revocation_nonce_for_send = Some(accept_channel.next_revocation_nonce.clone());
         self.remote_revocation_nonce_for_verify =
             Some(accept_channel.next_revocation_nonce.clone());
+        self.log_ack_state("[ack] handle_accept_channel_message");
         let remote_pubkeys = (&accept_channel).into();
         self.remote_channel_public_keys = Some(remote_pubkeys);
         self.remote_commitment_points = vec![
@@ -6677,6 +6723,7 @@ impl ChannelActorState {
         } else {
             self.remote_revocation_nonce_for_verify = None;
         }
+        self.log_ack_state("[ack] handle_revoke_and_ack_peer_message");
 
         self.network()
             .send_message(NetworkActorMessage::new_notification(