diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 519ebd907..9f82c4ecb 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -89,6 +89,7 @@ jobs:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
         profile: [dev, release]
+    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
     steps:
       - uses: actions/checkout@v2
       - uses: dsherret/rust-toolchain-file@v1
diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
index effee321b..5da46db0f 100644
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -63,7 +63,7 @@ jobs:
           fi
 
           # Prebuild the program so that we can run the following script faster
-          export FNN="$(cargo build --message-format=json-render-diagnostics | jq -js '[.[] | select(.reason == "compiler-artifact") | select(.executable != null)] | last | .executable')"
+          cargo build
           cd tests/deploy/udt-init && cargo build && cd -
           if [ ${{ matrix.workflow }} = "router-pay" ]; then
             export START_BOOTNODE=y
@@ -81,9 +81,9 @@ jobs:
             if [ -f $port_file ]; then
               break
             else
+                retry_count=$((retry_count + 1))
                 echo "File $port_file not found. Retrying in 2 seconds..."
                 sleep 2
-                retry_count=$((retry_count + 1))
             fi
           done
 
@@ -92,11 +92,15 @@ jobs:
             ports+=("$line")
           done < ./tests/nodes/.ports
 
-          for i in {1..20}; do
+          echo "Checking if all ports are open ... ${ports[@]}"
+
+          try_number=60
+          count=0
+          while [ $count -lt $try_number ]; do
             all_open=true
-            for port in $ports; do
-              echo "Checking port $port"
+            for port in "${ports[@]}"; do
               if ! nc -z 127.0.0.1 $port; then
+                echo "Port $port is not open yet ..."
                 all_open=false
                 break
               fi
@@ -105,11 +109,17 @@ jobs:
               echo "All ports are open now ..."
               break
             else
+              count=$((count + 1))
+              if [ $count -eq $try_number ]; then
+                echo "Reached maximum number of tries ($try_number), exiting with status 1"
+                exit 1
+              fi
               echo "Not all ports are open, waiting 3 seconds before retrying"
               sleep 3
             fi
           done
 
+
           (cd ./tests/bruno; npm exec -- @usebruno/cli@1.20.0 run e2e/${{ matrix.workflow }} -r --env ${{ matrix.test_env }} ${{ matrix.extra_bru_args }} ) &
 
           # -n means we will exit when any of the background processes exits.
diff --git a/Cargo.lock b/Cargo.lock
index 4049c90f9..fa35198a7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1589,7 +1589,7 @@ dependencies = [
 
 [[package]]
 name = "fnn"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "anyhow",
  "arcode",
@@ -1621,6 +1621,7 @@ dependencies = [
  "molecule",
  "musig2",
  "nom",
+ "num_enum",
  "once_cell",
  "ractor",
  "rand 0.8.5",
@@ -2809,6 +2810,27 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "num_enum"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179"
+dependencies = [
+ "num_enum_derive",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.90",
+]
+
 [[package]]
 name = "number_prefix"
 version = "0.4.0"
diff --git a/Cargo.toml b/Cargo.toml
index 4b6d37c80..983451b07 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "fnn"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -63,6 +63,7 @@ tokio = { version = "1", features = [
 indicatif = "0.16"
 console = "0.15.8"
 bincode = "1.3.3"
+num_enum = "0.7.3"
 
 [features]
 default = []
diff --git a/Makefile b/Makefile
index d14e3a6b1..116f1a1ff 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@ GRCOV_EXCL_LINE = ^\s*(\})*(\))*(;)*$$|\s*((log::|tracing::)?(trace|debug|info|w
 
 .PHONY: test
 test:
-	RUST_LOG=off cargo nextest run --no-fail-fast
+	TEST_TEMP_RETAIN=1 RUST_LOG=off cargo nextest run --no-fail-fast
 
 .PHONY: clippy
 clippy:
@@ -55,7 +55,7 @@ coverage: coverage-run-unittests coverage-collect-data coverage-generate-report
 
 .PHONY: gen-rpc-doc
 gen-rpc-doc:
-	cargo install fiber-rpc-gen
+	$(if $(shell command -v fiber-rpc-gen),,cargo install fiber-rpc-gen --force)
 	fiber-rpc-gen ./src/rpc
 	if grep -q "TODO: add desc" ./src/rpc/README.md; then \
         echo "Warning: There are 'TODO: add desc' in src/rpc/README.md, please add documentation comments to resolve them"; \
diff --git a/README.md b/README.md
index caf0f06f0..612e69dab 100644
--- a/README.md
+++ b/README.md
@@ -7,16 +7,13 @@ Fiber Network Node (FNN) is a reference implementation of Fiber Network Protocol
 * Payments over fiber channel (via [fiber-scripts])
 * Cross-chain asset transfer
 
-Please note that the implementation is still under development, there are two major features not implemented yet:
-
-* Watchtower service to monitor and revoke on-chain transactions
-* Multihop payments
+Please note that the implementation is still under development, there are many limitations and known issues, you may find or report them in the issue tracker.
 
 But as a prototype, it's a good starting point for developers to understand the FNP and try out the integration with their applications.
 
 ## Build and run a testnet node
 
-1. Build the project:
+1. Build the project, if you are using the released binary, you can skip this step:
 
 ```
 cargo build --release
@@ -26,6 +23,7 @@ cargo build --release
 
 ```
 mkdir /folder-to/my-fnn
+// if you are using the released binary, replace target/release/fnn with the path of released binary
 cp target/release/fnn /folder-to/my-fnn
 cp config/testnet/config.yml /folder-to/my-fnn
 cd /folder-to/my-fnn
@@ -46,6 +44,20 @@ head -n 1 ./ckb/exported-key > ./ckb/key
 RUST_LOG=info ./fnn -c config.yml -d .
 ```
 
+## Testnet compatibility issues
+
+The current state of the FNN is not stable, the protocol and storage format may changed between versions. We strongly recommend you to close the channel before upgrading the node, otherwise, you may lose the channel state:
+
+1. [list all channels](./src/rpc/README.md#channel-list_channels) and [close](./src/rpc/README.md#channel-shutdown_channel) them via RPC.
+
+2. Stop the node and remove the storage of the node:
+
+```
+rm -rf /folder-to/my-fnn/fiber/store
+```
+
+3. Repalce the binary with the new version and start the node again.
+
 ## Documentation
 
 * [Light Paper](./docs/light-paper.md)
diff --git a/docs/specs/p2p-message.md b/docs/specs/p2p-message.md
index 33f1e43e9..acaceb4b8 100644
--- a/docs/specs/p2p-message.md
+++ b/docs/specs/p2p-message.md
@@ -287,11 +287,19 @@ After establishing a channel, nodes can perform payment operations by sending Ad
     |       |                               |       |
     |       |--(2)---- commitment_signed -->|       |
     |       |<-(3)---- revoke_and_ack  -----|       |
+    |       |                               |       |
+    |       |<-(4)---- commitment_signed ---|       |
+    |       |--(5)---- revoke_and_ack  ---->|       |
+    |       |                               |       |
     |   A   |                               |   B   |
-    |       |<-(4)---- remove_tlc      -----|       |
     |       |                               |       |
-    |       |<-(5)---- commitment_signed ---|       |
-    |       |--(6)---- revoke_and_ack  ---->|       |
+    |       |<-(6)---- remove_tlc      -----|       |
+    |       |                               |       |
+    |       |<-(7)---- commitment_signed ---|       |
+    |       |--(8)---- revoke_and_ack  ---->|       |
+    |       |                               |       |
+    |       |--(9)---- commitment_signed -->|       |
+    |       |<-(10)---- revoke_and_ack  ----|       |
     +-------+                               +-------+
 ```
 
diff --git a/src/actors.rs b/src/actors.rs
index 2f2db43a2..e077e4c0d 100644
--- a/src/actors.rs
+++ b/src/actors.rs
@@ -1,6 +1,6 @@
 use ractor::{async_trait as rasync_trait, Actor, ActorProcessingErr, ActorRef, SupervisionEvent};
 use tokio_util::{sync::CancellationToken, task::TaskTracker};
-use tracing::{debug, error};
+use tracing::debug;
 
 /// A root actor that listens for cancellation token and stops all sub actors (those who started by spawn_linked).
 pub struct RootActor;
@@ -69,7 +69,7 @@ impl Actor for RootActor {
                 }
             },
             SupervisionEvent::ActorPanicked(who, err) => {
-                error!("Actor unexpectedly panicked (id: {:?}): {:?}", who, err);
+                panic!("Actor unexpectedly panicked (id: {:?}): {:?}", who, err);
             }
             _ => {}
         }
diff --git a/src/ckb/actor.rs b/src/ckb/actor.rs
index 87488a9e7..2c26e7362 100644
--- a/src/ckb/actor.rs
+++ b/src/ckb/actor.rs
@@ -4,6 +4,7 @@ use ractor::{
     concurrency::{sleep, Duration},
     Actor, ActorProcessingErr, ActorRef, RpcReplyPort,
 };
+use tracing::debug;
 
 use crate::ckb::contracts::{get_script_by_contract, Contract};
 
@@ -81,7 +82,7 @@ impl Actor for CkbChainActor {
 
     async fn pre_start(
         &self,
-        myself: ActorRef<Self::Msg>,
+        _myself: ActorRef<Self::Msg>,
         config: Self::Arguments,
     ) -> Result<Self::State, ActorProcessingErr> {
         let secret_key = config.read_secret_key()?;
@@ -90,12 +91,6 @@ impl Actor for CkbChainActor {
         let pub_key_hash = ckb_hash::blake2b_256(pub_key.serialize());
         let funding_source_lock_script =
             get_script_by_contract(Contract::Secp256k1Lock, &pub_key_hash[0..20]);
-        tracing::info!(
-            "[{}] funding lock args: {}",
-            myself.get_name().unwrap_or_default(),
-            funding_source_lock_script.args()
-        );
-
         Ok(CkbChainState {
             config,
             secret_key,
@@ -180,7 +175,7 @@ impl Actor for CkbChainActor {
                 },
                 reply_port,
             ) => {
-                tracing::info!(
+                debug!(
                     "[{}] trace transaction {} with {} confs",
                     myself.get_name().unwrap_or_default(),
                     tx_hash,
diff --git a/src/ckb/config.rs b/src/ckb/config.rs
index 9ddded8ec..19f50b743 100644
--- a/src/ckb/config.rs
+++ b/src/ckb/config.rs
@@ -1,5 +1,6 @@
+use ckb_hash::blake2b_256;
 use clap_serde_derive::ClapSerde;
-use secp256k1::SecretKey;
+use secp256k1::{Secp256k1, SecretKey};
 use serde_with::serde_as;
 use std::{
     io::{ErrorKind, Read},
@@ -13,12 +14,14 @@ use ckb_types::prelude::Pack;
 use ckb_types::H256;
 use ckb_types::{
     core::DepType,
-    packed::{CellDep, OutPoint},
+    packed::{CellDep, OutPoint, Script},
 };
 use clap_serde_derive::clap::{self};
 use molecule::prelude::Entity;
 use serde::{Deserialize, Serialize};
 
+use super::contracts::{get_script_by_contract, Contract};
+
 pub const DEFAULT_CKB_BASE_DIR_NAME: &str = "ckb";
 const DEFAULT_CKB_NODE_RPC_URL: &str = "http://127.0.0.1:8114";
 
@@ -101,6 +104,16 @@ impl CkbConfig {
             std::io::Error::new(ErrorKind::InvalidData, "invalid secret key data").into()
         })
     }
+
+    pub fn get_default_funding_lock_script(&self) -> crate::Result<Script> {
+        let secret_key = self.read_secret_key()?;
+        let secp = Secp256k1::new();
+        let pubkey_hash = blake2b_256(secret_key.public_key(&secp).serialize());
+        Ok(get_script_by_contract(
+            Contract::Secp256k1Lock,
+            &pubkey_hash[0..20],
+        ))
+    }
 }
 
 serde_with::serde_conv!(
diff --git a/src/ckb/tests/test_utils.rs b/src/ckb/tests/test_utils.rs
index b9fcd7310..f47a8166c 100644
--- a/src/ckb/tests/test_utils.rs
+++ b/src/ckb/tests/test_utils.rs
@@ -472,6 +472,7 @@ impl Actor for MockChainActor {
                 }
             }
             TraceTx(tx, reply_port) => {
+                debug!("Tracing transaction: {:?}", &tx);
                 match state.tx_status.get(&tx.tx_hash).cloned() {
                     Some((tx_view, status)) => {
                         reply_trace_tx(Some(tx_view), status, reply_port);
diff --git a/src/fiber/channel.rs b/src/fiber/channel.rs
index 35a74662d..d542d6c55 100644
--- a/src/fiber/channel.rs
+++ b/src/fiber/channel.rs
@@ -1,8 +1,10 @@
 #[cfg(debug_assertions)]
 use crate::fiber::network::DebugEvent;
-use crate::fiber::serde_utils::U64Hex;
+use crate::{
+    debug_event,
+    fiber::{serde_utils::U64Hex, types::BroadcastMessageWithTimestamp},
+};
 use bitflags::bitflags;
-use ckb_jsonrpc_types::BlockNumber;
 use futures::future::OptionFuture;
 use secp256k1::XOnlyPublicKey;
 use tracing::{debug, error, info, trace, warn};
@@ -25,7 +27,7 @@ use crate::{
         },
         serde_utils::{CompactSignatureAsBytes, EntityHex, PubNonceAsBytes},
         types::{
-            AcceptChannel, AddTlc, AnnouncementSignatures, BroadcastMessage, BroadcastMessageQuery,
+            AcceptChannel, AddTlc, AnnouncementSignatures, BroadcastMessageQuery,
             BroadcastMessageQueryFlags, ChannelAnnouncement, ChannelReady, ChannelUpdate,
             ClosingSigned, CommitmentSigned, EcdsaSignature, FiberChannelMessage, FiberMessage,
             Hash256, OpenChannel, PaymentOnionPacket, PeeledPaymentOnionPacket, Privkey, Pubkey,
@@ -47,6 +49,7 @@ use ckb_types::{
     },
     packed::{Bytes, CellInput, CellOutput, OutPoint, Script, Transaction},
     prelude::{AsTransactionBuilder, IntoTransactionView, Pack, Unpack},
+    H256,
 };
 use molecule::prelude::{Builder, Entity};
 use musig2::{
@@ -58,7 +61,7 @@ use musig2::{
 };
 use ractor::{
     async_trait as rasync_trait, call, concurrency::Duration, Actor, ActorProcessingErr, ActorRef,
-    OutputPort, RpcReplyPort, SpawnErr,
+    OutputPort, RpcReplyPort,
 };
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
@@ -66,9 +69,10 @@ use tentacle::secio::PeerId;
 use thiserror::Error;
 use tokio::sync::oneshot;
 
+use super::types::ForwardTlcResult;
 use std::{
-    collections::{BTreeMap, HashMap},
-    fmt::Debug,
+    collections::HashSet,
+    fmt::{self, Debug},
     sync::Arc,
     time::{SystemTime, UNIX_EPOCH},
     u128,
@@ -102,7 +106,7 @@ pub const MESSAGE_OF_NODE2_FLAG: u32 = 1;
 // The channel is disabled, and no more tlcs can be added to the channel.
 pub const CHANNEL_DISABLED_FLAG: u32 = 1;
 
-const AUTO_SETDOWN_TLC_INTERVAL: Duration = Duration::from_secs(2);
+const RETRYABLE_TLC_OPS_INTERVAL: Duration = Duration::from_millis(1000);
 
 #[derive(Debug)]
 pub enum ChannelActorMessage {
@@ -120,23 +124,33 @@ pub struct AddTlcResponse {
     pub tlc_id: u64,
 }
 
+#[derive(Clone)]
+pub struct TlcNotifyInfo {
+    pub payment_hash: Hash256,
+    pub tlc_id: TLCId,
+    pub amount: u128,
+    pub payment_preimage: Option<Hash256>,
+}
+
 #[derive(Clone)]
 pub struct TlcNotification {
     pub channel_id: Hash256,
-    pub tlc: AddTlcInfo,
+    pub tlc: TlcNotifyInfo,
     pub script: Script,
 }
 
 #[derive(Debug)]
 pub enum ChannelCommand {
     TxCollaborationCommand(TxCollaborationCommand),
-    // TODO: maybe we should automatically send commitment_signed message after receiving
-    // tx_complete event.
     CommitmentSigned(),
     AddTlc(AddTlcCommand, RpcReplyPort<Result<AddTlcResponse, TlcErr>>),
-    RemoveTlc(RemoveTlcCommand, RpcReplyPort<Result<(), String>>),
+    RemoveTlc(
+        RemoveTlcCommand,
+        RpcReplyPort<Result<(), ProcessingChannelError>>,
+    ),
     Shutdown(ShutdownCommand, RpcReplyPort<Result<(), String>>),
     Update(UpdateCommand, RpcReplyPort<Result<(), String>>),
+    ForwardTlcResult(ForwardTlcResult),
     #[cfg(test)]
     ReloadState(),
 }
@@ -163,7 +177,7 @@ pub struct AddTlcCommand {
     pub previous_tlc: Option<(Hash256, u64)>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct RemoveTlcCommand {
     pub id: u64,
     pub reason: RemoveTlcReason,
@@ -199,7 +213,6 @@ pub const MIN_COMMITMENT_DELAY_EPOCHS: u64 = 1;
 // The max commitment delay is 84 epochs = 14 days.
 pub const MAX_COMMITMENT_DELAY_EPOCHS: u64 = 84;
 pub const DEFAULT_MAX_TLC_VALUE_IN_FLIGHT: u128 = u128::MAX;
-pub const DEFAULT_MAX_TLC_NUMBER_IN_FLIGHT: u64 = 30;
 pub const DEFAULT_MIN_TLC_VALUE: u128 = 0;
 pub const SYS_MAX_TLC_NUMBER_IN_FLIGHT: u64 = 253;
 pub const MAX_TLC_NUMBER_IN_FLIGHT: u64 = 125;
@@ -439,7 +452,12 @@ where
                 Ok(())
             }
             FiberChannelMessage::RevokeAndAck(revoke_and_ack) => {
-                state.handle_revoke_and_ack_peer_message(&self.network, revoke_and_ack)?;
+                let need_commitment_signed =
+                    state.handle_revoke_and_ack_peer_message(&self.network, revoke_and_ack)?;
+                if need_commitment_signed {
+                    self.handle_commitment_signed_command(state)?;
+                }
+                self.update_tlc_status_on_ack(myself, state).await;
                 Ok(())
             }
             FiberChannelMessage::ChannelReady(_channel_ready) => {
@@ -601,8 +619,11 @@ where
             ProcessingChannelError::TlcAmountIsTooLow => TlcErrorCode::AmountBelowMinimum,
             ProcessingChannelError::TlcNumberExceedLimit
             | ProcessingChannelError::TlcAmountExceedLimit
-            | ProcessingChannelError::TlcValueInflightExceedLimit
-            | ProcessingChannelError::WaitingTlcAck => TlcErrorCode::TemporaryChannelFailure,
+            | ProcessingChannelError::TlcValueInflightExceedLimit => {
+                TlcErrorCode::TemporaryChannelFailure
+            }
+            ProcessingChannelError::WaitingTlcAck => TlcErrorCode::TemporaryChannelFailure,
+            ProcessingChannelError::InternalError(_) => TlcErrorCode::TemporaryNodeFailure,
             ProcessingChannelError::InvalidState(error) => match state.state {
                 // we can not revert back up `ChannelReady` after `ShuttingDown`
                 ChannelState::Closed(_) | ChannelState::ShuttingDown(_) => {
@@ -655,72 +676,129 @@ where
         commitment_signed: CommitmentSigned,
     ) -> Result<(), ProcessingChannelError> {
         // build commitment tx and verify signature from remote, if passed send ACK for partner
-        state.verify_commitment_signed_and_send_ack(commitment_signed, &self.network)?;
-        self.flush_staging_tlc_operations(myself, state).await;
+        state.verify_commitment_signed_and_send_ack(commitment_signed.clone(), &self.network)?;
+        debug!(
+            "handled commitment_signed peer message: {:?}",
+            commitment_signed
+        );
+
+        let need_commitment_signed = state.tlc_state.update_for_commitment_signed();
+        if need_commitment_signed && !state.tlc_state.waiting_ack {
+            self.handle_commitment_signed_command(state)?;
+        }
+
+        // flush remove tlc for received tlcs after replying ack for peer
+        self.apply_settled_remove_tlcs(myself, state, true).await;
         Ok(())
     }
 
-    async fn flush_staging_tlc_operations(
+    async fn apply_settled_remove_tlcs(
         &self,
         myself: &ActorRef<ChannelActorMessage>,
         state: &mut ChannelActorState,
+        inbound: bool,
     ) {
-        let pending_apply_tlcs = state.tlc_state.commit_remote_tlcs();
-        for tlc_info in pending_apply_tlcs {
-            match tlc_info {
-                TlcKind::AddTlc(add_tlc) => {
-                    assert!(add_tlc.is_received());
-                    if let Err(e) = self.apply_add_tlc_operation(myself, state, &add_tlc).await {
-                        let tlc_err = match e.source {
-                            // If we already have TlcErr, we can directly use it to send back to the peer.
-                            ProcessingChannelError::TlcForwardingError(tlc_err) => tlc_err,
-                            _ => {
-                                let error_detail = self.get_tlc_error(state, &e.source).await;
-                                #[cfg(debug_assertions)]
-                                self.network
-                                    .clone()
-                                    .send_message(NetworkActorMessage::new_notification(
-                                        NetworkServiceEvent::DebugEvent(DebugEvent::AddTlcFailed(
-                                            state.get_local_peer_id(),
-                                            add_tlc.payment_hash,
-                                            error_detail.clone(),
-                                        )),
-                                    ))
-                                    .expect(ASSUME_NETWORK_ACTOR_ALIVE);
-                                error_detail
-                            }
-                        };
-                        let error_packet = TlcErrPacket::new(
-                            tlc_err,
-                            // There's no shared secret stored in the received TLC, use the one found in the peeled onion packet.
-                            &e.shared_secret,
-                        );
-                        self.register_retryable_tlc_remove(
-                            myself,
-                            state,
-                            add_tlc.tlc_id,
-                            RemoveTlcReason::RemoveTlcFail(error_packet),
-                        )
-                        .await;
-                    }
-                }
-                TlcKind::RemoveTlc(remove_tlc) => {
-                    let _ = self
-                        .apply_remove_tlc_operation(myself, state, remove_tlc)
-                        .await
-                        .map_err(|e| {
-                            error!("Error handling apply_remove_tlc_operation: {:?}", e);
-                        });
-                }
+        let pending_tlcs = if inbound {
+            state.tlc_state.received_tlcs.tlcs.iter_mut()
+        } else {
+            state.tlc_state.offered_tlcs.tlcs.iter_mut()
+        };
+        let settled_tlcs: Vec<_> = pending_tlcs
+            .filter(|tlc| {
+                tlc.removed_reason.is_some()
+                    && matches!(
+                        tlc.status,
+                        TlcStatus::Inbound(InboundTlcStatus::RemoveAckConfirmed)
+                            | TlcStatus::Outbound(OutboundTlcStatus::RemoveAckConfirmed)
+                    )
+            })
+            .map(|tlc| tlc.tlc_id)
+            .collect();
+
+        for tlc_id in settled_tlcs {
+            self.apply_remove_tlc_operation(myself, state, tlc_id)
+                .await
+                .expect("expect remove tlc success");
+        }
+    }
+
+    async fn process_add_tlc_error(
+        &self,
+        myself: &ActorRef<ChannelActorMessage>,
+        state: &mut ChannelActorState,
+        payment_hash: Hash256,
+        tlc_id: TLCId,
+        error: ProcessingChannelErrorWithSharedSecret,
+    ) {
+        let tlc_err = match error.source {
+            // If we already have TlcErr, we can directly use it to send back to the peer.
+            ProcessingChannelError::TlcForwardingError(tlc_err) => tlc_err,
+            _ => {
+                let error_detail = self.get_tlc_error(state, &error.source).await;
+                #[cfg(debug_assertions)]
+                self.network
+                    .clone()
+                    .send_message(NetworkActorMessage::new_notification(
+                        NetworkServiceEvent::DebugEvent(DebugEvent::AddTlcFailed(
+                            state.get_local_peer_id(),
+                            payment_hash,
+                            error_detail.clone(),
+                        )),
+                    ))
+                    .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+                error_detail
+            }
+        };
+        let error_packet = TlcErrPacket::new(
+            tlc_err,
+            // There's no shared secret stored in the received TLC, use the one found in the peeled onion packet.
+            &error.shared_secret,
+        );
+        self.register_retryable_tlc_remove(
+            myself,
+            state,
+            tlc_id,
+            RemoveTlcReason::RemoveTlcFail(error_packet),
+        )
+        .await;
+    }
+
+    async fn update_tlc_status_on_ack(
+        &self,
+        myself: &ActorRef<ChannelActorMessage>,
+        state: &mut ChannelActorState,
+    ) {
+        let apply_tlcs: Vec<TlcInfo> = state
+            .tlc_state
+            .get_committed_received_tlcs()
+            .into_iter()
+            .filter(|tlc| tlc.removed_reason.is_none())
+            .filter(|tlc| !state.tlc_state.applied_add_tlcs.contains(&tlc.tlc_id))
+            .collect();
+
+        for add_tlc in apply_tlcs {
+            assert!(add_tlc.is_received());
+            if let Err(error) = self.apply_add_tlc_operation(myself, state, &add_tlc).await {
+                self.process_add_tlc_error(
+                    myself,
+                    state,
+                    add_tlc.payment_hash,
+                    add_tlc.tlc_id,
+                    error,
+                )
+                .await;
             }
         }
+
+        // flush outbound tlcs
+        self.apply_settled_remove_tlcs(myself, state, false).await;
     }
 
     async fn try_to_relay_remove_tlc(
         &self,
         myself: &ActorRef<ChannelActorMessage>,
         state: &mut ChannelActorState,
-        tlc_info: &AddTlcInfo,
+        tlc_info: &TlcInfo,
         remove_reason: RemoveTlcReason,
     ) {
         assert!(tlc_info.is_offered());
@@ -745,12 +823,10 @@ where
         &self,
         myself: &ActorRef<ChannelActorMessage>,
         state: &mut ChannelActorState,
-        tlc_id: u64,
+        tlc_id: TLCId,
     ) {
         let tlc_info = state.get_received_tlc(tlc_id).expect("expect tlc");
-        let preimage = tlc_info
-            .payment_preimage
-            .or_else(|| self.store.get_invoice_preimage(&tlc_info.payment_hash));
+        let preimage = self.store.get_invoice_preimage(&tlc_info.payment_hash);
 
         let preimage = if let Some(preimage) = preimage {
             preimage
@@ -783,9 +859,8 @@ where
                     error!("invoice already paid, ignore");
                 }
                 _ => {
-                    self.store
-                        .update_invoice_status(&tlc.payment_hash, CkbInvoiceStatus::Paid)
-                        .expect("update invoice status error");
+                    // do nothing
+                    // invoice status will be updated to paid after apply remove tlc operation
                 }
             }
         }
@@ -798,7 +873,7 @@ where
         &self,
         myself: &ActorRef<ChannelActorMessage>,
         state: &mut ChannelActorState,
-        add_tlc: &AddTlcInfo,
+        add_tlc: &TlcInfo,
     ) -> Result<(), ProcessingChannelErrorWithSharedSecret> {
         // If needed, shared secret also get be extracted from the encrypted onion packet:
         // - Extract public key from onion_packet[1..34]
@@ -810,6 +885,7 @@ where
         {
             let shared_secret = peeled_onion_packet.shared_secret.clone();
             self.apply_add_tlc_operation_with_peeled_onion_packet(
+                myself,
                 state,
                 add_tlc,
                 peeled_onion_packet,
@@ -822,7 +898,7 @@ where
             self.subscribers
                 .pending_received_tlcs_subscribers
                 .send(TlcNotification {
-                    tlc: add_tlc.clone(),
+                    tlc: add_tlc.clone().into(),
                     channel_id: state.get_id(),
                     script: udt_type_script.clone(),
                 });
@@ -831,7 +907,7 @@ where
         // we don't need to settle down the tlc if it is not the last hop here,
         // some e2e tests are calling AddTlc manually, so we can not use onion packet to
         // check whether it's the last hop here, maybe need to revisit in future.
-        self.try_to_settle_down_tlc(myself, state, add_tlc.tlc_id.into())
+        self.try_to_settle_down_tlc(myself, state, add_tlc.tlc_id)
             .await;
 
         warn!("finished check tlc for peer message: {:?}", &add_tlc.tlc_id);
@@ -841,7 +917,7 @@ where
     async fn try_add_tlc_peel_onion_packet(
         &self,
         state: &mut ChannelActorState,
-        add_tlc: &AddTlcInfo,
+        add_tlc: &TlcInfo,
     ) -> Result<Option<PeeledPaymentOnionPacket>, ProcessingChannelError> {
         state.check_tlc_expiry(add_tlc.expiry)?;
 
@@ -858,14 +934,16 @@ where
 
     async fn apply_add_tlc_operation_with_peeled_onion_packet(
         &self,
+        myself: &ActorRef<ChannelActorMessage>,
         state: &mut ChannelActorState,
-        add_tlc: &AddTlcInfo,
+        add_tlc: &TlcInfo,
         peeled_onion_packet: PeeledPaymentOnionPacket,
     ) -> Result<(), ProcessingChannelError> {
         let payment_hash = add_tlc.payment_hash;
         let received_amount = add_tlc.amount;
         let forward_amount = peeled_onion_packet.current.amount;
 
+        state.tlc_state.applied_add_tlcs.insert(add_tlc.tlc_id);
         if peeled_onion_packet.is_last() {
             if forward_amount != add_tlc.amount {
                 return Err(ProcessingChannelError::FinalIncorrectHTLCAmount);
@@ -883,9 +961,6 @@ where
                 if invoice_status != CkbInvoiceStatus::Open {
                     return Err(ProcessingChannelError::FinalInvoiceInvalid(invoice_status));
                 }
-                self.store
-                    .update_invoice_status(&payment_hash, CkbInvoiceStatus::Received)
-                    .expect("update invoice status failed");
             }
 
             // if this is the last hop, store the preimage.
@@ -901,7 +976,17 @@ where
                 if add_tlc.payment_hash != filled_payment_hash {
                     return Err(ProcessingChannelError::FinalIncorrectPreimage);
                 }
-                state.set_received_tlc_preimage(add_tlc.tlc_id.into(), Some(preimage));
+                // update invoice status to received only all the error checking passed
+                if let Some(_invoice) = self.store.get_invoice(&payment_hash) {
+                    self.store
+                        .update_invoice_status(&payment_hash, CkbInvoiceStatus::Received)
+                        .expect("update invoice status failed");
+                }
+                self.store
+                    .insert_payment_preimage(payment_hash, preimage)
+                    .map_err(|_| {
+                        ProcessingChannelError::InternalError("insert preimage failed".to_string())
+                    })?;
             } else {
                 return Err(ProcessingChannelError::FinalIncorrectPaymentHash);
             }
@@ -932,13 +1017,14 @@ where
                         return Err(ProcessingChannelError::TlcForwardFeeIsTooLow);
                     }
                     // if this is not the last hop, forward TLC to next hop
-                    self.handle_forward_onion_packet(
+                    self.register_retryable_forward_tlc(
+                        myself,
                         state,
+                        add_tlc.tlc_id,
                         add_tlc.payment_hash,
                         peeled_onion_packet.clone(),
-                        add_tlc.tlc_id.into(),
                     )
-                    .await?;
+                    .await;
                 }
                 _ => {
                     // if we don't have public channel info, we can not forward the TLC
@@ -964,9 +1050,7 @@ where
         state.check_for_tlc_update(Some(add_tlc.amount), false, false)?;
         let tlc_info = state.create_inbounding_tlc(add_tlc.clone())?;
         state.check_insert_tlc(&tlc_info)?;
-        state
-            .tlc_state
-            .add_remote_tlc(TlcKind::AddTlc(tlc_info.clone()));
+        state.tlc_state.add_received_tlc(tlc_info);
         state.increment_next_received_tlc_id();
         Ok(())
     }
@@ -981,12 +1065,22 @@ where
         // maybe we need to go through shutdown process for this error
         state
             .check_remove_tlc_with_reason(TLCId::Offered(remove_tlc.tlc_id), &remove_tlc.reason)?;
-        let tlc_kind = TlcKind::RemoveTlc(RemoveTlcInfo {
-            tlc_id: TLCId::Offered(remove_tlc.tlc_id),
-            channel_id: remove_tlc.channel_id,
-            reason: remove_tlc.reason.clone(),
-        });
-        state.tlc_state.add_remote_tlc(tlc_kind.clone());
+        let payment_hash = state
+            .tlc_state
+            .set_offered_tlc_removed(remove_tlc.tlc_id, remove_tlc.reason.clone());
+        if let RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill { payment_preimage }) =
+            remove_tlc.reason
+        {
+            // we need to store the preimage if the TLC is fulfilled
+            // incase the peer has already shutdown the channel,
+            // so we can send setttlement transaction to get money when necessary
+            // the preimage must be valid since we have checked it in check_remove_tlc_with_reason
+            self.store
+                .insert_payment_preimage(payment_hash, payment_preimage)
+                .map_err(|_| {
+                    ProcessingChannelError::InternalError("insert preimage failed".to_string())
+                })?;
+        }
         Ok(())
     }
 
@@ -994,24 +1088,29 @@ where
         &self,
         myself: &ActorRef<ChannelActorMessage>,
         state: &mut ChannelActorState,
-        remove_tlc: RemoveTlcInfo,
+        tlc_id: TLCId,
     ) -> Result<(), ProcessingChannelError> {
         let channel_id = state.get_id();
-        let remove_reason = remove_tlc.reason.clone();
-        let tlc_info = state
-            .remove_tlc_with_reason(remove_tlc.tlc_id, &remove_reason)
-            .expect("expect remove tlc successfully");
+        let (tlc_info, remove_reason) = state.remove_tlc_with_reason(tlc_id)?;
+        if matches!(remove_reason, RemoveTlcReason::RemoveTlcFulfill(_))
+            && self.store.get_invoice(&tlc_info.payment_hash).is_some()
+        {
+            self.store
+                .update_invoice_status(&tlc_info.payment_hash, CkbInvoiceStatus::Paid)
+                .expect("update invoice status failed");
+        }
+
         if let (
             Some(ref udt_type_script),
             RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill { payment_preimage }),
         ) = (state.funding_udt_type_script.clone(), &remove_reason)
         {
-            let mut tlc = tlc_info.clone();
-            tlc.payment_preimage = Some(*payment_preimage);
+            let mut tlc_notify_info: TlcNotifyInfo = tlc_info.clone().into();
+            tlc_notify_info.payment_preimage = Some(*payment_preimage);
             self.subscribers
                 .settled_tlcs_subscribers
                 .send(TlcNotification {
-                    tlc,
+                    tlc: tlc_notify_info,
                     channel_id,
                     script: udt_type_script.clone(),
                 });
@@ -1019,14 +1118,16 @@ where
         if tlc_info.previous_tlc.is_none() {
             // only the original sender of the TLC should send `TlcRemoveReceived` event
             // because only the original sender cares about the TLC event to settle the payment
-            self.network
-                .send_message(NetworkActorMessage::new_event(
-                    NetworkActorEvent::TlcRemoveReceived(
-                        tlc_info.payment_hash,
-                        remove_reason.clone(),
-                    ),
-                ))
-                .expect("myself alive");
+            if tlc_info.is_offered() {
+                self.network
+                    .send_message(NetworkActorMessage::new_event(
+                        NetworkActorEvent::TlcRemoveReceived(
+                            tlc_info.payment_hash,
+                            remove_reason.clone(),
+                        ),
+                    ))
+                    .expect("myself alive");
+            }
         } else {
             // relay RemoveTlc to previous channel if needed
             self.try_to_relay_remove_tlc(myself, state, &tlc_info, remove_reason)
@@ -1035,35 +1136,6 @@ where
         Ok(())
     }
 
-    async fn handle_forward_onion_packet(
-        &self,
-        state: &mut ChannelActorState,
-        payment_hash: Hash256,
-        peeled_onion_packet: PeeledPaymentOnionPacket,
-        added_tlc_id: u64,
-    ) -> Result<(), ProcessingChannelError> {
-        let (send, recv) = oneshot::channel::<Result<u64, TlcErr>>();
-        let rpc_reply = RpcReplyPort::from(send);
-        self.network
-            .send_message(NetworkActorMessage::Command(
-                NetworkActorCommand::SendPaymentOnionPacket(
-                    SendOnionPacketCommand {
-                        peeled_onion_packet,
-                        previous_tlc: Some((state.get_id(), added_tlc_id)),
-                        payment_hash,
-                    },
-                    rpc_reply,
-                ),
-            ))
-            .expect(ASSUME_NETWORK_ACTOR_ALIVE);
-
-        // If we failed to forward the onion packet, we should remove the tlc.
-        if let Err(res) = recv.await.expect("expect command replied") {
-            return Err(ProcessingChannelError::TlcForwardingError(res));
-        }
-        Ok(())
-    }
-
     pub fn handle_commitment_signed_command(
         &self,
         state: &mut ChannelActorState,
@@ -1117,11 +1189,12 @@ where
             commitment_tx_partial_signature,
             next_local_nonce: state.get_next_local_nonce(),
         };
+
         self.network
             .send_message(NetworkActorMessage::new_command(
                 NetworkActorCommand::SendFiberMessage(FiberMessageWithPeerId::new(
                     state.get_remote_peer_id(),
-                    FiberMessage::commitment_signed(commitment_signed),
+                    FiberMessage::commitment_signed(commitment_signed.clone()),
                 )),
             ))
             .expect(ASSUME_NETWORK_ACTOR_ALIVE);
@@ -1133,7 +1206,9 @@ where
                 state.update_state(ChannelState::SigningCommitment(flags));
                 state.maybe_transition_to_tx_signatures(flags, &self.network)?;
             }
-            CommitmentSignedFlags::ChannelReady() => {}
+            CommitmentSignedFlags::ChannelReady() => {
+                state.tlc_state.set_waiting_ack(true);
+            }
             CommitmentSignedFlags::PendingShutdown() => {
                 state.maybe_transition_to_shutdown(&self.network)?;
             }
@@ -1150,7 +1225,7 @@ where
         state.check_tlc_expiry(command.expiry)?;
         let tlc = state.create_outbounding_tlc(command.clone());
         state.check_insert_tlc(&tlc)?;
-        state.tlc_state.add_local_tlc(TlcKind::AddTlc(tlc.clone()));
+        state.tlc_state.add_offered_tlc(tlc.clone());
         state.increment_next_offered_tlc_id();
 
         let add_tlc = AddTlc {
@@ -1164,8 +1239,10 @@ where
         };
 
         // Send tlc update message to peer.
-        let msg =
-            FiberMessageWithPeerId::new(state.get_remote_peer_id(), FiberMessage::add_tlc(add_tlc));
+        let msg = FiberMessageWithPeerId::new(
+            state.get_remote_peer_id(),
+            FiberMessage::add_tlc(add_tlc.clone()),
+        );
 
         self.network
             .send_message(NetworkActorMessage::new_command(
@@ -1174,7 +1251,6 @@ where
             .expect(ASSUME_NETWORK_ACTOR_ALIVE);
 
         self.handle_commitment_signed_command(state)?;
-        state.tlc_state.set_waiting_ack(true);
         Ok(tlc.tlc_id.into())
     }
 
@@ -1185,12 +1261,9 @@ where
     ) -> ProcessingChannelResult {
         state.check_for_tlc_update(None, true, false)?;
         state.check_remove_tlc_with_reason(TLCId::Received(command.id), &command.reason)?;
-        let tlc_kind = TlcKind::RemoveTlc(RemoveTlcInfo {
-            channel_id: state.get_id(),
-            tlc_id: TLCId::Received(command.id),
-            reason: command.reason.clone(),
-        });
-        state.tlc_state.add_local_tlc(tlc_kind.clone());
+        state
+            .tlc_state
+            .set_received_tlc_removed(command.id, command.reason.clone());
         let msg = FiberMessageWithPeerId::new(
             state.get_remote_peer_id(),
             FiberMessage::remove_tlc(RemoveTlc {
@@ -1207,7 +1280,6 @@ where
 
         state.maybe_transition_to_shutdown(&self.network)?;
         self.handle_commitment_signed_command(state)?;
-        state.tlc_state.set_waiting_ack(true);
         Ok(())
     }
 
@@ -1355,8 +1427,8 @@ where
         tlc_id: TLCId,
         reason: RemoveTlcReason,
     ) {
-        state.tlc_state.set_tlc_pending_remove(tlc_id, reason);
-        self.check_and_apply_retryable_remove_tlcs(myself, state)
+        let remove_tlc = RetryableTlcOperation::RemoveTlc(tlc_id, reason);
+        self.register_retryable_tlc_operation(myself, state, remove_tlc)
             .await;
     }
 
@@ -1368,56 +1440,88 @@ where
         channel_id: Hash256,
         reason: RemoveTlcReason,
     ) {
-        state
-            .tlc_state
-            .insert_relay_tlc_remove(channel_id, tlc_id, reason);
-        self.check_and_apply_retryable_remove_tlcs(myself, state)
+        let remove_tlc = RetryableTlcOperation::RelayRemoveTlc(channel_id, tlc_id, reason);
+        self.register_retryable_tlc_operation(myself, state, remove_tlc)
             .await;
     }
 
-    pub async fn check_and_apply_retryable_remove_tlcs(
+    pub async fn register_retryable_forward_tlc(
         &self,
         myself: &ActorRef<ChannelActorMessage>,
         state: &mut ChannelActorState,
+        tlc_id: TLCId,
+        payment_hash: Hash256,
+        peeled_onion_packet: PeeledPaymentOnionPacket,
     ) {
-        let pending_removes = state.tlc_state.get_pending_remove();
-        for retryable_remove in pending_removes.into_iter() {
-            match retryable_remove {
-                RetryableRemoveTlc::RemoveTlc(tlc_id, ref reason) => {
-                    let command = RemoveTlcCommand {
-                        id: tlc_id.into(),
-                        reason: reason.clone(),
-                    };
+        let forward_tlc =
+            RetryableTlcOperation::ForwardTlc(payment_hash, tlc_id, peeled_onion_packet, true);
+        self.register_retryable_tlc_operation(myself, state, forward_tlc)
+            .await;
+    }
 
-                    match self.handle_remove_tlc_command(state, command) {
-                        Ok(_) | Err(ProcessingChannelError::RepeatedProcessing(_)) => {
-                            state.tlc_state.remove_pending_remove_tlc(&retryable_remove);
-                        }
-                        Err(ProcessingChannelError::WaitingTlcAck) => {
-                            error!(
-                                "Failed to remove tlc: {:?} because of WaitingTlcAck, retry it later",
-                                &retryable_remove
-                            );
-                        }
-                        Err(err) => {
-                            error!(
-                                "Failed to remove tlc: {:?} with reason: {:?}, will not retry",
-                                &retryable_remove, err
-                            );
-                            state.tlc_state.remove_pending_remove_tlc(&retryable_remove);
-                        }
+    async fn register_retryable_tlc_operation(
+        &self,
+        myself: &ActorRef<ChannelActorMessage>,
+        state: &mut ChannelActorState,
+        operation: RetryableTlcOperation,
+    ) {
+        if state.tlc_state.insert_retryable_tlc_operation(operation) {
+            myself
+                .send_message(ChannelActorMessage::Event(
+                    ChannelEvent::CheckTlcRetryOperation,
+                ))
+                .expect("myself alive");
+        }
+    }
+
+    fn set_forward_tlc_status(
+        &self,
+        state: &mut ChannelActorState,
+        payment_hash: Hash256,
+        try_one_time: bool,
+    ) {
+        if let Some(RetryableTlcOperation::ForwardTlc(_, _, _, ref mut sent)) = state
+            .tlc_state
+            .retryable_tlc_operations
+            .iter_mut()
+            .find(|op| matches!(op, RetryableTlcOperation::ForwardTlc(ph, _, _, _) if *ph == payment_hash))
+        {
+            *sent = try_one_time;
+        }
+    }
+
+    pub async fn apply_retryable_tlc_operations(
+        &self,
+        myself: &ActorRef<ChannelActorMessage>,
+        state: &mut ChannelActorState,
+    ) {
+        let mut pending_tlc_ops = state.tlc_state.get_pending_operations();
+        pending_tlc_ops.retain_mut(|retryable_operation| {
+            match retryable_operation {
+                RetryableTlcOperation::RemoveTlc(tlc_id, ref reason) => {
+                    match self.handle_remove_tlc_command(
+                        state,
+                        RemoveTlcCommand {
+                            id: u64::from(*tlc_id),
+                            reason: reason.clone(),
+                        },
+                    ) {
+                        Ok(_) | Err(ProcessingChannelError::RepeatedProcessing(_)) => false,
+                        Err(ProcessingChannelError::WaitingTlcAck) => true,
+                        Err(_err) => false,
                     }
                 }
-                RetryableRemoveTlc::RelayRemoveTlc(channel_id, tlc_id, ref reason) => {
-                    let (send, recv) = oneshot::channel::<Result<(), String>>();
+                RetryableTlcOperation::RelayRemoveTlc(channel_id, tlc_id, ref reason) => {
+                    // send relay remove tlc with network actor to previous hop
+                    let (send, _recv) = oneshot::channel::<Result<(), ProcessingChannelError>>();
                     let port = RpcReplyPort::from(send);
                     self.network
                         .send_message(NetworkActorMessage::new_command(
                             NetworkActorCommand::ControlFiberChannel(ChannelCommandWithId {
-                                channel_id: channel_id,
+                                channel_id: *channel_id,
                                 command: ChannelCommand::RemoveTlc(
                                     RemoveTlcCommand {
-                                        id: tlc_id,
+                                        id: u64::from(*tlc_id),
                                         reason: reason.clone(),
                                     },
                                     port,
@@ -1425,37 +1529,105 @@ where
                             }),
                         ))
                         .expect(ASSUME_NETWORK_ACTOR_ALIVE);
-                    if let Ok(res) = recv.await {
-                        match res {
+                    // the previous hop will automatically retry if there is Waiting_Ack error
+                    false
+                }
+                RetryableTlcOperation::ForwardTlc(
+                    payment_hash,
+                    tlc_id,
+                    ref peeled_onion_packet,
+                    try_one_time,
+                ) => {
+                    // there is a potential deadlock for waiting the result from another channel actor
+                    // for the scenario these two things happen at the same time:
+                    //  1. channel A send forward tlc to channel B
+                    //  2. channel B send forward tlc to channel A
+                    // we may end up waiting for each other forever
+                    //
+                    // but we need the result for better error handling
+                    // so we introduce the ForwardTlcResult to get the result based on actor message
+                    if !*try_one_time {
+                        // we need to decide whether to retry it until we get ForwardTlcResult
+                        true
+                    } else {
+                        match self.network.send_message(NetworkActorMessage::Command(
+                            NetworkActorCommand::SendPaymentOnionPacket(SendOnionPacketCommand {
+                                peeled_onion_packet: peeled_onion_packet.clone(),
+                                previous_tlc: Some((state.get_id(), u64::from(*tlc_id))),
+                                payment_hash: *payment_hash,
+                            }),
+                        )) {
                             Ok(_) => {
-                                state.tlc_state.remove_pending_remove_tlc(&retryable_remove);
-                            }
-                            Err(err) if err.contains("WaitingTlcAck") => {
-                                error!(
-                                "Failed to relay remove tlc: {:?} because of WaitingTlcAck, retry it later",
-                                &retryable_remove
-                            );
+                                // here we just make sure the forward tlc is sent, we don't need to wait for the result
+                                // retry it if necessary until we get ForwardTlcResult
+                                // self.set_forward_tlc_status(state, *payment_hash, false);
+                                *try_one_time = false;
+                                true
                             }
-                            Err(err) => {
-                                error!(
-                                "Failed to relay remove tlc: {:?} with reason: {:?}, will not retry",
-                                &retryable_remove, err
-                            );
-                                state.tlc_state.remove_pending_remove_tlc(&retryable_remove);
+                            Err(_err) => {
+                                // network actor is dead? we will retry it later
+                                false
                             }
                         }
                     }
                 }
             }
-        }
-        // If there are more pending removes, we will retry it later
-        if !state.tlc_state.get_pending_remove().is_empty() {
-            myself.send_after(AUTO_SETDOWN_TLC_INTERVAL, || {
-                ChannelActorMessage::Event(ChannelEvent::CheckTlcSetdown)
+        });
+
+        state.tlc_state.retryable_tlc_operations = pending_tlc_ops;
+        if state.tlc_state.has_pending_operations() {
+            myself.send_after(RETRYABLE_TLC_OPS_INTERVAL, || {
+                ChannelActorMessage::Event(ChannelEvent::CheckTlcRetryOperation)
             });
         }
     }
 
+    async fn handle_forward_tlc_result(
+        &self,
+        myself: &ActorRef<ChannelActorMessage>,
+        state: &mut ChannelActorState,
+        result: ForwardTlcResult,
+    ) {
+        let pending_ops = state.tlc_state.get_pending_operations();
+        if let Some((tlc_op, peeled_onion)) = pending_ops.iter().find_map(|op| match op {
+            RetryableTlcOperation::ForwardTlc(payment_hash, _, peel_onion_packet, _)
+                if *payment_hash == result.payment_hash =>
+            {
+                Some((op, peel_onion_packet))
+            }
+            _ => None,
+        }) {
+            if let Some((channel_err, tlc_err)) = result.error_info {
+                match channel_err {
+                    ProcessingChannelError::WaitingTlcAck => {
+                        // if we get WaitingTlcAck error, we will retry it later
+                        self.set_forward_tlc_status(state, result.payment_hash, true);
+                    }
+                    ProcessingChannelError::RepeatedProcessing(_) => {
+                        // ignore repeated processing error, we have already handled it
+                        state.tlc_state.remove_pending_tlc_operation(tlc_op);
+                    }
+                    _ => {
+                        let error = ProcessingChannelError::TlcForwardingError(tlc_err)
+                            .with_shared_secret(peeled_onion.shared_secret.clone());
+                        self.process_add_tlc_error(
+                            myself,
+                            state,
+                            result.payment_hash,
+                            TLCId::Received(result.tlc_id),
+                            error,
+                        )
+                        .await;
+                        state.tlc_state.remove_pending_tlc_operation(tlc_op);
+                    }
+                }
+            } else {
+                // if we get success result from AddTlc, we will remove the pending operation
+                state.tlc_state.remove_pending_tlc_operation(tlc_op);
+            }
+        }
+    }
+
     // This is the dual of `handle_tx_collaboration_msg`. Any logic error here is likely
     // to present in the other function as well.
     pub fn handle_tx_collaboration_command(
@@ -1561,6 +1733,7 @@ where
 
     pub async fn handle_command(
         &self,
+        myself: &ActorRef<ChannelActorMessage>,
         state: &mut ChannelActorState,
         command: ChannelCommand,
     ) -> Result<(), ProcessingChannelError> {
@@ -1570,13 +1743,29 @@ where
             }
             ChannelCommand::CommitmentSigned() => self.handle_commitment_signed_command(state),
             ChannelCommand::AddTlc(command, reply) => {
-                match self.handle_add_tlc_command(state, command) {
+                let res = self.handle_add_tlc_command(state, command.clone());
+                let error_info = if let Err(ref err) = res {
+                    Some((err.clone(), self.get_tlc_error(state, &err).await))
+                } else {
+                    None
+                };
+
+                self.network
+                    .send_message(NetworkActorMessage::new_event(
+                        NetworkActorEvent::AddTlcResult(
+                            command.payment_hash,
+                            error_info,
+                            command.previous_tlc,
+                        ),
+                    ))
+                    .expect("network actor alive");
+
+                match res {
                     Ok(tlc_id) => {
                         let _ = reply.send(Ok(AddTlcResponse { tlc_id }));
                         Ok(())
                     }
                     Err(err) => {
-                        debug!("Error processing AddTlc command: {:?}", &err);
                         let tlc_err = self.get_tlc_error(state, &err).await;
                         let _ = reply.send(Err(tlc_err));
                         Err(err)
@@ -1584,13 +1773,22 @@ where
                 }
             }
             ChannelCommand::RemoveTlc(command, reply) => {
-                match self.handle_remove_tlc_command(state, command) {
+                match self.handle_remove_tlc_command(state, command.clone()) {
                     Ok(_) => {
                         let _ = reply.send(Ok(()));
                         Ok(())
                     }
                     Err(err) => {
-                        let _ = reply.send(Err(err.to_string()));
+                        if matches!(err, ProcessingChannelError::WaitingTlcAck) {
+                            self.register_retryable_tlc_remove(
+                                myself,
+                                state,
+                                TLCId::Received(command.id),
+                                command.reason,
+                            )
+                            .await;
+                        }
+                        let _ = reply.send(Err(err.clone()));
                         Err(err)
                     }
                 }
@@ -1623,6 +1821,11 @@ where
                     }
                 }
             }
+            ChannelCommand::ForwardTlcResult(forward_tlc_res) => {
+                self.handle_forward_tlc_result(myself, state, forward_tlc_res)
+                    .await;
+                Ok(())
+            }
             #[cfg(test)]
             ChannelCommand::ReloadState() => {
                 *state = self
@@ -1641,7 +1844,7 @@ where
         event: ChannelEvent,
     ) -> Result<(), ProcessingChannelError> {
         match event {
-            ChannelEvent::FundingTransactionConfirmed(block_number, tx_index) => {
+            ChannelEvent::FundingTransactionConfirmed(block_hash, tx_index, timestamp) => {
                 debug!("Funding transaction confirmed");
                 let flags = match state.state {
                     ChannelState::AwaitingChannelReady(flags) => flags,
@@ -1655,7 +1858,7 @@ where
                             "Expecting funding transaction confirmed event in state AwaitingChannelReady or after TX_SIGNATURES_SENT, but got state {:?}", &state.state)));
                     }
                 };
-                state.funding_tx_confirmed_at = Some((block_number, tx_index));
+                state.funding_tx_confirmed_at = Some((block_hash, tx_index, timestamp));
                 self.network
                     .send_message(NetworkActorMessage::new_command(
                         NetworkActorCommand::SendFiberMessage(FiberMessageWithPeerId::new(
@@ -1683,25 +1886,26 @@ where
                 state.update_state(ChannelState::Closed(CloseFlags::UNCOOPERATIVE));
                 debug!("Channel closed with uncooperative close");
             }
-            ChannelEvent::CheckTlcSetdown => {
-                self.check_and_apply_retryable_remove_tlcs(myself, state)
-                    .await;
+            ChannelEvent::CheckTlcRetryOperation => {
+                self.apply_retryable_tlc_operations(myself, state).await;
             }
             ChannelEvent::PeerDisconnected => {
                 myself.stop(Some("PeerDisconnected".to_string()));
             }
             ChannelEvent::ClosingTransactionConfirmed => {
                 // Broadcast the channel update message which disables the channel.
-                let update = state.generate_disabled_channel_update(&self.network).await;
-
-                self.network
-                    .send_message(NetworkActorMessage::new_command(
-                        NetworkActorCommand::BroadcastMessages(vec![
-                            BroadcastMessage::ChannelUpdate(update),
-                        ]),
-                    ))
-                    .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+                if state.is_public() {
+                    let update = state.generate_disabled_channel_update(&self.network).await;
 
+                    self.network
+                        .send_message(NetworkActorMessage::new_command(
+                            NetworkActorCommand::BroadcastMessages(vec![
+                                BroadcastMessageWithTimestamp::ChannelUpdate(update),
+                            ]),
+                        ))
+                        .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+                }
+                debug_event!(self.network, "ChannelClosed");
                 myself.stop(Some("ChannelClosed".to_string()));
             }
         }
@@ -1795,8 +1999,7 @@ where
 
                 // TODO: we may reject the channel opening request here
                 // if the peer want to open a public channel, but we don't want to.
-                if public && channel_announcement_nonce.is_none()
-                    || public && public_channel_info.is_none()
+                if public && (channel_announcement_nonce.is_none() || public_channel_info.is_none())
                 {
                     return Err(Box::new(ProcessingChannelError::InvalidParameter(
                         "Public channel should have channel announcement nonce and public channel info".to_string(),
@@ -2005,14 +2208,12 @@ where
                     remote_commitment_number: channel.get_current_commitment_number(false),
                 };
 
-                let command = FiberMessageWithPeerId::new(
-                    self.get_remote_peer_id(),
-                    FiberMessage::reestablish_channel(reestablish_channel),
-                );
-
                 self.network
                     .send_message(NetworkActorMessage::new_command(
-                        NetworkActorCommand::SendFiberMessage(command),
+                        NetworkActorCommand::SendFiberMessage(FiberMessageWithPeerId::new(
+                            self.get_remote_peer_id(),
+                            FiberMessage::reestablish_channel(reestablish_channel),
+                        )),
                     ))
                     .expect(ASSUME_NETWORK_ACTOR_ALIVE);
 
@@ -2049,22 +2250,19 @@ where
 
         match message {
             ChannelActorMessage::PeerMessage(message) => {
-                if let Err(error) = self.handle_peer_message(&myself, state, message).await {
-                    error!("Error while processing channel message: {:?}", error);
-                    #[cfg(debug_assertions)]
-                    self.network
-                        .clone()
-                        .send_message(NetworkActorMessage::new_notification(
-                            NetworkServiceEvent::DebugEvent(DebugEvent::Common(format!(
-                                "{:?}",
-                                error
-                            ))),
-                        ))
-                        .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+                if let Err(error) = self
+                    .handle_peer_message(&myself, state, message.clone())
+                    .await
+                {
+                    error!(
+                        "Error while processing channel message: {:?} with message: {:?}",
+                        error, message
+                    );
+                    debug_event!(&self.network, &format!("{:?}", error));
                 }
             }
             ChannelActorMessage::Command(command) => {
-                if let Err(err) = self.handle_command(state, command).await {
+                if let Err(err) = self.handle_command(&myself, state, command).await {
                     error!("Error while processing channel command: {:?}", err);
                 }
             }
@@ -2078,6 +2276,22 @@ where
         self.store.insert_channel_actor_state(state.clone());
         Ok(())
     }
+
+    async fn post_start(
+        &self,
+        myself: ActorRef<Self::Msg>,
+        state: &mut Self::State,
+    ) -> Result<(), ActorProcessingErr> {
+        if state.tlc_state.has_pending_operations() {
+            myself
+                .send_message(ChannelActorMessage::Event(
+                    ChannelEvent::CheckTlcRetryOperation,
+                ))
+                .expect("myself alive");
+        }
+
+        Ok(())
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -2161,27 +2375,69 @@ impl TLCId {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
-pub enum TlcKind {
-    AddTlc(AddTlcInfo),
-    RemoveTlc(RemoveTlcInfo),
+pub enum OutboundTlcStatus {
+    // Offered tlc created and sent to remote party
+    LocalAnnounced,
+    // Received ACK from remote party for this offered tlc
+    Committed,
+    // Remote party removed this tlc
+    RemoteRemoved,
+    // We received another RemoveTlc message from peer when we are waiting for the ack of the last one.
+    // So we need another ACK to confirm the removal.
+    RemoveWaitPrevAck,
+    // We have sent commitment signed to peer and waiting ACK for confirming this RemoveTlc
+    RemoveWaitAck,
+    // We have received the ACK for the RemoveTlc, it's safe to remove this tlc
+    RemoveAckConfirmed,
 }
 
-impl TlcKind {
-    pub fn log(&self) -> String {
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+pub enum InboundTlcStatus {
+    // Received tlc from remote party, but not committed yet
+    RemoteAnnounced,
+    // We received another AddTlc peer message when we are waiting for the ack of the last one.
+    // So we need another ACK to confirm the addition.
+    AnnounceWaitPrevAck,
+    // We have sent commitment signed to peer and waiting ACK for confirming this AddTlc
+    AnnounceWaitAck,
+    // We have received ACK from peer and Committed this tlc
+    Committed,
+    // We have removed this tlc, but haven't received ACK from peer
+    LocalRemoved,
+    // We have received the ACK for the RemoveTlc, it's safe to remove this tlc
+    RemoveAckConfirmed,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+pub enum TlcStatus {
+    Outbound(OutboundTlcStatus),
+    Inbound(InboundTlcStatus),
+}
+
+impl TlcStatus {
+    pub fn as_outbound_status(&self) -> OutboundTlcStatus {
         match self {
-            TlcKind::AddTlc(add_tlc) => {
-                format!("{:?}", &add_tlc.tlc_id)
+            TlcStatus::Outbound(status) => status.clone(),
+            _ => {
+                unreachable!("unexpected status")
             }
-            TlcKind::RemoveTlc(remove_tlc) => {
-                format!("RemoveTlc({:?})", &remove_tlc.tlc_id)
+        }
+    }
+
+    pub fn as_inbound_status(&self) -> InboundTlcStatus {
+        match self {
+            TlcStatus::Inbound(status) => status.clone(),
+            _ => {
+                unreachable!("unexpected status ")
             }
         }
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
-pub struct AddTlcInfo {
+#[derive(Clone, Serialize, Deserialize, Eq, PartialEq)]
+pub struct TlcInfo {
     pub channel_id: Hash256,
+    pub status: TlcStatus,
     pub tlc_id: TLCId,
     pub amount: u128,
     pub payment_hash: Hash256,
@@ -2194,8 +2450,7 @@ pub struct AddTlcInfo {
     /// Save it to backward errors. Use all zeros when no shared secrets are available.
     pub shared_secret: [u8; 32],
     pub created_at: CommitmentNumbers,
-    pub removed_at: Option<(CommitmentNumbers, RemoveTlcReason)>,
-    pub payment_preimage: Option<Hash256>,
+    pub removed_reason: Option<RemoveTlcReason>,
 
     /// Note: `previous_tlc` is used to track the tlc chain for a multi-tlc payment,
     ///       we need to know previous when removing tlc backwardly.
@@ -2207,7 +2462,25 @@ pub struct AddTlcInfo {
     pub previous_tlc: Option<(Hash256, TLCId)>,
 }
 
-impl AddTlcInfo {
+impl Debug for TlcInfo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TlcInfo")
+            .field("tlc_id", &self.tlc_id)
+            .field("status", &self.status)
+            .field("amount", &self.amount)
+            .field("removed_reason", &self.removed_reason)
+            .finish()
+    }
+}
+
+impl TlcInfo {
+    pub fn log(&self) -> String {
+        format!(
+            "id: {:?} status: {:?} amount: {:?}",
+            &self.tlc_id, self.status, self.amount
+        )
+    }
+
     pub fn is_offered(&self) -> bool {
         self.tlc_id.is_offered()
     }
@@ -2224,6 +2497,20 @@ impl AddTlcInfo {
         self.tlc_id.flip_mut();
     }
 
+    pub fn outbound_status(&self) -> OutboundTlcStatus {
+        self.status.as_outbound_status()
+    }
+
+    pub fn inbound_status(&self) -> InboundTlcStatus {
+        self.status.as_inbound_status()
+    }
+
+    fn get_hash(&self) -> ShortHash {
+        self.payment_hash.as_ref()[..20]
+            .try_into()
+            .expect("short hash from payment hash")
+    }
+
     /// Get the value for the field `htlc_type` in commitment lock witness.
     /// - Lowest 1 bit: 0 if the tlc is offered by the remote party, 1 otherwise.
     /// - High 7 bits:
@@ -2233,431 +2520,362 @@ impl AddTlcInfo {
         let offered_flag = if self.is_offered() { 0u8 } else { 1u8 };
         ((self.hash_algorithm as u8) << 1) + offered_flag
     }
+}
 
-    fn get_hash(&self) -> ShortHash {
-        self.payment_hash.as_ref()[..20]
-            .try_into()
-            .expect("short hash from payment hash")
+impl From<TlcInfo> for TlcNotifyInfo {
+    fn from(tlc: TlcInfo) -> Self {
+        TlcNotifyInfo {
+            tlc_id: tlc.tlc_id,
+            amount: tlc.amount,
+            payment_hash: tlc.payment_hash,
+            payment_preimage: None,
+        }
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
-pub struct RemoveTlcInfo {
-    pub channel_id: Hash256,
-    pub tlc_id: TLCId,
-    pub reason: RemoveTlcReason,
+#[derive(Clone, Serialize, Deserialize, Eq, PartialEq)]
+pub enum RetryableTlcOperation {
+    RemoveTlc(TLCId, RemoveTlcReason),
+    RelayRemoveTlc(Hash256, u64, RemoveTlcReason),
+    ForwardTlc(Hash256, TLCId, PeeledPaymentOnionPacket, bool),
 }
 
-impl TlcKind {
-    pub fn tlc_id_u64(&self) -> u64 {
-        match self {
-            TlcKind::AddTlc(add_tlc) => add_tlc.tlc_id.into(),
-            TlcKind::RemoveTlc(remove_tlc) => remove_tlc.tlc_id.into(),
-        }
-    }
-
-    pub fn tlc_id(&self) -> TLCId {
+impl Debug for RetryableTlcOperation {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            TlcKind::AddTlc(info) => info.tlc_id,
-            TlcKind::RemoveTlc(remove_tlc) => remove_tlc.tlc_id,
+            RetryableTlcOperation::RemoveTlc(tlc_id, reason) => f
+                .debug_tuple("RemoveTlc")
+                .field(tlc_id)
+                .field(reason)
+                .finish(),
+            RetryableTlcOperation::RelayRemoveTlc(payment_hash, tlc_id, reason) => f
+                .debug_tuple("RelayRemoveTlc")
+                .field(payment_hash)
+                .field(tlc_id)
+                .field(reason)
+                .finish(),
+            RetryableTlcOperation::ForwardTlc(payment_hash, tlc_id, _, run_once) => f
+                .debug_tuple("ForwardTlc")
+                .field(payment_hash)
+                .field(tlc_id)
+                .field(run_once)
+                .finish(),
         }
     }
-
-    pub fn is_offered(&self) -> bool {
-        self.tlc_id().is_offered()
-    }
-
-    pub fn is_received(&self) -> bool {
-        !self.is_offered()
-    }
 }
 
-#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Default)]
 pub struct PendingTlcs {
-    tlcs: Vec<TlcKind>,
-    committed_index: usize,
-    next_tlc_id: u64,
+    pub tlcs: Vec<TlcInfo>,
+    pub next_tlc_id: u64,
 }
-
-impl PendingTlcs {
-    pub fn new() -> Self {
-        Self {
-            tlcs: Vec::new(),
-            committed_index: 0,
-            next_tlc_id: 0,
-        }
-    }
-
-    pub fn next_tlc_id(&self) -> u64 {
-        self.next_tlc_id
-    }
-
-    pub fn increment_next_tlc_id(&mut self) {
-        self.next_tlc_id += 1;
-    }
-
-    pub fn add_tlc_operation(&mut self, tlc_op: TlcKind) {
-        self.tlcs.push(tlc_op);
-    }
-
-    pub fn get_staging_tlcs(&self) -> &[TlcKind] {
-        &self.tlcs[self.committed_index..]
-    }
-
-    pub fn get_committed_tlcs(&self) -> &[TlcKind] {
-        &self.tlcs[..self.committed_index]
-    }
-
-    pub fn get_committed_tlcs_mut(&mut self) -> &mut [TlcKind] {
-        &mut self.tlcs[..self.committed_index]
-    }
-
-    pub fn tlcs(&self) -> &[TlcKind] {
-        &self.tlcs
-    }
-
-    pub fn tlcs_mut(&mut self) -> &mut Vec<TlcKind> {
-        &mut self.tlcs
-    }
-
-    pub fn push(&mut self, tlc: TlcKind) {
-        assert!(!self.is_tlc_present(&tlc));
-        self.tlcs.push(tlc);
-    }
-
-    fn is_tlc_present(&self, tlc: &TlcKind) -> bool {
-        self.tlcs.iter().any(|t| match (t, tlc) {
-            (TlcKind::AddTlc(info1), TlcKind::AddTlc(info2)) => info1.tlc_id == info2.tlc_id,
-            (TlcKind::RemoveTlc(info1), TlcKind::RemoveTlc(info2)) => info1.tlc_id == info2.tlc_id,
-            _ => false,
-        })
+
+impl PendingTlcs {
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut TlcInfo> {
+        self.tlcs.iter_mut()
     }
 
-    pub fn commit_tlcs(&mut self, committed_tlcs: &[TlcKind]) -> Vec<TlcKind> {
-        let staging_tlcs = self.get_staging_tlcs().to_vec();
-        for tlc in committed_tlcs {
-            if !self.is_tlc_present(tlc) {
-                self.tlcs.push(tlc.clone());
-            }
-        }
-        self.committed_index = self.tlcs.len();
-        return staging_tlcs;
+    pub fn get_next_id(&self) -> u64 {
+        self.next_tlc_id
     }
 
-    pub fn get_mut(&mut self, tlc_id: &TLCId) -> Option<&mut AddTlcInfo> {
-        self.tlcs.iter_mut().find_map(|tlc| match tlc {
-            TlcKind::AddTlc(info) if info.tlc_id == *tlc_id => Some(info),
-            _ => None,
-        })
+    pub fn increment_next_id(&mut self) {
+        self.next_tlc_id += 1;
     }
 
-    pub fn drop_remove_tlc(&mut self, tlc_id: &TLCId) {
-        self.tlcs.retain(|tlc| match tlc {
-            TlcKind::RemoveTlc(info) => info.tlc_id != *tlc_id,
-            _ => true,
-        });
-        self.committed_index = self.tlcs.len();
+    pub fn add_tlc(&mut self, tlc: TlcInfo) {
+        self.tlcs.push(tlc);
     }
 
-    pub fn shrink_removed_tlc(&mut self) {
-        assert_eq!(self.committed_index, self.tlcs.len());
-        let new_committed_index = self
-            .get_committed_tlcs()
+    pub fn get_committed_tlcs(&self) -> Vec<TlcInfo> {
+        self.tlcs
             .iter()
-            .filter(|tlc| match tlc {
-                TlcKind::AddTlc(info) => info.removed_at.is_none(),
-                _ => true,
+            .filter(|tlc| {
+                if tlc.is_offered() {
+                    match tlc.outbound_status() {
+                        OutboundTlcStatus::Committed => true,
+                        _ => false,
+                    }
+                } else {
+                    match tlc.inbound_status() {
+                        InboundTlcStatus::Committed => true,
+                        _ => false,
+                    }
+                }
             })
-            .count();
-        self.tlcs.retain(|tlc| match tlc {
-            TlcKind::AddTlc(info) => info.removed_at.is_none(),
-            _ => true,
-        });
-        self.committed_index = new_committed_index;
+            .cloned()
+            .collect()
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
-pub enum RetryableRemoveTlc {
-    RemoveTlc(TLCId, RemoveTlcReason),
-    RelayRemoveTlc(Hash256, u64, RemoveTlcReason),
-}
-
 #[derive(Default, Clone, Debug, Serialize, Deserialize)]
 pub struct TlcState {
-    local_pending_tlcs: PendingTlcs,
-    remote_pending_tlcs: PendingTlcs,
-    // if the tlc is pending to be removed, the reason will be stored here
-    // this will only used for retrying remove TLC
-    retryable_remove_tlcs: Vec<RetryableRemoveTlc>,
-    waiting_ack: bool,
+    pub offered_tlcs: PendingTlcs,
+    pub received_tlcs: PendingTlcs,
+    pub retryable_tlc_operations: Vec<RetryableTlcOperation>,
+    pub applied_add_tlcs: HashSet<TLCId>,
+    pub waiting_ack: bool,
 }
 
 impl TlcState {
-    pub fn get_next_offering(&self) -> u64 {
-        self.local_pending_tlcs.next_tlc_id()
-    }
-
-    pub fn get_next_received(&self) -> u64 {
-        self.remote_pending_tlcs.next_tlc_id()
+    #[cfg(debug_assertions)]
+    pub fn debug(&self) {
+        for tlc in self.offered_tlcs.tlcs.iter() {
+            debug!("offered_tlc: {:?}", tlc.log());
+        }
+        for tlc in self.received_tlcs.tlcs.iter() {
+            debug!("received_tlc: {:?}", tlc.log());
+        }
     }
 
-    pub fn increment_offering(&mut self) {
-        self.local_pending_tlcs.increment_next_tlc_id();
+    pub fn get_mut(&mut self, tlc_id: &TLCId) -> Option<&mut TlcInfo> {
+        self.offered_tlcs
+            .tlcs
+            .iter_mut()
+            .find(|tlc| tlc.tlc_id == *tlc_id)
+            .or_else(|| {
+                self.received_tlcs
+                    .tlcs
+                    .iter_mut()
+                    .find(|tlc| tlc.tlc_id == *tlc_id)
+            })
     }
 
-    pub fn increment_received(&mut self) {
-        self.remote_pending_tlcs.increment_next_tlc_id();
+    pub fn get(&self, tlc_id: &TLCId) -> Option<&TlcInfo> {
+        if tlc_id.is_offered() {
+            self.offered_tlcs
+                .tlcs
+                .iter()
+                .find(|tlc| tlc.tlc_id == *tlc_id)
+        } else {
+            self.received_tlcs
+                .tlcs
+                .iter()
+                .find(|tlc| tlc.tlc_id == *tlc_id)
+        }
     }
 
-    pub fn set_waiting_ack(&mut self, waiting_ack: bool) {
-        self.waiting_ack = waiting_ack;
+    pub fn get_committed_received_tlcs(&self) -> Vec<TlcInfo> {
+        self.received_tlcs.get_committed_tlcs()
     }
 
-    pub fn set_tlc_pending_remove(&mut self, tlc_id: TLCId, reason: RemoveTlcReason) {
-        self.retryable_remove_tlcs
-            .push(RetryableRemoveTlc::RemoveTlc(tlc_id, reason));
+    pub fn get_next_offering(&self) -> u64 {
+        self.offered_tlcs.get_next_id()
     }
 
-    pub fn insert_relay_tlc_remove(
-        &mut self,
-        channel_id: Hash256,
-        tlc_id: u64,
-        reason: RemoveTlcReason,
-    ) {
-        self.retryable_remove_tlcs
-            .push(RetryableRemoveTlc::RelayRemoveTlc(
-                channel_id, tlc_id, reason,
-            ));
+    pub fn get_next_received(&self) -> u64 {
+        self.received_tlcs.get_next_id()
     }
 
-    pub fn get_pending_remove(&self) -> Vec<RetryableRemoveTlc> {
-        self.retryable_remove_tlcs.clone()
+    pub fn increment_offering(&mut self) {
+        self.offered_tlcs.increment_next_id();
     }
 
-    pub fn remove_pending_remove_tlc(&mut self, retryable_remove: &RetryableRemoveTlc) {
-        self.retryable_remove_tlcs
-            .retain(|remove| remove != retryable_remove);
+    pub fn increment_received(&mut self) {
+        self.received_tlcs.increment_next_id();
     }
 
-    pub fn get(&self, id: &TLCId) -> Option<&AddTlcInfo> {
-        match id {
-            TLCId::Offered(_id) => {
-                self.local_pending_tlcs
-                    .tlcs()
-                    .iter()
-                    .find_map(|tlc| match tlc {
-                        TlcKind::AddTlc(info) if info.tlc_id == *id => Some(info),
-                        _ => None,
-                    })
-            }
-            TLCId::Received(_id) => {
-                self.remote_pending_tlcs
-                    .tlcs()
-                    .iter()
-                    .find_map(|tlc| match tlc {
-                        TlcKind::AddTlc(info) if info.tlc_id == *id => Some(info),
-                        _ => None,
-                    })
-            }
-        }
+    pub fn set_waiting_ack(&mut self, waiting_ack: bool) {
+        self.waiting_ack = waiting_ack;
     }
 
-    pub fn get_mut(&mut self, id: &TLCId) -> Option<&mut AddTlcInfo> {
-        match id {
-            TLCId::Offered(_id) => {
-                self.local_pending_tlcs
-                    .tlcs
-                    .iter_mut()
-                    .find_map(|tlc| match tlc {
-                        TlcKind::AddTlc(info) if info.tlc_id == *id => Some(info),
-                        _ => None,
-                    })
-            }
-            TLCId::Received(_id) => {
-                self.remote_pending_tlcs
-                    .tlcs
-                    .iter_mut()
-                    .find_map(|tlc| match tlc {
-                        TlcKind::AddTlc(info) if info.tlc_id == *id => Some(info),
-                        _ => None,
-                    })
-            }
+    pub fn insert_retryable_tlc_operation(&mut self, operation: RetryableTlcOperation) -> bool {
+        if self.retryable_tlc_operations.contains(&operation) {
+            return false;
         }
+        self.retryable_tlc_operations.push(operation);
+        true
     }
 
-    pub fn add_local_tlc(&mut self, tlc_info: TlcKind) {
-        self.local_pending_tlcs.push(tlc_info);
+    pub fn all_tlcs(&self) -> impl Iterator<Item = &TlcInfo> + '_ {
+        self.offered_tlcs
+            .tlcs
+            .iter()
+            .chain(self.received_tlcs.tlcs.iter())
     }
 
-    pub fn add_remote_tlc(&mut self, tlc_info: TlcKind) {
-        self.remote_pending_tlcs.push(tlc_info);
+    pub fn all_commited_tlcs(&self) -> impl Iterator<Item = &TlcInfo> + '_ {
+        self.offered_tlcs
+            .tlcs
+            .iter()
+            .chain(self.received_tlcs.tlcs.iter())
+            .filter(|tlc| {
+                if tlc.is_offered() {
+                    matches!(tlc.outbound_status(), OutboundTlcStatus::Committed)
+                } else {
+                    matches!(tlc.inbound_status(), InboundTlcStatus::Committed)
+                }
+            })
     }
 
-    pub fn next_local_tlc_id(&self) -> u64 {
-        self.local_pending_tlcs.next_tlc_id()
+    pub fn apply_remove_tlc(&mut self, tlc_id: TLCId) {
+        self.applied_add_tlcs.remove(&tlc_id);
+        if tlc_id.is_offered() {
+            self.offered_tlcs.tlcs.retain(|tlc| tlc.tlc_id != tlc_id);
+        } else {
+            self.received_tlcs.tlcs.retain(|tlc| tlc.tlc_id != tlc_id);
+        }
     }
 
-    pub fn increment_local_tlc_id(&mut self) {
-        self.local_pending_tlcs.increment_next_tlc_id();
+    pub fn get_pending_operations(&self) -> Vec<RetryableTlcOperation> {
+        self.retryable_tlc_operations.clone()
     }
 
-    pub fn next_remote_tlc_id(&self) -> u64 {
-        self.remote_pending_tlcs.next_tlc_id()
+    pub fn has_pending_operations(&self) -> bool {
+        !self.retryable_tlc_operations.is_empty()
     }
 
-    pub fn increment_remote_tlc_id(&mut self) {
-        self.remote_pending_tlcs.increment_next_tlc_id();
-    }
+    pub fn remove_pending_tlc_operation(&mut self, retryable_tlc_op: &RetryableTlcOperation) {
+        self.retryable_tlc_operations
+            .retain(|op| op != retryable_tlc_op);
 
-    fn unify_tlcs<'a>(
-        &self,
-        staging_tlcs: impl Iterator<Item = &'a TlcKind>,
-        committed_tlcs: impl Iterator<Item = &'a TlcKind>,
-    ) -> Vec<TlcKind> {
-        let mut add_tlcs: BTreeMap<TLCId, TlcKind> = Default::default();
-        let mut remove_tlcs = vec![];
-        for tlc in committed_tlcs {
-            match tlc {
-                TlcKind::AddTlc(info) => {
-                    if info.removed_at.is_none() {
-                        let _ = add_tlcs.insert(tlc.tlc_id(), tlc.clone());
-                    }
-                }
-                TlcKind::RemoveTlc(..) => {
-                    unreachable!("RemoveTlc should not be in committed tlcs")
-                }
-            }
-        }
-        for tlc in staging_tlcs {
-            match tlc {
-                TlcKind::AddTlc(_info) => {
-                    // If the tlc is already in the committed tlcs, we should not add it again.
-                    // committed tlcs always have the latest tlc information
-                    if add_tlcs.contains_key(&tlc.tlc_id()) {
-                        continue;
-                    }
-                    let _ = add_tlcs.insert(tlc.tlc_id(), tlc.clone());
-                }
-                TlcKind::RemoveTlc(..) => remove_tlcs.push(tlc.clone()),
+        // if we already finished the RemoveTlc operation for the tlc,
+        // we should also remove the ForwardTlc to avoid any later retry.
+        match retryable_tlc_op {
+            RetryableTlcOperation::RemoveTlc(tlc_id, _) => {
+                self.retryable_tlc_operations.retain(|op| match op {
+                    RetryableTlcOperation::ForwardTlc(_, id, ..) => id != tlc_id,
+                    _ => true,
+                });
             }
+            _ => {}
         }
-        for tlc in remove_tlcs {
-            let tlc_id = tlc.tlc_id();
-            let _ = add_tlcs.remove(&tlc_id);
-        }
-        add_tlcs.values().map(|tlc| tlc.clone()).collect()
     }
 
-    pub fn get_tlcs_for_local(&self) -> Vec<TlcKind> {
-        self.unify_tlcs(
-            self.local_pending_tlcs.get_staging_tlcs().into_iter(),
-            self.local_pending_tlcs
-                .get_committed_tlcs()
-                .into_iter()
-                .chain(self.remote_pending_tlcs.get_committed_tlcs().into_iter()),
-        )
+    pub fn add_offered_tlc(&mut self, tlc: TlcInfo) {
+        self.offered_tlcs.add_tlc(tlc);
     }
 
-    pub fn get_tlcs_for_remote(&self) -> Vec<TlcKind> {
-        self.unify_tlcs(
-            self.remote_pending_tlcs.get_staging_tlcs().into_iter(),
-            self.remote_pending_tlcs
-                .get_committed_tlcs()
-                .into_iter()
-                .chain(self.local_pending_tlcs.get_committed_tlcs().into_iter()),
-        )
+    pub fn add_received_tlc(&mut self, tlc: TlcInfo) {
+        self.received_tlcs.add_tlc(tlc);
     }
 
-    pub fn get_tlcs_with(&self, local_commitment: bool) -> Vec<TlcKind> {
-        if local_commitment {
-            self.get_tlcs_for_local()
-        } else {
-            self.get_tlcs_for_remote()
+    pub fn set_received_tlc_removed(&mut self, tlc_id: u64, reason: RemoveTlcReason) {
+        if let Some(tlc) = self.get_mut(&TLCId::Received(tlc_id)) {
+            assert_eq!(tlc.inbound_status(), InboundTlcStatus::Committed);
+            tlc.removed_reason = Some(reason);
+            tlc.status = TlcStatus::Inbound(InboundTlcStatus::LocalRemoved);
         }
     }
 
-    pub fn commit_local_tlcs(&mut self) -> Vec<TlcKind> {
-        self.local_pending_tlcs
-            .commit_tlcs(self.remote_pending_tlcs.get_committed_tlcs())
+    pub fn set_offered_tlc_removed(&mut self, tlc_id: u64, reason: RemoveTlcReason) -> Hash256 {
+        let tlc = self.get_mut(&TLCId::Offered(tlc_id)).expect("get tlc");
+        assert_eq!(tlc.outbound_status(), OutboundTlcStatus::Committed);
+        tlc.removed_reason = Some(reason);
+        tlc.status = TlcStatus::Outbound(OutboundTlcStatus::RemoteRemoved);
+        tlc.payment_hash
     }
 
-    pub fn commit_remote_tlcs(&mut self) -> Vec<TlcKind> {
-        self.remote_pending_tlcs
-            .commit_tlcs(self.local_pending_tlcs.get_committed_tlcs())
+    pub fn commitment_signed_tlcs(&self, for_remote: bool) -> impl Iterator<Item = &TlcInfo> + '_ {
+        self.offered_tlcs
+            .tlcs
+            .iter()
+            .filter(move |tlc| match tlc.outbound_status() {
+                OutboundTlcStatus::LocalAnnounced => for_remote,
+                OutboundTlcStatus::Committed => true,
+                OutboundTlcStatus::RemoteRemoved => for_remote,
+                OutboundTlcStatus::RemoveWaitPrevAck => for_remote,
+                OutboundTlcStatus::RemoveWaitAck => false,
+                OutboundTlcStatus::RemoveAckConfirmed => false,
+            })
+            .chain(
+                self.received_tlcs
+                    .tlcs
+                    .iter()
+                    .filter(move |tlc| match tlc.inbound_status() {
+                        InboundTlcStatus::RemoteAnnounced => !for_remote,
+                        InboundTlcStatus::AnnounceWaitPrevAck => !for_remote,
+                        InboundTlcStatus::AnnounceWaitAck => true,
+                        InboundTlcStatus::Committed => true,
+                        InboundTlcStatus::LocalRemoved => !for_remote,
+                        InboundTlcStatus::RemoveAckConfirmed => false,
+                    }),
+            )
     }
 
-    fn filter_add_tlcs<'a, I>(tlcs: I) -> impl Iterator<Item = &'a AddTlcInfo>
-    where
-        I: Iterator<Item = &'a TlcKind>,
-    {
-        tlcs.filter_map(|tlc| match tlc {
-            TlcKind::AddTlc(info) => {
-                if info.removed_at.is_some() {
-                    None
-                } else {
-                    Some((info.tlc_id, info))
+    pub fn update_for_commitment_signed(&mut self) -> bool {
+        for tlc in self.offered_tlcs.tlcs.iter_mut() {
+            match tlc.outbound_status() {
+                OutboundTlcStatus::RemoteRemoved => {
+                    let status = if self.waiting_ack {
+                        OutboundTlcStatus::RemoveWaitPrevAck
+                    } else {
+                        OutboundTlcStatus::RemoveWaitAck
+                    };
+                    tlc.status = TlcStatus::Outbound(status);
                 }
+                _ => {}
             }
-            TlcKind::RemoveTlc(..) => None,
-        })
-        .collect::<BTreeMap<_, _>>()
-        .into_iter()
-        .map(|(_, v)| v)
-    }
-
-    pub fn all_commited_tlcs(&self) -> impl Iterator<Item = &AddTlcInfo> {
-        Self::filter_add_tlcs(
-            self.local_pending_tlcs
-                .get_committed_tlcs()
-                .into_iter()
-                .chain(self.remote_pending_tlcs.get_committed_tlcs().into_iter()),
-        )
-    }
-
-    pub fn all_tlcs(&self) -> impl Iterator<Item = &AddTlcInfo> {
-        Self::filter_add_tlcs(
-            self.local_pending_tlcs
-                .tlcs()
-                .into_iter()
-                .chain(self.remote_pending_tlcs.tlcs().into_iter()),
-        )
-    }
-
-    pub fn mark_tlc_remove(
-        &mut self,
-        tlc_id: TLCId,
-        removed_at: CommitmentNumbers,
-        reason: RemoveTlcReason,
-    ) {
-        // we don't consider RemoveTLC in the pending TLCS when build commitment signature
-        // so it's safe to remove them all from remote and local pending TLCS
-        self.local_pending_tlcs.drop_remove_tlc(&tlc_id);
-        self.remote_pending_tlcs.drop_remove_tlc(&tlc_id);
-        if let Some(tlc) = self.local_pending_tlcs.get_mut(&tlc_id) {
-            tlc.removed_at = Some((removed_at, reason.clone()));
         }
-        if let Some(tlc) = self.remote_pending_tlcs.get_mut(&tlc_id) {
-            tlc.removed_at = Some((removed_at, reason));
+        for tlc in self.received_tlcs.tlcs.iter_mut() {
+            match tlc.inbound_status() {
+                InboundTlcStatus::RemoteAnnounced => {
+                    let status = if self.waiting_ack {
+                        InboundTlcStatus::AnnounceWaitPrevAck
+                    } else {
+                        InboundTlcStatus::AnnounceWaitAck
+                    };
+                    tlc.status = TlcStatus::Inbound(status)
+                }
+                _ => {}
+            }
         }
+        self.need_another_commitment_signed()
     }
 
-    pub fn apply_remove_tlc(
-        &mut self,
-        tlc_id: TLCId,
-        removed_at: CommitmentNumbers,
-        reason: RemoveTlcReason,
-    ) {
-        self.mark_tlc_remove(tlc_id, removed_at, reason);
-        // it's safe to remove multiple removed tlcs from pending TLCS,
-        // just make sure the two partners are operating on correct pending list,
-        // in other words, when one is remove from local TLCS,
-        // the peer should remove it from remote TLCS
-        if tlc_id.is_offered() {
-            self.local_pending_tlcs.shrink_removed_tlc();
-        } else {
-            self.remote_pending_tlcs.shrink_removed_tlc();
+    pub fn update_for_revoke_and_ack(&mut self) -> bool {
+        self.set_waiting_ack(false);
+        for tlc in self.offered_tlcs.tlcs.iter_mut() {
+            match tlc.outbound_status() {
+                OutboundTlcStatus::LocalAnnounced => {
+                    tlc.status = TlcStatus::Outbound(OutboundTlcStatus::Committed);
+                }
+                OutboundTlcStatus::RemoveWaitPrevAck => {
+                    tlc.status = TlcStatus::Outbound(OutboundTlcStatus::RemoveWaitAck);
+                }
+                OutboundTlcStatus::RemoveWaitAck => {
+                    tlc.status = TlcStatus::Outbound(OutboundTlcStatus::RemoveAckConfirmed);
+                }
+                _ => {}
+            }
+        }
+
+        for tlc in self.received_tlcs.tlcs.iter_mut() {
+            match tlc.inbound_status() {
+                InboundTlcStatus::AnnounceWaitPrevAck => {
+                    tlc.status = TlcStatus::Inbound(InboundTlcStatus::AnnounceWaitAck);
+                }
+                InboundTlcStatus::AnnounceWaitAck => {
+                    tlc.status = TlcStatus::Inbound(InboundTlcStatus::Committed);
+                }
+                InboundTlcStatus::LocalRemoved => {
+                    tlc.status = TlcStatus::Inbound(InboundTlcStatus::RemoveAckConfirmed);
+                }
+                _ => {}
+            }
         }
+        self.need_another_commitment_signed()
+    }
+
+    pub fn need_another_commitment_signed(&self) -> bool {
+        self.offered_tlcs.tlcs.iter().any(|tlc| {
+            let status = tlc.outbound_status();
+            matches!(
+                status,
+                OutboundTlcStatus::LocalAnnounced
+                    | OutboundTlcStatus::RemoteRemoved
+                    | OutboundTlcStatus::RemoveWaitPrevAck
+                    | OutboundTlcStatus::RemoveWaitAck
+            )
+        }) || self.received_tlcs.tlcs.iter().any(|tlc| {
+            let status = tlc.inbound_status();
+            matches!(
+                status,
+                InboundTlcStatus::RemoteAnnounced
+                    | InboundTlcStatus::AnnounceWaitPrevAck
+                    | InboundTlcStatus::AnnounceWaitAck
+            )
+        })
     }
 }
 
@@ -2676,13 +2894,6 @@ impl ChannelConstraints {
             max_tlc_number_in_flight,
         }
     }
-
-    pub fn default() -> Self {
-        Self::new(
-            DEFAULT_MAX_TLC_VALUE_IN_FLIGHT,
-            DEFAULT_MAX_TLC_NUMBER_IN_FLIGHT,
-        )
-    }
 }
 
 #[serde_as]
@@ -2730,7 +2941,7 @@ pub struct ChannelActorState {
     #[serde_as(as = "Option<EntityHex>")]
     pub funding_tx: Option<Transaction>,
 
-    pub funding_tx_confirmed_at: Option<(BlockNumber, u32)>,
+    pub funding_tx_confirmed_at: Option<(H256, u32, u64)>,
 
     #[serde_as(as = "Option<EntityHex>")]
     pub funding_udt_type_script: Option<Script>,
@@ -2896,15 +3107,15 @@ pub struct ClosedChannel {}
 #[derive(Debug)]
 pub enum ChannelEvent {
     PeerDisconnected,
-    FundingTransactionConfirmed(BlockNumber, u32),
+    FundingTransactionConfirmed(H256, u32, u64),
     CommitmentTransactionConfirmed,
     ClosingTransactionConfirmed,
-    CheckTlcSetdown,
+    CheckTlcRetryOperation,
 }
 
 pub type ProcessingChannelResult = Result<(), ProcessingChannelError>;
 
-#[derive(Error, Debug)]
+#[derive(Error, Debug, Clone)]
 pub enum ProcessingChannelError {
     #[error("Invalid state: {0}")]
     InvalidState(String),
@@ -2912,10 +3123,12 @@ pub enum ProcessingChannelError {
     RepeatedProcessing(String),
     #[error("Invalid parameter: {0}")]
     InvalidParameter(String),
+    #[error("Internal error: {0}")]
+    InternalError(String),
     #[error("Capacity error: {0}")]
     CapacityError(#[from] CapacityError),
     #[error("Failed to spawn actor: {0}")]
-    SpawnErr(#[from] SpawnErr),
+    SpawnErr(String),
     #[error("Musig2 VerifyError: {0}")]
     Musig2VerifyError(#[from] VerifyError),
     #[error("Musig2 SigningError: {0}")]
@@ -3371,6 +3584,7 @@ impl ChannelActorState {
         // The function that would change the channel update parameters.
         f: impl FnOnce(&mut ChannelUpdate),
     ) -> ChannelUpdate {
+        assert!(self.is_public());
         let mut channel_update = self
             .get_unsigned_channel_update_message()
             .expect("public channel can generate channel update message");
@@ -3414,9 +3628,9 @@ impl ChannelActorState {
         let channel_update = self.generate_channel_update(network).await;
         network
             .send_message(NetworkActorMessage::new_command(
-                NetworkActorCommand::BroadcastMessages(vec![BroadcastMessage::ChannelUpdate(
-                    channel_update,
-                )]),
+                NetworkActorCommand::BroadcastMessages(vec![
+                    BroadcastMessageWithTimestamp::ChannelUpdate(channel_update),
+                ]),
             ))
             .expect(ASSUME_NETWORK_ACTOR_ALIVE);
     }
@@ -4023,7 +4237,7 @@ impl ChannelActorState {
             } else {
                 let capacity = self.get_total_ckb_amount() - commitment_tx_fee;
                 let output = CellOutput::new_builder()
-                    .lock(lock_script)
+                    .lock(lock_script.clone())
                     .capacity(capacity.pack())
                     .build();
                 let output_data = Bytes::default();
@@ -4046,6 +4260,7 @@ impl ChannelActorState {
                 ]
                 .concat(),
             );
+
             sign_ctx
                 .clone()
                 .sign(message.as_slice())
@@ -4203,12 +4418,12 @@ impl ChannelActorState {
         self.get_current_commitment_number(for_remote) + 1
     }
 
-    pub fn get_next_offering_tlc_id(&self) -> u64 {
-        self.tlc_state.get_next_offering()
+    pub fn get_next_offering_tlc_id(&self) -> TLCId {
+        TLCId::Offered(self.tlc_state.get_next_offering())
     }
 
-    pub fn get_next_received_tlc_id(&self) -> u64 {
-        self.tlc_state.get_next_received()
+    pub fn get_next_received_tlc_id(&self) -> TLCId {
+        TLCId::Received(self.tlc_state.get_next_received())
     }
 
     pub fn increment_next_offered_tlc_id(&mut self) {
@@ -4219,21 +4434,26 @@ impl ChannelActorState {
         self.tlc_state.increment_received();
     }
 
-    pub fn get_offered_tlc(&self, tlc_id: u64) -> Option<&AddTlcInfo> {
-        self.tlc_state.get(&TLCId::Offered(tlc_id))
+    pub fn get_offered_tlc(&self, tlc_id: TLCId) -> Option<&TlcInfo> {
+        self.tlc_state.get(&tlc_id)
     }
 
-    pub fn get_received_tlc(&self, tlc_id: u64) -> Option<&AddTlcInfo> {
-        self.tlc_state.get(&TLCId::Received(tlc_id))
+    pub fn get_received_tlc(&self, tlc_id: TLCId) -> Option<&TlcInfo> {
+        self.tlc_state.get(&tlc_id)
     }
 
-    pub(crate) fn set_received_tlc_preimage(&mut self, tlc_id: u64, preimage: Option<Hash256>) {
-        if let Some(tlc) = self.tlc_state.get_mut(&TLCId::Received(tlc_id)) {
-            tlc.payment_preimage = preimage;
+    pub fn check_insert_tlc(&mut self, tlc: &TlcInfo) -> Result<(), ProcessingChannelError> {
+        let next_tlc_id = if tlc.is_offered() {
+            self.get_next_offering_tlc_id()
+        } else {
+            self.get_next_received_tlc_id()
+        };
+        if tlc.tlc_id != next_tlc_id {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Received tlc id {:?} is not the expected next id {:?}",
+                tlc.tlc_id, next_tlc_id
+            )));
         }
-    }
-
-    pub fn check_insert_tlc(&mut self, tlc: &AddTlcInfo) -> Result<(), ProcessingChannelError> {
         let payment_hash = tlc.payment_hash;
         if let Some(tlc) = self
             .tlc_state
@@ -4273,55 +4493,49 @@ impl ChannelActorState {
     pub fn remove_tlc_with_reason(
         &mut self,
         tlc_id: TLCId,
-        reason: &RemoveTlcReason,
-    ) -> Result<AddTlcInfo, ProcessingChannelError> {
-        let removed_at = self.get_current_commitment_numbers();
-        let current = self.tlc_state.get(&tlc_id).expect("TLC exists").clone();
+    ) -> Result<(TlcInfo, RemoveTlcReason), ProcessingChannelError> {
+        let current = self.tlc_state.get_mut(&tlc_id).expect("TLC exists").clone();
+        let reason = current
+            .removed_reason
+            .clone()
+            .expect("expect removed_reason exist");
+        assert!(matches!(
+            current.status,
+            TlcStatus::Inbound(InboundTlcStatus::RemoveAckConfirmed)
+                | TlcStatus::Outbound(OutboundTlcStatus::RemoveAckConfirmed)
+        ));
 
-        match &current.removed_at {
-            Some((current_removed_at, current_remove_reason))
-                if current_remove_reason == reason && removed_at == *current_removed_at =>
-            {
-                debug!("Skipping removing of tlc {:?} as it is already removed at {:?} with the same reason {:?}", tlc_id, removed_at, reason);
-                return Err(ProcessingChannelError::RepeatedProcessing(
-                    "TLC is already removed".to_string(),
-                ));
+        if let RemoveTlcReason::RemoveTlcFulfill(fulfill) = &reason {
+            let filled_payment_hash: Hash256 =
+                current.hash_algorithm.hash(fulfill.payment_preimage).into();
+            if current.payment_hash != filled_payment_hash {
+                return Err(ProcessingChannelError::FinalIncorrectPreimage);
             }
-            Some((current_remove_reason, current_removed_at)) => {
-                return Err(ProcessingChannelError::InvalidParameter(
-                            format!("Illegally removing the same tlc: {:?} was previously removed at {:?} for {:?}, and trying to remove it again at {:?} for {:?}",
-                                tlc_id,  current_removed_at, reason, removed_at, current_remove_reason)));
+
+            // update balance according to the tlc
+            let (mut to_local_amount, mut to_remote_amount) =
+                (self.to_local_amount, self.to_remote_amount);
+            if current.is_offered() {
+                to_local_amount -= current.amount;
+                to_remote_amount += current.amount;
+            } else {
+                to_local_amount += current.amount;
+                to_remote_amount -= current.amount;
             }
-            None => {
-                if let RemoveTlcReason::RemoveTlcFulfill(fulfill) = reason {
-                    let filled_payment_hash: Hash256 =
-                        current.hash_algorithm.hash(fulfill.payment_preimage).into();
-                    if current.payment_hash != filled_payment_hash {
-                        return Err(ProcessingChannelError::FinalIncorrectPreimage);
-                    }
 
-                    // update balance according to the tlc
-                    let (mut to_local_amount, mut to_remote_amount) =
-                        (self.to_local_amount, self.to_remote_amount);
-                    if current.is_offered() {
-                        to_local_amount -= current.amount;
-                        to_remote_amount += current.amount;
-                    } else {
-                        to_local_amount += current.amount;
-                        to_remote_amount -= current.amount;
-                    }
-                    self.to_local_amount = to_local_amount;
-                    self.to_remote_amount = to_remote_amount;
+            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 {:?}",
+            debug!("Updated local balance to {} and remote balance to {} by removing tlc {:?} with reason {:?}",
                             to_local_amount, to_remote_amount, tlc_id, reason);
-                }
-                self.tlc_state
-                    .apply_remove_tlc(tlc_id, removed_at, reason.clone());
-            }
         }
+        self.tlc_state.apply_remove_tlc(tlc_id);
+        debug!(
+            "Removed tlc payment_hash {:?} with reason {:?}",
+            current.payment_hash, reason
+        );
 
-        Ok(current.clone())
+        Ok((current.clone(), reason))
     }
 
     pub fn get_local_channel_public_keys(&self) -> &ChannelBasePublicKeys {
@@ -4352,16 +4566,11 @@ impl ChannelActorState {
             .expect("Funding transaction outpoint is present")
     }
 
-    pub fn get_funding_transaction_block_number(&self) -> BlockNumber {
-        self.funding_tx_confirmed_at
-            .expect("funding tx confirmed_at is present")
-            .0
-    }
-
-    pub fn get_funding_transaction_index(&self) -> u32 {
+    pub fn must_get_funding_transaction_timestamp(&self) -> u64 {
         self.funding_tx_confirmed_at
-            .expect("funding tx confirmed_at is present")
-            .1
+            .as_ref()
+            .expect("Funding transaction confirmed at present")
+            .2
     }
 
     pub fn get_local_shutdown_script(&self) -> Script {
@@ -4466,77 +4675,27 @@ impl ChannelActorState {
         AggNonce::sum(nonces)
     }
 
-    fn get_active_received_tlcs(&self, local_commitment: bool) -> impl Iterator<Item = AddTlcInfo> {
+    fn get_active_received_tlcs(&self, for_remote: bool) -> Vec<TlcInfo> {
         self.tlc_state
-            .get_tlcs_with(local_commitment)
-            .into_iter()
-            .filter_map(|tlc| match tlc {
-                TlcKind::AddTlc(tlc) if tlc.is_received() => Some(tlc),
-                _ => None,
-            })
+            .commitment_signed_tlcs(for_remote)
+            .filter(|tlc| tlc.is_received())
+            .map(|tlc| tlc.clone())
+            .collect()
     }
 
-    fn get_active_offered_tlcs(&self, local_commitment: bool) -> impl Iterator<Item = AddTlcInfo> {
+    fn get_active_offered_tlcs(&self, for_remote: bool) -> Vec<TlcInfo> {
         self.tlc_state
-            .get_tlcs_with(local_commitment)
-            .into_iter()
-            .filter_map(|tlc| match tlc {
-                TlcKind::AddTlc(tlc) if tlc.is_offered() => Some(tlc),
-                _ => None,
-            })
-    }
-
-    // Get the total amount of pending tlcs that are fulfilled
-    fn get_pending_fulfilled_tlcs_amount(&self, for_remote: bool, offered: bool) -> u128 {
-        let (local_pending_tlcs, remote_pending_tlcs) = if for_remote {
-            (
-                &self.tlc_state.local_pending_tlcs,
-                &self.tlc_state.remote_pending_tlcs,
-            )
-        } else {
-            (
-                &self.tlc_state.remote_pending_tlcs,
-                &self.tlc_state.local_pending_tlcs,
-            )
-        };
-        let mut pending = local_pending_tlcs
-            .get_committed_tlcs()
-            .into_iter()
-            .chain(remote_pending_tlcs.get_committed_tlcs().into_iter())
-            .filter_map(|tlc| match tlc {
-                TlcKind::AddTlc(info)
-                    if info.removed_at.is_none() && info.is_offered() == offered =>
-                {
-                    Some((tlc.tlc_id(), info.amount))
-                }
-                _ => None,
-            })
-            .collect::<HashMap<TLCId, u128>>();
-        let mut fulfilled = 0;
-
-        for tlc in local_pending_tlcs.get_staging_tlcs() {
-            match tlc {
-                TlcKind::AddTlc(info) => {
-                    pending.insert(tlc.tlc_id(), info.amount);
-                }
-                TlcKind::RemoveTlc(remove_tlc) => {
-                    if let Some(amount) = pending.remove(&remove_tlc.tlc_id) {
-                        if matches!(remove_tlc.reason, RemoveTlcReason::RemoveTlcFulfill(_)) {
-                            fulfilled += amount;
-                        }
-                    }
-                }
-            }
-        }
-
-        fulfilled
+            .commitment_signed_tlcs(for_remote)
+            .filter(|tlc| tlc.is_offered())
+            .map(|tlc| tlc.clone())
+            .collect()
     }
 
-    pub fn get_all_received_tlcs(&self) -> impl Iterator<Item = &AddTlcInfo> {
+    pub fn get_all_received_tlcs(&self) -> impl Iterator<Item = &TlcInfo> {
         self.tlc_state.all_tlcs().filter(|tlc| tlc.is_received())
     }
 
-    pub fn get_all_offer_tlcs(&self) -> impl Iterator<Item = &AddTlcInfo> {
+    pub fn get_all_offer_tlcs(&self) -> impl Iterator<Item = &TlcInfo> {
         self.tlc_state.all_tlcs().filter(|tlc| tlc.is_offered())
     }
 
@@ -4546,7 +4705,7 @@ impl ChannelActorState {
     // The offerer who offered this tlc will have the first pubkey, and the receiver
     // will have the second pubkey.
     // This tlc must have valid local_committed_at and remote_committed_at fields.
-    pub fn get_tlc_pubkeys(&self, tlc: &AddTlcInfo) -> (Pubkey, Pubkey) {
+    pub fn get_tlc_pubkeys(&self, tlc: &TlcInfo) -> (Pubkey, Pubkey) {
         let is_offered = tlc.is_offered();
         let CommitmentNumbers {
             local: local_commitment_number,
@@ -4574,9 +4733,10 @@ impl ChannelActorState {
 
     fn get_active_received_tlc_with_pubkeys(
         &self,
-        local: bool,
-    ) -> Vec<(AddTlcInfo, Pubkey, Pubkey)> {
-        self.get_active_received_tlcs(local)
+        for_remote: bool,
+    ) -> Vec<(TlcInfo, Pubkey, Pubkey)> {
+        self.get_active_received_tlcs(for_remote)
+            .into_iter()
             .map(move |tlc| {
                 let (k1, k2) = self.get_tlc_pubkeys(&tlc);
                 (tlc, k1, k2)
@@ -4586,9 +4746,10 @@ impl ChannelActorState {
 
     fn get_active_offered_tlc_with_pubkeys(
         &self,
-        local: bool,
-    ) -> Vec<(AddTlcInfo, Pubkey, Pubkey)> {
-        self.get_active_offered_tlcs(local)
+        for_remote: bool,
+    ) -> Vec<(TlcInfo, Pubkey, Pubkey)> {
+        self.get_active_offered_tlcs(for_remote)
+            .into_iter()
             .map(move |tlc| {
                 let (k1, k2) = self.get_tlc_pubkeys(&tlc);
                 (tlc, k1, k2)
@@ -4596,14 +4757,14 @@ impl ChannelActorState {
             .collect()
     }
 
-    fn get_active_htlcs(&self, local: bool) -> Vec<u8> {
+    fn get_active_htlcs(&self, for_remote: bool) -> Vec<u8> {
         // Build a sorted array of TLC so that both party can generate the same commitment transaction.
         let tlcs = {
             let (mut received_tlcs, mut offered_tlcs) = (
-                self.get_active_received_tlc_with_pubkeys(local),
-                self.get_active_offered_tlc_with_pubkeys(local),
+                self.get_active_received_tlc_with_pubkeys(for_remote),
+                self.get_active_offered_tlc_with_pubkeys(for_remote),
             );
-            let (mut a, mut b) = if local {
+            let (mut a, mut b) = if for_remote {
                 (received_tlcs, offered_tlcs)
             } else {
                 for (tlc, _, _) in received_tlcs.iter_mut().chain(offered_tlcs.iter_mut()) {
@@ -4616,6 +4777,7 @@ impl ChannelActorState {
             b.sort_by(|x, y| u64::from(x.0.tlc_id).cmp(&u64::from(y.0.tlc_id)));
             [a, b].concat()
         };
+
         if tlcs.is_empty() {
             Vec::new()
         } else {
@@ -4639,7 +4801,7 @@ impl ChannelActorState {
     fn any_tlc_pending(&self) -> bool {
         self.tlc_state
             .all_tlcs()
-            .any(|tlc| tlc.removed_at.is_none())
+            .any(|tlc| tlc.removed_reason.is_none())
     }
 
     pub fn get_local_funding_pubkey(&self) -> &Pubkey {
@@ -4708,15 +4870,25 @@ impl ChannelActorState {
         reason: &RemoveTlcReason,
     ) -> ProcessingChannelResult {
         if let Some(tlc) = self.tlc_state.get(&tlc_id) {
-            if tlc.removed_at.is_some() {
+            if tlc.removed_reason.is_some() {
                 return Err(ProcessingChannelError::RepeatedProcessing(
                     "TLC is already removed".to_string(),
                 ));
             }
+            if (tlc.is_offered() && tlc.outbound_status() != OutboundTlcStatus::Committed)
+                || (tlc.is_received() && tlc.inbound_status() != InboundTlcStatus::Committed)
+            {
+                return Err(ProcessingChannelError::InvalidState(
+                    "TLC is not in Committed status".to_string(),
+                ));
+            }
             if let RemoveTlcReason::RemoveTlcFulfill(fulfill) = reason {
                 let filled_payment_hash: Hash256 =
                     tlc.hash_algorithm.hash(fulfill.payment_preimage).into();
                 if tlc.payment_hash != filled_payment_hash {
+                    // actually this branch should never be reached in normal case
+                    // `FinalIncorrectPreimage` will be returned in `apply_add_tlc_operation_with_peeled_onion_packet`
+                    // when the preimage is incorrect
                     return Err(ProcessingChannelError::FinalIncorrectPreimage);
                 }
             }
@@ -4799,23 +4971,23 @@ impl ChannelActorState {
         Ok(())
     }
 
-    fn create_outbounding_tlc(&self, command: AddTlcCommand) -> AddTlcInfo {
-        let id = self.get_next_offering_tlc_id();
+    fn create_outbounding_tlc(&self, command: AddTlcCommand) -> TlcInfo {
+        let tlc_id = self.get_next_offering_tlc_id();
         assert!(
-            self.get_offered_tlc(id).is_none(),
+            self.get_offered_tlc(tlc_id).is_none(),
             "Must not have the same id in pending offered tlcs"
         );
 
-        AddTlcInfo {
+        TlcInfo {
             channel_id: self.get_id(),
-            tlc_id: TLCId::Offered(id),
+            status: TlcStatus::Outbound(OutboundTlcStatus::LocalAnnounced),
+            tlc_id,
             amount: command.amount,
             payment_hash: command.payment_hash,
             expiry: command.expiry,
             hash_algorithm: command.hash_algorithm,
             created_at: self.get_current_commitment_numbers(),
-            payment_preimage: None,
-            removed_at: None,
+            removed_reason: None,
             onion_packet: command.onion_packet,
             shared_secret: command.shared_secret,
             previous_tlc: command
@@ -4824,9 +4996,10 @@ impl ChannelActorState {
         }
     }
 
-    fn create_inbounding_tlc(&self, message: AddTlc) -> Result<AddTlcInfo, ProcessingChannelError> {
-        let tlc_info = AddTlcInfo {
+    fn create_inbounding_tlc(&self, message: AddTlc) -> Result<TlcInfo, ProcessingChannelError> {
+        let tlc_info = TlcInfo {
             tlc_id: TLCId::Received(message.tlc_id),
+            status: TlcStatus::Inbound(InboundTlcStatus::RemoteAnnounced),
             channel_id: self.get_id(),
             amount: message.amount,
             payment_hash: message.payment_hash,
@@ -4837,8 +5010,7 @@ impl ChannelActorState {
             // No need to save shared secret for inbound TLC.
             shared_secret: NO_SHARED_SECRET.clone(),
             created_at: self.get_current_commitment_numbers(),
-            payment_preimage: None,
-            removed_at: None,
+            removed_reason: None,
             previous_tlc: None,
         };
         Ok(tlc_info)
@@ -5398,8 +5570,11 @@ impl ChannelActorState {
             network
                 .send_message(NetworkActorMessage::new_command(
                     NetworkActorCommand::BroadcastMessages(vec![
-                        BroadcastMessage::ChannelAnnouncement(channel_announcement),
-                        BroadcastMessage::ChannelUpdate(channel_update),
+                        BroadcastMessageWithTimestamp::ChannelAnnouncement(
+                            self.must_get_funding_transaction_timestamp(),
+                            channel_announcement,
+                        ),
+                        BroadcastMessageWithTimestamp::ChannelUpdate(channel_update),
                     ]),
                 ))
                 .expect(ASSUME_NETWORK_ACTOR_ALIVE);
@@ -5483,28 +5658,31 @@ impl ChannelActorState {
         self.remote_commitment_points
             .push((self.get_local_commitment_number(), commitment_point));
 
+        // shrink the remote commitment points list
+        // TODO: use all_tlcs as filter instead of select the minimal commitment number
         let len = self.remote_commitment_points.len();
         if len > (self.local_constraints.max_tlc_number_in_flight + 1) as usize {
             let min_remote_commitment = self
                 .tlc_state
                 .all_tlcs()
-                .map(|x| x.created_at.remote)
+                .map(|x| x.created_at.remote.min(x.created_at.local))
                 .min()
                 .unwrap_or_default();
             self.remote_commitment_points
                 .retain(|(num, _)| *num >= min_remote_commitment);
         }
-        assert!(
-            self.remote_commitment_points.len()
-                <= (self.local_constraints.max_tlc_number_in_flight + 1) as usize
-        );
     }
 
     fn handle_revoke_and_ack_peer_message(
         &mut self,
         network: &ActorRef<NetworkActorMessage>,
         revoke_and_ack: RevokeAndAck,
-    ) -> ProcessingChannelResult {
+    ) -> Result<bool, ProcessingChannelError> {
+        if !self.tlc_state.waiting_ack {
+            return Err(ProcessingChannelError::InvalidState(
+                "unexpected RevokeAndAck message".to_string(),
+            ));
+        }
         let RevokeAndAck {
             channel_id: _,
             revocation_partial_signature,
@@ -5550,7 +5728,7 @@ impl ChannelActorState {
             {
                 let capacity = self.get_total_reserved_ckb_amount() - commitment_tx_fee;
                 let output = CellOutput::new_builder()
-                    .lock(lock_script)
+                    .lock(lock_script.clone())
                     .type_(Some(udt_type_script.clone()).pack())
                     .capacity(capacity.pack())
                     .build();
@@ -5560,7 +5738,7 @@ impl ChannelActorState {
             } else {
                 let capacity = self.get_total_ckb_amount() - commitment_tx_fee;
                 let output = CellOutput::new_builder()
-                    .lock(lock_script)
+                    .lock(lock_script.clone())
                     .capacity(capacity.pack())
                     .build();
                 let output_data = Bytes::default();
@@ -5568,7 +5746,6 @@ impl ChannelActorState {
             };
 
             let commitment_number = self.get_local_commitment_number() - 1;
-
             let commitment_lock_script_args = [
                 &blake2b_256(x_only_aggregated_pubkey)[0..20],
                 self.get_delay_epoch_as_lock_args_bytes().as_slice(),
@@ -5584,7 +5761,9 @@ impl ChannelActorState {
                 ]
                 .concat(),
             );
+
             verify_ctx.verify(revocation_partial_signature, message.as_slice())?;
+
             let our_signature = sign_ctx.clone().sign(message.as_slice())?;
             let aggregated_signature = verify_ctx.aggregate_partial_signatures_for_msg(
                 [revocation_partial_signature, our_signature],
@@ -5640,15 +5819,7 @@ impl ChannelActorState {
         self.increment_local_commitment_number();
         self.append_remote_commitment_point(next_per_commitment_point);
 
-        let staging_tlcs = self.tlc_state.commit_local_tlcs();
-        for tlc in staging_tlcs {
-            if let TlcKind::RemoveTlc(remove_tlc) = tlc {
-                self.remove_tlc_with_reason(remove_tlc.tlc_id, &remove_tlc.reason)
-                    .expect("expect remove tlc successfully");
-            }
-        }
-        self.tlc_state.set_waiting_ack(false);
-
+        let need_commitment_signed = self.tlc_state.update_for_revoke_and_ack();
         network
             .send_message(NetworkActorMessage::new_notification(
                 NetworkServiceEvent::RevokeAndAckReceived(
@@ -5659,7 +5830,7 @@ impl ChannelActorState {
                 ),
             ))
             .expect(ASSUME_NETWORK_ACTOR_ALIVE);
-        Ok(())
+        Ok(need_commitment_signed)
     }
 
     fn handle_reestablish_channel_message(
@@ -5668,8 +5839,8 @@ impl ChannelActorState {
         network: &ActorRef<NetworkActorMessage>,
     ) -> ProcessingChannelResult {
         debug!(
-            "Handling reestablish channel message: {:?}, our commitment_numbers {:?}",
-            reestablish_channel, self.commitment_numbers,
+            "Handling reestablish channel message: {:?}, our commitment_numbers {:?} in channel state {:?}",
+            reestablish_channel, self.commitment_numbers, self.state
         );
         self.reestablishing = false;
         match self.state {
@@ -5684,32 +5855,34 @@ impl ChannelActorState {
                     // resend AddTlc, RemoveTlc and CommitmentSigned messages if needed
                     let mut need_resend_commitment_signed = false;
                     for info in self.tlc_state.all_tlcs() {
-                        if info.is_offered() {
-                            if info.created_at.get_local() >= acutal_local_commitment_number {
-                                // resend AddTlc message
-                                network
-                                    .send_message(NetworkActorMessage::new_command(
-                                        NetworkActorCommand::SendFiberMessage(
-                                            FiberMessageWithPeerId::new(
-                                                self.get_remote_peer_id(),
-                                                FiberMessage::add_tlc(AddTlc {
-                                                    channel_id: self.get_id(),
-                                                    tlc_id: info.tlc_id.into(),
-                                                    amount: info.amount,
-                                                    payment_hash: info.payment_hash,
-                                                    expiry: info.expiry,
-                                                    hash_algorithm: info.hash_algorithm,
-                                                    onion_packet: info.onion_packet.clone(),
-                                                }),
-                                            ),
+                        if info.is_offered()
+                            && matches!(info.outbound_status(), OutboundTlcStatus::LocalAnnounced)
+                        {
+                            // resend AddTlc message
+                            network
+                                .send_message(NetworkActorMessage::new_command(
+                                    NetworkActorCommand::SendFiberMessage(
+                                        FiberMessageWithPeerId::new(
+                                            self.get_remote_peer_id(),
+                                            FiberMessage::add_tlc(AddTlc {
+                                                channel_id: self.get_id(),
+                                                tlc_id: info.tlc_id.into(),
+                                                amount: info.amount,
+                                                payment_hash: info.payment_hash,
+                                                expiry: info.expiry,
+                                                hash_algorithm: info.hash_algorithm,
+                                                onion_packet: info.onion_packet.clone(),
+                                            }),
                                         ),
-                                    ))
-                                    .expect(ASSUME_NETWORK_ACTOR_ALIVE);
-
-                                need_resend_commitment_signed = true;
-                            }
-                        } else if let Some((commitment_number, remove_reason)) = &info.removed_at {
-                            if commitment_number.get_local() >= acutal_local_commitment_number {
+                                    ),
+                                ))
+                                .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+                            need_resend_commitment_signed = true;
+                            debug_event!(network, "resend add tlc");
+                        } else if let Some(remove_reason) = &info.removed_reason {
+                            if info.is_received()
+                                && matches!(info.inbound_status(), InboundTlcStatus::LocalRemoved)
+                            {
                                 // resend RemoveTlc message
                                 network
                                     .send_message(NetworkActorMessage::new_command(
@@ -5727,10 +5900,20 @@ impl ChannelActorState {
                                     .expect(ASSUME_NETWORK_ACTOR_ALIVE);
 
                                 need_resend_commitment_signed = true;
+                                debug_event!(network, "resend remove tlc");
                             }
                         }
                     }
-                    if need_resend_commitment_signed {
+                    // previous waiting_ack maybe true, reset it after reestablish the channel
+                    // if we need to resend CommitmentSigned message, it will be set to proper status again
+                    self.tlc_state.set_waiting_ack(false);
+                    debug!(
+                        "Resend AddTlc and RemoveTlc messages if needed: {}",
+                        need_resend_commitment_signed
+                    );
+                    if need_resend_commitment_signed
+                        || self.tlc_state.need_another_commitment_signed()
+                    {
                         debug!("Resend CommitmentSigned message");
                         network
                             .send_message(NetworkActorMessage::new_command(
@@ -5743,6 +5926,7 @@ impl ChannelActorState {
                     }
                 } else if acutal_local_commitment_number == expected_local_commitment_number + 1 {
                     // wait for remote to resend the RevokeAndAck message, do nothing here
+                    warn!("wait for remote to resend the RevokeAndAck message, do nothing here");
                 } else {
                     // unreachable state, just log an error for potential bugs
                     error!(
@@ -5760,6 +5944,17 @@ impl ChannelActorState {
                     // and resend the RevokeAndAck message.
                     self.set_remote_commitment_number(acutal_remote_commitment_number);
                     self.send_revoke_and_ack_message(network)?;
+                    let need_commitment_signed = self.tlc_state.update_for_commitment_signed();
+                    if need_commitment_signed {
+                        network
+                            .send_message(NetworkActorMessage::new_command(
+                                NetworkActorCommand::ControlFiberChannel(ChannelCommandWithId {
+                                    channel_id: self.get_id(),
+                                    command: ChannelCommand::CommitmentSigned(),
+                                }),
+                            ))
+                            .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+                    }
                 } else {
                     // unreachable state, just log an error for potential bugs
                     error!(
@@ -5767,6 +5962,8 @@ impl ChannelActorState {
                         expected_remote_commitment_number, acutal_remote_commitment_number
                     );
                 }
+
+                debug_event!(network, "Reestablished channel in ChannelReady");
             }
             _ => {
                 // TODO: @quake we need to handle other states.
@@ -6273,11 +6470,63 @@ impl ChannelActorState {
         &self,
         for_remote: bool,
     ) -> ([CellOutput; 2], [Bytes; 2]) {
-        let offered_fulfilled = self.get_pending_fulfilled_tlcs_amount(for_remote, true);
-        let received_fulfilled = self.get_pending_fulfilled_tlcs_amount(for_remote, false);
+        let pending_tlcs = self
+            .tlc_state
+            .offered_tlcs
+            .tlcs
+            .iter()
+            .filter(move |tlc| match tlc.outbound_status() {
+                OutboundTlcStatus::LocalAnnounced => for_remote,
+                OutboundTlcStatus::Committed => true,
+                OutboundTlcStatus::RemoteRemoved => true,
+                OutboundTlcStatus::RemoveWaitPrevAck => true,
+                OutboundTlcStatus::RemoveWaitAck => true,
+                OutboundTlcStatus::RemoveAckConfirmed => true,
+            })
+            .chain(self.tlc_state.received_tlcs.tlcs.iter().filter(move |tlc| {
+                match tlc.inbound_status() {
+                    InboundTlcStatus::RemoteAnnounced => !for_remote,
+                    InboundTlcStatus::AnnounceWaitPrevAck => !for_remote,
+                    InboundTlcStatus::AnnounceWaitAck => true,
+                    InboundTlcStatus::Committed => true,
+                    InboundTlcStatus::LocalRemoved => true,
+                    InboundTlcStatus::RemoveAckConfirmed => true,
+                }
+            }));
+
+        let mut offered_pending = 0;
+        let mut offered_fullfilled = 0;
+        let mut received_pending = 0;
+        let mut received_fullfilled = 0;
+        for info in pending_tlcs {
+            if info.is_offered() {
+                offered_pending += info.amount;
+                if (info.outbound_status() == OutboundTlcStatus::RemoveWaitAck
+                    || info.outbound_status() == OutboundTlcStatus::RemoveAckConfirmed)
+                    && info
+                        .removed_reason
+                        .as_ref()
+                        .map(|r| matches!(r, RemoveTlcReason::RemoveTlcFulfill(_)))
+                        .unwrap_or_default()
+                {
+                    offered_fullfilled += info.amount;
+                }
+            } else {
+                received_pending += info.amount;
+                if info.inbound_status() == InboundTlcStatus::RemoveAckConfirmed
+                    && info
+                        .removed_reason
+                        .as_ref()
+                        .map(|r| matches!(r, RemoveTlcReason::RemoveTlcFulfill(_)))
+                        .unwrap_or_default()
+                {
+                    received_fullfilled += info.amount;
+                }
+            }
+        }
+        let to_local_value = self.to_local_amount + received_fullfilled - offered_pending;
+        let to_remote_value = self.to_remote_amount + offered_fullfilled - received_pending;
 
-        let to_local_value = self.to_local_amount - offered_fulfilled + received_fulfilled;
-        let to_remote_value = self.to_remote_amount - received_fulfilled + offered_fulfilled;
         let commitment_tx_fee =
             calculate_commitment_tx_fee(self.commitment_fee_rate, &self.funding_udt_type_script);
 
diff --git a/src/fiber/config.rs b/src/fiber/config.rs
index a5c7b7222..911f60be1 100644
--- a/src/fiber/config.rs
+++ b/src/fiber/config.rs
@@ -89,7 +89,7 @@ pub struct FiberConfig {
     )]
     pub(crate) announce_listening_addr: Option<bool>,
 
-    /// whether to announce private address, this should be set to false unless you are running a private network or testing [default: false]
+    /// whether to announce or process private address, this should be set to false unless you are running a private network or testing [default: false]
     #[arg(
         name = "FIBER_ANNOUNCE_PRIVATE_ADDR",
         long = "fiber-announce-private-addr",
@@ -377,6 +377,10 @@ impl FiberConfig {
         self.announce_listening_addr.unwrap_or(false)
     }
 
+    pub fn announce_private_addr(&self) -> bool {
+        self.announce_private_addr.unwrap_or(false)
+    }
+
     pub fn open_channel_auto_accept_min_ckb_funding_amount(&self) -> u64 {
         self.open_channel_auto_accept_min_ckb_funding_amount
             .unwrap_or(DEFAULT_OPEN_CHANNEL_AUTO_ACCEPT_MIN_CKB_FUNDING_AMOUNT)
diff --git a/src/fiber/gen/fiber.rs b/src/fiber/gen/fiber.rs
index a553f2eed..16edafea5 100644
--- a/src/fiber/gen/fiber.rs
+++ b/src/fiber/gen/fiber.rs
@@ -3,6 +3,231 @@
 use super::blockchain::*;
 use molecule::prelude::*;
 #[derive(Clone)]
+pub struct Uint16(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for Uint16 {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for Uint16 {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for Uint16 {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        let raw_data = hex_string(&self.raw_data());
+        write!(f, "{}(0x{})", Self::NAME, raw_data)
+    }
+}
+impl ::core::default::Default for Uint16 {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        Uint16::new_unchecked(v)
+    }
+}
+impl Uint16 {
+    const DEFAULT_VALUE: [u8; 2] = [0, 0];
+    pub const TOTAL_SIZE: usize = 2;
+    pub const ITEM_SIZE: usize = 1;
+    pub const ITEM_COUNT: usize = 2;
+    pub fn nth0(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(0..1))
+    }
+    pub fn nth1(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(1..2))
+    }
+    pub fn raw_data(&self) -> molecule::bytes::Bytes {
+        self.as_bytes()
+    }
+    pub fn as_reader<'r>(&'r self) -> Uint16Reader<'r> {
+        Uint16Reader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for Uint16 {
+    type Builder = Uint16Builder;
+    const NAME: &'static str = "Uint16";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        Uint16(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        Uint16Reader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        Uint16Reader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().set([self.nth0(), self.nth1()])
+    }
+}
+#[derive(Clone, Copy)]
+pub struct Uint16Reader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for Uint16Reader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for Uint16Reader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for Uint16Reader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        let raw_data = hex_string(&self.raw_data());
+        write!(f, "{}(0x{})", Self::NAME, raw_data)
+    }
+}
+impl<'r> Uint16Reader<'r> {
+    pub const TOTAL_SIZE: usize = 2;
+    pub const ITEM_SIZE: usize = 1;
+    pub const ITEM_COUNT: usize = 2;
+    pub fn nth0(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[0..1])
+    }
+    pub fn nth1(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[1..2])
+    }
+    pub fn raw_data(&self) -> &'r [u8] {
+        self.as_slice()
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for Uint16Reader<'r> {
+    type Entity = Uint16;
+    const NAME: &'static str = "Uint16Reader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        Uint16Reader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], _compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len != Self::TOTAL_SIZE {
+            return ve!(Self, TotalSizeNotMatch, Self::TOTAL_SIZE, slice_len);
+        }
+        Ok(())
+    }
+}
+#[derive(Clone)]
+pub struct Uint16Builder(pub(crate) [Byte; 2]);
+impl ::core::fmt::Debug for Uint16Builder {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:?})", Self::NAME, &self.0[..])
+    }
+}
+impl ::core::default::Default for Uint16Builder {
+    fn default() -> Self {
+        Uint16Builder([Byte::default(), Byte::default()])
+    }
+}
+impl Uint16Builder {
+    pub const TOTAL_SIZE: usize = 2;
+    pub const ITEM_SIZE: usize = 1;
+    pub const ITEM_COUNT: usize = 2;
+    pub fn set(mut self, v: [Byte; 2]) -> Self {
+        self.0 = v;
+        self
+    }
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
+        self
+    }
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for Uint16Builder {
+    type Entity = Uint16;
+    const NAME: &'static str = "Uint16Builder";
+    fn expected_length(&self) -> usize {
+        Self::TOTAL_SIZE
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        writer.write_all(self.0[0].as_slice())?;
+        writer.write_all(self.0[1].as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        Uint16::new_unchecked(inner.into())
+    }
+}
+impl From<[Byte; 2usize]> for Uint16 {
+    fn from(value: [Byte; 2usize]) -> Self {
+        Self::new_builder().set(value).build()
+    }
+}
+impl ::core::convert::TryFrom<&[Byte]> for Uint16 {
+    type Error = ::core::array::TryFromSliceError;
+    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
+        Ok(Self::new_builder()
+            .set(<&[Byte; 2usize]>::try_from(value)?.clone())
+            .build())
+    }
+}
+impl From<Uint16> for [Byte; 2usize] {
+    #[track_caller]
+    fn from(value: Uint16) -> Self {
+        [value.nth0(), value.nth1()]
+    }
+}
+impl From<[u8; 2usize]> for Uint16 {
+    fn from(value: [u8; 2usize]) -> Self {
+        Uint16Reader::new_unchecked(&value).to_entity()
+    }
+}
+impl ::core::convert::TryFrom<&[u8]> for Uint16 {
+    type Error = ::core::array::TryFromSliceError;
+    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
+        Ok(<[u8; 2usize]>::try_from(value)?.into())
+    }
+}
+impl From<Uint16> for [u8; 2usize] {
+    #[track_caller]
+    fn from(value: Uint16) -> Self {
+        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
+    }
+}
+impl<'a> From<Uint16Reader<'a>> for &'a [u8; 2usize] {
+    #[track_caller]
+    fn from(value: Uint16Reader<'a>) -> Self {
+        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
+    }
+}
+impl<'a> From<&'a Uint16Reader<'a>> for &'a [u8; 2usize] {
+    #[track_caller]
+    fn from(value: &'a Uint16Reader<'a>) -> Self {
+        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
+    }
+}
+#[derive(Clone)]
 pub struct EcdsaSignature(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for EcdsaSignature {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -11764,3 +11989,2439 @@ impl From<AnnouncementSignatures> for FiberMessage {
         Self::new_builder().set(value).build()
     }
 }
+#[derive(Clone)]
+pub struct PaymentPreimageOpt(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for PaymentPreimageOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for PaymentPreimageOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for PaymentPreimageOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        if let Some(v) = self.to_opt() {
+            write!(f, "{}(Some({}))", Self::NAME, v)
+        } else {
+            write!(f, "{}(None)", Self::NAME)
+        }
+    }
+}
+impl ::core::default::Default for PaymentPreimageOpt {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        PaymentPreimageOpt::new_unchecked(v)
+    }
+}
+impl PaymentPreimageOpt {
+    const DEFAULT_VALUE: [u8; 0] = [];
+    pub fn is_none(&self) -> bool {
+        self.0.is_empty()
+    }
+    pub fn is_some(&self) -> bool {
+        !self.0.is_empty()
+    }
+    pub fn to_opt(&self) -> Option<Byte32> {
+        if self.is_none() {
+            None
+        } else {
+            Some(Byte32::new_unchecked(self.0.clone()))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> PaymentPreimageOptReader<'r> {
+        PaymentPreimageOptReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for PaymentPreimageOpt {
+    type Builder = PaymentPreimageOptBuilder;
+    const NAME: &'static str = "PaymentPreimageOpt";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        PaymentPreimageOpt(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        PaymentPreimageOptReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        PaymentPreimageOptReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().set(self.to_opt())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct PaymentPreimageOptReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for PaymentPreimageOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for PaymentPreimageOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for PaymentPreimageOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        if let Some(v) = self.to_opt() {
+            write!(f, "{}(Some({}))", Self::NAME, v)
+        } else {
+            write!(f, "{}(None)", Self::NAME)
+        }
+    }
+}
+impl<'r> PaymentPreimageOptReader<'r> {
+    pub fn is_none(&self) -> bool {
+        self.0.is_empty()
+    }
+    pub fn is_some(&self) -> bool {
+        !self.0.is_empty()
+    }
+    pub fn to_opt(&self) -> Option<Byte32Reader<'r>> {
+        if self.is_none() {
+            None
+        } else {
+            Some(Byte32Reader::new_unchecked(self.as_slice()))
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for PaymentPreimageOptReader<'r> {
+    type Entity = PaymentPreimageOpt;
+    const NAME: &'static str = "PaymentPreimageOptReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        PaymentPreimageOptReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        if !slice.is_empty() {
+            Byte32Reader::verify(&slice[..], compatible)?;
+        }
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct PaymentPreimageOptBuilder(pub(crate) Option<Byte32>);
+impl PaymentPreimageOptBuilder {
+    pub fn set(mut self, v: Option<Byte32>) -> Self {
+        self.0 = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for PaymentPreimageOptBuilder {
+    type Entity = PaymentPreimageOpt;
+    const NAME: &'static str = "PaymentPreimageOptBuilder";
+    fn expected_length(&self) -> usize {
+        self.0
+            .as_ref()
+            .map(|ref inner| inner.as_slice().len())
+            .unwrap_or(0)
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        self.0
+            .as_ref()
+            .map(|ref inner| writer.write_all(inner.as_slice()))
+            .unwrap_or(Ok(()))
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        PaymentPreimageOpt::new_unchecked(inner.into())
+    }
+}
+impl From<Byte32> for PaymentPreimageOpt {
+    fn from(value: Byte32) -> Self {
+        Self::new_builder().set(Some(value)).build()
+    }
+}
+#[derive(Clone)]
+pub struct PubkeyOpt(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for PubkeyOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for PubkeyOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for PubkeyOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        if let Some(v) = self.to_opt() {
+            write!(f, "{}(Some({}))", Self::NAME, v)
+        } else {
+            write!(f, "{}(None)", Self::NAME)
+        }
+    }
+}
+impl ::core::default::Default for PubkeyOpt {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        PubkeyOpt::new_unchecked(v)
+    }
+}
+impl PubkeyOpt {
+    const DEFAULT_VALUE: [u8; 0] = [];
+    pub fn is_none(&self) -> bool {
+        self.0.is_empty()
+    }
+    pub fn is_some(&self) -> bool {
+        !self.0.is_empty()
+    }
+    pub fn to_opt(&self) -> Option<Pubkey> {
+        if self.is_none() {
+            None
+        } else {
+            Some(Pubkey::new_unchecked(self.0.clone()))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> PubkeyOptReader<'r> {
+        PubkeyOptReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for PubkeyOpt {
+    type Builder = PubkeyOptBuilder;
+    const NAME: &'static str = "PubkeyOpt";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        PubkeyOpt(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        PubkeyOptReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        PubkeyOptReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().set(self.to_opt())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct PubkeyOptReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for PubkeyOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for PubkeyOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for PubkeyOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        if let Some(v) = self.to_opt() {
+            write!(f, "{}(Some({}))", Self::NAME, v)
+        } else {
+            write!(f, "{}(None)", Self::NAME)
+        }
+    }
+}
+impl<'r> PubkeyOptReader<'r> {
+    pub fn is_none(&self) -> bool {
+        self.0.is_empty()
+    }
+    pub fn is_some(&self) -> bool {
+        !self.0.is_empty()
+    }
+    pub fn to_opt(&self) -> Option<PubkeyReader<'r>> {
+        if self.is_none() {
+            None
+        } else {
+            Some(PubkeyReader::new_unchecked(self.as_slice()))
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for PubkeyOptReader<'r> {
+    type Entity = PubkeyOpt;
+    const NAME: &'static str = "PubkeyOptReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        PubkeyOptReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        if !slice.is_empty() {
+            PubkeyReader::verify(&slice[..], compatible)?;
+        }
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct PubkeyOptBuilder(pub(crate) Option<Pubkey>);
+impl PubkeyOptBuilder {
+    pub fn set(mut self, v: Option<Pubkey>) -> Self {
+        self.0 = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for PubkeyOptBuilder {
+    type Entity = PubkeyOpt;
+    const NAME: &'static str = "PubkeyOptBuilder";
+    fn expected_length(&self) -> usize {
+        self.0
+            .as_ref()
+            .map(|ref inner| inner.as_slice().len())
+            .unwrap_or(0)
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        self.0
+            .as_ref()
+            .map(|ref inner| writer.write_all(inner.as_slice()))
+            .unwrap_or(Ok(()))
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        PubkeyOpt::new_unchecked(inner.into())
+    }
+}
+impl From<Pubkey> for PubkeyOpt {
+    fn from(value: Pubkey) -> Self {
+        Self::new_builder().set(Some(value)).build()
+    }
+}
+#[derive(Clone)]
+pub struct PaymentHopData(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for PaymentHopData {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for PaymentHopData {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for PaymentHopData {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "amount", self.amount())?;
+        write!(f, ", {}: {}", "expiry", self.expiry())?;
+        write!(f, ", {}: {}", "payment_preimage", self.payment_preimage())?;
+        write!(f, ", {}: {}", "hash_algorithm", self.hash_algorithm())?;
+        write!(f, ", {}: {}", "funding_tx_hash", self.funding_tx_hash())?;
+        write!(f, ", {}: {}", "next_hop", self.next_hop())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl ::core::default::Default for PaymentHopData {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        PaymentHopData::new_unchecked(v)
+    }
+}
+impl PaymentHopData {
+    const DEFAULT_VALUE: [u8; 85] = [
+        85, 0, 0, 0, 28, 0, 0, 0, 44, 0, 0, 0, 52, 0, 0, 0, 52, 0, 0, 0, 53, 0, 0, 0, 85, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ];
+    pub const FIELD_COUNT: usize = 6;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn amount(&self) -> Uint128 {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        Uint128::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn expiry(&self) -> Uint64 {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        Uint64::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn payment_preimage(&self) -> PaymentPreimageOpt {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        let end = molecule::unpack_number(&slice[16..]) as usize;
+        PaymentPreimageOpt::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn hash_algorithm(&self) -> Byte {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[16..]) as usize;
+        let end = molecule::unpack_number(&slice[20..]) as usize;
+        Byte::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn funding_tx_hash(&self) -> Byte32 {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[20..]) as usize;
+        let end = molecule::unpack_number(&slice[24..]) as usize;
+        Byte32::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn next_hop(&self) -> PubkeyOpt {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[24..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[28..]) as usize;
+            PubkeyOpt::new_unchecked(self.0.slice(start..end))
+        } else {
+            PubkeyOpt::new_unchecked(self.0.slice(start..))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> PaymentHopDataReader<'r> {
+        PaymentHopDataReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for PaymentHopData {
+    type Builder = PaymentHopDataBuilder;
+    const NAME: &'static str = "PaymentHopData";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        PaymentHopData(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        PaymentHopDataReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        PaymentHopDataReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder()
+            .amount(self.amount())
+            .expiry(self.expiry())
+            .payment_preimage(self.payment_preimage())
+            .hash_algorithm(self.hash_algorithm())
+            .funding_tx_hash(self.funding_tx_hash())
+            .next_hop(self.next_hop())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct PaymentHopDataReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for PaymentHopDataReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for PaymentHopDataReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for PaymentHopDataReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "amount", self.amount())?;
+        write!(f, ", {}: {}", "expiry", self.expiry())?;
+        write!(f, ", {}: {}", "payment_preimage", self.payment_preimage())?;
+        write!(f, ", {}: {}", "hash_algorithm", self.hash_algorithm())?;
+        write!(f, ", {}: {}", "funding_tx_hash", self.funding_tx_hash())?;
+        write!(f, ", {}: {}", "next_hop", self.next_hop())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl<'r> PaymentHopDataReader<'r> {
+    pub const FIELD_COUNT: usize = 6;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn amount(&self) -> Uint128Reader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        Uint128Reader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn expiry(&self) -> Uint64Reader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn payment_preimage(&self) -> PaymentPreimageOptReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        let end = molecule::unpack_number(&slice[16..]) as usize;
+        PaymentPreimageOptReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn hash_algorithm(&self) -> ByteReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[16..]) as usize;
+        let end = molecule::unpack_number(&slice[20..]) as usize;
+        ByteReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn funding_tx_hash(&self) -> Byte32Reader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[20..]) as usize;
+        let end = molecule::unpack_number(&slice[24..]) as usize;
+        Byte32Reader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn next_hop(&self) -> PubkeyOptReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[24..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[28..]) as usize;
+            PubkeyOptReader::new_unchecked(&self.as_slice()[start..end])
+        } else {
+            PubkeyOptReader::new_unchecked(&self.as_slice()[start..])
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for PaymentHopDataReader<'r> {
+    type Entity = PaymentHopData;
+    const NAME: &'static str = "PaymentHopDataReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        PaymentHopDataReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let total_size = molecule::unpack_number(slice) as usize;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        if slice_len < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
+        }
+        let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
+        if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        if slice_len < offset_first {
+            return ve!(Self, HeaderIsBroken, offset_first, slice_len);
+        }
+        let field_count = offset_first / molecule::NUMBER_SIZE - 1;
+        if field_count < Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        } else if !compatible && field_count > Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        };
+        let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
+            .chunks_exact(molecule::NUMBER_SIZE)
+            .map(|x| molecule::unpack_number(x) as usize)
+            .collect();
+        offsets.push(total_size);
+        if offsets.windows(2).any(|i| i[0] > i[1]) {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        Uint128Reader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
+        Uint64Reader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
+        PaymentPreimageOptReader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
+        ByteReader::verify(&slice[offsets[3]..offsets[4]], compatible)?;
+        Byte32Reader::verify(&slice[offsets[4]..offsets[5]], compatible)?;
+        PubkeyOptReader::verify(&slice[offsets[5]..offsets[6]], compatible)?;
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct PaymentHopDataBuilder {
+    pub(crate) amount: Uint128,
+    pub(crate) expiry: Uint64,
+    pub(crate) payment_preimage: PaymentPreimageOpt,
+    pub(crate) hash_algorithm: Byte,
+    pub(crate) funding_tx_hash: Byte32,
+    pub(crate) next_hop: PubkeyOpt,
+}
+impl PaymentHopDataBuilder {
+    pub const FIELD_COUNT: usize = 6;
+    pub fn amount(mut self, v: Uint128) -> Self {
+        self.amount = v;
+        self
+    }
+    pub fn expiry(mut self, v: Uint64) -> Self {
+        self.expiry = v;
+        self
+    }
+    pub fn payment_preimage(mut self, v: PaymentPreimageOpt) -> Self {
+        self.payment_preimage = v;
+        self
+    }
+    pub fn hash_algorithm(mut self, v: Byte) -> Self {
+        self.hash_algorithm = v;
+        self
+    }
+    pub fn funding_tx_hash(mut self, v: Byte32) -> Self {
+        self.funding_tx_hash = v;
+        self
+    }
+    pub fn next_hop(mut self, v: PubkeyOpt) -> Self {
+        self.next_hop = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for PaymentHopDataBuilder {
+    type Entity = PaymentHopData;
+    const NAME: &'static str = "PaymentHopDataBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
+            + self.amount.as_slice().len()
+            + self.expiry.as_slice().len()
+            + self.payment_preimage.as_slice().len()
+            + self.hash_algorithm.as_slice().len()
+            + self.funding_tx_hash.as_slice().len()
+            + self.next_hop.as_slice().len()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
+        let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
+        offsets.push(total_size);
+        total_size += self.amount.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.expiry.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.payment_preimage.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.hash_algorithm.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.funding_tx_hash.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.next_hop.as_slice().len();
+        writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
+        for offset in offsets.into_iter() {
+            writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
+        }
+        writer.write_all(self.amount.as_slice())?;
+        writer.write_all(self.expiry.as_slice())?;
+        writer.write_all(self.payment_preimage.as_slice())?;
+        writer.write_all(self.hash_algorithm.as_slice())?;
+        writer.write_all(self.funding_tx_hash.as_slice())?;
+        writer.write_all(self.next_hop.as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        PaymentHopData::new_unchecked(inner.into())
+    }
+}
+#[derive(Clone)]
+pub struct ChannelUpdate(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for ChannelUpdate {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for ChannelUpdate {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for ChannelUpdate {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "signature", self.signature())?;
+        write!(f, ", {}: {}", "chain_hash", self.chain_hash())?;
+        write!(f, ", {}: {}", "channel_outpoint", self.channel_outpoint())?;
+        write!(f, ", {}: {}", "timestamp", self.timestamp())?;
+        write!(f, ", {}: {}", "message_flags", self.message_flags())?;
+        write!(f, ", {}: {}", "channel_flags", self.channel_flags())?;
+        write!(f, ", {}: {}", "tlc_expiry_delta", self.tlc_expiry_delta())?;
+        write!(f, ", {}: {}", "tlc_minimum_value", self.tlc_minimum_value())?;
+        write!(f, ", {}: {}", "tlc_maximum_value", self.tlc_maximum_value())?;
+        write!(
+            f,
+            ", {}: {}",
+            "tlc_fee_proportional_millionths",
+            self.tlc_fee_proportional_millionths()
+        )?;
+        write!(f, " }}")
+    }
+}
+impl ::core::default::Default for ChannelUpdate {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        ChannelUpdate::new_unchecked(v)
+    }
+}
+impl ChannelUpdate {
+    const DEFAULT_VALUE: [u8; 204] = [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ];
+    pub const TOTAL_SIZE: usize = 204;
+    pub const FIELD_SIZES: [usize; 10] = [64, 32, 36, 8, 4, 4, 8, 16, 16, 16];
+    pub const FIELD_COUNT: usize = 10;
+    pub fn signature(&self) -> EcdsaSignature {
+        EcdsaSignature::new_unchecked(self.0.slice(0..64))
+    }
+    pub fn chain_hash(&self) -> Byte32 {
+        Byte32::new_unchecked(self.0.slice(64..96))
+    }
+    pub fn channel_outpoint(&self) -> OutPoint {
+        OutPoint::new_unchecked(self.0.slice(96..132))
+    }
+    pub fn timestamp(&self) -> Uint64 {
+        Uint64::new_unchecked(self.0.slice(132..140))
+    }
+    pub fn message_flags(&self) -> Uint32 {
+        Uint32::new_unchecked(self.0.slice(140..144))
+    }
+    pub fn channel_flags(&self) -> Uint32 {
+        Uint32::new_unchecked(self.0.slice(144..148))
+    }
+    pub fn tlc_expiry_delta(&self) -> Uint64 {
+        Uint64::new_unchecked(self.0.slice(148..156))
+    }
+    pub fn tlc_minimum_value(&self) -> Uint128 {
+        Uint128::new_unchecked(self.0.slice(156..172))
+    }
+    pub fn tlc_maximum_value(&self) -> Uint128 {
+        Uint128::new_unchecked(self.0.slice(172..188))
+    }
+    pub fn tlc_fee_proportional_millionths(&self) -> Uint128 {
+        Uint128::new_unchecked(self.0.slice(188..204))
+    }
+    pub fn as_reader<'r>(&'r self) -> ChannelUpdateReader<'r> {
+        ChannelUpdateReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for ChannelUpdate {
+    type Builder = ChannelUpdateBuilder;
+    const NAME: &'static str = "ChannelUpdate";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        ChannelUpdate(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        ChannelUpdateReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        ChannelUpdateReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder()
+            .signature(self.signature())
+            .chain_hash(self.chain_hash())
+            .channel_outpoint(self.channel_outpoint())
+            .timestamp(self.timestamp())
+            .message_flags(self.message_flags())
+            .channel_flags(self.channel_flags())
+            .tlc_expiry_delta(self.tlc_expiry_delta())
+            .tlc_minimum_value(self.tlc_minimum_value())
+            .tlc_maximum_value(self.tlc_maximum_value())
+            .tlc_fee_proportional_millionths(self.tlc_fee_proportional_millionths())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct ChannelUpdateReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for ChannelUpdateReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for ChannelUpdateReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for ChannelUpdateReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "signature", self.signature())?;
+        write!(f, ", {}: {}", "chain_hash", self.chain_hash())?;
+        write!(f, ", {}: {}", "channel_outpoint", self.channel_outpoint())?;
+        write!(f, ", {}: {}", "timestamp", self.timestamp())?;
+        write!(f, ", {}: {}", "message_flags", self.message_flags())?;
+        write!(f, ", {}: {}", "channel_flags", self.channel_flags())?;
+        write!(f, ", {}: {}", "tlc_expiry_delta", self.tlc_expiry_delta())?;
+        write!(f, ", {}: {}", "tlc_minimum_value", self.tlc_minimum_value())?;
+        write!(f, ", {}: {}", "tlc_maximum_value", self.tlc_maximum_value())?;
+        write!(
+            f,
+            ", {}: {}",
+            "tlc_fee_proportional_millionths",
+            self.tlc_fee_proportional_millionths()
+        )?;
+        write!(f, " }}")
+    }
+}
+impl<'r> ChannelUpdateReader<'r> {
+    pub const TOTAL_SIZE: usize = 204;
+    pub const FIELD_SIZES: [usize; 10] = [64, 32, 36, 8, 4, 4, 8, 16, 16, 16];
+    pub const FIELD_COUNT: usize = 10;
+    pub fn signature(&self) -> EcdsaSignatureReader<'r> {
+        EcdsaSignatureReader::new_unchecked(&self.as_slice()[0..64])
+    }
+    pub fn chain_hash(&self) -> Byte32Reader<'r> {
+        Byte32Reader::new_unchecked(&self.as_slice()[64..96])
+    }
+    pub fn channel_outpoint(&self) -> OutPointReader<'r> {
+        OutPointReader::new_unchecked(&self.as_slice()[96..132])
+    }
+    pub fn timestamp(&self) -> Uint64Reader<'r> {
+        Uint64Reader::new_unchecked(&self.as_slice()[132..140])
+    }
+    pub fn message_flags(&self) -> Uint32Reader<'r> {
+        Uint32Reader::new_unchecked(&self.as_slice()[140..144])
+    }
+    pub fn channel_flags(&self) -> Uint32Reader<'r> {
+        Uint32Reader::new_unchecked(&self.as_slice()[144..148])
+    }
+    pub fn tlc_expiry_delta(&self) -> Uint64Reader<'r> {
+        Uint64Reader::new_unchecked(&self.as_slice()[148..156])
+    }
+    pub fn tlc_minimum_value(&self) -> Uint128Reader<'r> {
+        Uint128Reader::new_unchecked(&self.as_slice()[156..172])
+    }
+    pub fn tlc_maximum_value(&self) -> Uint128Reader<'r> {
+        Uint128Reader::new_unchecked(&self.as_slice()[172..188])
+    }
+    pub fn tlc_fee_proportional_millionths(&self) -> Uint128Reader<'r> {
+        Uint128Reader::new_unchecked(&self.as_slice()[188..204])
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for ChannelUpdateReader<'r> {
+    type Entity = ChannelUpdate;
+    const NAME: &'static str = "ChannelUpdateReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        ChannelUpdateReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], _compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len != Self::TOTAL_SIZE {
+            return ve!(Self, TotalSizeNotMatch, Self::TOTAL_SIZE, slice_len);
+        }
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct ChannelUpdateBuilder {
+    pub(crate) signature: EcdsaSignature,
+    pub(crate) chain_hash: Byte32,
+    pub(crate) channel_outpoint: OutPoint,
+    pub(crate) timestamp: Uint64,
+    pub(crate) message_flags: Uint32,
+    pub(crate) channel_flags: Uint32,
+    pub(crate) tlc_expiry_delta: Uint64,
+    pub(crate) tlc_minimum_value: Uint128,
+    pub(crate) tlc_maximum_value: Uint128,
+    pub(crate) tlc_fee_proportional_millionths: Uint128,
+}
+impl ChannelUpdateBuilder {
+    pub const TOTAL_SIZE: usize = 204;
+    pub const FIELD_SIZES: [usize; 10] = [64, 32, 36, 8, 4, 4, 8, 16, 16, 16];
+    pub const FIELD_COUNT: usize = 10;
+    pub fn signature(mut self, v: EcdsaSignature) -> Self {
+        self.signature = v;
+        self
+    }
+    pub fn chain_hash(mut self, v: Byte32) -> Self {
+        self.chain_hash = v;
+        self
+    }
+    pub fn channel_outpoint(mut self, v: OutPoint) -> Self {
+        self.channel_outpoint = v;
+        self
+    }
+    pub fn timestamp(mut self, v: Uint64) -> Self {
+        self.timestamp = v;
+        self
+    }
+    pub fn message_flags(mut self, v: Uint32) -> Self {
+        self.message_flags = v;
+        self
+    }
+    pub fn channel_flags(mut self, v: Uint32) -> Self {
+        self.channel_flags = v;
+        self
+    }
+    pub fn tlc_expiry_delta(mut self, v: Uint64) -> Self {
+        self.tlc_expiry_delta = v;
+        self
+    }
+    pub fn tlc_minimum_value(mut self, v: Uint128) -> Self {
+        self.tlc_minimum_value = v;
+        self
+    }
+    pub fn tlc_maximum_value(mut self, v: Uint128) -> Self {
+        self.tlc_maximum_value = v;
+        self
+    }
+    pub fn tlc_fee_proportional_millionths(mut self, v: Uint128) -> Self {
+        self.tlc_fee_proportional_millionths = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for ChannelUpdateBuilder {
+    type Entity = ChannelUpdate;
+    const NAME: &'static str = "ChannelUpdateBuilder";
+    fn expected_length(&self) -> usize {
+        Self::TOTAL_SIZE
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        writer.write_all(self.signature.as_slice())?;
+        writer.write_all(self.chain_hash.as_slice())?;
+        writer.write_all(self.channel_outpoint.as_slice())?;
+        writer.write_all(self.timestamp.as_slice())?;
+        writer.write_all(self.message_flags.as_slice())?;
+        writer.write_all(self.channel_flags.as_slice())?;
+        writer.write_all(self.tlc_expiry_delta.as_slice())?;
+        writer.write_all(self.tlc_minimum_value.as_slice())?;
+        writer.write_all(self.tlc_maximum_value.as_slice())?;
+        writer.write_all(self.tlc_fee_proportional_millionths.as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        ChannelUpdate::new_unchecked(inner.into())
+    }
+}
+#[derive(Clone)]
+pub struct ChannelUpdateOpt(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for ChannelUpdateOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for ChannelUpdateOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for ChannelUpdateOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        if let Some(v) = self.to_opt() {
+            write!(f, "{}(Some({}))", Self::NAME, v)
+        } else {
+            write!(f, "{}(None)", Self::NAME)
+        }
+    }
+}
+impl ::core::default::Default for ChannelUpdateOpt {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        ChannelUpdateOpt::new_unchecked(v)
+    }
+}
+impl ChannelUpdateOpt {
+    const DEFAULT_VALUE: [u8; 0] = [];
+    pub fn is_none(&self) -> bool {
+        self.0.is_empty()
+    }
+    pub fn is_some(&self) -> bool {
+        !self.0.is_empty()
+    }
+    pub fn to_opt(&self) -> Option<ChannelUpdate> {
+        if self.is_none() {
+            None
+        } else {
+            Some(ChannelUpdate::new_unchecked(self.0.clone()))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> ChannelUpdateOptReader<'r> {
+        ChannelUpdateOptReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for ChannelUpdateOpt {
+    type Builder = ChannelUpdateOptBuilder;
+    const NAME: &'static str = "ChannelUpdateOpt";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        ChannelUpdateOpt(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        ChannelUpdateOptReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        ChannelUpdateOptReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().set(self.to_opt())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct ChannelUpdateOptReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for ChannelUpdateOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for ChannelUpdateOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for ChannelUpdateOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        if let Some(v) = self.to_opt() {
+            write!(f, "{}(Some({}))", Self::NAME, v)
+        } else {
+            write!(f, "{}(None)", Self::NAME)
+        }
+    }
+}
+impl<'r> ChannelUpdateOptReader<'r> {
+    pub fn is_none(&self) -> bool {
+        self.0.is_empty()
+    }
+    pub fn is_some(&self) -> bool {
+        !self.0.is_empty()
+    }
+    pub fn to_opt(&self) -> Option<ChannelUpdateReader<'r>> {
+        if self.is_none() {
+            None
+        } else {
+            Some(ChannelUpdateReader::new_unchecked(self.as_slice()))
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for ChannelUpdateOptReader<'r> {
+    type Entity = ChannelUpdateOpt;
+    const NAME: &'static str = "ChannelUpdateOptReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        ChannelUpdateOptReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        if !slice.is_empty() {
+            ChannelUpdateReader::verify(&slice[..], compatible)?;
+        }
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct ChannelUpdateOptBuilder(pub(crate) Option<ChannelUpdate>);
+impl ChannelUpdateOptBuilder {
+    pub fn set(mut self, v: Option<ChannelUpdate>) -> Self {
+        self.0 = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for ChannelUpdateOptBuilder {
+    type Entity = ChannelUpdateOpt;
+    const NAME: &'static str = "ChannelUpdateOptBuilder";
+    fn expected_length(&self) -> usize {
+        self.0
+            .as_ref()
+            .map(|ref inner| inner.as_slice().len())
+            .unwrap_or(0)
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        self.0
+            .as_ref()
+            .map(|ref inner| writer.write_all(inner.as_slice()))
+            .unwrap_or(Ok(()))
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        ChannelUpdateOpt::new_unchecked(inner.into())
+    }
+}
+impl From<ChannelUpdate> for ChannelUpdateOpt {
+    fn from(value: ChannelUpdate) -> Self {
+        Self::new_builder().set(Some(value)).build()
+    }
+}
+#[derive(Clone)]
+pub struct ChannelFailed(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for ChannelFailed {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for ChannelFailed {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for ChannelFailed {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "channel_outpoint", self.channel_outpoint())?;
+        write!(f, ", {}: {}", "channel_update", self.channel_update())?;
+        write!(f, ", {}: {}", "node_id", self.node_id())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl ::core::default::Default for ChannelFailed {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        ChannelFailed::new_unchecked(v)
+    }
+}
+impl ChannelFailed {
+    const DEFAULT_VALUE: [u8; 85] = [
+        85, 0, 0, 0, 16, 0, 0, 0, 52, 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ];
+    pub const FIELD_COUNT: usize = 3;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn channel_outpoint(&self) -> OutPoint {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        OutPoint::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn channel_update(&self) -> ChannelUpdateOpt {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        ChannelUpdateOpt::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn node_id(&self) -> Pubkey {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[16..]) as usize;
+            Pubkey::new_unchecked(self.0.slice(start..end))
+        } else {
+            Pubkey::new_unchecked(self.0.slice(start..))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> ChannelFailedReader<'r> {
+        ChannelFailedReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for ChannelFailed {
+    type Builder = ChannelFailedBuilder;
+    const NAME: &'static str = "ChannelFailed";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        ChannelFailed(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        ChannelFailedReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        ChannelFailedReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder()
+            .channel_outpoint(self.channel_outpoint())
+            .channel_update(self.channel_update())
+            .node_id(self.node_id())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct ChannelFailedReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for ChannelFailedReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for ChannelFailedReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for ChannelFailedReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "channel_outpoint", self.channel_outpoint())?;
+        write!(f, ", {}: {}", "channel_update", self.channel_update())?;
+        write!(f, ", {}: {}", "node_id", self.node_id())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl<'r> ChannelFailedReader<'r> {
+    pub const FIELD_COUNT: usize = 3;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn channel_outpoint(&self) -> OutPointReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        OutPointReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn channel_update(&self) -> ChannelUpdateOptReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        ChannelUpdateOptReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn node_id(&self) -> PubkeyReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[16..]) as usize;
+            PubkeyReader::new_unchecked(&self.as_slice()[start..end])
+        } else {
+            PubkeyReader::new_unchecked(&self.as_slice()[start..])
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for ChannelFailedReader<'r> {
+    type Entity = ChannelFailed;
+    const NAME: &'static str = "ChannelFailedReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        ChannelFailedReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let total_size = molecule::unpack_number(slice) as usize;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        if slice_len < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
+        }
+        let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
+        if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        if slice_len < offset_first {
+            return ve!(Self, HeaderIsBroken, offset_first, slice_len);
+        }
+        let field_count = offset_first / molecule::NUMBER_SIZE - 1;
+        if field_count < Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        } else if !compatible && field_count > Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        };
+        let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
+            .chunks_exact(molecule::NUMBER_SIZE)
+            .map(|x| molecule::unpack_number(x) as usize)
+            .collect();
+        offsets.push(total_size);
+        if offsets.windows(2).any(|i| i[0] > i[1]) {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        OutPointReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
+        ChannelUpdateOptReader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
+        PubkeyReader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct ChannelFailedBuilder {
+    pub(crate) channel_outpoint: OutPoint,
+    pub(crate) channel_update: ChannelUpdateOpt,
+    pub(crate) node_id: Pubkey,
+}
+impl ChannelFailedBuilder {
+    pub const FIELD_COUNT: usize = 3;
+    pub fn channel_outpoint(mut self, v: OutPoint) -> Self {
+        self.channel_outpoint = v;
+        self
+    }
+    pub fn channel_update(mut self, v: ChannelUpdateOpt) -> Self {
+        self.channel_update = v;
+        self
+    }
+    pub fn node_id(mut self, v: Pubkey) -> Self {
+        self.node_id = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for ChannelFailedBuilder {
+    type Entity = ChannelFailed;
+    const NAME: &'static str = "ChannelFailedBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
+            + self.channel_outpoint.as_slice().len()
+            + self.channel_update.as_slice().len()
+            + self.node_id.as_slice().len()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
+        let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
+        offsets.push(total_size);
+        total_size += self.channel_outpoint.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.channel_update.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.node_id.as_slice().len();
+        writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
+        for offset in offsets.into_iter() {
+            writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
+        }
+        writer.write_all(self.channel_outpoint.as_slice())?;
+        writer.write_all(self.channel_update.as_slice())?;
+        writer.write_all(self.node_id.as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        ChannelFailed::new_unchecked(inner.into())
+    }
+}
+#[derive(Clone)]
+pub struct NodeFailed(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for NodeFailed {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for NodeFailed {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for NodeFailed {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "node_id", self.node_id())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl ::core::default::Default for NodeFailed {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        NodeFailed::new_unchecked(v)
+    }
+}
+impl NodeFailed {
+    const DEFAULT_VALUE: [u8; 41] = [
+        41, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ];
+    pub const FIELD_COUNT: usize = 1;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn node_id(&self) -> Pubkey {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[8..]) as usize;
+            Pubkey::new_unchecked(self.0.slice(start..end))
+        } else {
+            Pubkey::new_unchecked(self.0.slice(start..))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> NodeFailedReader<'r> {
+        NodeFailedReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for NodeFailed {
+    type Builder = NodeFailedBuilder;
+    const NAME: &'static str = "NodeFailed";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        NodeFailed(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        NodeFailedReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        NodeFailedReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().node_id(self.node_id())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct NodeFailedReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for NodeFailedReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for NodeFailedReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for NodeFailedReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "node_id", self.node_id())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl<'r> NodeFailedReader<'r> {
+    pub const FIELD_COUNT: usize = 1;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn node_id(&self) -> PubkeyReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[8..]) as usize;
+            PubkeyReader::new_unchecked(&self.as_slice()[start..end])
+        } else {
+            PubkeyReader::new_unchecked(&self.as_slice()[start..])
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for NodeFailedReader<'r> {
+    type Entity = NodeFailed;
+    const NAME: &'static str = "NodeFailedReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        NodeFailedReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let total_size = molecule::unpack_number(slice) as usize;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        if slice_len < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
+        }
+        let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
+        if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        if slice_len < offset_first {
+            return ve!(Self, HeaderIsBroken, offset_first, slice_len);
+        }
+        let field_count = offset_first / molecule::NUMBER_SIZE - 1;
+        if field_count < Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        } else if !compatible && field_count > Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        };
+        let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
+            .chunks_exact(molecule::NUMBER_SIZE)
+            .map(|x| molecule::unpack_number(x) as usize)
+            .collect();
+        offsets.push(total_size);
+        if offsets.windows(2).any(|i| i[0] > i[1]) {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        PubkeyReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct NodeFailedBuilder {
+    pub(crate) node_id: Pubkey,
+}
+impl NodeFailedBuilder {
+    pub const FIELD_COUNT: usize = 1;
+    pub fn node_id(mut self, v: Pubkey) -> Self {
+        self.node_id = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for NodeFailedBuilder {
+    type Entity = NodeFailed;
+    const NAME: &'static str = "NodeFailedBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1) + self.node_id.as_slice().len()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
+        let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
+        offsets.push(total_size);
+        total_size += self.node_id.as_slice().len();
+        writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
+        for offset in offsets.into_iter() {
+            writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
+        }
+        writer.write_all(self.node_id.as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        NodeFailed::new_unchecked(inner.into())
+    }
+}
+#[derive(Clone)]
+pub struct TlcErrData(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for TlcErrData {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for TlcErrData {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for TlcErrData {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}(", Self::NAME)?;
+        self.to_enum().display_inner(f)?;
+        write!(f, ")")
+    }
+}
+impl ::core::default::Default for TlcErrData {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        TlcErrData::new_unchecked(v)
+    }
+}
+impl TlcErrData {
+    const DEFAULT_VALUE: [u8; 89] = [
+        0, 0, 0, 0, 85, 0, 0, 0, 16, 0, 0, 0, 52, 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ];
+    pub const ITEMS_COUNT: usize = 2;
+    pub fn item_id(&self) -> molecule::Number {
+        molecule::unpack_number(self.as_slice())
+    }
+    pub fn to_enum(&self) -> TlcErrDataUnion {
+        let inner = self.0.slice(molecule::NUMBER_SIZE..);
+        match self.item_id() {
+            0 => ChannelFailed::new_unchecked(inner).into(),
+            1 => NodeFailed::new_unchecked(inner).into(),
+            _ => panic!("{}: invalid data", Self::NAME),
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> TlcErrDataReader<'r> {
+        TlcErrDataReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for TlcErrData {
+    type Builder = TlcErrDataBuilder;
+    const NAME: &'static str = "TlcErrData";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        TlcErrData(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        TlcErrDataReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        TlcErrDataReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().set(self.to_enum())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct TlcErrDataReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for TlcErrDataReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for TlcErrDataReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for TlcErrDataReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}(", Self::NAME)?;
+        self.to_enum().display_inner(f)?;
+        write!(f, ")")
+    }
+}
+impl<'r> TlcErrDataReader<'r> {
+    pub const ITEMS_COUNT: usize = 2;
+    pub fn item_id(&self) -> molecule::Number {
+        molecule::unpack_number(self.as_slice())
+    }
+    pub fn to_enum(&self) -> TlcErrDataUnionReader<'r> {
+        let inner = &self.as_slice()[molecule::NUMBER_SIZE..];
+        match self.item_id() {
+            0 => ChannelFailedReader::new_unchecked(inner).into(),
+            1 => NodeFailedReader::new_unchecked(inner).into(),
+            _ => panic!("{}: invalid data", Self::NAME),
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for TlcErrDataReader<'r> {
+    type Entity = TlcErrData;
+    const NAME: &'static str = "TlcErrDataReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        TlcErrDataReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let item_id = molecule::unpack_number(slice);
+        let inner_slice = &slice[molecule::NUMBER_SIZE..];
+        match item_id {
+            0 => ChannelFailedReader::verify(inner_slice, compatible),
+            1 => NodeFailedReader::verify(inner_slice, compatible),
+            _ => ve!(Self, UnknownItem, Self::ITEMS_COUNT, item_id),
+        }?;
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct TlcErrDataBuilder(pub(crate) TlcErrDataUnion);
+impl TlcErrDataBuilder {
+    pub const ITEMS_COUNT: usize = 2;
+    pub fn set<I>(mut self, v: I) -> Self
+    where
+        I: ::core::convert::Into<TlcErrDataUnion>,
+    {
+        self.0 = v.into();
+        self
+    }
+}
+impl molecule::prelude::Builder for TlcErrDataBuilder {
+    type Entity = TlcErrData;
+    const NAME: &'static str = "TlcErrDataBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE + self.0.as_slice().len()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        writer.write_all(&molecule::pack_number(self.0.item_id()))?;
+        writer.write_all(self.0.as_slice())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        TlcErrData::new_unchecked(inner.into())
+    }
+}
+#[derive(Debug, Clone)]
+pub enum TlcErrDataUnion {
+    ChannelFailed(ChannelFailed),
+    NodeFailed(NodeFailed),
+}
+#[derive(Debug, Clone, Copy)]
+pub enum TlcErrDataUnionReader<'r> {
+    ChannelFailed(ChannelFailedReader<'r>),
+    NodeFailed(NodeFailedReader<'r>),
+}
+impl ::core::default::Default for TlcErrDataUnion {
+    fn default() -> Self {
+        TlcErrDataUnion::ChannelFailed(::core::default::Default::default())
+    }
+}
+impl ::core::fmt::Display for TlcErrDataUnion {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        match self {
+            TlcErrDataUnion::ChannelFailed(ref item) => {
+                write!(f, "{}::{}({})", Self::NAME, ChannelFailed::NAME, item)
+            }
+            TlcErrDataUnion::NodeFailed(ref item) => {
+                write!(f, "{}::{}({})", Self::NAME, NodeFailed::NAME, item)
+            }
+        }
+    }
+}
+impl<'r> ::core::fmt::Display for TlcErrDataUnionReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        match self {
+            TlcErrDataUnionReader::ChannelFailed(ref item) => {
+                write!(f, "{}::{}({})", Self::NAME, ChannelFailed::NAME, item)
+            }
+            TlcErrDataUnionReader::NodeFailed(ref item) => {
+                write!(f, "{}::{}({})", Self::NAME, NodeFailed::NAME, item)
+            }
+        }
+    }
+}
+impl TlcErrDataUnion {
+    pub(crate) fn display_inner(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        match self {
+            TlcErrDataUnion::ChannelFailed(ref item) => write!(f, "{}", item),
+            TlcErrDataUnion::NodeFailed(ref item) => write!(f, "{}", item),
+        }
+    }
+}
+impl<'r> TlcErrDataUnionReader<'r> {
+    pub(crate) fn display_inner(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        match self {
+            TlcErrDataUnionReader::ChannelFailed(ref item) => write!(f, "{}", item),
+            TlcErrDataUnionReader::NodeFailed(ref item) => write!(f, "{}", item),
+        }
+    }
+}
+impl ::core::convert::From<ChannelFailed> for TlcErrDataUnion {
+    fn from(item: ChannelFailed) -> Self {
+        TlcErrDataUnion::ChannelFailed(item)
+    }
+}
+impl ::core::convert::From<NodeFailed> for TlcErrDataUnion {
+    fn from(item: NodeFailed) -> Self {
+        TlcErrDataUnion::NodeFailed(item)
+    }
+}
+impl<'r> ::core::convert::From<ChannelFailedReader<'r>> for TlcErrDataUnionReader<'r> {
+    fn from(item: ChannelFailedReader<'r>) -> Self {
+        TlcErrDataUnionReader::ChannelFailed(item)
+    }
+}
+impl<'r> ::core::convert::From<NodeFailedReader<'r>> for TlcErrDataUnionReader<'r> {
+    fn from(item: NodeFailedReader<'r>) -> Self {
+        TlcErrDataUnionReader::NodeFailed(item)
+    }
+}
+impl TlcErrDataUnion {
+    pub const NAME: &'static str = "TlcErrDataUnion";
+    pub fn as_bytes(&self) -> molecule::bytes::Bytes {
+        match self {
+            TlcErrDataUnion::ChannelFailed(item) => item.as_bytes(),
+            TlcErrDataUnion::NodeFailed(item) => item.as_bytes(),
+        }
+    }
+    pub fn as_slice(&self) -> &[u8] {
+        match self {
+            TlcErrDataUnion::ChannelFailed(item) => item.as_slice(),
+            TlcErrDataUnion::NodeFailed(item) => item.as_slice(),
+        }
+    }
+    pub fn item_id(&self) -> molecule::Number {
+        match self {
+            TlcErrDataUnion::ChannelFailed(_) => 0,
+            TlcErrDataUnion::NodeFailed(_) => 1,
+        }
+    }
+    pub fn item_name(&self) -> &str {
+        match self {
+            TlcErrDataUnion::ChannelFailed(_) => "ChannelFailed",
+            TlcErrDataUnion::NodeFailed(_) => "NodeFailed",
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> TlcErrDataUnionReader<'r> {
+        match self {
+            TlcErrDataUnion::ChannelFailed(item) => item.as_reader().into(),
+            TlcErrDataUnion::NodeFailed(item) => item.as_reader().into(),
+        }
+    }
+}
+impl<'r> TlcErrDataUnionReader<'r> {
+    pub const NAME: &'r str = "TlcErrDataUnionReader";
+    pub fn as_slice(&self) -> &'r [u8] {
+        match self {
+            TlcErrDataUnionReader::ChannelFailed(item) => item.as_slice(),
+            TlcErrDataUnionReader::NodeFailed(item) => item.as_slice(),
+        }
+    }
+    pub fn item_id(&self) -> molecule::Number {
+        match self {
+            TlcErrDataUnionReader::ChannelFailed(_) => 0,
+            TlcErrDataUnionReader::NodeFailed(_) => 1,
+        }
+    }
+    pub fn item_name(&self) -> &str {
+        match self {
+            TlcErrDataUnionReader::ChannelFailed(_) => "ChannelFailed",
+            TlcErrDataUnionReader::NodeFailed(_) => "NodeFailed",
+        }
+    }
+}
+impl From<ChannelFailed> for TlcErrData {
+    fn from(value: ChannelFailed) -> Self {
+        Self::new_builder().set(value).build()
+    }
+}
+impl From<NodeFailed> for TlcErrData {
+    fn from(value: NodeFailed) -> Self {
+        Self::new_builder().set(value).build()
+    }
+}
+#[derive(Clone)]
+pub struct TlcErrDataOpt(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for TlcErrDataOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for TlcErrDataOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for TlcErrDataOpt {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        if let Some(v) = self.to_opt() {
+            write!(f, "{}(Some({}))", Self::NAME, v)
+        } else {
+            write!(f, "{}(None)", Self::NAME)
+        }
+    }
+}
+impl ::core::default::Default for TlcErrDataOpt {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        TlcErrDataOpt::new_unchecked(v)
+    }
+}
+impl TlcErrDataOpt {
+    const DEFAULT_VALUE: [u8; 0] = [];
+    pub fn is_none(&self) -> bool {
+        self.0.is_empty()
+    }
+    pub fn is_some(&self) -> bool {
+        !self.0.is_empty()
+    }
+    pub fn to_opt(&self) -> Option<TlcErrData> {
+        if self.is_none() {
+            None
+        } else {
+            Some(TlcErrData::new_unchecked(self.0.clone()))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> TlcErrDataOptReader<'r> {
+        TlcErrDataOptReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for TlcErrDataOpt {
+    type Builder = TlcErrDataOptBuilder;
+    const NAME: &'static str = "TlcErrDataOpt";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        TlcErrDataOpt(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        TlcErrDataOptReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        TlcErrDataOptReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().set(self.to_opt())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct TlcErrDataOptReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for TlcErrDataOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for TlcErrDataOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for TlcErrDataOptReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        if let Some(v) = self.to_opt() {
+            write!(f, "{}(Some({}))", Self::NAME, v)
+        } else {
+            write!(f, "{}(None)", Self::NAME)
+        }
+    }
+}
+impl<'r> TlcErrDataOptReader<'r> {
+    pub fn is_none(&self) -> bool {
+        self.0.is_empty()
+    }
+    pub fn is_some(&self) -> bool {
+        !self.0.is_empty()
+    }
+    pub fn to_opt(&self) -> Option<TlcErrDataReader<'r>> {
+        if self.is_none() {
+            None
+        } else {
+            Some(TlcErrDataReader::new_unchecked(self.as_slice()))
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for TlcErrDataOptReader<'r> {
+    type Entity = TlcErrDataOpt;
+    const NAME: &'static str = "TlcErrDataOptReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        TlcErrDataOptReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        if !slice.is_empty() {
+            TlcErrDataReader::verify(&slice[..], compatible)?;
+        }
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct TlcErrDataOptBuilder(pub(crate) Option<TlcErrData>);
+impl TlcErrDataOptBuilder {
+    pub fn set(mut self, v: Option<TlcErrData>) -> Self {
+        self.0 = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for TlcErrDataOptBuilder {
+    type Entity = TlcErrDataOpt;
+    const NAME: &'static str = "TlcErrDataOptBuilder";
+    fn expected_length(&self) -> usize {
+        self.0
+            .as_ref()
+            .map(|ref inner| inner.as_slice().len())
+            .unwrap_or(0)
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        self.0
+            .as_ref()
+            .map(|ref inner| writer.write_all(inner.as_slice()))
+            .unwrap_or(Ok(()))
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        TlcErrDataOpt::new_unchecked(inner.into())
+    }
+}
+impl From<TlcErrData> for TlcErrDataOpt {
+    fn from(value: TlcErrData) -> Self {
+        Self::new_builder().set(Some(value)).build()
+    }
+}
+#[derive(Clone)]
+pub struct TlcErr(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for TlcErr {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for TlcErr {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for TlcErr {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "error_code", self.error_code())?;
+        write!(f, ", {}: {}", "extra_data", self.extra_data())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl ::core::default::Default for TlcErr {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        TlcErr::new_unchecked(v)
+    }
+}
+impl TlcErr {
+    const DEFAULT_VALUE: [u8; 14] = [14, 0, 0, 0, 12, 0, 0, 0, 14, 0, 0, 0, 0, 0];
+    pub const FIELD_COUNT: usize = 2;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn error_code(&self) -> Uint16 {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        Uint16::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn extra_data(&self) -> TlcErrDataOpt {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[12..]) as usize;
+            TlcErrDataOpt::new_unchecked(self.0.slice(start..end))
+        } else {
+            TlcErrDataOpt::new_unchecked(self.0.slice(start..))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> TlcErrReader<'r> {
+        TlcErrReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for TlcErr {
+    type Builder = TlcErrBuilder;
+    const NAME: &'static str = "TlcErr";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        TlcErr(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        TlcErrReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        TlcErrReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder()
+            .error_code(self.error_code())
+            .extra_data(self.extra_data())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct TlcErrReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for TlcErrReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for TlcErrReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for TlcErrReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "error_code", self.error_code())?;
+        write!(f, ", {}: {}", "extra_data", self.extra_data())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl<'r> TlcErrReader<'r> {
+    pub const FIELD_COUNT: usize = 2;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn error_code(&self) -> Uint16Reader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        Uint16Reader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn extra_data(&self) -> TlcErrDataOptReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[12..]) as usize;
+            TlcErrDataOptReader::new_unchecked(&self.as_slice()[start..end])
+        } else {
+            TlcErrDataOptReader::new_unchecked(&self.as_slice()[start..])
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for TlcErrReader<'r> {
+    type Entity = TlcErr;
+    const NAME: &'static str = "TlcErrReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        TlcErrReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let total_size = molecule::unpack_number(slice) as usize;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        if slice_len < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
+        }
+        let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
+        if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        if slice_len < offset_first {
+            return ve!(Self, HeaderIsBroken, offset_first, slice_len);
+        }
+        let field_count = offset_first / molecule::NUMBER_SIZE - 1;
+        if field_count < Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        } else if !compatible && field_count > Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        };
+        let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
+            .chunks_exact(molecule::NUMBER_SIZE)
+            .map(|x| molecule::unpack_number(x) as usize)
+            .collect();
+        offsets.push(total_size);
+        if offsets.windows(2).any(|i| i[0] > i[1]) {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        Uint16Reader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
+        TlcErrDataOptReader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct TlcErrBuilder {
+    pub(crate) error_code: Uint16,
+    pub(crate) extra_data: TlcErrDataOpt,
+}
+impl TlcErrBuilder {
+    pub const FIELD_COUNT: usize = 2;
+    pub fn error_code(mut self, v: Uint16) -> Self {
+        self.error_code = v;
+        self
+    }
+    pub fn extra_data(mut self, v: TlcErrDataOpt) -> Self {
+        self.extra_data = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for TlcErrBuilder {
+    type Entity = TlcErr;
+    const NAME: &'static str = "TlcErrBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
+            + self.error_code.as_slice().len()
+            + self.extra_data.as_slice().len()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
+        let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
+        offsets.push(total_size);
+        total_size += self.error_code.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.extra_data.as_slice().len();
+        writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
+        for offset in offsets.into_iter() {
+            writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
+        }
+        writer.write_all(self.error_code.as_slice())?;
+        writer.write_all(self.extra_data.as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        TlcErr::new_unchecked(inner.into())
+    }
+}
diff --git a/src/fiber/gen/gossip.rs b/src/fiber/gen/gossip.rs
index 26a503603..b10697dd5 100644
--- a/src/fiber/gen/gossip.rs
+++ b/src/fiber/gen/gossip.rs
@@ -4,231 +4,6 @@ use super::blockchain::*;
 use super::fiber::*;
 use molecule::prelude::*;
 #[derive(Clone)]
-pub struct Uint16(molecule::bytes::Bytes);
-impl ::core::fmt::LowerHex for Uint16 {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        use molecule::hex_string;
-        if f.alternate() {
-            write!(f, "0x")?;
-        }
-        write!(f, "{}", hex_string(self.as_slice()))
-    }
-}
-impl ::core::fmt::Debug for Uint16 {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        write!(f, "{}({:#x})", Self::NAME, self)
-    }
-}
-impl ::core::fmt::Display for Uint16 {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        use molecule::hex_string;
-        let raw_data = hex_string(&self.raw_data());
-        write!(f, "{}(0x{})", Self::NAME, raw_data)
-    }
-}
-impl ::core::default::Default for Uint16 {
-    fn default() -> Self {
-        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
-        Uint16::new_unchecked(v)
-    }
-}
-impl Uint16 {
-    const DEFAULT_VALUE: [u8; 2] = [0, 0];
-    pub const TOTAL_SIZE: usize = 2;
-    pub const ITEM_SIZE: usize = 1;
-    pub const ITEM_COUNT: usize = 2;
-    pub fn nth0(&self) -> Byte {
-        Byte::new_unchecked(self.0.slice(0..1))
-    }
-    pub fn nth1(&self) -> Byte {
-        Byte::new_unchecked(self.0.slice(1..2))
-    }
-    pub fn raw_data(&self) -> molecule::bytes::Bytes {
-        self.as_bytes()
-    }
-    pub fn as_reader<'r>(&'r self) -> Uint16Reader<'r> {
-        Uint16Reader::new_unchecked(self.as_slice())
-    }
-}
-impl molecule::prelude::Entity for Uint16 {
-    type Builder = Uint16Builder;
-    const NAME: &'static str = "Uint16";
-    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
-        Uint16(data)
-    }
-    fn as_bytes(&self) -> molecule::bytes::Bytes {
-        self.0.clone()
-    }
-    fn as_slice(&self) -> &[u8] {
-        &self.0[..]
-    }
-    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
-        Uint16Reader::from_slice(slice).map(|reader| reader.to_entity())
-    }
-    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
-        Uint16Reader::from_compatible_slice(slice).map(|reader| reader.to_entity())
-    }
-    fn new_builder() -> Self::Builder {
-        ::core::default::Default::default()
-    }
-    fn as_builder(self) -> Self::Builder {
-        Self::new_builder().set([self.nth0(), self.nth1()])
-    }
-}
-#[derive(Clone, Copy)]
-pub struct Uint16Reader<'r>(&'r [u8]);
-impl<'r> ::core::fmt::LowerHex for Uint16Reader<'r> {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        use molecule::hex_string;
-        if f.alternate() {
-            write!(f, "0x")?;
-        }
-        write!(f, "{}", hex_string(self.as_slice()))
-    }
-}
-impl<'r> ::core::fmt::Debug for Uint16Reader<'r> {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        write!(f, "{}({:#x})", Self::NAME, self)
-    }
-}
-impl<'r> ::core::fmt::Display for Uint16Reader<'r> {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        use molecule::hex_string;
-        let raw_data = hex_string(&self.raw_data());
-        write!(f, "{}(0x{})", Self::NAME, raw_data)
-    }
-}
-impl<'r> Uint16Reader<'r> {
-    pub const TOTAL_SIZE: usize = 2;
-    pub const ITEM_SIZE: usize = 1;
-    pub const ITEM_COUNT: usize = 2;
-    pub fn nth0(&self) -> ByteReader<'r> {
-        ByteReader::new_unchecked(&self.as_slice()[0..1])
-    }
-    pub fn nth1(&self) -> ByteReader<'r> {
-        ByteReader::new_unchecked(&self.as_slice()[1..2])
-    }
-    pub fn raw_data(&self) -> &'r [u8] {
-        self.as_slice()
-    }
-}
-impl<'r> molecule::prelude::Reader<'r> for Uint16Reader<'r> {
-    type Entity = Uint16;
-    const NAME: &'static str = "Uint16Reader";
-    fn to_entity(&self) -> Self::Entity {
-        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
-    }
-    fn new_unchecked(slice: &'r [u8]) -> Self {
-        Uint16Reader(slice)
-    }
-    fn as_slice(&self) -> &'r [u8] {
-        self.0
-    }
-    fn verify(slice: &[u8], _compatible: bool) -> molecule::error::VerificationResult<()> {
-        use molecule::verification_error as ve;
-        let slice_len = slice.len();
-        if slice_len != Self::TOTAL_SIZE {
-            return ve!(Self, TotalSizeNotMatch, Self::TOTAL_SIZE, slice_len);
-        }
-        Ok(())
-    }
-}
-#[derive(Clone)]
-pub struct Uint16Builder(pub(crate) [Byte; 2]);
-impl ::core::fmt::Debug for Uint16Builder {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        write!(f, "{}({:?})", Self::NAME, &self.0[..])
-    }
-}
-impl ::core::default::Default for Uint16Builder {
-    fn default() -> Self {
-        Uint16Builder([Byte::default(), Byte::default()])
-    }
-}
-impl Uint16Builder {
-    pub const TOTAL_SIZE: usize = 2;
-    pub const ITEM_SIZE: usize = 1;
-    pub const ITEM_COUNT: usize = 2;
-    pub fn set(mut self, v: [Byte; 2]) -> Self {
-        self.0 = v;
-        self
-    }
-    pub fn nth0(mut self, v: Byte) -> Self {
-        self.0[0] = v;
-        self
-    }
-    pub fn nth1(mut self, v: Byte) -> Self {
-        self.0[1] = v;
-        self
-    }
-}
-impl molecule::prelude::Builder for Uint16Builder {
-    type Entity = Uint16;
-    const NAME: &'static str = "Uint16Builder";
-    fn expected_length(&self) -> usize {
-        Self::TOTAL_SIZE
-    }
-    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
-        writer.write_all(self.0[0].as_slice())?;
-        writer.write_all(self.0[1].as_slice())?;
-        Ok(())
-    }
-    fn build(&self) -> Self::Entity {
-        let mut inner = Vec::with_capacity(self.expected_length());
-        self.write(&mut inner)
-            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
-        Uint16::new_unchecked(inner.into())
-    }
-}
-impl From<[Byte; 2usize]> for Uint16 {
-    fn from(value: [Byte; 2usize]) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl ::core::convert::TryFrom<&[Byte]> for Uint16 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(Self::new_builder()
-            .set(<&[Byte; 2usize]>::try_from(value)?.clone())
-            .build())
-    }
-}
-impl From<Uint16> for [Byte; 2usize] {
-    #[track_caller]
-    fn from(value: Uint16) -> Self {
-        [value.nth0(), value.nth1()]
-    }
-}
-impl From<[u8; 2usize]> for Uint16 {
-    fn from(value: [u8; 2usize]) -> Self {
-        Uint16Reader::new_unchecked(&value).to_entity()
-    }
-}
-impl ::core::convert::TryFrom<&[u8]> for Uint16 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(<[u8; 2usize]>::try_from(value)?.into())
-    }
-}
-impl From<Uint16> for [u8; 2usize] {
-    #[track_caller]
-    fn from(value: Uint16) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<Uint16Reader<'a>> for &'a [u8; 2usize] {
-    #[track_caller]
-    fn from(value: Uint16Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<&'a Uint16Reader<'a>> for &'a [u8; 2usize] {
-    #[track_caller]
-    fn from(value: &'a Uint16Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-#[derive(Clone)]
 pub struct SchnorrSignature(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for SchnorrSignature {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -3308,7 +3083,7 @@ impl ::core::fmt::Display for NodeAnnouncement {
         write!(f, ", {}: {}", "features", self.features())?;
         write!(f, ", {}: {}", "timestamp", self.timestamp())?;
         write!(f, ", {}: {}", "node_id", self.node_id())?;
-        write!(f, ", {}: {}", "alias", self.alias())?;
+        write!(f, ", {}: {}", "node_name", self.node_name())?;
         write!(f, ", {}: {}", "address", self.address())?;
         write!(f, ", {}: {}", "chain_hash", self.chain_hash())?;
         write!(
@@ -3383,7 +3158,7 @@ impl NodeAnnouncement {
         let end = molecule::unpack_number(&slice[20..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn alias(&self) -> Byte32 {
+    pub fn node_name(&self) -> Byte32 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[20..]) as usize;
         let end = molecule::unpack_number(&slice[24..]) as usize;
@@ -3448,7 +3223,7 @@ impl molecule::prelude::Entity for NodeAnnouncement {
             .features(self.features())
             .timestamp(self.timestamp())
             .node_id(self.node_id())
-            .alias(self.alias())
+            .node_name(self.node_name())
             .address(self.address())
             .chain_hash(self.chain_hash())
             .auto_accept_min_ckb_funding_amount(self.auto_accept_min_ckb_funding_amount())
@@ -3478,7 +3253,7 @@ impl<'r> ::core::fmt::Display for NodeAnnouncementReader<'r> {
         write!(f, ", {}: {}", "features", self.features())?;
         write!(f, ", {}: {}", "timestamp", self.timestamp())?;
         write!(f, ", {}: {}", "node_id", self.node_id())?;
-        write!(f, ", {}: {}", "alias", self.alias())?;
+        write!(f, ", {}: {}", "node_name", self.node_name())?;
         write!(f, ", {}: {}", "address", self.address())?;
         write!(f, ", {}: {}", "chain_hash", self.chain_hash())?;
         write!(
@@ -3537,7 +3312,7 @@ impl<'r> NodeAnnouncementReader<'r> {
         let end = molecule::unpack_number(&slice[20..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn alias(&self) -> Byte32Reader<'r> {
+    pub fn node_name(&self) -> Byte32Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[20..]) as usize;
         let end = molecule::unpack_number(&slice[24..]) as usize;
@@ -3636,7 +3411,7 @@ pub struct NodeAnnouncementBuilder {
     pub(crate) features: Uint64,
     pub(crate) timestamp: Uint64,
     pub(crate) node_id: Pubkey,
-    pub(crate) alias: Byte32,
+    pub(crate) node_name: Byte32,
     pub(crate) address: BytesVec,
     pub(crate) chain_hash: Byte32,
     pub(crate) auto_accept_min_ckb_funding_amount: Uint64,
@@ -3660,8 +3435,8 @@ impl NodeAnnouncementBuilder {
         self.node_id = v;
         self
     }
-    pub fn alias(mut self, v: Byte32) -> Self {
-        self.alias = v;
+    pub fn node_name(mut self, v: Byte32) -> Self {
+        self.node_name = v;
         self
     }
     pub fn address(mut self, v: BytesVec) -> Self {
@@ -3690,7 +3465,7 @@ impl molecule::prelude::Builder for NodeAnnouncementBuilder {
             + self.features.as_slice().len()
             + self.timestamp.as_slice().len()
             + self.node_id.as_slice().len()
-            + self.alias.as_slice().len()
+            + self.node_name.as_slice().len()
             + self.address.as_slice().len()
             + self.chain_hash.as_slice().len()
             + self.auto_accept_min_ckb_funding_amount.as_slice().len()
@@ -3708,7 +3483,7 @@ impl molecule::prelude::Builder for NodeAnnouncementBuilder {
         offsets.push(total_size);
         total_size += self.node_id.as_slice().len();
         offsets.push(total_size);
-        total_size += self.alias.as_slice().len();
+        total_size += self.node_name.as_slice().len();
         offsets.push(total_size);
         total_size += self.address.as_slice().len();
         offsets.push(total_size);
@@ -3725,7 +3500,7 @@ impl molecule::prelude::Builder for NodeAnnouncementBuilder {
         writer.write_all(self.features.as_slice())?;
         writer.write_all(self.timestamp.as_slice())?;
         writer.write_all(self.node_id.as_slice())?;
-        writer.write_all(self.alias.as_slice())?;
+        writer.write_all(self.node_name.as_slice())?;
         writer.write_all(self.address.as_slice())?;
         writer.write_all(self.chain_hash.as_slice())?;
         writer.write_all(self.auto_accept_min_ckb_funding_amount.as_slice())?;
@@ -4241,308 +4016,6 @@ impl molecule::prelude::Builder for ChannelAnnouncementBuilder {
     }
 }
 #[derive(Clone)]
-pub struct ChannelUpdate(molecule::bytes::Bytes);
-impl ::core::fmt::LowerHex for ChannelUpdate {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        use molecule::hex_string;
-        if f.alternate() {
-            write!(f, "0x")?;
-        }
-        write!(f, "{}", hex_string(self.as_slice()))
-    }
-}
-impl ::core::fmt::Debug for ChannelUpdate {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        write!(f, "{}({:#x})", Self::NAME, self)
-    }
-}
-impl ::core::fmt::Display for ChannelUpdate {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        write!(f, "{} {{ ", Self::NAME)?;
-        write!(f, "{}: {}", "signature", self.signature())?;
-        write!(f, ", {}: {}", "chain_hash", self.chain_hash())?;
-        write!(f, ", {}: {}", "channel_outpoint", self.channel_outpoint())?;
-        write!(f, ", {}: {}", "timestamp", self.timestamp())?;
-        write!(f, ", {}: {}", "message_flags", self.message_flags())?;
-        write!(f, ", {}: {}", "channel_flags", self.channel_flags())?;
-        write!(f, ", {}: {}", "tlc_expiry_delta", self.tlc_expiry_delta())?;
-        write!(f, ", {}: {}", "tlc_minimum_value", self.tlc_minimum_value())?;
-        write!(f, ", {}: {}", "tlc_maximum_value", self.tlc_maximum_value())?;
-        write!(
-            f,
-            ", {}: {}",
-            "tlc_fee_proportional_millionths",
-            self.tlc_fee_proportional_millionths()
-        )?;
-        write!(f, " }}")
-    }
-}
-impl ::core::default::Default for ChannelUpdate {
-    fn default() -> Self {
-        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
-        ChannelUpdate::new_unchecked(v)
-    }
-}
-impl ChannelUpdate {
-    const DEFAULT_VALUE: [u8; 204] = [
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ];
-    pub const TOTAL_SIZE: usize = 204;
-    pub const FIELD_SIZES: [usize; 10] = [64, 32, 36, 8, 4, 4, 8, 16, 16, 16];
-    pub const FIELD_COUNT: usize = 10;
-    pub fn signature(&self) -> EcdsaSignature {
-        EcdsaSignature::new_unchecked(self.0.slice(0..64))
-    }
-    pub fn chain_hash(&self) -> Byte32 {
-        Byte32::new_unchecked(self.0.slice(64..96))
-    }
-    pub fn channel_outpoint(&self) -> OutPoint {
-        OutPoint::new_unchecked(self.0.slice(96..132))
-    }
-    pub fn timestamp(&self) -> Uint64 {
-        Uint64::new_unchecked(self.0.slice(132..140))
-    }
-    pub fn message_flags(&self) -> Uint32 {
-        Uint32::new_unchecked(self.0.slice(140..144))
-    }
-    pub fn channel_flags(&self) -> Uint32 {
-        Uint32::new_unchecked(self.0.slice(144..148))
-    }
-    pub fn tlc_expiry_delta(&self) -> Uint64 {
-        Uint64::new_unchecked(self.0.slice(148..156))
-    }
-    pub fn tlc_minimum_value(&self) -> Uint128 {
-        Uint128::new_unchecked(self.0.slice(156..172))
-    }
-    pub fn tlc_maximum_value(&self) -> Uint128 {
-        Uint128::new_unchecked(self.0.slice(172..188))
-    }
-    pub fn tlc_fee_proportional_millionths(&self) -> Uint128 {
-        Uint128::new_unchecked(self.0.slice(188..204))
-    }
-    pub fn as_reader<'r>(&'r self) -> ChannelUpdateReader<'r> {
-        ChannelUpdateReader::new_unchecked(self.as_slice())
-    }
-}
-impl molecule::prelude::Entity for ChannelUpdate {
-    type Builder = ChannelUpdateBuilder;
-    const NAME: &'static str = "ChannelUpdate";
-    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
-        ChannelUpdate(data)
-    }
-    fn as_bytes(&self) -> molecule::bytes::Bytes {
-        self.0.clone()
-    }
-    fn as_slice(&self) -> &[u8] {
-        &self.0[..]
-    }
-    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
-        ChannelUpdateReader::from_slice(slice).map(|reader| reader.to_entity())
-    }
-    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
-        ChannelUpdateReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
-    }
-    fn new_builder() -> Self::Builder {
-        ::core::default::Default::default()
-    }
-    fn as_builder(self) -> Self::Builder {
-        Self::new_builder()
-            .signature(self.signature())
-            .chain_hash(self.chain_hash())
-            .channel_outpoint(self.channel_outpoint())
-            .timestamp(self.timestamp())
-            .message_flags(self.message_flags())
-            .channel_flags(self.channel_flags())
-            .tlc_expiry_delta(self.tlc_expiry_delta())
-            .tlc_minimum_value(self.tlc_minimum_value())
-            .tlc_maximum_value(self.tlc_maximum_value())
-            .tlc_fee_proportional_millionths(self.tlc_fee_proportional_millionths())
-    }
-}
-#[derive(Clone, Copy)]
-pub struct ChannelUpdateReader<'r>(&'r [u8]);
-impl<'r> ::core::fmt::LowerHex for ChannelUpdateReader<'r> {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        use molecule::hex_string;
-        if f.alternate() {
-            write!(f, "0x")?;
-        }
-        write!(f, "{}", hex_string(self.as_slice()))
-    }
-}
-impl<'r> ::core::fmt::Debug for ChannelUpdateReader<'r> {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        write!(f, "{}({:#x})", Self::NAME, self)
-    }
-}
-impl<'r> ::core::fmt::Display for ChannelUpdateReader<'r> {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        write!(f, "{} {{ ", Self::NAME)?;
-        write!(f, "{}: {}", "signature", self.signature())?;
-        write!(f, ", {}: {}", "chain_hash", self.chain_hash())?;
-        write!(f, ", {}: {}", "channel_outpoint", self.channel_outpoint())?;
-        write!(f, ", {}: {}", "timestamp", self.timestamp())?;
-        write!(f, ", {}: {}", "message_flags", self.message_flags())?;
-        write!(f, ", {}: {}", "channel_flags", self.channel_flags())?;
-        write!(f, ", {}: {}", "tlc_expiry_delta", self.tlc_expiry_delta())?;
-        write!(f, ", {}: {}", "tlc_minimum_value", self.tlc_minimum_value())?;
-        write!(f, ", {}: {}", "tlc_maximum_value", self.tlc_maximum_value())?;
-        write!(
-            f,
-            ", {}: {}",
-            "tlc_fee_proportional_millionths",
-            self.tlc_fee_proportional_millionths()
-        )?;
-        write!(f, " }}")
-    }
-}
-impl<'r> ChannelUpdateReader<'r> {
-    pub const TOTAL_SIZE: usize = 204;
-    pub const FIELD_SIZES: [usize; 10] = [64, 32, 36, 8, 4, 4, 8, 16, 16, 16];
-    pub const FIELD_COUNT: usize = 10;
-    pub fn signature(&self) -> EcdsaSignatureReader<'r> {
-        EcdsaSignatureReader::new_unchecked(&self.as_slice()[0..64])
-    }
-    pub fn chain_hash(&self) -> Byte32Reader<'r> {
-        Byte32Reader::new_unchecked(&self.as_slice()[64..96])
-    }
-    pub fn channel_outpoint(&self) -> OutPointReader<'r> {
-        OutPointReader::new_unchecked(&self.as_slice()[96..132])
-    }
-    pub fn timestamp(&self) -> Uint64Reader<'r> {
-        Uint64Reader::new_unchecked(&self.as_slice()[132..140])
-    }
-    pub fn message_flags(&self) -> Uint32Reader<'r> {
-        Uint32Reader::new_unchecked(&self.as_slice()[140..144])
-    }
-    pub fn channel_flags(&self) -> Uint32Reader<'r> {
-        Uint32Reader::new_unchecked(&self.as_slice()[144..148])
-    }
-    pub fn tlc_expiry_delta(&self) -> Uint64Reader<'r> {
-        Uint64Reader::new_unchecked(&self.as_slice()[148..156])
-    }
-    pub fn tlc_minimum_value(&self) -> Uint128Reader<'r> {
-        Uint128Reader::new_unchecked(&self.as_slice()[156..172])
-    }
-    pub fn tlc_maximum_value(&self) -> Uint128Reader<'r> {
-        Uint128Reader::new_unchecked(&self.as_slice()[172..188])
-    }
-    pub fn tlc_fee_proportional_millionths(&self) -> Uint128Reader<'r> {
-        Uint128Reader::new_unchecked(&self.as_slice()[188..204])
-    }
-}
-impl<'r> molecule::prelude::Reader<'r> for ChannelUpdateReader<'r> {
-    type Entity = ChannelUpdate;
-    const NAME: &'static str = "ChannelUpdateReader";
-    fn to_entity(&self) -> Self::Entity {
-        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
-    }
-    fn new_unchecked(slice: &'r [u8]) -> Self {
-        ChannelUpdateReader(slice)
-    }
-    fn as_slice(&self) -> &'r [u8] {
-        self.0
-    }
-    fn verify(slice: &[u8], _compatible: bool) -> molecule::error::VerificationResult<()> {
-        use molecule::verification_error as ve;
-        let slice_len = slice.len();
-        if slice_len != Self::TOTAL_SIZE {
-            return ve!(Self, TotalSizeNotMatch, Self::TOTAL_SIZE, slice_len);
-        }
-        Ok(())
-    }
-}
-#[derive(Clone, Debug, Default)]
-pub struct ChannelUpdateBuilder {
-    pub(crate) signature: EcdsaSignature,
-    pub(crate) chain_hash: Byte32,
-    pub(crate) channel_outpoint: OutPoint,
-    pub(crate) timestamp: Uint64,
-    pub(crate) message_flags: Uint32,
-    pub(crate) channel_flags: Uint32,
-    pub(crate) tlc_expiry_delta: Uint64,
-    pub(crate) tlc_minimum_value: Uint128,
-    pub(crate) tlc_maximum_value: Uint128,
-    pub(crate) tlc_fee_proportional_millionths: Uint128,
-}
-impl ChannelUpdateBuilder {
-    pub const TOTAL_SIZE: usize = 204;
-    pub const FIELD_SIZES: [usize; 10] = [64, 32, 36, 8, 4, 4, 8, 16, 16, 16];
-    pub const FIELD_COUNT: usize = 10;
-    pub fn signature(mut self, v: EcdsaSignature) -> Self {
-        self.signature = v;
-        self
-    }
-    pub fn chain_hash(mut self, v: Byte32) -> Self {
-        self.chain_hash = v;
-        self
-    }
-    pub fn channel_outpoint(mut self, v: OutPoint) -> Self {
-        self.channel_outpoint = v;
-        self
-    }
-    pub fn timestamp(mut self, v: Uint64) -> Self {
-        self.timestamp = v;
-        self
-    }
-    pub fn message_flags(mut self, v: Uint32) -> Self {
-        self.message_flags = v;
-        self
-    }
-    pub fn channel_flags(mut self, v: Uint32) -> Self {
-        self.channel_flags = v;
-        self
-    }
-    pub fn tlc_expiry_delta(mut self, v: Uint64) -> Self {
-        self.tlc_expiry_delta = v;
-        self
-    }
-    pub fn tlc_minimum_value(mut self, v: Uint128) -> Self {
-        self.tlc_minimum_value = v;
-        self
-    }
-    pub fn tlc_maximum_value(mut self, v: Uint128) -> Self {
-        self.tlc_maximum_value = v;
-        self
-    }
-    pub fn tlc_fee_proportional_millionths(mut self, v: Uint128) -> Self {
-        self.tlc_fee_proportional_millionths = v;
-        self
-    }
-}
-impl molecule::prelude::Builder for ChannelUpdateBuilder {
-    type Entity = ChannelUpdate;
-    const NAME: &'static str = "ChannelUpdateBuilder";
-    fn expected_length(&self) -> usize {
-        Self::TOTAL_SIZE
-    }
-    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
-        writer.write_all(self.signature.as_slice())?;
-        writer.write_all(self.chain_hash.as_slice())?;
-        writer.write_all(self.channel_outpoint.as_slice())?;
-        writer.write_all(self.timestamp.as_slice())?;
-        writer.write_all(self.message_flags.as_slice())?;
-        writer.write_all(self.channel_flags.as_slice())?;
-        writer.write_all(self.tlc_expiry_delta.as_slice())?;
-        writer.write_all(self.tlc_minimum_value.as_slice())?;
-        writer.write_all(self.tlc_maximum_value.as_slice())?;
-        writer.write_all(self.tlc_fee_proportional_millionths.as_slice())?;
-        Ok(())
-    }
-    fn build(&self) -> Self::Entity {
-        let mut inner = Vec::with_capacity(self.expected_length());
-        self.write(&mut inner)
-            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
-        ChannelUpdate::new_unchecked(inner.into())
-    }
-}
-#[derive(Clone)]
 pub struct BroadcastMessage(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for BroadcastMessage {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
diff --git a/src/fiber/gossip.rs b/src/fiber/gossip.rs
index 62952fdc8..e44ce9015 100644
--- a/src/fiber/gossip.rs
+++ b/src/fiber/gossip.rs
@@ -1,5 +1,5 @@
 use std::{
-    collections::{HashMap, HashSet, VecDeque},
+    collections::{HashMap, HashSet},
     marker::PhantomData,
     sync::Arc,
     time::Duration,
@@ -23,6 +23,7 @@ use tentacle::{
     secio::PeerId,
     service::{ProtocolHandle, ProtocolMeta, ServiceAsyncControl, SessionType},
     traits::ServiceProtocol,
+    utils::{is_reachable, multiaddr_to_socketaddr},
     SessionId,
 };
 use tokio::sync::oneshot;
@@ -39,7 +40,7 @@ use super::{
     types::{
         BroadcastMessage, BroadcastMessageID, BroadcastMessageQuery, BroadcastMessageQueryFlags,
         BroadcastMessageWithTimestamp, BroadcastMessagesFilter, BroadcastMessagesFilterResult,
-        ChannelAnnouncement, ChannelUpdate, Cursor, GetBroadcastMessages,
+        ChannelAnnouncement, ChannelOnchainInfo, ChannelUpdate, Cursor, GetBroadcastMessages,
         GetBroadcastMessagesResult, GossipMessage, NodeAnnouncement, Pubkey,
         QueryBroadcastMessages, QueryBroadcastMessagesResult,
     },
@@ -322,13 +323,7 @@ pub enum GossipActorMessage {
     // Try to broadcast BroadcastMessage created by us to the network.
     // We will save and broadcast the messages. Note that we don't check the dependencies of
     // these messages because we assume that the messages created by us are always valid.
-    TryBroadcastMessages(Vec<BroadcastMessage>),
-    // Broadcast a message to the network. The message here must have all its dependencies met.
-    // This is normally the case when we saved a message to the store.
-    // This is an internal command used by both TryBroadcastMessages and ProcessBroadcastMessage,
-    // in which we will normally enrich the BroadcastMessage and check their dependencies,
-    // and then broadcast them to the network.
-    BroadcastMessageImmediately(BroadcastMessageWithTimestamp),
+    TryBroadcastMessages(Vec<BroadcastMessageWithTimestamp>),
     // Send gossip message to a peer.
     SendGossipMessage(GossipMessageWithPeerId),
     // Received GossipMessage from a peer
@@ -463,10 +458,6 @@ where
         match message {
             GossipSyncingActorMessage::RequestTimeout(request_id) => {
                 state.inflight_requests.remove(&request_id);
-                debug!(
-                    "Sending new GetBroadcastMessages request after timeout: id {}",
-                    request_id
-                );
                 // TODO: When the peer failed for too many times, we should consider disconnecting from the peer.
                 state.peer_state.failed_times += 1;
                 myself
@@ -488,7 +479,7 @@ where
                         Some(last_message) => {
                             // We need the message timestamp to construct a valid cursor.
                             match get_message_cursor(
-                                last_message.clone(),
+                                last_message,
                                 &state.store.store,
                                 &state.chain_actor,
                             )
@@ -529,14 +520,11 @@ where
                         }
                     }
 
-                    for message in messages {
-                        let _ = state
-                            .store
-                            .actor
-                            .send_message(ExtendedGossipMessageStoreMessage::SaveMessage(message))
-                            .expect("store actor alive");
-                    }
-                    debug!("Sending new GetBroadcastMessages request after receiving response: peer_id {:?}", &state.peer_id);
+                    let _ = state
+                        .store
+                        .actor
+                        .send_message(ExtendedGossipMessageStoreMessage::SaveMessages(messages))
+                        .expect("store actor alive");
                     myself
                         .send_message(GossipSyncingActorMessage::NewGetRequest())
                         .expect("gossip syncing actor alive");
@@ -563,7 +551,6 @@ where
                 // Send a new GetBroadcastMessages request to the newly-connected peer.
                 // If we have less than NUM_SIMULTANEOUS_GET_REQUESTS requests inflight.
                 if state.inflight_requests.len() > NUM_SIMULTANEOUS_GET_REQUESTS {
-                    debug!("Not sending new GetBroadcastMessages request because there are already {} requests inflight (max {})", state.inflight_requests.len(), NUM_SIMULTANEOUS_GET_REQUESTS);
                     return Ok(());
                 }
                 state
@@ -628,10 +615,6 @@ impl PeerFilterProcessor {
         Self { filter, actor }
     }
 
-    fn get_filter(&self) -> &Cursor {
-        &self.filter
-    }
-
     fn update_filter(&mut self, filter: &Cursor) {
         self.filter = filter.clone();
         self.actor
@@ -819,10 +802,6 @@ impl PeerState {
     }
 
     fn change_sync_status(&mut self, new_status: PeerSyncStatus) {
-        debug!(
-            "Peer {:?} sync status changed from {:?} to {:?}",
-            self.session_id, self.sync_status, new_status
-        );
         self.sync_status = new_status;
     }
 }
@@ -857,8 +836,8 @@ where
 {
     async fn new(
         maintenance_interval: Duration,
+        announce_private_addr: bool,
         store: S,
-        gossip_actor: ActorRef<GossipActorMessage>,
         chain_actor: ActorRef<CkbChainMessage>,
         supervisor: ActorCell,
     ) -> Self {
@@ -870,8 +849,8 @@ where
             ExtendedGossipMessageStoreActor::new(),
             (
                 maintenance_interval,
+                announce_private_addr,
                 store.clone(),
-                gossip_actor,
                 chain_actor,
             ),
             supervisor,
@@ -899,10 +878,6 @@ impl<S: GossipMessageStore + Sync> SubscribableGossipMessageStore
         receiver: ActorRef<TReceiverMsg>,
         converter: F,
     ) -> Result<Self::Subscription, Self::Error> {
-        debug!(
-            "Creating a new subscription from cursor {:?} with receiver {:?}",
-            &cursor, &receiver
-        );
         match call!(
             &self.actor,
             ExtendedGossipMessageStoreMessage::NewSubscription,
@@ -981,139 +956,131 @@ pub enum GossipMessageProcessingError {
 }
 
 pub struct ExtendedGossipMessageStoreState<S> {
+    announce_private_addr: bool,
     store: S,
-    gossip_actor: ActorRef<GossipActorMessage>,
     chain_actor: ActorRef<CkbChainMessage>,
     next_id: u64,
     output_ports: HashMap<u64, BroadcastMessageOutput>,
-    last_cursor: Cursor,
-    messages_to_be_saved: HashSet<BroadcastMessageWithTimestamp>,
+    messages_to_be_saved: HashSet<BroadcastMessage>,
 }
 
 impl<S: GossipMessageStore> ExtendedGossipMessageStoreState<S> {
-    fn new(
-        store: S,
-        gossip_actor: ActorRef<GossipActorMessage>,
-        chain_actor: ActorRef<CkbChainMessage>,
-    ) -> Self {
+    fn new(announce_private_addr: bool, store: S, chain_actor: ActorRef<CkbChainMessage>) -> Self {
         Self {
+            announce_private_addr,
             store,
-            gossip_actor,
             chain_actor,
             next_id: Default::default(),
             output_ports: Default::default(),
-            last_cursor: Default::default(),
             messages_to_be_saved: Default::default(),
         }
     }
 
-    fn update_last_cursor(&mut self, cursor: Cursor) {
-        if cursor > self.last_cursor {
-            self.last_cursor = cursor;
-        }
-    }
-
-    // Saving all the messages whose transitive dependencies are already available.
-    // We will also change the relevant state (e.g. update the latest cursor).
-    // The returned list may be sent to the subscribers.
+    // Obtaining all the messages whose transitive dependencies are already available,
+    // check their validity and then save valid messages to store and
+    // return the list of saved messages that can be sent to the subscribers.
     async fn prune_messages_to_be_saved(&mut self) -> Vec<BroadcastMessageWithTimestamp> {
-        let complete_messages = self
+        // Note that we have to call has_dependencies_available before changing messages_to_be_saved,
+        // as the function will check the dependencies of the message in the current messages_to_be_saved.
+        let (complete_messages, incomplete_messages) = self
             .messages_to_be_saved
-            .iter()
-            .filter(|m| self.has_dependencies_available(m))
-            .cloned()
-            .collect::<HashSet<_>>();
-        self.messages_to_be_saved
-            .retain(|v| !complete_messages.contains(v));
-
-        let mut sorted_messages = Vec::with_capacity(complete_messages.len());
-
-        // Save all the messages to a map so that we can easily order messages by their dependencies.
-        let mut messages_map: HashMap<
-            (BroadcastMessageID, bool),
-            VecDeque<BroadcastMessageWithTimestamp>,
-        > = HashMap::new();
-
-        for new_message in complete_messages {
-            let key = (
-                new_message.message_id(),
-                match &new_message {
-                    // Message id alone is not enough to differentiate channel updates.
-                    // We need a flag to indicate if the message is an update of node 1.
-                    BroadcastMessageWithTimestamp::ChannelUpdate(channel_update) => {
-                        channel_update.is_update_of_node_1()
-                    }
-                    _ => true,
-                },
-            );
-            let messages = messages_map.entry(key).or_default();
-            let index = messages.partition_point(|m| m.cursor() < new_message.cursor());
-            match messages.get(index + 1) {
-                Some(message) if message == &new_message => {
-                    // The same message is already saved.
-                    continue;
+            .clone()
+            .into_iter()
+            .partition(|m| self.has_dependencies_available(m));
+        self.messages_to_be_saved = incomplete_messages;
+
+        let mut sorted_messages = complete_messages.into_iter().collect::<Vec<_>>();
+        sorted_messages.sort_unstable();
+        trace!(
+            "Saving complete messages to the store: {:?}",
+            &sorted_messages
+        );
+
+        let mut verified_sorted_messages = Vec::with_capacity(sorted_messages.len());
+        for message in sorted_messages {
+            match verify_and_save_broadcast_message(&message, &self.store, &self.chain_actor).await
+            {
+                Ok(message) => {
+                    verified_sorted_messages.push(message);
                 }
-                _ => {
-                    messages.insert(index, new_message);
+                Err(error) => {
+                    trace!(
+                        "Failed to verify and save message {:?}: {:?}",
+                        message,
+                        error
+                    );
                 }
             }
         }
 
-        loop {
-            let key = match messages_map.keys().next() {
-                None => break,
-                Some(key) => key.clone(),
-            };
-            let messages = messages_map.remove(&key).expect("key exists");
-            if let BroadcastMessageWithTimestamp::ChannelUpdate(channel_update) = &messages[0] {
-                let outpoint = channel_update.channel_outpoint.clone();
-                if let Some(message) =
-                    messages_map.remove(&(BroadcastMessageID::ChannelAnnouncement(outpoint), true))
-                {
-                    for message in message {
-                        sorted_messages.push(message);
-                    }
+        verified_sorted_messages
+    }
+
+    fn store_messages(&mut self, messages: &[BroadcastMessageWithTimestamp]) {
+        for message in messages {
+            match message {
+                BroadcastMessageWithTimestamp::ChannelAnnouncement(
+                    timestamp,
+                    channel_announcement,
+                ) => {
+                    self.store
+                        .save_channel_announcement(*timestamp, channel_announcement.clone());
+                }
+                BroadcastMessageWithTimestamp::ChannelUpdate(channel_update) => {
+                    self.store.save_channel_update(channel_update.clone());
+                }
+                BroadcastMessageWithTimestamp::NodeAnnouncement(node_announcement) => {
+                    self.store.save_node_announcement(node_announcement.clone());
                 }
-            }
-            for message in messages {
-                sorted_messages.push(message);
             }
         }
+    }
 
-        let mut verified_sorted_messages = Vec::with_capacity(sorted_messages.len());
+    fn broadcast_messages(&mut self, messages: &[BroadcastMessageWithTimestamp]) {
+        if messages.is_empty() {
+            return;
+        }
 
-        for message in sorted_messages {
-            if let Err(error) =
-                verify_and_save_broadcast_message(&message, &self.store, &self.chain_actor).await
-            {
-                warn!(
-                    "Failed to verify and save message {:?}: {:?}",
-                    message, error
-                );
-                continue;
+        for (id, subscription) in self.output_ports.iter() {
+            let messages_to_send = messages
+                .iter()
+                .filter(|m| &m.cursor() > &subscription.filter)
+                .cloned()
+                .collect::<Vec<_>>();
+            trace!(
+                "Sending complete messages in memory to subscription #{}: number of messages = {}",
+                id,
+                messages_to_send.len()
+            );
+            for chunk in messages_to_send.chunks(MAX_NUM_OF_BROADCAST_MESSAGES as usize) {
+                subscription
+                    .output_port
+                    .send(GossipMessageUpdates::new(chunk.to_vec()));
             }
-            self.update_last_cursor(message.cursor());
-            verified_sorted_messages.push(message);
         }
+    }
 
-        verified_sorted_messages
+    fn store_and_broadcast_messages(&mut self, messages: &[BroadcastMessageWithTimestamp]) {
+        self.store_messages(messages);
+        self.broadcast_messages(messages);
     }
 
-    fn get_channel_annnouncement(&self, outpoint: &OutPoint) -> Option<(u64, ChannelAnnouncement)> {
+    fn get_channel_annnouncement(&self, outpoint: &OutPoint) -> Option<ChannelAnnouncement> {
         self.store
             .get_latest_channel_announcement(outpoint)
+            .map(|(_, m)| m)
             .or_else(|| self.get_channel_annnouncement_in_memory(outpoint))
     }
 
     fn get_channel_annnouncement_in_memory(
         &self,
         outpoint: &OutPoint,
-    ) -> Option<(u64, ChannelAnnouncement)> {
+    ) -> Option<ChannelAnnouncement> {
         self.messages_to_be_saved.iter().find_map(|m| match m {
-            BroadcastMessageWithTimestamp::ChannelAnnouncement(timestamp, channel_announcement)
+            BroadcastMessage::ChannelAnnouncement(channel_announcement)
                 if &channel_announcement.channel_outpoint == outpoint =>
             {
-                Some((*timestamp, channel_announcement.clone()))
+                Some(channel_announcement.clone())
             }
             _ => None,
         })
@@ -1122,40 +1089,53 @@ impl<S: GossipMessageStore> ExtendedGossipMessageStoreState<S> {
     async fn insert_message_to_be_saved_list(
         &mut self,
         message: &BroadcastMessage,
-    ) -> Result<BroadcastMessageWithTimestamp, GossipMessageProcessingError> {
+    ) -> Result<(), GossipMessageProcessingError> {
         if let Some(existing_message) = get_existing_newer_broadcast_message(message, &self.store) {
             if &BroadcastMessage::from(existing_message.clone()) != message {
                 return Err(GossipMessageProcessingError::NewerMessageSaved(
                     existing_message,
                 ));
             } else {
-                return Ok(existing_message);
+                return Ok(());
             }
         }
 
-        let message =
-            get_broadcast_message_with_timestamp(message.clone(), &self.store, &self.chain_actor)
-                .await
-                .map_err(|error| {
-                    GossipMessageProcessingError::ProcessingError(error.to_string())
-                })?;
-
-        let max_acceptable_gossip_message_timestamp = max_acceptable_gossip_message_timestamp();
-        if message.timestamp() > max_acceptable_gossip_message_timestamp {
-            return Err(GossipMessageProcessingError::MessageTooNew(
-                message.timestamp(),
-                max_acceptable_gossip_message_timestamp,
-            ));
+        if self.messages_to_be_saved.contains(&message) {
+            return Ok(());
+        }
+
+        if let Some(timestamp) = message.timestamp() {
+            let max_acceptable_gossip_message_timestamp = max_acceptable_gossip_message_timestamp();
+            if timestamp > max_acceptable_gossip_message_timestamp {
+                return Err(GossipMessageProcessingError::MessageTooNew(
+                    timestamp,
+                    max_acceptable_gossip_message_timestamp,
+                ));
+            }
+        }
+
+        if !self.announce_private_addr {
+            if let BroadcastMessage::NodeAnnouncement(node_announcement) = &message {
+                if !node_announcement.addresses.iter().any(|addr| {
+                    multiaddr_to_socketaddr(addr)
+                        .map(|socket_addr| is_reachable(socket_addr.ip()))
+                        .unwrap_or_default()
+                }) {
+                    return Err(GossipMessageProcessingError::ProcessingError(
+                        "private address node announcement".to_string(),
+                    ));
+                }
+            }
         }
 
         trace!("New gossip message saved to memory: {:?}", message);
         self.messages_to_be_saved.insert(message.clone());
-        Ok(message)
+        Ok(())
     }
 
-    fn has_dependencies_available(&self, message: &BroadcastMessageWithTimestamp) -> bool {
+    fn has_dependencies_available(&self, message: &BroadcastMessage) -> bool {
         match message {
-            BroadcastMessageWithTimestamp::ChannelUpdate(channel_update) => self
+            BroadcastMessage::ChannelUpdate(channel_update) => self
                 .get_channel_annnouncement(&channel_update.channel_outpoint)
                 .is_some(),
             _ => true,
@@ -1187,24 +1167,24 @@ impl<S: GossipMessageStore> ExtendedGossipMessageStoreActor<S> {
 impl<S: GossipMessageStore + Send + Sync + 'static> Actor for ExtendedGossipMessageStoreActor<S> {
     type Msg = ExtendedGossipMessageStoreMessage;
     type State = ExtendedGossipMessageStoreState<S>;
-    type Arguments = (
-        Duration,
-        S,
-        ActorRef<GossipActorMessage>,
-        ActorRef<CkbChainMessage>,
-    );
+    type Arguments = (Duration, bool, S, ActorRef<CkbChainMessage>);
 
     async fn pre_start(
         &self,
         myself: ActorRef<Self::Msg>,
-        (gossip_store_maintenance_interval, store, gossip_actor, chain_actor): Self::Arguments,
+        (
+            gossip_store_maintenance_interval,
+            announce_private_addr,
+            store,
+            chain_actor,
+        ): Self::Arguments,
     ) -> Result<Self::State, ActorProcessingErr> {
         myself.send_interval(gossip_store_maintenance_interval, || {
             ExtendedGossipMessageStoreMessage::Tick
         });
         Ok(ExtendedGossipMessageStoreState::new(
+            announce_private_addr,
             store,
-            gossip_actor,
             chain_actor,
         ))
     }
@@ -1300,11 +1280,6 @@ impl<S: GossipMessageStore + Send + Sync + 'static> Actor for ExtendedGossipMess
                                 m.cursor(),
                             ))
                             .expect("actor alive");
-                        debug!(
-                            "Sending messages to subscription #{}: number of messages = {}",
-                            id,
-                            messages.len()
-                        );
                         subscription
                             .output_port
                             .send(GossipMessageUpdates::new(messages));
@@ -1315,62 +1290,28 @@ impl<S: GossipMessageStore + Send + Sync + 'static> Actor for ExtendedGossipMess
                 }
             }
 
-            ExtendedGossipMessageStoreMessage::SaveMessage(message) => {
-                if let Err(error) = state.insert_message_to_be_saved_list(&message).await {
-                    error!(
-                        "Failed to save message to the store: {:?}, error: {:?}",
-                        message, error
-                    );
+            ExtendedGossipMessageStoreMessage::SaveMessages(messages) => {
+                for message in messages {
+                    if let Err(error) = state.insert_message_to_be_saved_list(&message).await {
+                        trace!("Failed to save message: {:?}, error: {:?}", message, error);
+                    }
                 }
             }
 
-            ExtendedGossipMessageStoreMessage::SaveAndBroadcastMessage(message) => {
-                match state.insert_message_to_be_saved_list(&message).await {
-                    Err(error) => error!(
-                        "Failed to save message to the store: {:?}, error: {:?}",
-                        message, error
-                    ),
-                    Ok(message) => {
-                        // Normally we will need to check if the message has any dependencies that are not saved yet.
-                        // But this is not necessary for the messages that we are proactively broadcasting.
-                        // These are our own channel announcements, channel updates and node announcements.
-                        let _ = state
-                            .gossip_actor
-                            .send_message(GossipActorMessage::BroadcastMessageImmediately(message));
-                    }
-                }
+            ExtendedGossipMessageStoreMessage::SaveAndBroadcastMessages(messages) => {
+                state.store_and_broadcast_messages(&messages);
             }
 
             ExtendedGossipMessageStoreMessage::Tick => {
                 trace!(
-                    "Gossip store maintenance ticked: last_cursor = {:?} #subscriptions = {},  #messages_to_be_saved = {}",
-                    state.last_cursor,
+                    "Gossip store maintenance ticked: #subscriptions = {},  #messages_to_be_saved = {}",
                     state.output_ports.len(),
                     state.messages_to_be_saved.len(),
                 );
 
                 // These are the messages that have complete dependencies and can be sent to the subscribers.
                 let complete_messages = state.prune_messages_to_be_saved().await;
-                if complete_messages.is_empty() {
-                    return Ok(());
-                }
-                for (id, subscription) in state.output_ports.iter() {
-                    let messages_to_send = complete_messages
-                        .iter()
-                        .filter(|m| &m.cursor() > &subscription.filter)
-                        .cloned()
-                        .collect::<Vec<_>>();
-                    trace!(
-                        "Sending complete messages in memory to subscription #{}: number of messages = {}",
-                        id,
-                        messages_to_send.len()
-                    );
-                    for chunk in messages_to_send.chunks(MAX_NUM_OF_BROADCAST_MESSAGES as usize) {
-                        subscription
-                            .output_port
-                            .send(GossipMessageUpdates::new(chunk.to_vec()));
-                    }
-                }
+                state.broadcast_messages(&complete_messages);
             }
         }
         Ok(())
@@ -1391,22 +1332,19 @@ pub enum ExtendedGossipMessageStoreMessage {
     // Update the subscription. If this Option is None, the subscription will be cancelled.
     // Otherwise the new cursor will be used to filter the messages that are sent to the subscriber.
     UpdateSubscription(u64, Option<Cursor>, RpcReplyPort<()>),
-    // Save a new broadcast message to the store. We will check if the message has any dependencies that are not
-    // saved yet. If it has, we will save it to messages_to_be_saved, otherwise we will save it to the store.
-    // We may also save the message to lagged_messages if the message is lagged.
-    // We may pass a bool parameter to indicate if a output port to wait for the message to be saved should be
-    // returned. If there is any error while saving the message, we will send an error message to the output port.
-    SaveMessage(BroadcastMessage),
-    // Save a new message to the store. If the message's dependencies are all met, then we will
-    // broadcast the message to the network. Otherwise, we will ignore the broadcasting.
-    SaveAndBroadcastMessage(BroadcastMessage),
+    // Save new broadcast messages to the store. The messages will be first saved to the memory,
+    // then if all the dependencies are met, they are periodically saved to the store and sent to the subscribers.
+    SaveMessages(Vec<BroadcastMessage>),
+    // Save new messages to the store, and broadcast them to the subscribers immediately.
+    // These messages will not be saved to the memory and wait for the dependencies to be met.
+    // We normally use this variant to send our own messages to the subscribers.
+    SaveAndBroadcastMessages(Vec<BroadcastMessageWithTimestamp>),
     // Send broadcast messages after the cursor to the subscriber specified in the u64 id.
     // This is normally called immediately after a new subscription is created. This is the time when
     // we need to send existing messages to the subscriber.
     LoadMessagesFromStore(u64, Cursor),
     // A tick message that is sent periodically to check if there are any messages that are saved out of order.
     // If there are, we will send them to the subscribers.
-    // This tick will also advance the last_cursor upon finishing.
     Tick,
 }
 
@@ -1543,10 +1481,6 @@ where
 
     async fn start_new_active_syncer(&mut self, peer_id: &PeerId) {
         let safe_cursor = self.get_safe_cursor_to_start_syncing();
-        debug!(
-            "Starting active syncer to peer {:?} with cursor {:?}",
-            peer_id, safe_cursor
-        );
         let sync_actor = Actor::spawn_linked(
             Some(format!(
                 "gossip syncing actor to peer {:?} supervised by {:?}",
@@ -1574,10 +1508,6 @@ where
 
     async fn start_passive_syncer(&mut self, peer_id: &PeerId) {
         let cursor = self.get_safe_cursor_to_start_syncing();
-        debug!(
-            "Starting passive syncer to peer {:?} from cursor {:?}",
-            peer_id, cursor
-        );
         let filter = BroadcastMessagesFilter {
             chain_hash: get_chain_hash(),
             after_cursor: cursor.clone(),
@@ -1600,7 +1530,6 @@ where
     }
 
     async fn stop_passive_syncer(&mut self, peer_id: &PeerId) {
-        debug!("Stopping passive syncer to peer {:?}", peer_id);
         let filter = BroadcastMessagesFilter {
             chain_hash: get_chain_hash(),
             after_cursor: Cursor::max(),
@@ -1631,10 +1560,6 @@ where
         peer_id: &PeerId,
         filter: BroadcastMessagesFilter,
     ) -> crate::Result<()> {
-        debug!(
-            "Sending BroadcastMessagesFilter to peer {:?}: {:?}",
-            &peer_id, &filter
-        );
         let message = GossipMessage::BroadcastMessagesFilter(filter);
         self.send_message_to_peer(peer_id, message).await?;
         Ok(())
@@ -1674,7 +1599,9 @@ where
         let _ = self
             .store
             .actor
-            .send_message(ExtendedGossipMessageStoreMessage::SaveMessage(message))
+            .send_message(ExtendedGossipMessageStoreMessage::SaveMessages(vec![
+                message,
+            ]))
             .expect("store actor alive");
     }
 
@@ -1767,12 +1694,30 @@ fn get_dependent_message_queries<S: GossipMessageStore>(
 }
 
 async fn get_message_cursor<S: GossipMessageStore>(
-    message: BroadcastMessage,
+    message: &BroadcastMessage,
     store: &S,
     chain: &ActorRef<CkbChainMessage>,
 ) -> Result<Cursor, Error> {
-    let m = get_broadcast_message_with_timestamp(message, store, chain).await?;
-    Ok(m.cursor())
+    match message {
+        BroadcastMessage::ChannelAnnouncement(channel_announcement) => {
+            let timestamp =
+                get_channel_timestamp(&channel_announcement.channel_outpoint, store, chain).await?;
+            Ok(Cursor::new(
+                timestamp,
+                BroadcastMessageID::ChannelAnnouncement(
+                    channel_announcement.channel_outpoint.clone(),
+                ),
+            ))
+        }
+        BroadcastMessage::ChannelUpdate(channel_update) => Ok(Cursor::new(
+            channel_update.timestamp,
+            BroadcastMessageID::ChannelUpdate(channel_update.channel_outpoint.clone()),
+        )),
+        BroadcastMessage::NodeAnnouncement(node_announcement) => Ok(Cursor::new(
+            node_announcement.timestamp,
+            BroadcastMessageID::NodeAnnouncement(node_announcement.node_id.clone()),
+        )),
+    }
 }
 
 fn get_existing_broadcast_message<S: GossipMessageStore>(
@@ -1813,60 +1758,42 @@ fn get_existing_newer_broadcast_message<S: GossipMessageStore>(
     })
 }
 
-async fn get_broadcast_message_with_timestamp<S: GossipMessageStore>(
-    message: BroadcastMessage,
+// Verify and save broadcast messages to the store.
+// Note that we can't relialy verify a message until we have all the messages that it depends on.
+// So this function should be called by the dependency order of the messages.
+// E.g. channel updates depends on channel announcements to obtain the node public keys,
+// so we should call this method to save and verify channel announcements before channel updates.
+async fn verify_and_save_broadcast_message<S: GossipMessageStore>(
+    message: &BroadcastMessage,
     store: &S,
     chain: &ActorRef<CkbChainMessage>,
 ) -> Result<BroadcastMessageWithTimestamp, Error> {
-    match message {
+    let timestamp = match message {
         BroadcastMessage::ChannelAnnouncement(channel_announcement) => {
-            let timestamp =
-                get_channel_timestamp(&channel_announcement.channel_outpoint, store, chain).await?;
-            Ok(BroadcastMessageWithTimestamp::ChannelAnnouncement(
-                timestamp,
-                channel_announcement,
-            ))
-        }
-        BroadcastMessage::ChannelUpdate(channel_update) => {
-            Ok(BroadcastMessageWithTimestamp::ChannelUpdate(channel_update))
-        }
-        BroadcastMessage::NodeAnnouncement(node_announcement) => Ok(
-            BroadcastMessageWithTimestamp::NodeAnnouncement(node_announcement),
-        ),
-    }
-}
-
-// Channel updates depends on channel announcements to obtain the node public keys.
-// If a channel update is saved before the channel announcement, we can't reliably determine if
-// this channel update is valid. So we need to save the channel update to lagged_messages and
-// wait for the channel announcement to be saved. The bool value returned indicates if the
-// message is fully verified and can be saved to the store.
-// In the same vein, channel announcement contains references to node announcements. If a node
-// announcement is saved before the channel announcement, we need to temporarily save the channel
-// announcement to lagged_messages and wait for the node announcement to be saved.
-async fn verify_and_save_broadcast_message<S: GossipMessageStore>(
-    message: &BroadcastMessageWithTimestamp,
-    store: &S,
-    chain: &ActorRef<CkbChainMessage>,
-) -> Result<(), Error> {
-    match message {
-        BroadcastMessageWithTimestamp::ChannelAnnouncement(timestamp, channel_announcement) => {
-            if !verify_channel_announcement(channel_announcement, store, chain).await? {
-                store.save_channel_announcement(*timestamp, channel_announcement.clone());
+            let on_chain_info =
+                get_channel_on_chain_info(channel_announcement.out_point(), chain).await?;
+            if !verify_channel_announcement(channel_announcement, &on_chain_info, store).await? {
+                store.save_channel_announcement(
+                    on_chain_info.timestamp,
+                    channel_announcement.clone(),
+                );
             }
+            on_chain_info.timestamp
         }
-        BroadcastMessageWithTimestamp::ChannelUpdate(channel_update) => {
+        BroadcastMessage::ChannelUpdate(channel_update) => {
             if !verify_channel_update(channel_update, store)? {
                 store.save_channel_update(channel_update.clone());
             }
+            channel_update.timestamp
         }
-        BroadcastMessageWithTimestamp::NodeAnnouncement(node_announcement) => {
+        BroadcastMessage::NodeAnnouncement(node_announcement) => {
             if !verify_node_announcement(node_announcement, store)? {
                 store.save_node_announcement(node_announcement.clone());
             }
+            node_announcement.timestamp
         }
-    }
-    Ok(())
+    };
+    Ok((message.clone(), timestamp).into())
 }
 
 async fn get_channel_tx(
@@ -1879,7 +1806,7 @@ async fn get_channel_tx(
         DEFAULT_CHAIN_ACTOR_TIMEOUT,
         TraceTxRequest {
             tx_hash: outpoint.tx_hash(),
-            confirmations: 1,
+            confirmations: 2,
         }
     ) {
         Ok(TraceTxResponse {
@@ -1908,7 +1835,26 @@ async fn get_channel_timestamp<S: GossipMessageStore>(
         return Ok(timestamp);
     }
 
-    let (_, block_hash) = get_channel_tx(outpoint, chain).await?;
+    let on_chain_info = get_channel_on_chain_info(outpoint, chain).await?;
+
+    Ok(on_chain_info.timestamp)
+}
+
+async fn get_channel_on_chain_info(
+    outpoint: &OutPoint,
+    chain: &ActorRef<CkbChainMessage>,
+) -> Result<ChannelOnchainInfo, Error> {
+    let (tx, block_hash) = get_channel_tx(outpoint, chain).await?;
+    let first_output = match tx.inner.outputs.first() {
+        None => {
+            return Err(Error::InvalidParameter(format!(
+                "On-chain transaction found but no output: {:?}",
+                &outpoint
+            )));
+        }
+        Some(output) => output.clone(),
+    };
+
     let timestamp: u64 = match call_t!(
         chain,
         CkbChainMessage::GetBlockTimestamp,
@@ -1936,7 +1882,10 @@ async fn get_channel_timestamp<S: GossipMessageStore>(
         }
     };
 
-    Ok(timestamp)
+    Ok(ChannelOnchainInfo {
+        timestamp,
+        first_output,
+    })
 }
 
 // Verify the channel announcement message. If any error occurs, return the error.
@@ -1945,13 +1894,9 @@ async fn get_channel_timestamp<S: GossipMessageStore>(
 // is true, otherwise it is false.
 async fn verify_channel_announcement<S: GossipMessageStore>(
     channel_announcement: &ChannelAnnouncement,
+    on_chain_info: &ChannelOnchainInfo,
     store: &S,
-    chain: &ActorRef<CkbChainMessage>,
 ) -> Result<bool, Error> {
-    debug!(
-        "Verifying channel announcement message: {:?}",
-        &channel_announcement
-    );
     if let Some((_, announcement)) =
         store.get_latest_channel_announcement(&channel_announcement.channel_outpoint)
     {
@@ -2007,45 +1952,32 @@ async fn verify_channel_announcement<S: GossipMessageStore>(
         )));
     }
 
-    debug!(
-        "Node signatures in channel announcement message verified: {:?}",
-        &channel_announcement
-    );
-
-    let (tx, _) = get_channel_tx(&channel_announcement.channel_outpoint, chain).await?;
-
-    debug!("Channel announcement transaction found: {:?}", &tx);
-
     let pubkey = channel_announcement.ckb_key.serialize();
     let pubkey_hash = &blake2b_256(pubkey.as_slice())[0..20];
-    match tx.inner.outputs.first() {
-        None => {
-            return Err(Error::InvalidParameter(format!(
-                "On-chain transaction found but no output: {:?}",
-                &channel_announcement
-            )));
-        }
-        Some(output) => {
-            if output.lock.args.as_bytes() != pubkey_hash {
-                return Err(Error::InvalidParameter(format!(
+
+    let output = &on_chain_info.first_output;
+    if output.lock.args.as_bytes() != pubkey_hash {
+        return Err(Error::InvalidParameter(format!(
                     "On-chain transaction found but pubkey hash mismatched: on chain hash {:?}, pub key ({:?}) hash {:?}",
                     &output.lock.args.as_bytes(),
                     hex::encode(pubkey),
                     &pubkey_hash
                 )));
-            }
-            let capacity: u128 = u64::from(output.capacity).into();
-            if channel_announcement.udt_type_script.is_none()
-                && channel_announcement.capacity > capacity
-            {
+    }
+    let capacity: u128 = u64::from(output.capacity).into();
+    match channel_announcement.udt_type_script {
+        Some(_) => {
+            // TODO: verify the capacity of the UDT
+        }
+        None => {
+            if channel_announcement.capacity > capacity {
                 return Err(Error::InvalidParameter(format!(
-                    "On-chain transaction found but capacity mismatched: on chain capacity {:?} smaller than annoucned channel capacity {:?}",
-                    &output.capacity, &channel_announcement.capacity
-                )));
+                            "On-chain transaction found but capacity mismatched: on chain capacity {:?} smaller than annoucned channel capacity {:?}",
+                            &output.capacity, &channel_announcement.capacity
+                        )));
             }
-            capacity
         }
-    };
+    }
 
     if let Err(err) = secp256k1_instance().verify_schnorr(
         ckb_signature,
@@ -2062,11 +1994,6 @@ async fn verify_channel_announcement<S: GossipMessageStore>(
         )));
     }
 
-    debug!(
-        "All signatures in channel announcement message verified: {:?}",
-        &channel_announcement
-    );
-
     Ok(false)
 }
 
@@ -2108,10 +2035,6 @@ fn verify_channel_update<S: GossipMessageStore>(
             } else {
                 channel_announcement.node2_id
             };
-            debug!(
-                "Verifying channel update message signature: {:?}, pubkey: {:?}, message: {:?}",
-                &channel_update, &pubkey, &message
-            );
             if !signature.verify(&pubkey, &message) {
                 return Err(Error::InvalidParameter(format!(
                     "Channel update message signature verification failed (invalid signature): {:?}",
@@ -2154,20 +2077,12 @@ fn verify_node_announcement<S: GossipMessageStore>(
     }
     let message = node_announcement.message_to_sign();
     match node_announcement.signature {
-        Some(ref signature) if signature.verify(&node_announcement.node_id, &message) => {
-            debug!(
-                "Node announcement message verified: {:?}",
-                &node_announcement
-            );
-        }
-        _ => {
-            return Err(Error::InvalidParameter(format!(
-                "Node announcement message signature verification failed: {:?}",
-                &node_announcement
-            )));
-        }
+        Some(ref signature) if signature.verify(&node_announcement.node_id, &message) => Ok(false),
+        _ => Err(Error::InvalidParameter(format!(
+            "Node announcement message signature verification failed: {:?}",
+            &node_announcement
+        ))),
     }
-    Ok(false)
 }
 
 impl GossipProtocolHandle {
@@ -2175,6 +2090,7 @@ impl GossipProtocolHandle {
         name: Option<String>,
         gossip_network_maintenance_interval: Duration,
         gossip_store_maintenance_interval: Duration,
+        announce_private_addr: bool,
         store: S,
         chain_actor: ActorRef<CkbChainMessage>,
         supervisor: ActorCell,
@@ -2193,6 +2109,7 @@ impl GossipProtocolHandle {
                 store_sender,
                 gossip_network_maintenance_interval,
                 gossip_store_maintenance_interval,
+                announce_private_addr,
                 store,
                 chain_actor,
             ),
@@ -2236,6 +2153,7 @@ where
         oneshot::Sender<ExtendedGossipMessageStore<S>>,
         Duration,
         Duration,
+        bool,
         S,
         ActorRef<CkbChainMessage>,
     );
@@ -2243,12 +2161,20 @@ where
     async fn pre_start(
         &self,
         myself: ActorRef<Self::Msg>,
-        (rx, tx, network_maintenance_interval, store_maintenance_interval, store, chain_actor): Self::Arguments,
+        (
+            rx,
+            tx,
+            network_maintenance_interval,
+            store_maintenance_interval,
+            announce_private_addr,
+            store,
+            chain_actor,
+        ): Self::Arguments,
     ) -> Result<Self::State, ActorProcessingErr> {
         let store = ExtendedGossipMessageStore::new(
             store_maintenance_interval,
+            announce_private_addr,
             store,
-            myself.clone(),
             chain_actor.clone(),
             myself.get_cell(),
         )
@@ -2262,9 +2188,6 @@ where
             .expect("receive control");
         debug!("Gossip actor received service control");
 
-        let _ = myself.send_after(Duration::from_millis(500), || {
-            GossipActorMessage::TickNetworkMaintenance
-        });
         let _ = myself.send_interval(network_maintenance_interval, || {
             GossipActorMessage::TickNetworkMaintenance
         });
@@ -2293,8 +2216,8 @@ where
             SupervisionEvent::ActorTerminated(who, _, _) => {
                 debug!("{:?} terminated", who);
             }
-            SupervisionEvent::ActorPanicked(who, _) => {
-                error!("{:?} panicked", who);
+            SupervisionEvent::ActorPanicked(who, err) => {
+                panic!("Actor unexpectedly panicked (id: {:?}): {:?}", who, err);
             }
             _ => {}
         }
@@ -2308,28 +2231,16 @@ where
         state: &mut Self::State,
     ) -> Result<(), ActorProcessingErr> {
         match message {
-            GossipActorMessage::PeerConnected(peer_id, pubkey, session) => {
+            GossipActorMessage::PeerConnected(peer_id, _pubkey, session) => {
                 if state.is_peer_connected(&peer_id) {
-                    warn!(
-                        "Repeated connection from {:?} for gossip protocol",
-                        &peer_id
-                    );
                     return Ok(());
                 }
-                debug!(
-                    "Gossip peer connected: peer {:?}, pubkey {:?}, session {:?}",
-                    &peer_id, &pubkey, &session.id
-                );
                 state
                     .peer_states
                     .insert(peer_id.clone(), PeerState::new(session.id, session.ty));
             }
-            GossipActorMessage::PeerDisconnected(peer_id, session) => {
-                debug!(
-                    "Peer disconnected: peer {:?}, session {:?}",
-                    &peer_id, &session.id
-                );
-                drop(state.peer_states.remove(&peer_id));
+            GossipActorMessage::PeerDisconnected(peer_id, _session) => {
+                state.peer_states.remove(&peer_id);
             }
             GossipActorMessage::ProcessBroadcastMessage(message) => {
                 state
@@ -2350,47 +2261,16 @@ where
                     .await?;
             }
             GossipActorMessage::TryBroadcastMessages(messages) => {
-                debug!("Trying to broadcast message: {:?}", &messages);
-                for message in messages {
-                    state
-                        .store
-                        .actor
-                        .send_message(ExtendedGossipMessageStoreMessage::SaveAndBroadcastMessage(
-                            message.clone(),
-                        ))
-                        .expect("store actor alive");
-                }
-            }
-            GossipActorMessage::BroadcastMessageImmediately(message) => {
-                for (peer, peer_state) in &state.peer_states {
-                    let session = peer_state.session_id;
-                    match &peer_state.filter_processor {
-                        Some(filter_processor)
-                            if filter_processor.get_filter() < &message.cursor() =>
-                        {
-                            trace!("Broadcasting message to peer {:?}: {:?}", &peer, &message);
-                            state
-                                .send_message_to_session(
-                                    session,
-                                    GossipMessage::BroadcastMessagesFilterResult(
-                                        message.create_broadcast_messages_filter_result(),
-                                    ),
-                                )
-                                .await?;
-                        }
-                        _ => {
-                            debug!(
-                                "Ignoring broadcast message for peer {:?}: {:?} as its filter processor is {:?}",
-                                peer, &message, &peer_state.filter_processor
-                            );
-                        }
-                    }
-                }
+                state
+                    .store
+                    .actor
+                    .send_message(ExtendedGossipMessageStoreMessage::SaveAndBroadcastMessages(
+                        messages,
+                    ))
+                    .expect("store actor alive");
             }
-
             GossipActorMessage::RotateOutboundPassiveSyncingPeers => {
                 if !state.is_ready_for_passive_syncing() {
-                    debug!("Not ready for passive syncing, skipping rotation");
                     return Ok(());
                 }
 
@@ -2461,10 +2341,6 @@ where
             }
 
             GossipActorMessage::ActiveSyncingFinished(peer_id, cursor) => {
-                debug!(
-                    "Active syncing finished for peer {:?}: {:?}",
-                    &peer_id, &cursor
-                );
                 state.num_finished_active_syncing_peers += 1;
                 if let Some(peer_state) = state.peer_states.get_mut(&peer_id) {
                     peer_state.change_sync_status(PeerSyncStatus::FinishedActiveSyncing(
@@ -2475,7 +2351,7 @@ where
             }
 
             GossipActorMessage::MaliciousPeerFound(peer_id) => {
-                debug!("Malicious peer found: {:?}", &peer_id);
+                warn!("Malicious peer found: {:?}", &peer_id);
             }
 
             GossipActorMessage::SendGossipMessage(GossipMessageWithPeerId { peer_id, message }) => {
@@ -2509,20 +2385,10 @@ where
                             Some(peer_state) => {
                                 match peer_state.filter_processor.as_mut() {
                                     Some(filter_processor) => {
-                                        debug!(
-                                        "Updating filter processor for peer {:?}: from {:?} {:?}",
-                                        &peer_id,
-                                        filter_processor.get_filter(),
-                                        &after_cursor
-                                    );
                                         filter_processor.update_filter(&after_cursor);
                                         return Ok(());
                                     }
                                     _ => {
-                                        debug!(
-                                            "Creating filter processor for peer {:?}: {:?}",
-                                            &peer_id, &after_cursor
-                                        );
                                         peer_state.filter_processor = Some(
                                             PeerFilterProcessor::new(
                                                 state.store.clone(),
diff --git a/src/fiber/graph.rs b/src/fiber/graph.rs
index b9d30de8b..dc080291f 100644
--- a/src/fiber/graph.rs
+++ b/src/fiber/graph.rs
@@ -2,7 +2,7 @@ use super::channel::ChannelActorStateStore;
 use super::config::AnnouncedNodeName;
 use super::gossip::GossipMessageStore;
 use super::history::{Direction, InternalResult, PaymentHistory, TimedResult};
-use super::network::{get_chain_hash, SendPaymentData, SendPaymentResponse};
+use super::network::{get_chain_hash, HopHint, SendPaymentData, SendPaymentResponse};
 use super::path::NodeHeap;
 use super::types::{
     BroadcastMessageID, BroadcastMessageWithTimestamp, ChannelAnnouncement, ChannelUpdate, Hash256,
@@ -17,11 +17,14 @@ use crate::fiber::types::PaymentHopData;
 use crate::invoice::CkbInvoice;
 use crate::now_timestamp_as_millis_u64;
 use ckb_types::packed::{OutPoint, Script};
+use rand::seq::SliceRandom;
+use rand::thread_rng;
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
 use std::collections::{HashMap, HashSet};
 use tentacle::multiaddr::MultiAddr;
 use tentacle::secio::PeerId;
+use tentacle::utils::{is_reachable, multiaddr_to_socketaddr};
 use thiserror::Error;
 use tracing::log::error;
 use tracing::{debug, info, trace};
@@ -38,8 +41,8 @@ pub struct NodeInfo {
     // Tentatively using 64 bits for features. May change the type later while developing.
     // rust-lightning uses a Vec<u8> here.
     pub features: u64,
-    // The alias of the node. This is a human-readable string that is meant to be used for labelling nodes in the UI.
-    pub alias: AnnouncedNodeName,
+    // The name of the node. This is a human-readable string that is meant to be used for labelling nodes in the UI.
+    pub node_name: AnnouncedNodeName,
     // All the reachable addresses.
     pub addresses: Vec<MultiAddr>,
     // If the other party funding more than this amount, we will automatically accept the channel.
@@ -63,7 +66,7 @@ impl From<NodeAnnouncement> for NodeInfo {
             node_id: value.node_id,
             timestamp: value.timestamp,
             features: value.features,
-            alias: value.alias,
+            node_name: value.node_name,
             addresses: value.addresses,
             auto_accept_min_ckb_funding_amount: value.auto_accept_min_ckb_funding_amount,
             udt_cfg_infos: value.udt_cfg_infos,
@@ -218,6 +221,8 @@ pub struct NetworkGraph<S> {
     // as a NetworkGraphStateStore.
     store: S,
     history: PaymentHistory<S>,
+    // Whether to process announcement of private address
+    announce_private_addr: bool,
 }
 
 #[derive(Error, Debug)]
@@ -246,7 +251,7 @@ where
         + Sync
         + 'static,
 {
-    pub fn new(store: S, source: Pubkey) -> Self {
+    pub fn new(store: S, source: Pubkey, announce_private_addr: bool) -> Self {
         let mut network_graph = Self {
             source,
             channels: HashMap::new(),
@@ -254,6 +259,7 @@ where
             latest_cursor: Cursor::default(),
             store: store.clone(),
             history: PaymentHistory::new(source, None, store),
+            announce_private_addr,
         };
         network_graph.load_from_store();
         network_graph
@@ -438,7 +444,21 @@ where
         }
     }
 
-    fn process_node_announcement(&mut self, node_announcement: NodeAnnouncement) -> Option<Cursor> {
+    fn process_node_announcement(
+        &mut self,
+        mut node_announcement: NodeAnnouncement,
+    ) -> Option<Cursor> {
+        if !self.announce_private_addr {
+            node_announcement.addresses.retain(|addr| {
+                multiaddr_to_socketaddr(addr)
+                    .map(|socket_addr| is_reachable(socket_addr.ip()))
+                    .unwrap_or_default()
+            });
+
+            if node_announcement.addresses.is_empty() {
+                return None;
+            }
+        }
         let node_info = NodeInfo::from(node_announcement);
         match self.nodes.get(&node_info.node_id) {
             Some(old_node) if old_node.timestamp > node_info.timestamp => {
@@ -523,7 +543,11 @@ where
                 ) => {
                     let mut channel_info = ChannelInfo::from((timestamp, channel_announcement));
                     self.load_channel_updates_from_store(&mut channel_info);
-                    Some(channel_info)
+                    if channel_info.is_explicitly_disabled() {
+                        None
+                    } else {
+                        Some(channel_info)
+                    }
                 }
                 _ => None,
             })
@@ -550,7 +574,7 @@ where
         &self,
         node_id: Pubkey,
     ) -> impl Iterator<Item = (Pubkey, Pubkey, &ChannelInfo, &ChannelUpdateInfo)> {
-        let mut channels: Vec<(Pubkey, Pubkey, &ChannelInfo, &ChannelUpdateInfo)> = self
+        let mut channels: Vec<_> = self
             .channels
             .values()
             .filter_map(move |channel| {
@@ -688,6 +712,7 @@ where
             final_tlc_expiry_delta,
             payment_data.tlc_expiry_limit,
             allow_self_payment,
+            payment_data.hop_hints,
         )?;
         assert!(!route.is_empty());
 
@@ -777,6 +802,7 @@ where
         final_tlc_expiry_delta: u64,
         tlc_expiry_limit: u64,
         allow_self: bool,
+        hop_hints: Vec<HopHint>,
     ) -> Result<Vec<PathEdge>, PathFindError> {
         let started_time = std::time::Instant::now();
         let nodes_len = self.nodes.len();
@@ -787,12 +813,6 @@ where
         let mut edges_expanded = 0;
         let mut nodes_heap = NodeHeap::new(nodes_len);
         let mut distances = HashMap::<Pubkey, NodeHeapElement>::new();
-        // a map from node_id to the selected channel outpoint
-        // suppose the scenario of A <-- channel_1 --> B <-- channel_2 --> A
-        // when we starting iterate channels from A, we may considerting channel_1 and channel_2,
-        // and we selected channel_1 according to weight
-        // in this case, `last_hop_channels` stores (B -> channel_1) so that we can skip channel_1 when we iterate channels from B
-        let mut last_hop_channels = HashMap::new();
 
         if amount == 0 {
             return Err(PathFindError::Amount(
@@ -806,19 +826,28 @@ where
             ));
         }
 
-        let Some(source_node) = self.nodes.get(&source) else {
-            return Err(PathFindError::PathFind(format!(
-                "source node not found: {:?}",
-                &source
-            )));
-        };
-        let Some(_target_node) = self.nodes.get(&target) else {
-            return Err(PathFindError::PathFind(format!(
-                "target node not found: {:?}",
-                &target
-            )));
-        };
-
+        let hop_hint_map: HashMap<(Pubkey, bool), OutPoint> = hop_hints
+            .into_iter()
+            .map(|hint| {
+                (
+                    (hint.pubkey, hint.inbound),
+                    OutPoint::new(hint.channel_funding_tx.into(), 0),
+                )
+            })
+            .collect::<HashMap<_, _>>();
+
+        let mut target = target;
+        let mut current_expiry = final_tlc_expiry_delta;
+        let mut last_edge = None;
+
+        if route_to_self {
+            let (new_target, expiry, edge) =
+                self.adjust_target_for_route_self(&hop_hint_map, amount, source, target)?;
+            target = new_target;
+            last_edge = edge;
+            current_expiry += expiry;
+        }
+        assert_ne!(source, target);
         // initialize the target node
         nodes_heap.push(NodeHeapElement {
             node_id: target,
@@ -828,7 +857,7 @@ where
             fee_charged: 0,
             probability: 1.0,
             next_hop: None,
-            incoming_tlc_expiry: final_tlc_expiry_delta,
+            incoming_tlc_expiry: current_expiry,
         });
 
         while let Some(cur_hop) = nodes_heap.pop() {
@@ -836,19 +865,26 @@ where
 
             for (from, to, channel_info, channel_update) in self.get_node_inbounds(cur_hop.node_id)
             {
-                if from == target && !route_to_self {
-                    continue;
-                }
+                assert_eq!(to, cur_hop.node_id);
                 if &udt_type_script != channel_info.udt_type_script() {
                     continue;
                 }
 
-                // if the channel is already visited in the last hop, skip it
-                if last_hop_channels
-                    .values()
-                    .any(|x| x == &channel_info.out_point())
-                {
-                    continue;
+                if let Some(channel) = hop_hint_map.get(&(from, false)) {
+                    if channel != channel_info.out_point() {
+                        continue;
+                    }
+                }
+                if let Some(channel) = hop_hint_map.get(&(to, true)) {
+                    if channel != channel_info.out_point() {
+                        continue;
+                    }
+                }
+
+                if let Some((_node, channel)) = &last_edge {
+                    if channel == channel_info.out_point() {
+                        continue;
+                    }
                 }
 
                 edges_expanded += 1;
@@ -900,12 +936,17 @@ where
                 }
 
                 // if this is a direct channel, try to load the channel actor state for balance
-                if from == self.source {
+                if from == self.source || to == self.source {
                     if let Some(state) = self
                         .store
                         .get_channel_state_by_outpoint(&channel_info.out_point())
                     {
-                        if amount_to_send > state.to_local_amount {
+                        let balance = if from == self.source {
+                            state.to_local_amount
+                        } else {
+                            state.to_remote_amount
+                        };
+                        if amount_to_send > balance {
                             continue;
                         }
                     }
@@ -962,13 +1003,12 @@ where
                     probability,
                     next_hop: Some((cur_hop.node_id, channel_info.out_point().clone())),
                 };
-                last_hop_channels.insert(node.node_id, channel_info.out_point());
                 distances.insert(node.node_id, node.clone());
                 nodes_heap.push_or_fix(node);
             }
         }
 
-        let mut current = source_node.node_id;
+        let mut current = source;
         while let Some(elem) = distances.remove(&current) {
             let (next_pubkey, next_out_point) = elem.next_hop.expect("next_hop is none");
             result.push(PathEdge {
@@ -991,10 +1031,72 @@ where
         if result.is_empty() || current != target {
             return Err(PathFindError::PathFind("no path found".to_string()));
         }
+        if let Some((node, channel)) = last_edge {
+            result.push(PathEdge {
+                target: node,
+                channel_outpoint: channel.clone(),
+            })
+        }
 
         Ok(result)
     }
 
+    fn adjust_target_for_route_self(
+        &self,
+        hop_hint_map: &HashMap<(Pubkey, bool), OutPoint>,
+        amount: u128,
+        source: Pubkey,
+        target: Pubkey,
+    ) -> Result<(Pubkey, u64, Option<(Pubkey, OutPoint)>), PathFindError> {
+        let direct_channels: Vec<(Pubkey, Pubkey, &ChannelInfo, &ChannelUpdateInfo)> = self
+            .get_node_inbounds(source)
+            .filter(|(_, _, channel_info, _)| {
+                if let Some(channel) = hop_hint_map.get(&(source, true)) {
+                    // if there is a hop hint for node -> source,
+                    // try to use this channel as the last candidate hop for route self
+                    // and we event don't check the direct balance of channel,
+                    // hop hint's priority is higher than direct balance
+                    return channel == channel_info.out_point();
+                }
+                if let Some(channel) = hop_hint_map.get(&(source, false)) {
+                    // if there is a hop hint for source -> node,
+                    // then we can not set this node as the last candidate hop for route self
+                    // so skip this channel
+                    if channel == channel_info.out_point() {
+                        return false;
+                    }
+                }
+                if let Some(state) = self
+                    .store
+                    .get_channel_state_by_outpoint(&channel_info.out_point())
+                {
+                    let balance = state.to_remote_amount;
+                    return balance >= amount;
+                }
+                // normal code path will not reach here, we must can get balance for direct channels
+                // anyway, check the capacity here for safety
+                return channel_info.capacity() >= amount;
+            })
+            .collect();
+
+        // a proper hop hint for route self will limit the direct_channels to only one
+        // if there are multiple channels, we will randomly select a channel from the source node for route to self
+        // so that the following part of algorithm will always trying to find a path without cycle
+        if let Some(&(from, _, channel_info, channel_update)) =
+            direct_channels.choose(&mut thread_rng())
+        {
+            let last_edge = Some((source, channel_info.out_point().clone()));
+            let current_expiry = channel_update.tlc_expiry_delta;
+            assert_ne!(target, from);
+            let target = from;
+            Ok((target, current_expiry, last_edge))
+        } else {
+            return Err(PathFindError::PathFind(
+                "no direct channel found for source node".to_string(),
+            ));
+        }
+    }
+
     fn edge_weight(&self, amount: u128, fee: u128, htlc_expiry_delta: u64) -> u128 {
         let risk_factor: u128 = 15;
         let time_lock_penalty = amount * htlc_expiry_delta as u128 * (risk_factor / 1000000000);
@@ -1028,7 +1130,7 @@ pub trait NetworkGraphStateStore {
 pub enum PaymentSessionStatus {
     // initial status, payment session is created, no HTLC is sent
     Created,
-    // related HTLC is send and waiting for the response
+    // the first hop AddTlc is sent successfully and waiting for the response
     Inflight,
     // related HTLC is successfully settled
     Success,
@@ -1103,10 +1205,6 @@ pub struct PaymentSession {
     pub status: PaymentSessionStatus,
     pub created_at: u64,
     pub last_updated_at: u64,
-    // The channel_outpoint and the tlc_id of the first hop
-    #[serde_as(as = "Option<EntityHex>")]
-    pub first_hop_channel_outpoint: Option<OutPoint>,
-    pub first_hop_tlc_id: Option<u64>,
     pub route: SessionRoute,
     // Session key for onion packet. Save it for decoding the error packet.
     pub session_key: [u8; 32],
@@ -1123,8 +1221,6 @@ impl PaymentSession {
             status: PaymentSessionStatus::Created,
             created_at: now,
             last_updated_at: now,
-            first_hop_channel_outpoint: None,
-            first_hop_tlc_id: None,
             route: SessionRoute::default(),
             session_key: Default::default(),
         }
@@ -1139,10 +1235,8 @@ impl PaymentSession {
         self.last_updated_at = now_timestamp_as_millis_u64();
     }
 
-    pub fn set_inflight_status(&mut self, channel_outpoint: OutPoint, tlc_id: u64) {
+    pub fn set_inflight_status(&mut self) {
         self.set_status(PaymentSessionStatus::Inflight);
-        self.first_hop_channel_outpoint = Some(channel_outpoint);
-        self.first_hop_tlc_id = Some(tlc_id);
     }
 
     pub fn set_success_status(&mut self) {
diff --git a/src/fiber/hash_algorithm.rs b/src/fiber/hash_algorithm.rs
index cc8a8603c..acc572bff 100644
--- a/src/fiber/hash_algorithm.rs
+++ b/src/fiber/hash_algorithm.rs
@@ -55,26 +55,3 @@ impl TryFrom<packed::Byte> for HashAlgorithm {
 pub fn sha256<T: AsRef<[u8]>>(s: T) -> [u8; 32] {
     Sha256::hash(s.as_ref()).to_byte_array()
 }
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn test_hash_algorithm_serialization_sha256() {
-        let algorithm = super::HashAlgorithm::Sha256;
-        let serialized = serde_json::to_string(&algorithm).expect("hash algorithm to json");
-        assert_eq!(serialized, r#""sha256""#);
-        let deserialized: super::HashAlgorithm =
-            serde_json::from_str(&serialized).expect("hash algorithm from json");
-        assert_eq!(deserialized, algorithm);
-    }
-
-    #[test]
-    fn test_hash_algorithm_serialization_ckb_hash() {
-        let algorithm = super::HashAlgorithm::CkbHash;
-        let serialized = serde_json::to_string(&algorithm).expect("hash algorithm to json");
-        assert_eq!(serialized, r#""ckb_hash""#);
-        let deserialized: super::HashAlgorithm =
-            serde_json::from_str(&serialized).expect("hash algorithm from json");
-        assert_eq!(deserialized, algorithm);
-    }
-}
diff --git a/src/fiber/network.rs b/src/fiber/network.rs
index f5b9cc709..132f696e0 100644
--- a/src/fiber/network.rs
+++ b/src/fiber/network.rs
@@ -1,8 +1,9 @@
 use ckb_hash::blake2b_256;
-use ckb_jsonrpc_types::{BlockNumber, Status, TxStatus};
+use ckb_jsonrpc_types::{Status, TxStatus};
 use ckb_types::core::{EpochNumberWithFraction, TransactionView};
 use ckb_types::packed::{Byte32, OutPoint, Script, Transaction};
 use ckb_types::prelude::{IntoTransactionView, Pack, Unpack};
+use ckb_types::H256;
 use once_cell::sync::OnceCell;
 use ractor::concurrency::Duration;
 use ractor::{
@@ -59,15 +60,18 @@ use super::gossip::{GossipActorMessage, GossipMessageStore, GossipMessageUpdates
 use super::graph::{NetworkGraph, NetworkGraphStateStore, SessionRoute};
 use super::key::blake2b_hash_with_salt;
 use super::types::{
-    BroadcastMessage, BroadcastMessageQuery, EcdsaSignature, FiberMessage, GossipMessage, Hash256,
-    NodeAnnouncement, OpenChannel, PaymentHopData, Privkey, Pubkey, RemoveTlcReason, TlcErr,
-    TlcErrData, TlcErrorCode,
+    BroadcastMessage, BroadcastMessageQuery, BroadcastMessageWithTimestamp, EcdsaSignature,
+    FiberMessage, ForwardTlcResult, GossipMessage, Hash256, NodeAnnouncement, OpenChannel,
+    PaymentHopData, Privkey, Pubkey, RemoveTlcReason, TlcErr, TlcErrData, TlcErrorCode,
 };
 use super::{FiberConfig, ASSUME_NETWORK_ACTOR_ALIVE};
 
 use crate::ckb::config::UdtCfgInfos;
 use crate::ckb::contracts::{check_udt_script, get_udt_whitelist, is_udt_type_auto_accept};
-use crate::ckb::{CkbChainMessage, FundingRequest, FundingTx, TraceTxRequest, TraceTxResponse};
+use crate::ckb::{
+    CkbChainMessage, FundingRequest, FundingTx, GetBlockTimestampRequest, TraceTxRequest,
+    TraceTxResponse,
+};
 use crate::fiber::channel::{
     AddTlcCommand, AddTlcResponse, TxCollaborationCommand, TxUpdateCommand,
 };
@@ -164,8 +168,7 @@ pub enum LocalInfoKind {
 #[derive(Debug, Clone)]
 pub struct NodeInfoResponse {
     pub node_name: Option<AnnouncedNodeName>,
-    pub peer_id: PeerId,
-    pub public_key: Pubkey,
+    pub node_id: Pubkey,
     pub addresses: Vec<MultiAddr>,
     pub chain_hash: Hash256,
     pub open_channel_auto_accept_min_ckb_funding_amount: u64,
@@ -214,7 +217,7 @@ pub enum NetworkActorCommand {
     ControlFiberChannel(ChannelCommandWithId),
     // The first parameter is the peeled onion in binary via `PeeledOnionPacket::serialize`. `PeeledOnionPacket::current`
     // is for the current node.
-    SendPaymentOnionPacket(SendOnionPacketCommand, RpcReplyPort<Result<u64, TlcErr>>),
+    SendPaymentOnionPacket(SendOnionPacketCommand),
     PeelPaymentOnionPacket(
         PaymentOnionPacket, // onion_packet
         Hash256,            // payment_hash
@@ -228,7 +231,7 @@ pub enum NetworkActorCommand {
     // we use this to query them.
     QueryBroadcastMessages(PeerId, Vec<BroadcastMessageQuery>),
     // Broadcast our BroadcastMessage to the network.
-    BroadcastMessages(Vec<BroadcastMessage>),
+    BroadcastMessages(Vec<BroadcastMessageWithTimestamp>),
     // Broadcast local information to the network.
     BroadcastLocalInfo(LocalInfoKind),
     SignMessage([u8; 32], RpcReplyPort<EcdsaSignature>),
@@ -302,10 +305,23 @@ pub struct SendPaymentCommand {
     pub udt_type_script: Option<Script>,
     // allow self payment, default is false
     pub allow_self_payment: bool,
+    // the hop hint which may help the find path algorithm to find the path
+    pub hop_hints: Option<Vec<HopHint>>,
     // dry_run only used for checking, default is false
     pub dry_run: bool,
 }
 
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct HopHint {
+    /// The public key of the node
+    pub pubkey: Pubkey,
+    /// The funding transaction hash of the channel outpoint
+    pub channel_funding_tx: Hash256,
+    /// inbound or outbound for the channel
+    pub inbound: bool,
+}
+
 #[serde_as]
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct SendPaymentData {
@@ -323,6 +339,7 @@ pub struct SendPaymentData {
     pub udt_type_script: Option<Script>,
     pub preimage: Option<Hash256>,
     pub allow_self_payment: bool,
+    pub hop_hints: Vec<HopHint>,
     pub dry_run: bool,
 }
 
@@ -450,6 +467,8 @@ impl SendPaymentData {
             ));
         }
 
+        let hop_hints = command.hop_hints.unwrap_or_default();
+
         Ok(SendPaymentData {
             target_pubkey: target,
             amount,
@@ -464,6 +483,7 @@ impl SendPaymentData {
             udt_type_script,
             preimage,
             allow_self_payment: command.allow_self_payment,
+            hop_hints,
             dry_run: command.dry_run,
         })
     }
@@ -511,6 +531,18 @@ pub enum DebugEvent {
     Common(String),
 }
 
+#[macro_export]
+macro_rules! debug_event {
+    ($network:expr, $debug_event:expr) => {
+        #[cfg(debug_assertions)]
+        $network
+            .send_message(NetworkActorMessage::new_notification(
+                NetworkServiceEvent::DebugEvent(DebugEvent::Common($debug_event.to_string())),
+            ))
+            .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+    };
+}
+
 #[derive(Clone, Debug)]
 pub enum NetworkServiceEvent {
     NetworkStarted(PeerId, MultiAddr, Vec<Multiaddr>),
@@ -587,8 +619,8 @@ pub enum NetworkActorEvent {
     FundingTransactionPending(Transaction, OutPoint, Hash256),
 
     /// A funding transaction has been confirmed. The transaction was included in the
-    /// block with the given transaction index.
-    FundingTransactionConfirmed(OutPoint, BlockNumber, u32),
+    /// block with the given transaction index, and the timestamp in the block header.
+    FundingTransactionConfirmed(OutPoint, H256, u32, u64),
 
     /// A funding transaction has failed.
     FundingTransactionFailed(OutPoint),
@@ -613,6 +645,13 @@ pub enum NetworkActorEvent {
 
     // A payment need to retry
     RetrySendPayment(Hash256),
+
+    // AddTlc result from peer (payment_hash, (process_channel_error, tlc_err), (previous_channel_id, previous_tlc_id))
+    AddTlcResult(
+        Hash256,
+        Option<(ProcessingChannelError, TlcErr)>,
+        Option<(Hash256, u64)>,
+    ),
 }
 
 #[derive(Debug)]
@@ -846,9 +885,14 @@ where
                     .on_funding_transaction_pending(transaction, outpoint.clone(), channel_id)
                     .await;
             }
-            NetworkActorEvent::FundingTransactionConfirmed(outpoint, block_number, tx_index) => {
+            NetworkActorEvent::FundingTransactionConfirmed(
+                outpoint,
+                block_hash,
+                tx_index,
+                timestamp,
+            ) => {
                 state
-                    .on_funding_transaction_confirmed(outpoint, block_number, tx_index)
+                    .on_funding_transaction_confirmed(outpoint, block_hash, tx_index, timestamp)
                     .await;
             }
             NetworkActorEvent::CommitmentTransactionPending(transaction, channel_id) => {
@@ -894,6 +938,10 @@ where
             NetworkActorEvent::RetrySendPayment(payment_hash) => {
                 let _ = self.try_payment_session(myself, state, payment_hash).await;
             }
+            NetworkActorEvent::AddTlcResult(payment_hash, error_info, previous_tlc) => {
+                self.on_add_tlc_result_event(myself, state, payment_hash, error_info, previous_tlc)
+                    .await;
+            }
             #[cfg(test)]
             NetworkActorEvent::GossipMessage(peer_id, message) => {
                 let _ = state
@@ -1088,9 +1136,8 @@ where
                     .await?
             }
 
-            NetworkActorCommand::SendPaymentOnionPacket(command, reply) => {
-                self.handle_send_onion_packet_command(state, command, reply)
-                    .await;
+            NetworkActorCommand::SendPaymentOnionPacket(command) => {
+                let _ = self.handle_send_onion_packet_command(state, command).await;
             }
             NetworkActorCommand::PeelPaymentOnionPacket(onion_packet, payment_hash, reply) => {
                 let response = onion_packet
@@ -1294,7 +1341,7 @@ where
                     myself
                         .send_message(NetworkActorMessage::new_command(
                             NetworkActorCommand::BroadcastMessages(vec![
-                                BroadcastMessage::NodeAnnouncement(message),
+                                BroadcastMessageWithTimestamp::NodeAnnouncement(message),
                             ]),
                         ))
                         .expect(ASSUME_NETWORK_MYSELF_ALIVE);
@@ -1306,8 +1353,7 @@ where
             NetworkActorCommand::NodeInfo(_, rpc) => {
                 let response = NodeInfoResponse {
                     node_name: state.node_name.clone(),
-                    peer_id: state.peer_id.clone(),
-                    public_key: state.get_public_key().clone(),
+                    node_id: state.get_public_key().clone(),
                     addresses: state.announced_addrs.clone(),
                     chain_hash: get_chain_hash(),
                     open_channel_auto_accept_min_ckb_funding_amount: state
@@ -1333,8 +1379,7 @@ where
         &self,
         state: &mut NetworkActorState<S>,
         command: SendOnionPacketCommand,
-        reply: RpcReplyPort<Result<u64, TlcErr>>,
-    ) {
+    ) -> Result<(), TlcErr> {
         let SendOnionPacketCommand {
             peeled_onion_packet,
             previous_tlc,
@@ -1343,8 +1388,6 @@ where
 
         let info = peeled_onion_packet.current.clone();
         let shared_secret = peeled_onion_packet.shared_secret;
-        debug!("Processing onion packet info: {:?}", info);
-
         let channel_outpoint = OutPoint::new(info.funding_tx_hash.into(), 0);
         let channel_id = match state.outpoint_channel_map.get(&channel_outpoint) {
             Some(channel_id) => channel_id,
@@ -1359,10 +1402,11 @@ where
                     channel_outpoint.clone(),
                     None,
                 );
-                return reply.send(Err(tlc_err)).expect("send add tlc response");
+                return Err(tlc_err);
             }
         };
-        let (send, recv) = oneshot::channel::<Result<AddTlcResponse, TlcErr>>();
+        let (send, _recv) = oneshot::channel::<Result<AddTlcResponse, TlcErr>>();
+        // explicitly don't wait for the response, we will handle the result in AddTlcResult
         let rpc_reply = RpcReplyPort::from(send);
         let command = ChannelCommand::AddTlc(
             AddTlcCommand {
@@ -1379,18 +1423,18 @@ where
 
         // we have already checked the channel_id is valid,
         match state.send_command_to_channel(*channel_id, command).await {
-            Ok(()) => {}
+            Ok(_) => {
+                return Ok(());
+            }
             Err(err) => {
                 error!(
                     "Failed to send onion packet to channel: {:?} with err: {:?}",
                     channel_id, err
                 );
                 let tlc_error = self.get_tlc_error(state, &err, &channel_outpoint);
-                return reply.send(Err(tlc_error)).expect("send add tlc response");
+                return Err(tlc_error);
             }
         }
-        let add_tlc_res = recv.await.expect("recv error").map(|res| res.tlc_id);
-        reply.send(add_tlc_res).expect("send error");
     }
 
     fn get_tlc_error(
@@ -1481,19 +1525,16 @@ where
         // https://github.com/lightning/bolts/blob/master/04-onion-routing.md#rationale-6
         // we now still update the graph, maybe we need to remove it later?
         if error_code.is_update() {
-            if let Some(extra_data) = &tcl_error_detail.extra_data {
-                match extra_data {
-                    TlcErrData::ChannelFailed { channel_update, .. } => {
-                        if let Some(channel_update) = channel_update {
-                            let _ = network.send_message(NetworkActorMessage::new_command(
-                                NetworkActorCommand::ProcessBroadcastMessage(
-                                    BroadcastMessage::ChannelUpdate(channel_update.clone()),
-                                ),
-                            ));
-                        }
-                    }
-                    _ => {}
-                }
+            if let Some(TlcErrData::ChannelFailed {
+                channel_update: Some(channel_update),
+                ..
+            }) = &tcl_error_detail.extra_data
+            {
+                let _ = network.send_message(NetworkActorMessage::new_command(
+                    NetworkActorCommand::ProcessBroadcastMessage(BroadcastMessage::ChannelUpdate(
+                        channel_update.clone(),
+                    )),
+                ));
             }
         }
         match tcl_error_detail.error_code() {
@@ -1558,7 +1599,6 @@ where
     ) -> Result<PaymentSession, Error> {
         let session_key = Privkey::from_slice(KeyPair::generate_random_key().as_ref());
         assert_ne!(hops[0].funding_tx_hash, Hash256::default());
-        let first_channel_outpoint = OutPoint::new(hops[0].funding_tx_hash.into(), 0);
 
         payment_session
             .session_key
@@ -1566,8 +1606,6 @@ where
         payment_session.route =
             SessionRoute::new(state.get_public_key(), payment_data.target_pubkey, &hops);
 
-        let (send, recv) = oneshot::channel::<Result<u64, TlcErr>>();
-        let rpc_reply = RpcReplyPort::from(send);
         let peeled_onion_packet = match PeeledPaymentOnionPacket::create(
             session_key,
             hops,
@@ -1581,18 +1619,21 @@ where
                     payment_data.payment_hash, e
                 );
                 self.set_payment_fail_with_error(payment_session, &err);
-                return Err(Error::SendPaymentError(err));
+                return Err(Error::SendPaymentFirstHopError(err, false));
             }
         };
-        let command = SendOnionPacketCommand {
-            peeled_onion_packet,
-            previous_tlc: None,
-            payment_hash: payment_data.payment_hash,
-        };
 
-        self.handle_send_onion_packet_command(state, command, rpc_reply)
-            .await;
-        match recv.await.expect("msg recv error") {
+        match self
+            .handle_send_onion_packet_command(
+                state,
+                SendOnionPacketCommand {
+                    peeled_onion_packet,
+                    previous_tlc: None,
+                    payment_hash: payment_data.payment_hash,
+                },
+            )
+            .await
+        {
             Err(error_detail) => {
                 self.update_graph_with_tlc_fail(&state.network, &error_detail)
                     .await;
@@ -1605,17 +1646,82 @@ where
                     "Failed to send onion packet with error {}",
                     error_detail.error_code_as_str()
                 );
-                self.set_payment_fail_with_error(payment_session, &err);
+                if !need_to_retry {
+                    // only update the payment session status when we don't need to retry
+                    // otherwise the endpoint user may get confused in the internal state changes
+                    self.set_payment_fail_with_error(payment_session, &err);
+                }
                 return Err(Error::SendPaymentFirstHopError(err, need_to_retry));
             }
-            Ok(tlc_id) => {
-                payment_session.set_inflight_status(first_channel_outpoint, tlc_id);
+            Ok(_) => {
                 self.store.insert_payment_session(payment_session.clone());
                 return Ok(payment_session.clone());
             }
         }
     }
 
+    async fn on_add_tlc_result_event(
+        &self,
+        myself: ActorRef<NetworkActorMessage>,
+        state: &mut NetworkActorState<S>,
+        payment_hash: Hash256,
+        error_info: Option<(ProcessingChannelError, TlcErr)>,
+        previous_tlc: Option<(Hash256, u64)>,
+    ) {
+        if let Some((channel_id, tlc_id)) = previous_tlc {
+            myself
+                .send_message(NetworkActorMessage::new_command(
+                    NetworkActorCommand::ControlFiberChannel(ChannelCommandWithId {
+                        channel_id: channel_id,
+                        command: ChannelCommand::ForwardTlcResult(ForwardTlcResult {
+                            payment_hash,
+                            channel_id,
+                            tlc_id,
+                            error_info: error_info.clone(),
+                        }),
+                    }),
+                ))
+                .expect("network actor alive");
+            return;
+        }
+
+        let Some(mut payment_session) = self.store.get_payment_session(payment_hash) else {
+            return;
+        };
+
+        if error_info.is_none() {
+            // Change the status from Created into Inflight
+            payment_session.set_inflight_status();
+            self.store.insert_payment_session(payment_session.clone());
+            return;
+        }
+
+        let (channel_error, tlc_err) = error_info.unwrap();
+        if matches!(channel_error, ProcessingChannelError::RepeatedProcessing(_)) {
+            return;
+        }
+
+        let need_to_retry = self
+            .network_graph
+            .write()
+            .await
+            .record_payment_fail(&payment_session, tlc_err.clone());
+        if matches!(channel_error, ProcessingChannelError::WaitingTlcAck) {
+            payment_session.last_error = Some("WaitingTlcAck".to_string());
+            self.store.insert_payment_session(payment_session.clone());
+        }
+        if need_to_retry {
+            let _ = self.try_payment_session(myself, state, payment_hash).await;
+        } else {
+            let error = format!(
+                "Failed to send payment session: {:?}, retried times: {}",
+                payment_session.payment_hash(),
+                payment_session.retried_times
+            );
+            self.set_payment_fail_with_error(&mut payment_session, &error);
+        }
+    }
+
     fn set_payment_fail_with_error(&self, payment_session: &mut PaymentSession, error: &str) {
         payment_session.set_failed_status(error);
         self.store.insert_payment_session(payment_session.clone());
@@ -1631,10 +1737,14 @@ where
         let Some(mut payment_session) = self.store.get_payment_session(payment_hash) else {
             return Err(Error::InvalidParameter(payment_hash.to_string()));
         };
+        assert!(payment_session.status != PaymentSessionStatus::Failed);
 
         let payment_data = payment_session.request.clone();
         if payment_session.can_retry() {
-            payment_session.retried_times += 1;
+            if payment_session.last_error != Some("WaitingTlcAck".to_string()) {
+                payment_session.retried_times += 1;
+            }
+
             let hops_info = self
                 .build_payment_route(&mut payment_session, &payment_data)
                 .await?;
@@ -1643,7 +1753,8 @@ where
                 .await
             {
                 Ok(payment_session) => return Ok(payment_session),
-                Err(Error::SendPaymentFirstHopError(err, need_retry)) => {
+                Err(err) => {
+                    let need_retry = matches!(err, Error::SendPaymentFirstHopError(_, true));
                     if need_retry {
                         // If this is the first hop error, like the WaitingTlcAck error,
                         // we will just retry later, return Ok here for letting endpoint user
@@ -1655,22 +1766,9 @@ where
                         });
                         return Ok(payment_session);
                     } else {
-                        return Err(Error::SendPaymentError(err));
+                        return Err(err);
                     }
                 }
-                Err(e) => {
-                    // we will retry the payment session,
-                    // but we need to retry later to let the actor to process failure,
-                    // so that we can make different choice for later try
-                    let payment_hash = payment_data.payment_hash;
-                    myself.send_after(Duration::from_millis(500), move || {
-                        NetworkActorMessage::new_event(NetworkActorEvent::RetrySendPayment(
-                            payment_hash,
-                        ))
-                    });
-                    debug!("send payment error: {:?}", e);
-                    return Err(e);
-                }
             }
         } else {
             let error = payment_session.last_error.clone().unwrap_or_else(|| {
@@ -1891,10 +1989,10 @@ where
                 debug!("Returning old node announcement message as it is still valid");
             }
             _ => {
-                let alias = self.node_name.unwrap_or_default();
+                let node_name = self.node_name.unwrap_or_default();
                 let addresses = self.announced_addrs.clone();
                 let announcement = NodeAnnouncement::new(
-                    alias,
+                    node_name,
                     addresses,
                     &self.private_key,
                     now,
@@ -2005,7 +2103,8 @@ where
             }),
             network.clone().get_cell(),
         )
-        .await?
+        .await
+        .map_err(|e| ProcessingChannelError::SpawnErr(e.to_string()))?
         .0;
         let temp_channel_id = rx.await.expect("msg received");
         self.on_channel_created(temp_channel_id, &peer_id, channel.clone());
@@ -2061,7 +2160,7 @@ where
         let seed = self.generate_channel_seed();
         let (tx, rx) = oneshot::channel::<Hash256>();
         let channel = Actor::spawn_linked(
-            None,
+            Some(generate_channel_actor_name(&self.peer_id, &peer_id)),
             ChannelActor::new(
                 self.get_public_key(),
                 remote_pubkey,
@@ -2087,7 +2186,8 @@ where
             }),
             network.clone().get_cell(),
         )
-        .await?
+        .await
+        .map_err(|e| ProcessingChannelError::SpawnErr(e.to_string()))?
         .0;
         let new_id = rx.await.expect("msg received");
         self.on_channel_created(new_id, &peer_id, channel.clone());
@@ -2429,9 +2529,9 @@ where
                 remote_peer_id, &message
             );
             let _ = self.network.send_message(NetworkActorMessage::new_command(
-                NetworkActorCommand::BroadcastMessages(vec![BroadcastMessage::NodeAnnouncement(
-                    message,
-                )]),
+                NetworkActorCommand::BroadcastMessages(vec![
+                    BroadcastMessageWithTimestamp::NodeAnnouncement(message),
+                ]),
             ));
         } else {
             debug!(
@@ -2566,18 +2666,18 @@ where
         channel_id: &Hash256,
         tx_hash: Byte32,
     ) {
-        self.remove_channel(channel_id);
-        if let Some(session) = self.get_peer_session(peer_id) {
-            if let Some(set) = self.session_channels_map.get_mut(&session) {
-                set.remove(channel_id);
-            }
-        }
         self.send_message_to_channel_actor(
             *channel_id,
             None,
             ChannelActorMessage::Event(ChannelEvent::ClosingTransactionConfirmed),
         )
         .await;
+        self.remove_channel(channel_id);
+        if let Some(session) = self.get_peer_session(peer_id) {
+            if let Some(set) = self.session_channels_map.get_mut(&session) {
+                set.remove(channel_id);
+            }
+        }
         // Notify outside observers.
         self.network
             .send_message(NetworkActorMessage::new_notification(
@@ -2650,41 +2750,80 @@ where
             &outpoint, &channel_id, &tx_hash
         );
         let network = self.network.clone();
+        let chain = self.chain_actor.clone();
         self.broadcast_tx_with_callback(transaction, move |result| {
-            let message = match result {
+            match result {
                 Ok(TraceTxResponse {
                     status:
                         TxStatus {
                             status: Status::Committed,
-                            block_number: Some(block_number),
+                            block_hash: Some(block_hash),
                             ..
                         },
                     ..
                 }) => {
-                    info!("Funding transaction {:?} confirmed", &tx_hash);
-                    NetworkActorEvent::FundingTransactionConfirmed(
-                        outpoint,
-                        block_number.into(),
-                        DUMMY_FUNDING_TX_INDEX,
-                    )
+                    tokio::spawn( async move  {
+                        match call!(
+                            chain,
+                            |reply| CkbChainMessage::GetBlockTimestamp(
+                                GetBlockTimestampRequest::from_block_hash(block_hash.clone()), reply
+                            )
+                        ) {
+                            Ok(Ok(Some(timestamp))) => {
+                                info!("Funding transaction {:?} confirmed", &tx_hash);
+                                // Notify outside observers.
+                                network.send_message(NetworkActorMessage::new_event(
+                                    NetworkActorEvent::FundingTransactionConfirmed(
+                                        outpoint.clone(),
+                                        block_hash.clone(),
+                                        DUMMY_FUNDING_TX_INDEX,
+                                        timestamp,
+                                    )
+                                ))
+                                .expect(ASSUME_NETWORK_MYSELF_ALIVE);
+                                return;
+                            },
+                            Ok(Ok(None)) => {
+                                error!(
+                                    "Failed to get block timestamp for block hash {:?}: block not found",
+                                    &block_hash
+                                );
+                            }
+                            Ok(Err(err)) => {
+                                error!(
+                                    "Failed to get block timestamp for block hash {:?}: {:?}",
+                                    &block_hash, &err
+                                );
+                            }
+                            Err(err) => {
+                                error!(
+                                    "Failed to get block timestamp for block hash {:?}: {:?}",
+                                    &block_hash, &err
+                                );
+                            }
+                        }
+                    });
                 }
                 Ok(status) => {
                     error!(
                         "Funding transaction {:?} failed to be confirmed with final status {:?}",
                         &tx_hash, &status
                     );
-                    NetworkActorEvent::FundingTransactionFailed(outpoint)
+                    // Notify outside observers.
+                    network
+                        .send_message(NetworkActorMessage::new_event(                    NetworkActorEvent::FundingTransactionFailed(outpoint)
+                    ))
+                        .expect(ASSUME_NETWORK_MYSELF_ALIVE);
                 }
                 Err(err) => {
                     error!("Failed to trace transaction {:?}: {:?}", &tx_hash, &err);
-                    NetworkActorEvent::FundingTransactionFailed(outpoint)
+                    // Notify outside observers.
+                    network
+                        .send_message(NetworkActorMessage::new_event(                    NetworkActorEvent::FundingTransactionFailed(outpoint)
+                    ))
+                        .expect(ASSUME_NETWORK_MYSELF_ALIVE);
                 }
             };
-
-            // Notify outside observers.
-            network
-                .send_message(NetworkActorMessage::new_event(message))
-                .expect(ASSUME_NETWORK_MYSELF_ALIVE);
         })
         .await;
     }
@@ -2740,8 +2879,9 @@ where
     async fn on_funding_transaction_confirmed(
         &mut self,
         outpoint: OutPoint,
-        block_number: BlockNumber,
+        block_hash: H256,
         tx_index: u32,
+        timestamp: u64,
     ) {
         debug!("Funding transaction is confirmed: {:?}", &outpoint);
         let channel_id = match self.pending_channels.remove(&outpoint) {
@@ -2758,8 +2898,7 @@ where
             channel_id,
             None,
             ChannelActorMessage::Event(ChannelEvent::FundingTransactionConfirmed(
-                block_number,
-                tx_index,
+                block_hash, tx_index, timestamp,
             )),
         )
         .await;
@@ -2880,6 +3019,7 @@ where
             Some(format!("gossip actor {:?}", my_peer_id)),
             Duration::from_millis(config.gossip_network_maintenance_interval_ms()).into(),
             Duration::from_millis(config.gossip_store_maintenance_interval_ms()).into(),
+            config.announce_private_addr(),
             self.store.clone(),
             self.chain_actor.clone(),
             myself.get_cell(),
@@ -3081,12 +3221,12 @@ where
         match message {
             NetworkActorMessage::Event(event) => {
                 if let Err(err) = self.handle_event(myself, state, event).await {
-                    error!("Failed to handle ckb network event: {}", err);
+                    error!("Failed to handle fiber network event: {}", err);
                 }
             }
             NetworkActorMessage::Command(command) => {
                 if let Err(err) = self.handle_command(myself, state, command).await {
-                    error!("Failed to handle ckb network command: {}", err);
+                    error!("Failed to handle fiber network command: {}", err);
                 }
             }
             NetworkActorMessage::Notification(event) => {
@@ -3128,8 +3268,8 @@ where
             SupervisionEvent::ActorTerminated(who, _, _) => {
                 debug!("Actor {:?} terminated", who);
             }
-            SupervisionEvent::ActorPanicked(who, _) => {
-                error!("Actor {:?} panicked", who);
+            SupervisionEvent::ActorPanicked(who, err) => {
+                panic!("Actor unexpectedly panicked (id: {:?}): {:?}", who, err);
             }
             _ => {}
         }
diff --git a/src/fiber/schema/fiber.mol b/src/fiber/schema/fiber.mol
index 19f0691e9..e454c1c3c 100644
--- a/src/fiber/schema/fiber.mol
+++ b/src/fiber/schema/fiber.mol
@@ -1,5 +1,6 @@
 import blockchain;
 
+array Uint16 [byte; 2];
 array EcdsaSignature [byte; 64];
 array PubNonce [byte; 66]; // PubNonce used by musig2 crate.
 option PubNonceOpt (PubNonce);
@@ -187,3 +188,52 @@ union FiberMessage {
     ReestablishChannel,
     AnnouncementSignatures,
 }
+
+option PaymentPreimageOpt (Byte32);
+option PubkeyOpt (Pubkey);
+table PaymentHopData {
+    amount: Uint128,
+    expiry: Uint64,
+    payment_preimage: PaymentPreimageOpt,
+    hash_algorithm: byte,
+    funding_tx_hash: Byte32,
+    next_hop: PubkeyOpt,
+}
+
+// A ChannelUpdate is a update to the public channel. Newer channel information may be updated with
+// a ChannelUpdate with a larger timestamp.
+struct ChannelUpdate {
+    // Signature of the node that wants to update the channel information.
+    signature: EcdsaSignature,
+    chain_hash: Byte32,
+    channel_outpoint: OutPoint,
+    timestamp: Uint64,
+    message_flags: Uint32,
+    channel_flags: Uint32,
+    tlc_expiry_delta: Uint64,
+    tlc_minimum_value: Uint128,
+    tlc_maximum_value: Uint128,
+    tlc_fee_proportional_millionths: Uint128,
+}
+
+option ChannelUpdateOpt (ChannelUpdate);
+table ChannelFailed {
+    channel_outpoint: OutPoint,
+    channel_update: ChannelUpdateOpt,
+    node_id: Pubkey,
+}
+
+table NodeFailed {
+    node_id: Pubkey,
+}
+
+union TlcErrData {
+    ChannelFailed,
+    NodeFailed,
+}
+
+option TlcErrDataOpt (TlcErrData);
+table TlcErr {
+    error_code: Uint16,
+    extra_data: TlcErrDataOpt,
+}
\ No newline at end of file
diff --git a/src/fiber/schema/gossip.mol b/src/fiber/schema/gossip.mol
index 5a4a23328..a2a4e7c08 100644
--- a/src/fiber/schema/gossip.mol
+++ b/src/fiber/schema/gossip.mol
@@ -1,7 +1,6 @@
 import blockchain;
 import fiber;
 
-array Uint16 [byte; 2];
 array SchnorrSignature [byte; 64];
 array SchnorrXOnlyPubkey [byte; 32];
 
@@ -34,7 +33,7 @@ struct BroadcastMessageQuery {
 vector BroadcastMessageQueries <BroadcastMessageQuery>;
 
 // A NodeAnnouncement is a broadcast message to the network for the node information.
-// An update to the node information can be broadcasted with a NodeAnnouncement with larger timestamp. 
+// An update to the node information can be broadcasted with a NodeAnnouncement with larger timestamp.
 table NodeAnnouncement {
     // Signature to this message.
     signature: EcdsaSignature,
@@ -46,7 +45,7 @@ table NodeAnnouncement {
     timestamp: Uint64,
     node_id: Pubkey,
     // Must be a valid utf-8 string of length maximal length 32 bytes.
-    alias: Byte32,
+    node_name: Byte32,
     // All the reachable addresses.
     address: BytesVec,
     // Chain hash
@@ -78,22 +77,6 @@ table ChannelAnnouncement {
     udt_type_script: ScriptOpt,
 }
 
-// A ChannelUpdate is a update to the public channel. Newer channel information may be updated with
-// a ChannelUpdate with a larger timestamp.
-struct ChannelUpdate {
-    // Signature of the node that wants to update the channel information.
-    signature: EcdsaSignature,
-    chain_hash: Byte32,
-    channel_outpoint: OutPoint,
-    timestamp: Uint64,
-    message_flags: Uint32,
-    channel_flags: Uint32,
-    tlc_expiry_delta: Uint64,
-    tlc_minimum_value: Uint128,
-    tlc_maximum_value: Uint128,
-    tlc_fee_proportional_millionths: Uint128,
-}
-
 // All the broadcast messages.
 union BroadcastMessage {
     NodeAnnouncement,
diff --git a/src/fiber/tests/channel.rs b/src/fiber/tests/channel.rs
index 858a59ab0..c5bd63090 100644
--- a/src/fiber/tests/channel.rs
+++ b/src/fiber/tests/channel.rs
@@ -1,14 +1,9 @@
-use crate::fiber::channel::{
-    AddTlcInfo, CommitmentNumbers, RemoveTlcInfo, TLCId, TlcKind, TlcState, UpdateCommand,
-};
+use super::test_utils::{init_tracing, NetworkNode};
+use crate::fiber::channel::UpdateCommand;
 use crate::fiber::config::MAX_PAYMENT_TLC_EXPIRY_LIMIT;
 use crate::fiber::graph::PaymentSessionStatus;
 use crate::fiber::network::{DebugEvent, SendPaymentCommand};
-use crate::fiber::tests::test_utils::create_n_nodes_with_index_and_amounts_with_established_channel;
-use crate::fiber::tests::test_utils::{
-    create_3_nodes_with_established_channel, create_n_nodes_with_established_channel,
-    create_nodes_with_established_channel, NetworkNodeConfigBuilder,
-};
+use crate::fiber::tests::test_utils::*;
 use crate::fiber::types::{
     Hash256, PaymentHopData, PeeledOnionPacket, TlcErrorCode, NO_SHARED_SECRET,
 };
@@ -42,8 +37,6 @@ use secp256k1::Secp256k1;
 use std::collections::HashSet;
 use std::time::Duration;
 
-use super::test_utils::{init_tracing, NetworkNode};
-
 const DEFAULT_EXPIRY_DELTA: u64 = 24 * 60 * 60 * 1000; // 24 hours
 
 #[test]
@@ -66,222 +59,6 @@ fn test_derive_private_and_public_tlc_keys() {
     assert_eq!(derived_privkey.pubkey(), derived_pubkey);
 }
 
-#[test]
-fn test_pending_tlcs() {
-    let mut tlc_state = TlcState::default();
-    let add_tlc1 = AddTlcInfo {
-        amount: 10000,
-        channel_id: gen_rand_sha256_hash(),
-        payment_hash: gen_rand_sha256_hash(),
-        expiry: now_timestamp_as_millis_u64() + 1000,
-        hash_algorithm: HashAlgorithm::Sha256,
-        onion_packet: None,
-        shared_secret: NO_SHARED_SECRET.clone(),
-        tlc_id: TLCId::Offered(0),
-        created_at: CommitmentNumbers::default(),
-        removed_at: None,
-        payment_preimage: None,
-        previous_tlc: None,
-    };
-    let add_tlc2 = AddTlcInfo {
-        amount: 20000,
-        channel_id: gen_rand_sha256_hash(),
-        payment_hash: gen_rand_sha256_hash(),
-        expiry: now_timestamp_as_millis_u64() + 2000,
-        hash_algorithm: HashAlgorithm::Sha256,
-        onion_packet: None,
-        shared_secret: NO_SHARED_SECRET.clone(),
-        tlc_id: TLCId::Offered(1),
-        created_at: CommitmentNumbers::default(),
-        removed_at: None,
-        payment_preimage: None,
-        previous_tlc: None,
-    };
-    tlc_state.add_local_tlc(TlcKind::AddTlc(add_tlc1.clone()));
-    tlc_state.add_local_tlc(TlcKind::AddTlc(add_tlc2.clone()));
-
-    let mut tlc_state_2 = TlcState::default();
-    tlc_state_2.add_remote_tlc(TlcKind::AddTlc(add_tlc1.clone()));
-    tlc_state_2.add_remote_tlc(TlcKind::AddTlc(add_tlc2.clone()));
-
-    let tx1 = tlc_state.get_tlcs_for_local();
-    let tx2 = tlc_state_2.get_tlcs_for_remote();
-
-    assert_eq!(tx1, tx2);
-
-    let tlcs = tlc_state.commit_local_tlcs();
-    assert_eq!(tlcs.len(), 2);
-
-    let tlcs2 = tlc_state_2.commit_remote_tlcs();
-    assert_eq!(tlcs2.len(), 2);
-
-    assert_eq!(tx1, tx2);
-
-    let tlcs = tlc_state.commit_local_tlcs();
-    assert_eq!(tlcs.len(), 0);
-
-    let tlcs2 = tlc_state_2.commit_remote_tlcs();
-    assert_eq!(tlcs2.len(), 0);
-
-    tlc_state_2.add_local_tlc(TlcKind::AddTlc(add_tlc1.clone()));
-    tlc_state_2.add_local_tlc(TlcKind::AddTlc(add_tlc2.clone()));
-
-    tlc_state.add_remote_tlc(TlcKind::AddTlc(add_tlc1.clone()));
-    tlc_state.add_remote_tlc(TlcKind::AddTlc(add_tlc2.clone()));
-
-    let tx1 = tlc_state.get_tlcs_for_remote();
-    let tx2 = tlc_state_2.get_tlcs_for_local();
-
-    assert_eq!(tx1, tx2);
-
-    let tlcs = tlc_state.commit_remote_tlcs();
-    assert_eq!(tlcs.len(), 2);
-    let tlcs2 = tlc_state_2.commit_local_tlcs();
-    assert_eq!(tlcs2.len(), 2);
-
-    assert_eq!(tx1, tx2);
-
-    let tlcs = tlc_state.commit_remote_tlcs();
-    assert_eq!(tlcs.len(), 0);
-    let tlcs2 = tlc_state_2.commit_local_tlcs();
-    assert_eq!(tlcs2.len(), 0);
-}
-
-#[test]
-fn test_pending_tlcs_duplicated_tlcs() {
-    let mut tlc_state = TlcState::default();
-    let add_tlc1 = AddTlcInfo {
-        amount: 10000,
-        channel_id: gen_rand_sha256_hash(),
-        payment_hash: gen_rand_sha256_hash(),
-        expiry: now_timestamp_as_millis_u64() + 1000,
-        hash_algorithm: HashAlgorithm::Sha256,
-        onion_packet: None,
-        shared_secret: NO_SHARED_SECRET.clone(),
-        tlc_id: TLCId::Offered(0),
-        created_at: CommitmentNumbers::default(),
-        removed_at: None,
-        payment_preimage: None,
-        previous_tlc: None,
-    };
-    tlc_state.add_local_tlc(TlcKind::AddTlc(add_tlc1.clone()));
-
-    let mut tlc_state_2 = TlcState::default();
-    tlc_state_2.add_remote_tlc(TlcKind::AddTlc(add_tlc1.clone()));
-
-    let tx1 = tlc_state.get_tlcs_for_local();
-    let tx2 = tlc_state_2.get_tlcs_for_remote();
-
-    assert_eq!(tx1, tx2);
-
-    let tlcs = tlc_state.commit_local_tlcs();
-    assert_eq!(tlcs.len(), 1);
-
-    let tlcs2 = tlc_state_2.commit_remote_tlcs();
-    assert_eq!(tlcs2.len(), 1);
-
-    assert_eq!(tx1, tx2);
-
-    let tlcs = tlc_state.commit_local_tlcs();
-    assert_eq!(tlcs.len(), 0);
-
-    let tlcs2 = tlc_state_2.commit_remote_tlcs();
-    assert_eq!(tlcs2.len(), 0);
-
-    let add_tlc2 = AddTlcInfo {
-        amount: 20000,
-        channel_id: gen_rand_sha256_hash(),
-        payment_hash: gen_rand_sha256_hash(),
-        expiry: now_timestamp_as_millis_u64() + 2000,
-        hash_algorithm: HashAlgorithm::Sha256,
-        onion_packet: None,
-        shared_secret: NO_SHARED_SECRET.clone(),
-        tlc_id: TLCId::Offered(1),
-        created_at: CommitmentNumbers::default(),
-        removed_at: None,
-        payment_preimage: None,
-        previous_tlc: None,
-    };
-
-    tlc_state_2.add_local_tlc(TlcKind::AddTlc(add_tlc2.clone()));
-    tlc_state.add_remote_tlc(TlcKind::AddTlc(add_tlc2.clone()));
-
-    let tx1 = tlc_state.get_tlcs_for_remote();
-    let tx2 = tlc_state_2.get_tlcs_for_local();
-
-    assert_eq!(tx1, tx2);
-
-    let tlcs = tlc_state.commit_remote_tlcs();
-    assert_eq!(tlcs.len(), 1);
-    let tlcs2 = tlc_state_2.commit_local_tlcs();
-    assert_eq!(tlcs2.len(), 1);
-    assert_eq!(tx1, tx2);
-
-    let tlcs = tlc_state.commit_remote_tlcs();
-    assert_eq!(tlcs.len(), 0);
-    let tlcs2 = tlc_state_2.commit_local_tlcs();
-    assert_eq!(tlcs2.len(), 0);
-
-    let committed_tlcs1 = tlc_state.all_commited_tlcs().collect::<Vec<_>>();
-    let committed_tlcs2 = tlc_state_2.all_commited_tlcs().collect::<Vec<_>>();
-    assert_eq!(committed_tlcs1, committed_tlcs2);
-}
-
-#[test]
-fn test_pending_tlcs_with_remove_tlc() {
-    let mut tlc_state = TlcState::default();
-    let add_tlc1 = AddTlcInfo {
-        amount: 10000,
-        channel_id: gen_rand_sha256_hash(),
-        payment_hash: gen_rand_sha256_hash(),
-        expiry: now_timestamp_as_millis_u64() + 1000,
-        hash_algorithm: HashAlgorithm::Sha256,
-        onion_packet: None,
-        shared_secret: NO_SHARED_SECRET.clone(),
-        tlc_id: TLCId::Offered(0),
-        created_at: CommitmentNumbers::default(),
-        removed_at: None,
-        payment_preimage: None,
-        previous_tlc: None,
-    };
-    let add_tlc2 = AddTlcInfo {
-        amount: 20000,
-        channel_id: gen_rand_sha256_hash(),
-        payment_hash: gen_rand_sha256_hash(),
-        expiry: now_timestamp_as_millis_u64() + 2000,
-        hash_algorithm: HashAlgorithm::Sha256,
-        onion_packet: None,
-        shared_secret: NO_SHARED_SECRET.clone(),
-        tlc_id: TLCId::Offered(1),
-        created_at: CommitmentNumbers::default(),
-        removed_at: None,
-        payment_preimage: None,
-        previous_tlc: None,
-    };
-    let remote_tlc = RemoveTlcInfo {
-        channel_id: gen_rand_sha256_hash(),
-        tlc_id: TLCId::Offered(0),
-        reason: RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill {
-            payment_preimage: gen_rand_sha256_hash(),
-        }),
-    };
-
-    tlc_state.add_local_tlc(TlcKind::AddTlc(add_tlc1.clone()));
-    tlc_state.add_local_tlc(TlcKind::AddTlc(add_tlc2.clone()));
-    tlc_state.add_local_tlc(TlcKind::RemoveTlc(remote_tlc.clone()));
-
-    let tx1 = tlc_state.get_tlcs_for_local();
-    assert_eq!(tx1.len(), 1);
-    let first = &tx1[0];
-    assert_eq!(first.tlc_id(), TLCId::Offered(1));
-
-    let tx1 = tlc_state.commit_local_tlcs();
-    assert_eq!(tx1.len(), 3);
-
-    let all_tlcs: Vec<&AddTlcInfo> = tlc_state.all_commited_tlcs().collect();
-    assert_eq!(all_tlcs.len(), 2);
-}
-
 #[tokio::test]
 async fn test_open_channel_to_peer() {
     let [node_a, mut node_b] = NetworkNode::new_n_interconnected_nodes().await;
@@ -586,6 +363,7 @@ async fn test_network_send_payment_normal_keysend_workflow() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -595,7 +373,7 @@ async fn test_network_send_payment_normal_keysend_workflow() {
         .expect("node_a alive")
         .unwrap();
     // this is the payment_hash generated by keysend
-    assert_eq!(res.status, PaymentSessionStatus::Inflight);
+    assert_eq!(res.status, PaymentSessionStatus::Created);
     let payment_hash = res.payment_hash;
 
     tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
@@ -634,6 +412,7 @@ async fn test_network_send_payment_normal_keysend_workflow() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -643,7 +422,7 @@ async fn test_network_send_payment_normal_keysend_workflow() {
         .expect("node_a alive")
         .unwrap();
     // this is the payment_hash generated by keysend
-    assert_eq!(res.status, PaymentSessionStatus::Inflight);
+    assert_eq!(res.status, PaymentSessionStatus::Created);
     let payment_hash = res.payment_hash;
 
     tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
@@ -666,11 +445,13 @@ async fn test_network_send_payment_send_each_other() {
     let node_a_funding_amount = 100000000000;
     let node_b_funding_amount = 6200000000;
 
-    let (node_a, node_b, _new_channel_id) =
+    let (node_a, node_b, new_channel_id) =
         create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, true)
             .await;
     // Wait for the channel announcement to be broadcasted
     tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+    let node_a_old_balance = node_a.get_local_balance_from_channel(new_channel_id);
+    let node_b_old_balance = node_b.get_local_balance_from_channel(new_channel_id);
 
     let node_a_pubkey = node_a.pubkey.clone();
     let node_b_pubkey = node_b.pubkey.clone();
@@ -689,6 +470,7 @@ async fn test_network_send_payment_send_each_other() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -698,7 +480,7 @@ async fn test_network_send_payment_send_each_other() {
         .expect("node_a alive")
         .unwrap();
     // this is the payment_hash generated by keysend
-    assert_eq!(res1.status, PaymentSessionStatus::Inflight);
+    assert_eq!(res1.status, PaymentSessionStatus::Created);
     let payment_hash1 = res1.payment_hash;
 
     // the second payment is send from node_b to node_a
@@ -706,7 +488,7 @@ async fn test_network_send_payment_send_each_other() {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
                 target_pubkey: Some(node_a_pubkey),
-                amount: Some(10000),
+                amount: Some(9999),
                 payment_hash: None,
                 final_tlc_expiry_delta: None,
                 invoice: None,
@@ -717,6 +499,7 @@ async fn test_network_send_payment_send_each_other() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -726,11 +509,11 @@ async fn test_network_send_payment_send_each_other() {
         .expect("node_a alive")
         .unwrap();
     // this is the payment_hash generated by keysend
-    assert_eq!(res2.status, PaymentSessionStatus::Inflight);
+    assert_eq!(res2.status, PaymentSessionStatus::Created);
     let payment_hash2 = res2.payment_hash;
 
     // sleep for 2 seconds to make sure the payment is processed
-    tokio::time::sleep(tokio::time::Duration::from_millis(6000)).await;
+    tokio::time::sleep(tokio::time::Duration::from_millis(4000)).await;
 
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash1, rpc_reply))
@@ -750,22 +533,42 @@ async fn test_network_send_payment_send_each_other() {
 
     assert_eq!(res.status, PaymentSessionStatus::Success);
     assert_eq!(res.failed_error, None);
+
+    let node_a_new_balance = node_a.get_local_balance_from_channel(new_channel_id);
+    let node_b_new_balance = node_b.get_local_balance_from_channel(new_channel_id);
+
+    // assert the balance is right,
+    // node_a send 10000 to node_b, and node_b send 9999 to node_a
+    // so the balance should be node_a_old_balance - 1, node_b_old_balance + 1
+    assert_eq!(node_a_new_balance, node_a_old_balance - 1);
+    assert_eq!(node_b_new_balance, node_b_old_balance + 1);
 }
 
 #[tokio::test]
-async fn test_network_send_payment_send_with_ack() {
+async fn test_network_send_payment_more_send_each_other() {
     init_tracing();
 
+    // node_a -> node_b  add_tlc 10000
+    // node_b -> node_a  add_tlc 9999
+    // node_a -> node_b  add_tlc 9999
+    // node_b -> node_a  add_tlc 10000
+    //
+    // all the add_tlc are added at the same time
+    // and the final balance should be same as the initial balance
+
     let _span = tracing::info_span!("node", node = "test").entered();
     let node_a_funding_amount = 100000000000;
     let node_b_funding_amount = 6200000000;
 
-    let (node_a, node_b, _new_channel_id) =
+    let (node_a, node_b, new_channel_id) =
         create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, true)
             .await;
     // Wait for the channel announcement to be broadcasted
     tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+    let node_a_old_balance = node_a.get_local_balance_from_channel(new_channel_id);
+    let node_b_old_balance = node_b.get_local_balance_from_channel(new_channel_id);
 
+    let node_a_pubkey = node_a.pubkey.clone();
     let node_b_pubkey = node_b.pubkey.clone();
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
@@ -782,6 +585,7 @@ async fn test_network_send_payment_send_with_ack() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -791,58 +595,184 @@ async fn test_network_send_payment_send_with_ack() {
         .expect("node_a alive")
         .unwrap();
     // this is the payment_hash generated by keysend
-    assert_eq!(res1.status, PaymentSessionStatus::Inflight);
+    assert_eq!(res1.status, PaymentSessionStatus::Created);
     let payment_hash1 = res1.payment_hash;
 
-    // DON'T WAIT FOR A MOMENT, so the second payment will meet WaitingTlcAck first
-    // but payment session will handle this case
+    // the second payment is send from node_b to node_a
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_a_pubkey),
+                amount: Some(9999),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                invoice: None,
+                timeout: None,
+                tlc_expiry_limit: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
+    };
+    let res2 = call!(node_b.network_actor, message)
+        .expect("node_a alive")
+        .unwrap();
+    // this is the payment_hash generated by keysend
+    assert_eq!(res2.status, PaymentSessionStatus::Created);
+    let payment_hash2 = res2.payment_hash;
 
-    // we can make the same payment again, since payment_hash will be generated randomly
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
                 target_pubkey: Some(node_b_pubkey),
-                amount: Some(10000),
+                amount: Some(9999),
                 payment_hash: None,
                 final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
                 invoice: None,
                 timeout: None,
-                tlc_expiry_limit: None,
                 max_fee_amount: None,
                 max_parts: None,
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
         ))
     };
-    let res2 = call!(node_a.network_actor, message).expect("node_a alive");
-    // the second send_payment will be blocked by WaitingTlcAck, since we didn't wait for a moment
-    assert!(res2.is_ok());
-    let payment_hash2 = res2.unwrap().payment_hash;
+    let res3 = call!(node_a.network_actor, message)
+        .expect("node_a alive")
+        .unwrap();
+    // this is the payment_hash generated by keysend
+    assert_eq!(res3.status, PaymentSessionStatus::Created);
+    let payment_hash3 = res3.payment_hash;
 
-    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
+    // the second payment is send from node_b to node_a
     let message = |rpc_reply| -> NetworkActorMessage {
-        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash1, rpc_reply))
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_a_pubkey),
+                amount: Some(10000),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                invoice: None,
+                timeout: None,
+                tlc_expiry_limit: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
     };
-    let res = call!(node_a.network_actor, message)
+    let res4 = call!(node_b.network_actor, message)
         .expect("node_a alive")
         .unwrap();
+    // this is the payment_hash generated by keysend
+    assert_eq!(res4.status, PaymentSessionStatus::Created);
+    let payment_hash4 = res4.payment_hash;
 
-    assert_eq!(res.status, PaymentSessionStatus::Success);
-    assert_eq!(res.failed_error, None);
+    // sleep for 3 seconds to make sure the payment is processed
+    node_a.wait_until_success(payment_hash1).await;
+    node_b.wait_until_success(payment_hash2).await;
+    node_a.wait_until_success(payment_hash3).await;
+    node_b.wait_until_success(payment_hash4).await;
+
+    let node_a_new_balance = node_a.get_local_balance_from_channel(new_channel_id);
+    let node_b_new_balance = node_b.get_local_balance_from_channel(new_channel_id);
+
+    // assert the balance is right, the balance should be same as the initial balance
+    assert_eq!(node_a_new_balance, node_a_old_balance);
+    assert_eq!(node_b_new_balance, node_b_old_balance);
+}
+
+#[tokio::test]
+async fn test_network_send_payment_send_with_ack() {
+    init_tracing();
+
+    let _span = tracing::info_span!("node", node = "test").entered();
+    let node_a_funding_amount = 100000000000;
+    let node_b_funding_amount = 6200000000;
+
+    let (node_a, node_b, _new_channel_id) =
+        create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, true)
+            .await;
+    // Wait for the channel announcement to be broadcasted
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
 
+    let node_b_pubkey = node_b.pubkey.clone();
     let message = |rpc_reply| -> NetworkActorMessage {
-        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash2, rpc_reply))
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_b_pubkey),
+                amount: Some(10000),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
     };
-    let res = call!(node_a.network_actor, message)
+    let res1 = call!(node_a.network_actor, message)
         .expect("node_a alive")
         .unwrap();
+    // this is the payment_hash generated by keysend
+    assert_eq!(res1.status, PaymentSessionStatus::Created);
+    let payment_hash1 = res1.payment_hash;
 
-    assert_eq!(res.status, PaymentSessionStatus::Success);
-    assert_eq!(res.failed_error, None);
+    // DON'T WAIT FOR A MOMENT, so the second payment will meet WaitingTlcAck first
+    // but payment session will handle this case
+
+    // we can make the same payment again, since payment_hash will be generated randomly
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_b_pubkey),
+                amount: Some(10000),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                invoice: None,
+                timeout: None,
+                tlc_expiry_limit: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
+    };
+    let res2 = call!(node_a.network_actor, message).expect("node_a alive");
+    // the second send_payment will be blocked by WaitingTlcAck, since we didn't wait for a moment
+    assert!(res2.is_ok());
+    let payment_hash2 = res2.unwrap().payment_hash;
+
+    node_a.wait_until_success(payment_hash1).await;
+    node_a.wait_until_success(payment_hash2).await;
 }
 
 #[tokio::test]
@@ -952,6 +882,7 @@ async fn test_network_send_previous_tlc_error() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
                 tlc_expiry_limit: None,
             },
@@ -962,14 +893,8 @@ async fn test_network_send_previous_tlc_error() {
     let res = call!(node_a.network_actor, message).expect("node_a alive");
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
 
-    let message = |rpc_reply| -> NetworkActorMessage {
-        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash, rpc_reply))
-    };
-    let res = call!(node_a.network_actor, message).expect("node_a alive");
-    assert!(res.is_ok());
-    assert_eq!(res.unwrap().status, PaymentSessionStatus::Success);
+    node_a.wait_until_success(payment_hash).await;
 }
 
 #[tokio::test]
@@ -1006,6 +931,7 @@ async fn test_network_send_payment_keysend_with_payment_hash() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1054,6 +980,7 @@ async fn test_network_send_payment_final_incorrect_hash() {
                 keysend: None,
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1119,6 +1046,7 @@ async fn test_network_send_payment_target_not_found() {
                 keysend: None,
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1126,7 +1054,7 @@ async fn test_network_send_payment_target_not_found() {
     };
     let res = call!(node_a.network_actor, message).expect("node_a alive");
     assert!(res.is_err());
-    assert!(res.err().unwrap().contains("target node not found"));
+    assert!(res.err().unwrap().contains("no path found"));
 }
 
 #[tokio::test]
@@ -1134,8 +1062,8 @@ async fn test_network_send_payment_amount_is_too_large() {
     init_tracing();
 
     let _span = tracing::info_span!("node", node = "test").entered();
-    let node_a_funding_amount = 100000000000 + 4200000000;
-    let node_b_funding_amount = 4200000000 + 2;
+    let node_a_funding_amount = 100000000000 + MIN_RESERVED_CKB;
+    let node_b_funding_amount = MIN_RESERVED_CKB + 2;
 
     let (node_a, node_b, _new_channel_id) =
         create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, true)
@@ -1159,6 +1087,7 @@ async fn test_network_send_payment_amount_is_too_large() {
                 keysend: None,
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1203,6 +1132,7 @@ async fn test_network_send_payment_with_dry_run() {
                 keysend: None,
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: true,
             },
             rpc_reply,
@@ -1230,6 +1160,7 @@ async fn test_network_send_payment_with_dry_run() {
                 keysend: None,
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: true,
             },
             rpc_reply,
@@ -1274,6 +1205,7 @@ async fn test_send_payment_with_3_nodes() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1282,10 +1214,10 @@ async fn test_send_payment_with_3_nodes() {
     let res = call!(node_a.network_actor, message).expect("node_a alive");
     assert!(res.is_ok());
     let res = res.unwrap();
-    assert_eq!(res.status, PaymentSessionStatus::Inflight);
+    assert_eq!(res.status, PaymentSessionStatus::Created);
     assert!(res.fee > 0);
     // sleep for 2 seconds to make sure the payment is sent
-    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::GetPayment(res.payment_hash, rpc_reply))
     };
@@ -1333,8 +1265,6 @@ async fn test_send_payment_with_rev_3_nodes() {
     let node_b_local_left = node_b.get_local_balance_from_channel(channel_2);
     let node_a_local = node_a.get_local_balance_from_channel(channel_2);
 
-    // sleep for 2 seconds to make sure the channel is established
-    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
     let sent_amount = 1000000 + 5;
     let node_a_pubkey = node_a.pubkey.clone();
     let message = |rpc_reply| -> NetworkActorMessage {
@@ -1352,6 +1282,7 @@ async fn test_send_payment_with_rev_3_nodes() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1360,10 +1291,10 @@ async fn test_send_payment_with_rev_3_nodes() {
     let res = call!(node_c.network_actor, message).expect("node_a alive");
     assert!(res.is_ok());
     let res = res.unwrap();
-    assert_eq!(res.status, PaymentSessionStatus::Inflight);
+    assert_eq!(res.status, PaymentSessionStatus::Created);
     assert!(res.fee > 0);
     // sleep for 2 seconds to make sure the payment is sent
-    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::GetPayment(res.payment_hash, rpc_reply))
     };
@@ -1422,6 +1353,7 @@ async fn test_send_payment_with_max_nodes() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: true,
             },
             rpc_reply,
@@ -1445,6 +1377,7 @@ async fn test_send_payment_with_max_nodes() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1454,18 +1387,10 @@ async fn test_send_payment_with_max_nodes() {
     let res = call!(source_node.network_actor, message).expect("node_a alive");
     assert!(res.is_ok());
     let res = res.unwrap();
-    assert_eq!(res.status, PaymentSessionStatus::Inflight);
+    assert_eq!(res.status, PaymentSessionStatus::Created);
     assert!(res.fee > 0);
-    // sleep for 2 seconds to make sure the payment is sent
-    tokio::time::sleep(tokio::time::Duration::from_millis(3000)).await;
-    let message = |rpc_reply| -> NetworkActorMessage {
-        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(res.payment_hash, rpc_reply))
-    };
-    let res = call!(nodes[0].network_actor, message)
-        .expect("node_a alive")
-        .unwrap();
-    assert_eq!(res.status, PaymentSessionStatus::Success);
-    assert_eq!(res.failed_error, None);
+
+    nodes[0].wait_until_success(res.payment_hash).await;
 
     let sender_local_new = nodes[0].get_local_balance_from_channel(channels[0]);
     let receiver_local_new = nodes[last].get_local_balance_from_channel(channels[last - 1]);
@@ -1509,6 +1434,7 @@ async fn test_send_payment_with_3_nodes_overflow() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1557,6 +1483,7 @@ async fn test_send_payment_fail_with_3_nodes_invalid_hash() {
                 keysend: None,
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1565,7 +1492,7 @@ async fn test_send_payment_fail_with_3_nodes_invalid_hash() {
     let res = call!(node_a.network_actor, message).expect("node_a alive");
     assert!(res.is_ok());
     let res = res.unwrap();
-    assert_eq!(res.status, PaymentSessionStatus::Inflight);
+    assert_eq!(res.status, PaymentSessionStatus::Created);
     assert!(res.fee > 0);
     // sleep for 2 seconds to make sure the payment is sent
     tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
@@ -1628,6 +1555,7 @@ async fn test_send_payment_fail_with_3_nodes_final_tlc_expiry_delta() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1636,7 +1564,7 @@ async fn test_send_payment_fail_with_3_nodes_final_tlc_expiry_delta() {
     let res = call!(node_a.network_actor, message).expect("node_a alive");
     assert!(res.is_ok());
     let res = res.unwrap();
-    assert_eq!(res.status, PaymentSessionStatus::Inflight);
+    assert_eq!(res.status, PaymentSessionStatus::Created);
 
     let node_c_pubkey = node_c.pubkey.clone();
     let message = |rpc_reply| -> NetworkActorMessage {
@@ -1654,6 +1582,7 @@ async fn test_send_payment_fail_with_3_nodes_final_tlc_expiry_delta() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1679,6 +1608,7 @@ async fn test_send_payment_fail_with_3_nodes_final_tlc_expiry_delta() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1721,6 +1651,7 @@ async fn test_send_payment_fail_with_3_nodes_dry_run_fee() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: true,
             },
             rpc_reply,
@@ -1746,6 +1677,7 @@ async fn test_send_payment_fail_with_3_nodes_dry_run_fee() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: true,
             },
             rpc_reply,
@@ -1773,6 +1705,7 @@ async fn test_send_payment_fail_with_3_nodes_dry_run_fee() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1799,6 +1732,7 @@ async fn test_send_payment_fail_with_3_nodes_dry_run_fee() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1839,6 +1773,7 @@ async fn test_network_send_payment_dry_run_can_still_query() {
                 keysend: None,
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -1864,6 +1799,7 @@ async fn test_network_send_payment_dry_run_can_still_query() {
                 keysend: None,
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: true,
             },
             rpc_reply,
@@ -1904,6 +1840,7 @@ async fn test_network_send_payment_dry_run_will_not_create_payment_session() {
                 keysend: None,
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: true,
             },
             rpc_reply,
@@ -1930,6 +1867,7 @@ async fn test_network_send_payment_dry_run_will_not_create_payment_session() {
                 keysend: None,
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -2095,6 +2033,8 @@ async fn do_test_channel_commitment_tx_after_add_tlc(algorithm: HashAlgorithm) {
         })
         .await;
 
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
     call!(node_b.network_actor, |rpc_reply| {
         NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
             ChannelCommandWithId {
@@ -2273,13 +2213,272 @@ async fn do_test_remove_tlc_with_wrong_hash_algorithm(
 }
 
 #[tokio::test]
-async fn test_remove_tlc_with_expiry_error() {
+async fn do_test_channel_remote_commitment_error() {
+    // https://github.com/nervosnetwork/fiber/issues/447
     let node_a_funding_amount = 100000000000;
-    let node_b_funding_amount = 6200000000;
+    let node_b_funding_amount = 100000000000;
 
-    let (node_a, _node_b, new_channel_id) =
-        create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, false)
-            .await;
+    let tlc_number_in_flight_limit = 5;
+    let [mut node_a, mut node_b] = NetworkNode::new_n_interconnected_nodes().await;
+
+    let (new_channel_id, _funding_tx) = establish_channel_between_nodes(
+        &mut node_a,
+        &mut node_b,
+        false,
+        node_a_funding_amount,
+        node_b_funding_amount,
+        Some(tlc_number_in_flight_limit as u64),
+        None,
+        None,
+        None,
+        None,
+        Some(tlc_number_in_flight_limit as u64),
+        None,
+        None,
+        None,
+        None,
+    )
+    .await;
+
+    let mut all_sent = vec![];
+    let mut batch_remove_count = 0;
+    while batch_remove_count <= 3 {
+        let preimage: [u8; 32] = gen_rand_sha256_hash().as_ref().try_into().unwrap();
+
+        // create a new payment hash
+        let hash_algorithm = HashAlgorithm::Sha256;
+        let digest = hash_algorithm.hash(&preimage);
+        if let Ok(add_tlc_result) = call!(node_a.network_actor, |rpc_reply| {
+            NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+                ChannelCommandWithId {
+                    channel_id: new_channel_id,
+                    command: ChannelCommand::AddTlc(
+                        AddTlcCommand {
+                            amount: 1000,
+                            hash_algorithm,
+                            payment_hash: digest.into(),
+                            expiry: now_timestamp_as_millis_u64() + DEFAULT_EXPIRY_DELTA,
+                            onion_packet: None,
+                            shared_secret: NO_SHARED_SECRET.clone(),
+                            previous_tlc: None,
+                        },
+                        rpc_reply,
+                    ),
+                },
+            ))
+        })
+        .expect("node_b alive")
+        {
+            dbg!(&add_tlc_result);
+            all_sent.push((preimage, add_tlc_result.tlc_id));
+        }
+        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+        if all_sent.len() >= tlc_number_in_flight_limit {
+            while all_sent.len() > tlc_number_in_flight_limit - 2 {
+                if let Some((preimage, tlc_id)) = all_sent.iter().next().cloned() {
+                    let remove_tlc_result = call!(node_b.network_actor, |rpc_reply| {
+                        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+                            ChannelCommandWithId {
+                                channel_id: new_channel_id,
+                                command: ChannelCommand::RemoveTlc(
+                                    RemoveTlcCommand {
+                                        id: tlc_id,
+                                        reason: RemoveTlcReason::RemoveTlcFulfill(
+                                            RemoveTlcFulfill {
+                                                payment_preimage: Hash256::from(preimage),
+                                            },
+                                        ),
+                                    },
+                                    rpc_reply,
+                                ),
+                            },
+                        ))
+                    })
+                    .expect("node_b alive");
+                    dbg!(&remove_tlc_result);
+                    if remove_tlc_result.is_ok()
+                        || remove_tlc_result
+                            .unwrap_err()
+                            .to_string()
+                            .contains("Trying to remove non-existing tlc")
+                    {
+                        all_sent.remove(0);
+                    }
+                }
+            }
+            batch_remove_count += 1;
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_network_add_two_tlcs_remove_one() {
+    let _span = tracing::info_span!("node", node = "test").entered();
+    let node_a_funding_amount = 100000000000;
+    let node_b_funding_amount = 100000000000;
+
+    let (node_a, node_b, channel_id) =
+        create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, true)
+            .await;
+    // Wait for the channel announcement to be broadcasted
+
+    let old_a_balance = node_a.get_local_balance_from_channel(channel_id);
+    let old_b_balance = node_b.get_local_balance_from_channel(channel_id);
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+    let preimage_a = [1; 32];
+    let algorithm = HashAlgorithm::Sha256;
+    let digest = algorithm.hash(&preimage_a);
+
+    let add_tlc_result_a = call!(node_a.network_actor, |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: channel_id,
+                command: ChannelCommand::AddTlc(
+                    AddTlcCommand {
+                        amount: 1000,
+                        hash_algorithm: algorithm,
+                        payment_hash: digest.into(),
+                        expiry: now_timestamp_as_millis_u64() + DEFAULT_EXPIRY_DELTA,
+                        onion_packet: None,
+                        shared_secret: NO_SHARED_SECRET.clone(),
+                        previous_tlc: None,
+                    },
+                    rpc_reply,
+                ),
+            },
+        ))
+    })
+    .expect("node_a alive")
+    .expect("successfully added tlc");
+    eprintln!("add_tlc_result: {:?}", add_tlc_result_a);
+
+    // if we don't wait for a while, the next add_tlc will fail with temporary failure
+    let preimage_b = [2; 32];
+    let algorithm = HashAlgorithm::Sha256;
+    let digest = algorithm.hash(&preimage_b);
+    let add_tlc_result = call!(node_a.network_actor, |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: channel_id,
+                command: ChannelCommand::AddTlc(
+                    AddTlcCommand {
+                        amount: 2000,
+                        hash_algorithm: algorithm,
+                        payment_hash: digest.into(),
+                        expiry: now_timestamp_as_millis_u64() + DEFAULT_EXPIRY_DELTA,
+                        onion_packet: None,
+                        shared_secret: NO_SHARED_SECRET.clone(),
+                        previous_tlc: None,
+                    },
+                    rpc_reply,
+                ),
+            },
+        ))
+    })
+    .expect("node_b alive");
+    assert!(add_tlc_result.is_err());
+
+    // now wait for a while, then add a tlc again, it will success
+    tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+    let add_tlc_result_b = call!(node_a.network_actor, |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: channel_id,
+                command: ChannelCommand::AddTlc(
+                    AddTlcCommand {
+                        amount: 2000,
+                        hash_algorithm: algorithm,
+                        payment_hash: digest.into(),
+                        expiry: now_timestamp_as_millis_u64() + DEFAULT_EXPIRY_DELTA,
+                        onion_packet: None,
+                        shared_secret: NO_SHARED_SECRET.clone(),
+                        previous_tlc: None,
+                    },
+                    rpc_reply,
+                ),
+            },
+        ))
+    })
+    .expect("node_b alive");
+    assert!(add_tlc_result_b.is_ok());
+
+    eprintln!("add_tlc_result: {:?}", add_tlc_result_b);
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+    // remove tlc from node_b
+    let res = call!(node_b.network_actor, |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: channel_id,
+                command: ChannelCommand::RemoveTlc(
+                    RemoveTlcCommand {
+                        id: add_tlc_result_a.tlc_id,
+                        reason: RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill {
+                            payment_preimage: preimage_a.into(),
+                        }),
+                    },
+                    rpc_reply,
+                ),
+            },
+        ))
+    })
+    .expect("node_b alive")
+    .expect("successfully removed tlc");
+    eprintln!("remove tlc result: {:?}", res);
+    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+
+    let new_a_balance = node_a.get_local_balance_from_channel(channel_id);
+    let new_b_balance = node_b.get_local_balance_from_channel(channel_id);
+    eprintln!(
+        "old_a_balance: {}, new_a_balance: {}, old_b_balance: {}, new_b_balance: {}",
+        old_a_balance, new_a_balance, old_b_balance, new_b_balance
+    );
+    assert_eq!(new_a_balance, old_a_balance - 1000);
+    assert_eq!(new_b_balance, old_b_balance + 1000);
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+    // remove the later tlc from node_b
+    let res = call!(node_b.network_actor, |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: channel_id,
+                command: ChannelCommand::RemoveTlc(
+                    RemoveTlcCommand {
+                        id: add_tlc_result_b.unwrap().tlc_id,
+                        reason: RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill {
+                            payment_preimage: preimage_b.into(),
+                        }),
+                    },
+                    rpc_reply,
+                ),
+            },
+        ))
+    })
+    .expect("node_b alive")
+    .expect("successfully removed tlc");
+    eprintln!("remove tlc result: {:?}", res);
+    tokio::time::sleep(tokio::time::Duration::from_millis(400)).await;
+
+    let new_a_balance = node_a.get_local_balance_from_channel(channel_id);
+    let new_b_balance = node_b.get_local_balance_from_channel(channel_id);
+    eprintln!(
+        "old_a_balance: {}, new_a_balance: {}, old_b_balance: {}, new_b_balance: {}",
+        old_a_balance, new_a_balance, old_b_balance, new_b_balance
+    );
+    assert_eq!(new_a_balance, old_a_balance - 3000);
+    assert_eq!(new_b_balance, old_b_balance + 3000);
+}
+
+#[tokio::test]
+async fn test_remove_tlc_with_expiry_error() {
+    let node_a_funding_amount = 100000000000;
+    let node_b_funding_amount = 6200000000;
+
+    let (node_a, _node_b, new_channel_id) =
+        create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, false)
+            .await;
 
     let preimage = [1; 32];
     let digest = HashAlgorithm::CkbHash.hash(&preimage);
@@ -2406,7 +2605,7 @@ async fn do_test_add_tlc_waiting_ack() {
         })
         .expect("node_b alive");
         if i == 2 {
-            // we are sending AddTlc constantly, so we should get a TemporaryChannelFailure
+            // we are sending AddTlc constantly, so we should get a WaitingTlcAck
             assert!(add_tlc_result.is_err());
             let code = add_tlc_result.unwrap_err();
             assert_eq!(code.error_code, TlcErrorCode::TemporaryChannelFailure);
@@ -2415,6 +2614,7 @@ async fn do_test_add_tlc_waiting_ack() {
         }
     }
 
+    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
     // send from b to a
     for i in 1..=2 {
         let add_tlc_command = AddTlcCommand {
@@ -2436,18 +2636,19 @@ async fn do_test_add_tlc_waiting_ack() {
         })
         .expect("node_b alive");
         if i == 2 {
-            // we are sending AddTlc constantly, so we should get a TemporaryChannelFailure
+            // we are sending AddTlc constantly, so we should get a WaitingTlcAck
             assert!(add_tlc_result.is_err());
             let code = add_tlc_result.unwrap_err();
             assert_eq!(code.error_code, TlcErrorCode::TemporaryChannelFailure);
         } else {
+            eprintln!("add_tlc_result: {:?}", add_tlc_result);
             assert!(add_tlc_result.is_ok());
         }
     }
 }
 
 #[tokio::test]
-async fn do_test_add_tlc_number_limit() {
+async fn do_test_add_tlc_with_number_limit() {
     let node_a_funding_amount = 100000000000;
     let node_b_funding_amount = 100000000000;
 
@@ -2729,6 +2930,7 @@ async fn do_test_add_tlc_min_tlc_value_limit() {
         None,
     )
     .await;
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
 
     // A -> B will be no limit
     let tlc_amount = 200;
@@ -2750,7 +2952,7 @@ async fn do_test_add_tlc_min_tlc_value_limit() {
         ))
     })
     .expect("node_b alive");
-
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
     assert!(add_tlc_result.is_ok());
 
     // B -> A can still able to send amount less than 100
@@ -2776,7 +2978,7 @@ async fn do_test_add_tlc_min_tlc_value_limit() {
     .expect("node_b alive");
     assert!(add_tlc_result.is_ok());
     // sleep for a while to make sure the AddTlc processed by both party
-    tokio::time::sleep(tokio::time::Duration::from_millis(300)).await;
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
 
     // B -> A can send at least 100
     let tlc_amount = 100;
@@ -2798,6 +3000,7 @@ async fn do_test_add_tlc_min_tlc_value_limit() {
         ))
     })
     .expect("node_b alive");
+    eprintln!("add_local_tlc_result: {:?}", add_tlc_result);
     assert!(add_tlc_result.is_ok());
 }
 
@@ -2917,6 +3120,7 @@ async fn test_channel_update_tlc_sync_up() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -2926,7 +3130,7 @@ async fn test_channel_update_tlc_sync_up() {
         .expect("node_a alive")
         .unwrap();
     // this is the payment_hash generated by keysend
-    assert_eq!(res.status, PaymentSessionStatus::Inflight);
+    assert_eq!(res.status, PaymentSessionStatus::Created);
     tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
 
     // A -> B now will be with limit, add tlc command with amount 99
@@ -2989,6 +3193,7 @@ async fn test_channel_update_tlc_sync_up() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -3043,6 +3248,7 @@ async fn test_channel_update_tlc_sync_up() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -3088,6 +3294,7 @@ async fn test_channel_update_tlc_sync_up() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -3767,7 +3974,7 @@ async fn test_connect_to_peers_with_mutual_channel_on_restart_1() {
     let node_a_funding_amount = 100000000000;
     let node_b_funding_amount = 6200000000;
 
-    let (mut node_a, node_b, _new_channel_id, _) =
+    let (mut node_a, mut node_b, _new_channel_id, _) =
         NetworkNode::new_2_nodes_with_established_channel(
             node_a_funding_amount,
             node_b_funding_amount,
@@ -3779,8 +3986,25 @@ async fn test_connect_to_peers_with_mutual_channel_on_restart_1() {
 
     node_a.expect_event(
         |event| matches!(event, NetworkServiceEvent::PeerConnected(id, _addr) if id == &node_b.peer_id),
-    )
-    .await;
+    ).await;
+    node_a
+        .expect_event(|event| {
+            matches!(
+                event,
+                NetworkServiceEvent::DebugEvent(DebugEvent::Common(
+                    info
+                )) if "Reestablished channel in ChannelReady" == info)
+        })
+        .await;
+    node_b
+        .expect_event(|event| {
+            matches!(
+                event,
+                NetworkServiceEvent::DebugEvent(DebugEvent::Common(
+                    info
+                )) if "Reestablished channel in ChannelReady" == info)
+        })
+        .await;
 }
 
 #[tokio::test]
@@ -3813,6 +4037,187 @@ async fn test_connect_to_peers_with_mutual_channel_on_restart_2() {
     .await;
 }
 
+#[tokio::test]
+async fn test_send_payment_with_node_restart_then_resend_add_tlc() {
+    init_tracing();
+
+    let node_a_funding_amount = 100000000000;
+    let node_b_funding_amount = 6200000000;
+
+    let (mut node_a, mut node_b, _new_channel_id, _) =
+        NetworkNode::new_2_nodes_with_established_channel(
+            node_a_funding_amount,
+            node_b_funding_amount,
+            true,
+        )
+        .await;
+
+    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
+
+    let node_b_pubkey = node_b.pubkey.clone();
+    let tlc_amount = 99;
+    let message = |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_b_pubkey),
+                amount: Some(tlc_amount),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
+    };
+    let res = call!(node_a.network_actor, message).expect("node_a alive");
+    assert!(res.is_ok());
+    let payment_hash = res.unwrap().payment_hash;
+
+    node_b.stop().await;
+
+    let payment_status = node_a.get_payment_status(payment_hash).await;
+    assert_eq!(payment_status, PaymentSessionStatus::Inflight);
+
+    node_b.start().await;
+
+    node_a.expect_event(
+        |event| matches!(event, NetworkServiceEvent::PeerConnected(id, _addr) if id == &node_b.peer_id),
+    )
+    .await;
+
+    node_a
+        .expect_event(|event| {
+            matches!(
+            event,
+            NetworkServiceEvent::DebugEvent(DebugEvent::Common(
+                info
+            )) if "resend add tlc" == info)
+        })
+        .await;
+
+    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
+    let payment_status = node_a.get_payment_status(payment_hash).await;
+    assert_eq!(payment_status, PaymentSessionStatus::Success);
+}
+
+#[tokio::test]
+async fn test_node_reestablish_resend_remove_tlc() {
+    init_tracing();
+
+    let node_a_funding_amount = 100000000000;
+    let node_b_funding_amount = 6200000000;
+
+    let (mut node_a, mut node_b, new_channel_id, _) =
+        NetworkNode::new_2_nodes_with_established_channel(
+            node_a_funding_amount,
+            node_b_funding_amount,
+            true,
+        )
+        .await;
+
+    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
+
+    let node_a_balance = node_a.get_local_balance_from_channel(new_channel_id);
+    let node_b_balance = node_b.get_local_balance_from_channel(new_channel_id);
+
+    let preimage = [2; 32];
+    // create a new payment hash
+    let payment_hash = HashAlgorithm::CkbHash.hash(&preimage);
+
+    let add_tlc_result = call!(node_a.network_actor, |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: new_channel_id,
+                command: ChannelCommand::AddTlc(
+                    AddTlcCommand {
+                        amount: 1000,
+                        hash_algorithm: HashAlgorithm::CkbHash,
+                        payment_hash: payment_hash.clone().into(),
+                        expiry: now_timestamp_as_millis_u64() + DEFAULT_EXPIRY_DELTA,
+                        onion_packet: None,
+                        shared_secret: NO_SHARED_SECRET.clone(),
+                        previous_tlc: None,
+                    },
+                    rpc_reply,
+                ),
+            },
+        ))
+    })
+    .expect("node_b alive")
+    .expect("successfully added tlc");
+
+    dbg!(&add_tlc_result);
+
+    dbg!("Sleeping for some time to wait for the AddTlc processed by both party");
+    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+
+    node_a.stop().await;
+
+    let remove_tlc_result = call!(node_b.network_actor, |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: new_channel_id,
+                command: ChannelCommand::RemoveTlc(
+                    RemoveTlcCommand {
+                        id: add_tlc_result.tlc_id,
+                        reason: RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill {
+                            payment_preimage: preimage.into(),
+                        }),
+                    },
+                    rpc_reply,
+                ),
+            },
+        ))
+    })
+    .expect("node_b alive");
+
+    dbg!(&remove_tlc_result);
+    assert!(remove_tlc_result.is_ok());
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+    // assert balance does not changed since remove tlc is not processed by node_a
+    let new_node_a_balance = node_a.get_local_balance_from_channel(new_channel_id);
+    let new_node_b_balance = node_b.get_local_balance_from_channel(new_channel_id);
+    assert_eq!(node_a_balance, new_node_a_balance);
+    assert_eq!(node_b_balance, new_node_b_balance);
+
+    node_a.start().await;
+    node_b
+        .expect_event(|event| {
+            matches!(
+        event,
+        NetworkServiceEvent::DebugEvent(DebugEvent::Common(
+            info
+        )) if "resend remove tlc" == info)
+        })
+        .await;
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+    // assert balance changed since remove tlc is processed by node_a after node_b resending remove tlc
+    let new_node_a_balance = node_a.get_local_balance_from_channel(new_channel_id);
+    let new_node_b_balance = node_b.get_local_balance_from_channel(new_channel_id);
+    assert_eq!(node_a_balance - 1000, new_node_a_balance);
+    assert_eq!(node_b_balance + 1000, new_node_b_balance);
+    eprintln!(
+        "node_a_balance: {}, new_node_a_balance: {}",
+        node_a_balance, new_node_a_balance
+    );
+    eprintln!(
+        "node_b_balance: {}, new_node_b_balance: {}",
+        node_b_balance, new_node_b_balance
+    );
+}
+
 #[tokio::test]
 async fn test_open_channel_with_large_size_shutdown_script_should_fail() {
     let [node_a, node_b] = NetworkNode::new_n_interconnected_nodes().await;
@@ -3957,6 +4362,8 @@ async fn test_shutdown_channel_with_different_size_shutdown_script() {
     let node_a_funding_amount = 100000000000;
     let node_b_funding_amount = 6200000000;
 
+    // create a private channel for testing shutdown,
+    // https://github.com/nervosnetwork/fiber/issues/431
     let (mut node_a, mut node_b, new_channel_id) =
         create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, false)
             .await;
@@ -4011,6 +4418,14 @@ async fn test_shutdown_channel_with_different_size_shutdown_script() {
         })
         .await;
 
+    node_a
+        .expect_event(|event| matches!(event, NetworkServiceEvent::DebugEvent(DebugEvent::Common(message)) if message == "ChannelClosed"))
+        .await;
+
+    node_b
+        .expect_event(|event| matches!(event, NetworkServiceEvent::DebugEvent(DebugEvent::Common(message)) if message == "ChannelClosed"))
+        .await;
+
     assert_eq!(node_a_shutdown_tx_hash, node_b_shutdown_tx_hash);
 
     assert_eq!(
@@ -4023,6 +4438,90 @@ async fn test_shutdown_channel_with_different_size_shutdown_script() {
     );
 }
 
+#[tokio::test]
+async fn test_shutdown_channel_network_graph_will_not_sync_private_channel() {
+    let node_a_funding_amount = 100000000000;
+    let node_b_funding_amount = 6200000000;
+
+    let (node_a, node_b, _channel_id) =
+        create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, false)
+            .await;
+
+    // sleep for 1 second
+    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
+
+    let network_nodes = node_a.get_network_nodes().await;
+    assert_eq!(network_nodes.len(), 2);
+
+    let network_nodes = node_b.get_network_nodes().await;
+    assert_eq!(network_nodes.len(), 2);
+
+    let network_channels = node_a.get_network_channels().await;
+    assert_eq!(network_channels.len(), 0);
+
+    let network_channels = node_b.get_network_channels().await;
+    assert_eq!(network_channels.len(), 0);
+}
+
+#[tokio::test]
+async fn test_shutdown_channel_network_graph_with_sync_up() {
+    let node_a_funding_amount = 100000000000;
+    let node_b_funding_amount = 6200000000;
+
+    let (node_a, node_b, channel_id) =
+        create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, true)
+            .await;
+
+    // sleep for 1 second
+    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
+
+    let network_nodes = node_a.get_network_nodes().await;
+    assert_eq!(network_nodes.len(), 2);
+
+    let network_nodes = node_b.get_network_nodes().await;
+    assert_eq!(network_nodes.len(), 2);
+
+    let network_channels = node_a.get_network_channels().await;
+    assert_eq!(network_channels.len(), 1);
+
+    let network_channels = node_b.get_network_channels().await;
+    assert_eq!(network_channels.len(), 1);
+
+    let message = |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: channel_id,
+                command: ChannelCommand::Shutdown(
+                    ShutdownCommand {
+                        close_script: Script::new_builder().args(vec![0u8; 19].pack()).build(),
+                        fee_rate: FeeRate::from_u64(DEFAULT_COMMITMENT_FEE_RATE),
+                        force: false,
+                    },
+                    rpc_reply,
+                ),
+            },
+        ))
+    };
+
+    call!(node_b.network_actor, message)
+        .expect("node_b alive")
+        .expect("successfully shutdown channel");
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
+
+    let network_nodes = node_a.get_network_nodes().await;
+    assert_eq!(network_nodes.len(), 2);
+
+    let network_nodes = node_b.get_network_nodes().await;
+    assert_eq!(network_nodes.len(), 2);
+
+    let network_channels = node_a.get_network_channels().await;
+    assert_eq!(network_channels.len(), 0);
+
+    let network_channels = node_b.get_network_channels().await;
+    assert_eq!(network_channels.len(), 0);
+}
+
 #[tokio::test]
 async fn test_send_payment_with_channel_balance_error() {
     init_tracing();
@@ -4053,6 +4552,7 @@ async fn test_send_payment_with_channel_balance_error() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4062,15 +4562,7 @@ async fn test_send_payment_with_channel_balance_error() {
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
     // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-    let message = |rpc_reply| -> NetworkActorMessage {
-        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash, rpc_reply))
-    };
-    let res = call!(source_node.network_actor, message)
-        .expect("node_a alive")
-        .unwrap();
-
-    assert_eq!(res.status, PaymentSessionStatus::Success);
+    source_node.wait_until_success(payment_hash).await;
 
     node_2.update_channel_local_balance(channels[2], 100).await;
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
@@ -4090,6 +4582,7 @@ async fn test_send_payment_with_channel_balance_error() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4100,14 +4593,9 @@ async fn test_send_payment_with_channel_balance_error() {
     let res = call!(source_node.network_actor, message).expect("source_node alive");
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
 
-    let message = |rpc_reply| -> NetworkActorMessage {
-        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash, rpc_reply))
-    };
-    let res = call!(source_node.network_actor, message)
-        .expect("node_a alive")
-        .unwrap();
+    source_node.wait_until_failed(payment_hash).await;
+    let res = source_node.get_payment_result(payment_hash).await;
 
     assert_eq!(res.status, PaymentSessionStatus::Failed);
     assert!(res.failed_error.unwrap().contains("Failed to build route"));
@@ -4152,6 +4640,7 @@ async fn test_send_payment_with_disable_channel() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4163,16 +4652,7 @@ async fn test_send_payment_with_disable_channel() {
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
 
-    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
-
-    let message = |rpc_reply| -> NetworkActorMessage {
-        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash, rpc_reply))
-    };
-    let res = call!(source_node.network_actor, message)
-        .expect("node_a alive")
-        .unwrap();
-
-    assert_eq!(res.status, PaymentSessionStatus::Failed);
+    source_node.wait_until_failed(payment_hash).await;
     // because there is only one path for the payment, the payment will fail in the second try
     // this assertion make sure we didn't do meaningless retry
     let payment_session = source_node.get_payment_session(payment_hash).unwrap();
@@ -4189,8 +4669,8 @@ async fn test_send_payment_with_multiple_edges_in_middle_hops() {
     let (nodes, _channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
         &[
             ((0, 1), (100000000000, 100000000000)),
-            ((1, 2), (4200000000 + 900, 5200000000)),
-            ((1, 2), (4200000000 + 1000, 5200000000)),
+            ((1, 2), (MIN_RESERVED_CKB + 900, 5200000000)),
+            ((1, 2), (MIN_RESERVED_CKB + 1000, 5200000000)),
             ((2, 3), (100000000000, 100000000000)),
         ],
         4,
@@ -4201,9 +4681,6 @@ async fn test_send_payment_with_multiple_edges_in_middle_hops() {
     let source_node = &node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
@@ -4219,6 +4696,7 @@ async fn test_send_payment_with_multiple_edges_in_middle_hops() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4229,17 +4707,8 @@ async fn test_send_payment_with_multiple_edges_in_middle_hops() {
     let res = call!(source_node.network_actor, message).expect("source_node alive");
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(4)).await;
 
-    let message = |rpc_reply| -> NetworkActorMessage {
-        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash, rpc_reply))
-    };
-    let res = call!(source_node.network_actor, message)
-        .expect("node_a alive")
-        .unwrap();
-
-    assert_eq!(res.status, PaymentSessionStatus::Success);
-    eprintln!("failed_error: {:?}", res);
+    source_node.wait_until_success(payment_hash).await;
     // because there is only one path for the payment, the payment will fail in the second try
     // this assertion make sure we didn't do meaningless retry
     let payment_session = source_node.get_payment_session(payment_hash).unwrap();
@@ -4256,8 +4725,8 @@ async fn test_send_payment_with_all_failed_middle_hops() {
     let (nodes, _channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
         &[
             ((0, 1), (100000000000, 100000000000)),
-            ((1, 2), (4200000000 + 900, 4200000000 + 1000)),
-            ((1, 2), (4200000000 + 910, 4200000000 + 1000)),
+            ((1, 2), (MIN_RESERVED_CKB + 900, MIN_RESERVED_CKB + 1000)),
+            ((1, 2), (MIN_RESERVED_CKB + 910, MIN_RESERVED_CKB + 1000)),
             ((2, 3), (100000000000, 100000000000)),
         ],
         4,
@@ -4268,9 +4737,6 @@ async fn test_send_payment_with_all_failed_middle_hops() {
     let source_node = &node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
@@ -4286,26 +4752,19 @@ async fn test_send_payment_with_all_failed_middle_hops() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
         ))
     };
 
-    // expect send payment to succeed
+    // expect send payment to failed
     let res = call!(source_node.network_actor, message).expect("source_node alive");
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(4)).await;
-    let message = |rpc_reply| -> NetworkActorMessage {
-        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash, rpc_reply))
-    };
-    let res = call!(source_node.network_actor, message)
-        .expect("node_a alive")
-        .unwrap();
+    source_node.wait_until_failed(payment_hash).await;
 
-    assert_eq!(res.status, PaymentSessionStatus::Failed);
-    eprintln!("failed_error: {:?}", res);
     // because there is only one path for the payment, the payment will fail in the second try
     // this assertion make sure we didn't do meaningless retry
     let payment_session = source_node.get_payment_session(payment_hash).unwrap();
@@ -4323,8 +4782,8 @@ async fn test_send_payment_with_multiple_edges_can_succeed_in_retry() {
     let (nodes, _channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
         &[
             ((0, 1), (100000000000, 100000000000)),
-            ((1, 2), (4200000000 + 1000, 5200000000)),
-            ((1, 2), (4200000000 + 900, 6200000000)),
+            ((1, 2), (MIN_RESERVED_CKB + 1000, 5200000000)),
+            ((1, 2), (MIN_RESERVED_CKB + 900, 6200000000)),
             ((2, 3), (100000000000, 100000000000)),
         ],
         4,
@@ -4335,9 +4794,6 @@ async fn test_send_payment_with_multiple_edges_can_succeed_in_retry() {
     let source_node = &node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
@@ -4353,6 +4809,7 @@ async fn test_send_payment_with_multiple_edges_can_succeed_in_retry() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4363,17 +4820,8 @@ async fn test_send_payment_with_multiple_edges_can_succeed_in_retry() {
     let res = call!(source_node.network_actor, message).expect("source_node alive");
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(4)).await;
+    source_node.wait_until_success(payment_hash).await;
 
-    let message = |rpc_reply| -> NetworkActorMessage {
-        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash, rpc_reply))
-    };
-    let res = call!(source_node.network_actor, message)
-        .expect("node_a alive")
-        .unwrap();
-
-    assert_eq!(res.status, PaymentSessionStatus::Success);
-    eprintln!("failed_error: {:?}", res);
     // because there is only one path for the payment, the payment will fail in the second try
     // this assertion make sure we didn't do meaningless retry
     let payment_session = source_node.get_payment_session(payment_hash).unwrap();
@@ -4391,8 +4839,8 @@ async fn test_send_payment_with_final_hop_multiple_edges_in_middle_hops() {
         &[
             ((0, 1), (100000000000, 100000000000)),
             ((1, 2), (100000000000, 100000000000)),
-            ((2, 3), (4200000000 + 900, 5200000000)),
-            ((2, 3), (4200000000 + 1000, 5200000000)),
+            ((2, 3), (MIN_RESERVED_CKB + 900, 5200000000)),
+            ((2, 3), (MIN_RESERVED_CKB + 1000, 5200000000)),
         ],
         4,
         true,
@@ -4402,9 +4850,6 @@ async fn test_send_payment_with_final_hop_multiple_edges_in_middle_hops() {
     let source_node = &node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
@@ -4420,6 +4865,7 @@ async fn test_send_payment_with_final_hop_multiple_edges_in_middle_hops() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4430,17 +4876,8 @@ async fn test_send_payment_with_final_hop_multiple_edges_in_middle_hops() {
     let res = call!(source_node.network_actor, message).expect("source_node alive");
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(4)).await;
+    source_node.wait_until_success(payment_hash).await;
 
-    let message = |rpc_reply| -> NetworkActorMessage {
-        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash, rpc_reply))
-    };
-    let res = call!(source_node.network_actor, message)
-        .expect("node_a alive")
-        .unwrap();
-
-    assert_eq!(res.status, PaymentSessionStatus::Success);
-    eprintln!("failed_error: {:?}", res);
     // because there is only one path for the payment, the payment will fail in the second try
     // this assertion make sure we didn't do meaningless retry
     let payment_session = source_node.get_payment_session(payment_hash).unwrap();
@@ -4458,8 +4895,8 @@ async fn test_send_payment_with_final_all_failed_middle_hops() {
         &[
             ((0, 1), (100000000000, 100000000000)),
             ((1, 2), (100000000000, 100000000000)),
-            ((2, 3), (4200000000 + 900, 4200000000 + 1000)),
-            ((2, 3), (4200000000 + 910, 4200000000 + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 900, MIN_RESERVED_CKB + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 910, MIN_RESERVED_CKB + 1000)),
         ],
         4,
         true,
@@ -4469,9 +4906,6 @@ async fn test_send_payment_with_final_all_failed_middle_hops() {
     let source_node = &node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
@@ -4487,6 +4921,7 @@ async fn test_send_payment_with_final_all_failed_middle_hops() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4497,8 +4932,8 @@ async fn test_send_payment_with_final_all_failed_middle_hops() {
     let res = call!(source_node.network_actor, message).expect("source_node alive");
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(4)).await;
 
+    source_node.wait_until_failed(payment_hash).await;
     source_node
         .assert_payment_status(payment_hash, PaymentSessionStatus::Failed, Some(3))
         .await;
@@ -4516,8 +4951,8 @@ async fn test_send_payment_with_final_multiple_edges_can_succeed_in_retry() {
         &[
             ((0, 1), (100000000000, 100000000000)),
             ((1, 2), (100000000000, 100000000000)),
-            ((2, 3), (4200000000 + 1000, 5200000000)),
-            ((2, 3), (4200000000 + 900, 6200000000)),
+            ((2, 3), (MIN_RESERVED_CKB + 1000, 5200000000)),
+            ((2, 3), (MIN_RESERVED_CKB + 900, 6200000000)),
         ],
         4,
         true,
@@ -4527,9 +4962,6 @@ async fn test_send_payment_with_final_multiple_edges_can_succeed_in_retry() {
     let source_node = &node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
@@ -4545,6 +4977,7 @@ async fn test_send_payment_with_final_multiple_edges_can_succeed_in_retry() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4555,8 +4988,8 @@ async fn test_send_payment_with_final_multiple_edges_can_succeed_in_retry() {
     let res = call!(source_node.network_actor, message).expect("source_node alive");
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(4)).await;
 
+    source_node.wait_until_success(payment_hash).await;
     source_node
         .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(2))
         .await;
@@ -4571,7 +5004,7 @@ async fn test_send_payment_with_first_hop_failed_with_fee() {
             // even 1000 > 999, but it's not enough for fee, and this is the direct channel
             // so we can check the actual balance of channel
             // the payment will fail
-            ((0, 1), (4200000000 + 1000, 5200000000)),
+            ((0, 1), (MIN_RESERVED_CKB + 1000, 5200000000)),
             ((1, 2), (100000000000, 100000000000)),
             ((2, 3), (100000000000, 100000000000)),
         ],
@@ -4583,9 +5016,6 @@ async fn test_send_payment_with_first_hop_failed_with_fee() {
     let source_node = &node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
@@ -4601,6 +5031,7 @@ async fn test_send_payment_with_first_hop_failed_with_fee() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4622,8 +5053,8 @@ async fn test_send_payment_succeed_with_multiple_edges_in_first_hop() {
     // the send payment should be succeed
     let (nodes, _channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
         &[
-            ((0, 1), (4200000000 + 900, 5200000000)),
-            ((0, 1), (4200000000 + 1001, 5200000000)),
+            ((0, 1), (MIN_RESERVED_CKB + 900, 5200000000)),
+            ((0, 1), (MIN_RESERVED_CKB + 1001, 5200000000)),
             ((1, 2), (100000000000, 100000000000)),
             ((2, 3), (100000000000, 100000000000)),
         ],
@@ -4635,9 +5066,6 @@ async fn test_send_payment_succeed_with_multiple_edges_in_first_hop() {
     let source_node = &node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
@@ -4653,6 +5081,7 @@ async fn test_send_payment_succeed_with_multiple_edges_in_first_hop() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4663,8 +5092,8 @@ async fn test_send_payment_succeed_with_multiple_edges_in_first_hop() {
     let res = call!(source_node.network_actor, message).expect("source_node alive");
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(4)).await;
 
+    source_node.wait_until_success(payment_hash).await;
     source_node
         .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
         .await;
@@ -4679,8 +5108,8 @@ async fn test_send_payment_with_first_hop_all_failed() {
     // path finding will fail in the first time of send payment
     let (nodes, _channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
         &[
-            ((0, 1), (4200000000 + 900, 4200000000 + 1000)),
-            ((0, 1), (4200000000 + 910, 4200000000 + 1000)),
+            ((0, 1), (MIN_RESERVED_CKB + 900, MIN_RESERVED_CKB + 1000)),
+            ((0, 1), (MIN_RESERVED_CKB + 910, MIN_RESERVED_CKB + 1000)),
             ((1, 2), (100000000000, 100000000000)),
             ((2, 3), (100000000000, 100000000000)),
         ],
@@ -4692,9 +5121,6 @@ async fn test_send_payment_with_first_hop_all_failed() {
     let source_node = &node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
@@ -4710,6 +5136,7 @@ async fn test_send_payment_with_first_hop_all_failed() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4733,8 +5160,8 @@ async fn test_send_payment_will_succeed_with_direct_channel_info_first_hop() {
     // so it will try the channel with smaller capacity and the payment will succeed
     let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
         &[
-            ((0, 1), (4200000000 + 2000, 4200000000 + 1000)),
-            ((0, 1), (4200000000 + 1005, 4200000000 + 1000)),
+            ((0, 1), (MIN_RESERVED_CKB + 2000, MIN_RESERVED_CKB + 1000)),
+            ((0, 1), (MIN_RESERVED_CKB + 1005, MIN_RESERVED_CKB + 1000)),
             ((1, 2), (100000000000, 100000000000)),
             ((2, 3), (100000000000, 100000000000)),
         ],
@@ -4746,9 +5173,6 @@ async fn test_send_payment_will_succeed_with_direct_channel_info_first_hop() {
     let source_node = &mut node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     // manually update the channel's to_local_amount
     source_node
         .update_channel_local_balance(channels[0], 100)
@@ -4770,6 +5194,7 @@ async fn test_send_payment_will_succeed_with_direct_channel_info_first_hop() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4781,8 +5206,7 @@ async fn test_send_payment_will_succeed_with_direct_channel_info_first_hop() {
     assert!(res.is_ok());
 
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
+    source_node.wait_until_success(payment_hash).await;
     source_node
         .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
         .await;
@@ -4795,14 +5219,14 @@ async fn test_send_payment_will_succeed_with_retry_in_middle_hops() {
     // we have two chaneels between node_2 and node_3
     // the path finding will first try the channel with larger capacity,
     // but we manually set the to_local_amount to smaller value for testing
-    // path finding will get the direct channel info with actual balance of channel,
+    // path finding will get a temporary failure in the first try and retry the second channel
     // so it will try the channel with smaller capacity and the payment will succeed
     let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
         &[
             ((0, 1), (100000000000, 100000000000)),
             ((1, 2), (100000000000, 100000000000)),
-            ((2, 3), (4200000000 + 2000, 4200000000 + 1000)),
-            ((2, 3), (4200000000 + 1005, 4200000000 + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 2000, MIN_RESERVED_CKB + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 1005, MIN_RESERVED_CKB + 1000)),
         ],
         4,
         true,
@@ -4810,20 +5234,19 @@ async fn test_send_payment_will_succeed_with_retry_in_middle_hops() {
     .await;
     let [mut node_0, _node_1, mut node_2, node_3] = nodes.try_into().expect("4 nodes");
     let source_node = &mut node_0;
+    let node_0_amount = source_node.get_local_balance_from_channel(channels[0]);
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     // manually update the channel's to_local_amount
     node_2.update_channel_local_balance(channels[2], 100).await;
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
 
+    let amount = 999;
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
             SendPaymentCommand {
                 target_pubkey: Some(target_pubkey.clone()),
-                amount: Some(999),
+                amount: Some(amount),
                 payment_hash: None,
                 final_tlc_expiry_delta: None,
                 tlc_expiry_limit: None,
@@ -4834,6 +5257,7 @@ async fn test_send_payment_will_succeed_with_retry_in_middle_hops() {
                 keysend: Some(true),
                 udt_type_script: None,
                 allow_self_payment: false,
+                hop_hints: None,
                 dry_run: false,
             },
             rpc_reply,
@@ -4841,15 +5265,21 @@ async fn test_send_payment_will_succeed_with_retry_in_middle_hops() {
     };
 
     // expect send payment to succeed
-    let res = call!(source_node.network_actor, message).expect("source_node alive");
-    assert!(res.is_ok());
+    let res = call!(source_node.network_actor, message)
+        .expect("source_node alive")
+        .unwrap();
 
-    let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
+    let payment_hash = res.payment_hash;
+    source_node.wait_until_success(payment_hash).await;
 
+    let fee = res.fee;
+    eprintln!("fee: {:?}", fee);
     source_node
         .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(2))
         .await;
+
+    let new_node0_amount = source_node.get_local_balance_from_channel(channels[0]);
+    assert_eq!(node_0_amount - amount - fee, new_node0_amount);
 }
 
 #[tokio::test]
@@ -4865,8 +5295,8 @@ async fn test_send_payment_will_fail_with_last_hop_info_in_add_tlc_peer() {
         &[
             ((0, 1), (100000000000, 100000000000)),
             ((1, 2), (100000000000, 100000000000)),
-            ((2, 3), (4200000000 + 2000, 4200000000 + 1000)),
-            ((2, 3), (4200000000 + 1005, 4200000000 + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 2000, MIN_RESERVED_CKB + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 1005, MIN_RESERVED_CKB + 1000)),
         ],
         4,
         true,
@@ -4876,9 +5306,6 @@ async fn test_send_payment_will_fail_with_last_hop_info_in_add_tlc_peer() {
     let source_node = &mut node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     // manually update the channel's to_remote_amount
     node_3
         .update_channel_remote_balance(channels[2], 100000000)
@@ -4899,6 +5326,7 @@ async fn test_send_payment_will_fail_with_last_hop_info_in_add_tlc_peer() {
             keysend: Some(true),
             udt_type_script: None,
             allow_self_payment: false,
+            hop_hints: None,
             dry_run: false,
         })
         .await;
@@ -4933,8 +5361,8 @@ async fn test_send_payment_will_fail_with_invoice_not_generated_by_target() {
         &[
             ((0, 1), (100000000000, 100000000000)),
             ((1, 2), (100000000000, 100000000000)),
-            ((2, 3), (4200000000 + 2000, 4200000000 + 1000)),
-            ((2, 3), (4200000000 + 1005, 4200000000 + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 2000, MIN_RESERVED_CKB + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 1005, MIN_RESERVED_CKB + 1000)),
         ],
         4,
         true,
@@ -4944,9 +5372,6 @@ async fn test_send_payment_will_fail_with_invoice_not_generated_by_target() {
     let source_node = &mut node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let invoice = InvoiceBuilder::new(Currency::Fibd)
         .amount(Some(100))
         .payment_preimage(gen_rand_sha256_hash())
@@ -4970,6 +5395,7 @@ async fn test_send_payment_will_fail_with_invoice_not_generated_by_target() {
             keysend: None,
             udt_type_script: None,
             allow_self_payment: false,
+            hop_hints: None,
             dry_run: false,
         })
         .await;
@@ -4978,8 +5404,7 @@ async fn test_send_payment_will_fail_with_invoice_not_generated_by_target() {
     assert!(res.is_ok());
 
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
+    source_node.wait_until_failed(payment_hash).await;
     source_node
         .assert_payment_status(payment_hash, PaymentSessionStatus::Failed, Some(1))
         .await;
@@ -4994,8 +5419,8 @@ async fn test_send_payment_will_succeed_with_valid_invoice() {
         &[
             ((0, 1), (100000000000, 100000000000)),
             ((1, 2), (100000000000, 100000000000)),
-            ((2, 3), (4200000000 + 2000, 4200000000 + 1000)),
-            ((2, 3), (4200000000 + 1005, 4200000000 + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 2000, MIN_RESERVED_CKB + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 1005, MIN_RESERVED_CKB + 1000)),
         ],
         4,
         true,
@@ -5006,9 +5431,6 @@ async fn test_send_payment_will_succeed_with_valid_invoice() {
     let target_pubkey = node_3.pubkey.clone();
     let old_amount = node_3.get_local_balance_from_channel(channels[2]);
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let preimage = gen_rand_sha256_hash();
     let ckb_invoice = InvoiceBuilder::new(Currency::Fibd)
         .amount(Some(100))
@@ -5034,6 +5456,7 @@ async fn test_send_payment_will_succeed_with_valid_invoice() {
             keysend: None,
             udt_type_script: None,
             allow_self_payment: false,
+            hop_hints: None,
             dry_run: false,
         })
         .await;
@@ -5042,7 +5465,7 @@ async fn test_send_payment_will_succeed_with_valid_invoice() {
     assert!(res.is_ok());
 
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+    source_node.wait_until_success(payment_hash).await;
 
     source_node
         .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
@@ -5064,8 +5487,8 @@ async fn test_send_payment_will_fail_with_no_invoice_preimage() {
         &[
             ((0, 1), (100000000000, 100000000000)),
             ((1, 2), (100000000000, 100000000000)),
-            ((2, 3), (4200000000 + 2000, 4200000000 + 1000)),
-            ((2, 3), (4200000000 + 1005, 4200000000 + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 2000, MIN_RESERVED_CKB + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 1005, MIN_RESERVED_CKB + 1000)),
         ],
         4,
         true,
@@ -5076,9 +5499,6 @@ async fn test_send_payment_will_fail_with_no_invoice_preimage() {
     let target_pubkey = node_3.pubkey.clone();
     let old_amount = node_3.get_local_balance_from_channel(channels[2]);
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let preimage = gen_rand_sha256_hash();
     let ckb_invoice = InvoiceBuilder::new(Currency::Fibd)
         .amount(Some(100))
@@ -5105,6 +5525,7 @@ async fn test_send_payment_will_fail_with_no_invoice_preimage() {
             keysend: None,
             udt_type_script: None,
             allow_self_payment: false,
+            hop_hints: None,
             dry_run: false,
         })
         .await;
@@ -5113,7 +5534,7 @@ async fn test_send_payment_will_fail_with_no_invoice_preimage() {
     assert!(res.is_ok());
 
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
 
     source_node
         .assert_payment_status(payment_hash, PaymentSessionStatus::Failed, Some(1))
@@ -5121,9 +5542,11 @@ async fn test_send_payment_will_fail_with_no_invoice_preimage() {
 
     let new_amount = node_3.get_local_balance_from_channel(channels[2]);
     assert_eq!(new_amount, old_amount);
+
+    // we should never update the invoice status if there is an error
     assert_eq!(
         node_3.get_invoice_status(ckb_invoice.payment_hash()),
-        Some(CkbInvoiceStatus::Received)
+        Some(CkbInvoiceStatus::Open)
     );
 }
 
@@ -5136,8 +5559,8 @@ async fn test_send_payment_will_fail_with_cancelled_invoice() {
         &[
             ((0, 1), (100000000000, 100000000000)),
             ((1, 2), (100000000000, 100000000000)),
-            ((2, 3), (4200000000 + 2000, 4200000000 + 1000)),
-            ((2, 3), (4200000000 + 1005, 4200000000 + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 2000, MIN_RESERVED_CKB + 1000)),
+            ((2, 3), (MIN_RESERVED_CKB + 1005, MIN_RESERVED_CKB + 1000)),
         ],
         4,
         true,
@@ -5148,9 +5571,6 @@ async fn test_send_payment_will_fail_with_cancelled_invoice() {
     let target_pubkey = node_3.pubkey.clone();
     let old_amount = node_3.get_local_balance_from_channel(channels[2]);
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let preimage = gen_rand_sha256_hash();
     let ckb_invoice = InvoiceBuilder::new(Currency::Fibd)
         .amount(Some(100))
@@ -5179,13 +5599,14 @@ async fn test_send_payment_will_fail_with_cancelled_invoice() {
             keysend: None,
             udt_type_script: None,
             allow_self_payment: false,
+            hop_hints: None,
             dry_run: false,
         })
         .await;
 
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
 
     source_node
         .assert_payment_status(payment_hash, PaymentSessionStatus::Failed, Some(1))
@@ -5207,7 +5628,7 @@ async fn test_send_payment_will_succeed_with_large_tlc_expiry_limit() {
 
     let (nodes, _channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
         &[
-            ((0, 1), (4200000000 + 2000, 4200000000 + 1000)),
+            ((0, 1), (MIN_RESERVED_CKB + 2000, MIN_RESERVED_CKB + 1000)),
             ((1, 2), (100000000000, 100000000000)),
             ((2, 3), (100000000000, 100000000000)),
         ],
@@ -5219,9 +5640,6 @@ async fn test_send_payment_will_succeed_with_large_tlc_expiry_limit() {
     let source_node = &mut node_0;
     let target_pubkey = node_3.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let expected_minimal_tlc_expiry_limit = (24 * 60 * 60 * 1000) * 3;
 
     let res = source_node
@@ -5238,6 +5656,7 @@ async fn test_send_payment_will_succeed_with_large_tlc_expiry_limit() {
             keysend: Some(true),
             udt_type_script: None,
             allow_self_payment: false,
+            hop_hints: None,
             dry_run: false,
         })
         .await;
@@ -5258,6 +5677,7 @@ async fn test_send_payment_will_succeed_with_large_tlc_expiry_limit() {
             keysend: Some(true),
             udt_type_script: None,
             allow_self_payment: false,
+            hop_hints: None,
             dry_run: false,
         })
         .await;
@@ -5265,7 +5685,7 @@ async fn test_send_payment_will_succeed_with_large_tlc_expiry_limit() {
     // expect send payment to succeed
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
 
     source_node
         .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
diff --git a/src/fiber/tests/gossip.rs b/src/fiber/tests/gossip.rs
index 8d02f57f9..26c7d8854 100644
--- a/src/fiber/tests/gossip.rs
+++ b/src/fiber/tests/gossip.rs
@@ -16,7 +16,6 @@ use tentacle::{
 };
 use tokio::{spawn, sync::RwLock};
 
-use crate::create_invalid_ecdsa_signature;
 use crate::fiber::tests::test_utils::{establish_channel_between_nodes, NetworkNode};
 use crate::fiber::types::NodeAnnouncement;
 use crate::{
@@ -31,9 +30,10 @@ use crate::{
         },
         types::{BroadcastMessage, BroadcastMessageWithTimestamp, Cursor},
     },
-    gen_node_announcement_from_privkey, gen_rand_channel_announcement, gen_rand_node_announcement,
+    gen_node_announcement_from_privkey, gen_rand_node_announcement,
     store::Store,
 };
+use crate::{create_invalid_ecdsa_signature, ChannelTestContext};
 
 use super::test_utils::{get_test_root_actor, TempDir};
 
@@ -70,6 +70,7 @@ impl GossipTestingContext {
             None,
             Duration::from_millis(50).into(),
             Duration::from_millis(50).into(),
+            true,
             store.clone(),
             chain_actor.clone(),
             root_actor.get_cell(),
@@ -113,7 +114,9 @@ impl GossipTestingContext {
 
     fn save_message(&self, message: BroadcastMessage) {
         self.get_store_actor()
-            .send_message(ExtendedGossipMessageStoreMessage::SaveMessage(message))
+            .send_message(ExtendedGossipMessageStoreMessage::SaveMessages(vec![
+                message,
+            ]))
             .expect("send message");
     }
 
@@ -225,34 +228,41 @@ async fn test_save_gossip_message() {
 #[tokio::test]
 async fn test_saving_unconfirmed_channel_announcement() {
     let context = GossipTestingContext::new().await;
-    let (_, announcement, _, _, _) = gen_rand_channel_announcement();
-    context.save_message(BroadcastMessage::ChannelAnnouncement(announcement.clone()));
+    let channel_context = ChannelTestContext::gen();
+    context.save_message(BroadcastMessage::ChannelAnnouncement(
+        channel_context.channel_announcement.clone(),
+    ));
     tokio::time::sleep(Duration::from_millis(200).into()).await;
     let new_announcement = context
         .get_store()
-        .get_latest_channel_announcement(&announcement.channel_outpoint);
+        .get_latest_channel_announcement(channel_context.channel_outpoint());
     assert_eq!(new_announcement, None);
 }
 
 #[tokio::test]
 async fn test_saving_confirmed_channel_announcement() {
     let context = GossipTestingContext::new().await;
-    let (_, announcement, tx, _, _) = gen_rand_channel_announcement();
-    context.save_message(BroadcastMessage::ChannelAnnouncement(announcement.clone()));
-    let status = context.submit_tx(tx).await;
+    let channel_context = ChannelTestContext::gen();
+    context.save_message(BroadcastMessage::ChannelAnnouncement(
+        channel_context.channel_announcement.clone(),
+    ));
+    let status = context.submit_tx(channel_context.funding_tx.clone()).await;
     assert_eq!(status, Status::Committed);
     tokio::time::sleep(Duration::from_millis(200).into()).await;
     let new_announcement = context
         .get_store()
-        .get_latest_channel_announcement(&announcement.channel_outpoint);
-    assert_eq!(new_announcement, None);
+        .get_latest_channel_announcement(channel_context.channel_outpoint());
+    assert_ne!(new_announcement, None);
 }
 
 #[tokio::test]
 async fn test_saving_invalid_channel_announcement() {
     let context = GossipTestingContext::new().await;
-    let (_, announcement, tx, _, _) = gen_rand_channel_announcement();
-    context.save_message(BroadcastMessage::ChannelAnnouncement(announcement.clone()));
+    let channel_context = ChannelTestContext::gen();
+    let tx = channel_context.funding_tx.clone();
+    context.save_message(BroadcastMessage::ChannelAnnouncement(
+        channel_context.channel_announcement.clone(),
+    ));
     let output = tx.output(0).expect("get output").clone();
     let invalid_lock = output
         .lock()
@@ -278,10 +288,215 @@ async fn test_saving_invalid_channel_announcement() {
     tokio::time::sleep(Duration::from_millis(200).into()).await;
     let new_announcement = context
         .get_store()
-        .get_latest_channel_announcement(&announcement.channel_outpoint);
+        .get_latest_channel_announcement(channel_context.channel_outpoint());
     assert_eq!(new_announcement, None);
 }
 
+#[tokio::test]
+async fn test_saving_channel_update_after_saving_channel_announcement() {
+    let context = GossipTestingContext::new().await;
+    let channel_context = ChannelTestContext::gen();
+    context.save_message(BroadcastMessage::ChannelAnnouncement(
+        channel_context.channel_announcement.clone(),
+    ));
+    let status = context.submit_tx(channel_context.funding_tx.clone()).await;
+    assert_eq!(status, Status::Committed);
+    tokio::time::sleep(Duration::from_millis(200).into()).await;
+    let new_announcement = context
+        .get_store()
+        .get_latest_channel_announcement(channel_context.channel_outpoint());
+    assert_ne!(new_announcement, None);
+    for channel_update in [
+        channel_context.create_channel_update_of_node1(0, 42, 42, 42),
+        channel_context.create_channel_update_of_node2(0, 42, 42, 42),
+    ] {
+        context.save_message(BroadcastMessage::ChannelUpdate(channel_update.clone()));
+    }
+    tokio::time::sleep(Duration::from_millis(200).into()).await;
+    for b in [true, false] {
+        let channel_update = context
+            .get_store()
+            .get_latest_channel_update(channel_context.channel_outpoint(), b);
+        assert_ne!(channel_update, None);
+    }
+}
+
+#[tokio::test]
+async fn test_saving_channel_update_before_saving_channel_announcement() {
+    let context = GossipTestingContext::new().await;
+    let channel_context = ChannelTestContext::gen();
+
+    for channel_update in [
+        channel_context.create_channel_update_of_node1(0, 42, 42, 42),
+        channel_context.create_channel_update_of_node2(0, 42, 42, 42),
+    ] {
+        context.save_message(BroadcastMessage::ChannelUpdate(channel_update.clone()));
+    }
+    tokio::time::sleep(Duration::from_millis(200).into()).await;
+    for b in [true, false] {
+        let channel_update = context
+            .get_store()
+            .get_latest_channel_update(channel_context.channel_outpoint(), b);
+        assert_eq!(channel_update, None);
+    }
+
+    context.save_message(BroadcastMessage::ChannelAnnouncement(
+        channel_context.channel_announcement.clone(),
+    ));
+    let status = context.submit_tx(channel_context.funding_tx.clone()).await;
+    assert_eq!(status, Status::Committed);
+    tokio::time::sleep(Duration::from_millis(200).into()).await;
+    let new_announcement = context
+        .get_store()
+        .get_latest_channel_announcement(channel_context.channel_outpoint());
+    assert_ne!(new_announcement, None);
+    for b in [true, false] {
+        let channel_update = context
+            .get_store()
+            .get_latest_channel_update(channel_context.channel_outpoint(), b);
+        assert_ne!(channel_update, None);
+    }
+}
+
+#[tokio::test]
+async fn test_saving_invalid_channel_update() {
+    let context = GossipTestingContext::new().await;
+    let channel_context = ChannelTestContext::gen();
+    context.save_message(BroadcastMessage::ChannelAnnouncement(
+        channel_context.channel_announcement.clone(),
+    ));
+    let status = context.submit_tx(channel_context.funding_tx.clone()).await;
+    assert_eq!(status, Status::Committed);
+    tokio::time::sleep(Duration::from_millis(200).into()).await;
+    let new_announcement = context
+        .get_store()
+        .get_latest_channel_announcement(channel_context.channel_outpoint());
+    assert_ne!(new_announcement, None);
+    for mut channel_update in [
+        channel_context.create_channel_update_of_node1(0, 42, 42, 42),
+        channel_context.create_channel_update_of_node2(0, 42, 42, 42),
+    ] {
+        channel_update.signature = Some(create_invalid_ecdsa_signature());
+        context.save_message(BroadcastMessage::ChannelUpdate(channel_update.clone()));
+    }
+    tokio::time::sleep(Duration::from_millis(200).into()).await;
+    for b in [true, false] {
+        let channel_update = context
+            .get_store()
+            .get_latest_channel_update(channel_context.channel_outpoint(), b);
+        assert_eq!(channel_update, None);
+    }
+}
+
+#[tokio::test]
+async fn test_saving_channel_update_independency() {
+    async fn test(node1_has_invalid_signature: bool, node2_has_invalid_signature: bool) {
+        let context = GossipTestingContext::new().await;
+        let channel_context = ChannelTestContext::gen();
+        context.save_message(BroadcastMessage::ChannelAnnouncement(
+            channel_context.channel_announcement.clone(),
+        ));
+        let status = context.submit_tx(channel_context.funding_tx.clone()).await;
+        assert_eq!(status, Status::Committed);
+        tokio::time::sleep(Duration::from_millis(200).into()).await;
+        let new_announcement = context
+            .get_store()
+            .get_latest_channel_announcement(channel_context.channel_outpoint());
+        assert_ne!(new_announcement, None);
+        for mut channel_update in [
+            channel_context.create_channel_update_of_node1(0, 42, 42, 42),
+            channel_context.create_channel_update_of_node2(0, 42, 42, 42),
+        ] {
+            if channel_update.is_update_of_node_1() && node1_has_invalid_signature {
+                channel_update.signature = Some(create_invalid_ecdsa_signature());
+            }
+            if channel_update.is_update_of_node_2() && node2_has_invalid_signature {
+                channel_update.signature = Some(create_invalid_ecdsa_signature());
+            }
+            context.save_message(BroadcastMessage::ChannelUpdate(channel_update.clone()));
+        }
+        tokio::time::sleep(Duration::from_millis(200).into()).await;
+        for is_channel_update_of_node1 in [true, false] {
+            let channel_update = context.get_store().get_latest_channel_update(
+                channel_context.channel_outpoint(),
+                is_channel_update_of_node1,
+            );
+            if is_channel_update_of_node1 {
+                if node1_has_invalid_signature {
+                    assert_eq!(channel_update, None);
+                } else {
+                    assert_ne!(channel_update, None);
+                }
+            } else {
+                if node2_has_invalid_signature {
+                    assert_eq!(channel_update, None);
+                } else {
+                    assert_ne!(channel_update, None);
+                }
+            }
+        }
+    }
+
+    for node1_has_invalid_signature in [true, false] {
+        for node2_has_invalid_signature in [true, false] {
+            test(node1_has_invalid_signature, node2_has_invalid_signature).await;
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_saving_channel_update_with_invalid_channel_announcement() {
+    let context = GossipTestingContext::new().await;
+    let channel_context = ChannelTestContext::gen();
+    context.save_message(BroadcastMessage::ChannelAnnouncement(
+        channel_context.channel_announcement.clone(),
+    ));
+    let tx = channel_context.funding_tx.clone();
+    context.save_message(BroadcastMessage::ChannelAnnouncement(
+        channel_context.channel_announcement.clone(),
+    ));
+    let output = tx.output(0).expect("get output").clone();
+    let invalid_lock = output
+        .lock()
+        .as_builder()
+        .args(
+            Bytes::new_builder()
+                .set(
+                    b"wrong lock args"
+                        .into_iter()
+                        .map(|b| Byte::new(*b))
+                        .collect(),
+                )
+                .build(),
+        )
+        .build();
+    let invalid_output = output.as_builder().lock(invalid_lock).build();
+    let invalid_tx = tx
+        .as_advanced_builder()
+        .set_outputs(vec![invalid_output])
+        .build();
+    let status = context.submit_tx(invalid_tx).await;
+    assert_eq!(status, Status::Committed);
+    tokio::time::sleep(Duration::from_millis(200).into()).await;
+    let new_announcement = context
+        .get_store()
+        .get_latest_channel_announcement(channel_context.channel_outpoint());
+    assert_eq!(new_announcement, None);
+    for channel_update in [
+        channel_context.create_channel_update_of_node1(0, 42, 42, 42),
+        channel_context.create_channel_update_of_node2(0, 42, 42, 42),
+    ] {
+        context.save_message(BroadcastMessage::ChannelUpdate(channel_update.clone()));
+    }
+    tokio::time::sleep(Duration::from_millis(200).into()).await;
+    for b in [true, false] {
+        let channel_update = context
+            .get_store()
+            .get_latest_channel_update(channel_context.channel_outpoint(), b);
+        assert_eq!(channel_update, None);
+    }
+}
+
 #[tokio::test]
 async fn test_save_outdated_gossip_message() {
     let context = GossipTestingContext::new().await;
diff --git a/src/fiber/tests/graph.rs b/src/fiber/tests/graph.rs
index cd3e49c5f..f019b7bab 100644
--- a/src/fiber/tests/graph.rs
+++ b/src/fiber/tests/graph.rs
@@ -60,7 +60,7 @@ impl MockNetworkGraph {
                 0,
             ));
         }
-        let graph = NetworkGraph::new(store.clone(), public_key1.into());
+        let graph = NetworkGraph::new(store.clone(), public_key1.into(), true);
 
         Self {
             keys: keypairs.into_iter().map(|x| x.1).collect(),
@@ -203,6 +203,7 @@ impl MockNetworkGraph {
             DEFAULT_TLC_EXPIRY_DELTA,
             MAX_PAYMENT_TLC_EXPIRY_LIMIT,
             false,
+            vec![],
         )
     }
 
@@ -225,6 +226,7 @@ impl MockNetworkGraph {
             DEFAULT_TLC_EXPIRY_DELTA,
             MAX_PAYMENT_TLC_EXPIRY_LIMIT,
             false,
+            vec![],
         )
     }
 
@@ -239,6 +241,22 @@ impl MockNetworkGraph {
             .collect::<Vec<_>>();
         assert_eq!(nodes, expecptected_nodes);
     }
+
+    pub fn build_route_with_possible_expects(
+        &self,
+        payment_data: &SendPaymentData,
+        expects: &Vec<Vec<usize>>,
+    ) {
+        let route = self.graph.build_route(payment_data.clone());
+        assert!(route.is_ok());
+        let route = route.unwrap();
+        let nodes = route.iter().filter_map(|x| x.next_hop).collect::<Vec<_>>();
+        let expecptected_nodes: Vec<Vec<Pubkey>> = expects
+            .iter()
+            .map(|x| x.iter().map(|i| self.keys[*i].into()).collect::<Vec<_>>())
+            .collect::<Vec<_>>();
+        assert!(expecptected_nodes.contains(&nodes));
+    }
 }
 
 #[test]
@@ -515,6 +533,7 @@ fn test_graph_build_router_is_ok_with_fee_rate() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_ok());
@@ -555,6 +574,7 @@ fn test_graph_build_router_fee_rate_optimize() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_ok());
@@ -587,6 +607,7 @@ fn test_graph_build_router_no_fee_with_direct_pay() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_ok());
@@ -614,6 +635,7 @@ fn test_graph_find_path_err() {
         DEFAULT_TLC_EXPIRY_DELTA,
         MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         false,
+        vec![],
     );
     assert!(route.is_err());
 
@@ -626,6 +648,7 @@ fn test_graph_find_path_err() {
         DEFAULT_TLC_EXPIRY_DELTA,
         MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         false,
+        vec![],
     );
     assert!(route.is_err());
 }
@@ -649,6 +672,7 @@ fn test_graph_find_path_node_order() {
         DEFAULT_TLC_EXPIRY_DELTA,
         MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         false,
+        vec![],
     );
     assert!(route.is_ok());
     // check the order of nodes in router is node1 -> node2 -> node3
@@ -674,6 +698,7 @@ fn test_graph_build_route_with_expiry_limit() {
         DEFAULT_TLC_EXPIRY_DELTA,
         MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         false,
+        vec![],
     );
     assert!(route.is_ok());
 
@@ -686,6 +711,7 @@ fn test_graph_build_route_with_expiry_limit() {
         DEFAULT_TLC_EXPIRY_DELTA,
         100,
         false,
+        vec![],
     );
     assert!(route.is_err());
 }
@@ -712,6 +738,7 @@ fn test_graph_build_route_three_nodes() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_ok());
@@ -758,6 +785,7 @@ fn test_graph_build_route_below_min_tlc_value() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_err());
@@ -787,6 +815,7 @@ fn test_graph_build_route_select_edge_with_latest_timestamp() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_ok());
@@ -824,6 +853,7 @@ fn test_graph_build_route_select_edge_with_large_capacity() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_ok());
@@ -878,6 +908,7 @@ fn test_graph_mark_failed_channel() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_err());
@@ -900,6 +931,7 @@ fn test_graph_mark_failed_channel() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_ok());
@@ -932,6 +964,7 @@ fn test_graph_session_router() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_ok());
@@ -972,6 +1005,7 @@ fn test_graph_mark_failed_node() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_ok());
@@ -992,6 +1026,7 @@ fn test_graph_mark_failed_node() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_ok());
@@ -1014,6 +1049,7 @@ fn test_graph_mark_failed_node() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_err());
@@ -1033,6 +1069,7 @@ fn test_graph_mark_failed_node() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     });
     assert!(route.is_err());
@@ -1061,6 +1098,7 @@ fn test_graph_payment_self_default_is_false() {
         keysend: Some(false),
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
     let payment_data = SendPaymentData::new(command);
@@ -1095,6 +1133,7 @@ fn test_graph_payment_pay_single_path() {
         keysend: Some(false),
         udt_type_script: None,
         allow_self_payment: true,
+        hop_hints: None,
         dry_run: false,
     };
     let payment_data = SendPaymentData::new(command);
@@ -1127,6 +1166,7 @@ fn test_graph_payment_pay_self_with_one_node() {
         keysend: Some(false),
         udt_type_script: None,
         allow_self_payment: true,
+        hop_hints: None,
         dry_run: false,
     };
     let payment_data = SendPaymentData::new(command);
@@ -1162,6 +1202,7 @@ fn test_graph_build_route_with_double_edge_node() {
         keysend: Some(false),
         udt_type_script: None,
         allow_self_payment: true,
+        hop_hints: None,
         dry_run: false,
     };
     let payment_data = SendPaymentData::new(command).unwrap();
@@ -1197,6 +1238,7 @@ fn test_graph_build_route_with_other_node_maybe_better() {
         keysend: Some(false),
         udt_type_script: None,
         allow_self_payment: true,
+        hop_hints: None,
         dry_run: false,
     };
     let payment_data = SendPaymentData::new(command).unwrap();
@@ -1230,6 +1272,7 @@ fn test_graph_payment_pay_self_will_ok() {
         keysend: Some(false),
         udt_type_script: None,
         allow_self_payment: true,
+        hop_hints: None,
         dry_run: false,
     };
     let payment_data = SendPaymentData::new(command);
@@ -1241,16 +1284,20 @@ fn test_graph_payment_pay_self_will_ok() {
     assert!(route.is_err());
 
     // add a long path
+    let mut possible_expects = vec![];
     network.add_edge(6, 0, Some(500), Some(2));
-    network.build_route_with_expect(&payment_data, vec![2, 4, 5, 6, 0]);
+    possible_expects.push(vec![2, 4, 5, 6, 0]);
+    network.build_route_with_possible_expects(&payment_data, &possible_expects);
 
     // now add another shorter path
     network.add_edge(4, 0, Some(1000), Some(2));
-    network.build_route_with_expect(&payment_data, vec![2, 4, 0]);
+    possible_expects.push(vec![2, 4, 0]);
+    network.build_route_with_possible_expects(&payment_data, &possible_expects);
 
     // now add another shorter path
     network.add_edge(2, 0, Some(1000), Some(2));
-    network.build_route_with_expect(&payment_data, vec![2, 0]);
+    possible_expects.push(vec![2, 0]);
+    network.build_route_with_possible_expects(&payment_data, &possible_expects);
 }
 
 #[test]
@@ -1287,6 +1334,7 @@ fn test_graph_build_route_with_path_limits() {
         keysend: Some(false),
         udt_type_script: None,
         allow_self_payment: true,
+        hop_hints: None,
         dry_run: false,
     };
     let payment_data = SendPaymentData::new(command).unwrap();
@@ -1336,6 +1384,7 @@ fn test_graph_build_route_with_path_limit_fail_with_fee_not_enough() {
         keysend: Some(false),
         udt_type_script: None,
         allow_self_payment: true,
+        hop_hints: None,
         dry_run: false,
     };
     let payment_data = SendPaymentData::new(command).unwrap();
@@ -1365,6 +1414,7 @@ fn test_graph_payment_expiry_is_in_right_order() {
         keysend: Some(false),
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
     let payment_data = SendPaymentData::new(command);
@@ -1396,6 +1446,7 @@ fn test_graph_payment_expiry_is_in_right_order() {
         keysend: Some(false),
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
     let payment_data = SendPaymentData::new(command);
diff --git a/src/fiber/tests/hash_algorithm.rs b/src/fiber/tests/hash_algorithm.rs
index a05ff055f..3de76f1fb 100644
--- a/src/fiber/tests/hash_algorithm.rs
+++ b/src/fiber/tests/hash_algorithm.rs
@@ -3,17 +3,19 @@ use crate::fiber::hash_algorithm::HashAlgorithm;
 #[test]
 fn test_hash_algorithm_serialization_sha256() {
     let algorithm = HashAlgorithm::Sha256;
-    let serialized = serde_json::to_string(&algorithm).unwrap();
+    let serialized = serde_json::to_string(&algorithm).expect("hash algorithm to json");
     assert_eq!(serialized, r#""sha256""#);
-    let deserialized: HashAlgorithm = serde_json::from_str(&serialized).unwrap();
+    let deserialized: HashAlgorithm =
+        serde_json::from_str(&serialized).expect("hash algorithm from json");
     assert_eq!(deserialized, algorithm);
 }
 
 #[test]
 fn test_hash_algorithm_serialization_ckb_hash() {
     let algorithm = HashAlgorithm::CkbHash;
-    let serialized = serde_json::to_string(&algorithm).unwrap();
+    let serialized = serde_json::to_string(&algorithm).expect("hash algorithm to json");
     assert_eq!(serialized, r#""ckb_hash""#);
-    let deserialized: HashAlgorithm = serde_json::from_str(&serialized).unwrap();
+    let deserialized: HashAlgorithm =
+        serde_json::from_str(&serialized).expect("hash algorithm from json");
     assert_eq!(deserialized, algorithm);
 }
diff --git a/src/fiber/tests/mod.rs b/src/fiber/tests/mod.rs
index ad7d7c7af..c236022df 100644
--- a/src/fiber/tests/mod.rs
+++ b/src/fiber/tests/mod.rs
@@ -8,4 +8,5 @@ mod path;
 mod payment;
 mod serde_utils;
 pub mod test_utils;
+mod tlc_op;
 mod types;
diff --git a/src/fiber/tests/network.rs b/src/fiber/tests/network.rs
index c2c114d37..329f317a0 100644
--- a/src/fiber/tests/network.rs
+++ b/src/fiber/tests/network.rs
@@ -751,6 +751,7 @@ fn test_send_payment_validate_payment_hash() {
         keysend: None,
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
 
@@ -775,6 +776,7 @@ fn test_send_payment_validate_amount() {
         keysend: None,
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
 
@@ -820,6 +822,7 @@ fn test_send_payment_validate_invoice() {
         keysend: None,
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
 
@@ -842,6 +845,7 @@ fn test_send_payment_validate_invoice() {
         keysend: None,
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
 
@@ -865,6 +869,7 @@ fn test_send_payment_validate_invoice() {
         keysend: Some(true),
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
 
@@ -885,6 +890,7 @@ fn test_send_payment_validate_invoice() {
         keysend: None,
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
 
@@ -905,6 +911,7 @@ fn test_send_payment_validate_invoice() {
         keysend: Some(true),
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
 
@@ -925,6 +932,7 @@ fn test_send_payment_validate_invoice() {
         keysend: None,
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
 
@@ -960,6 +968,7 @@ fn test_send_payment_validate_invoice() {
         keysend: None,
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
 
@@ -985,6 +994,7 @@ fn test_send_payment_validate_htlc_expiry_delta() {
         keysend: None,
         udt_type_script: None,
         allow_self_payment: false,
+        hop_hints: None,
         dry_run: false,
     };
 
diff --git a/src/fiber/tests/payment.rs b/src/fiber/tests/payment.rs
index 692c0fba8..2812f21a1 100644
--- a/src/fiber/tests/payment.rs
+++ b/src/fiber/tests/payment.rs
@@ -1,7 +1,14 @@
+use std::collections::HashSet;
+
 use super::test_utils::init_tracing;
 use crate::fiber::graph::PaymentSessionStatus;
+use crate::fiber::network::HopHint;
 use crate::fiber::network::SendPaymentCommand;
 use crate::fiber::tests::test_utils::*;
+use crate::fiber::types::Hash256;
+use crate::fiber::NetworkActorCommand;
+use crate::fiber::NetworkActorMessage;
+use ractor::call;
 
 #[tokio::test]
 async fn test_send_payment_for_direct_channel_and_dry_run() {
@@ -11,8 +18,8 @@ async fn test_send_payment_for_direct_channel_and_dry_run() {
 
     let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
         &[
-            ((0, 1), (4200000000 + 10000000000, 4200000000)),
-            ((0, 1), (4200000000, 4200000000 + 10000000000)),
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((0, 1), (MIN_RESERVED_CKB, MIN_RESERVED_CKB + 10000000000)),
         ],
         2,
         true,
@@ -22,9 +29,6 @@ async fn test_send_payment_for_direct_channel_and_dry_run() {
     let source_node = &mut node_0;
     let target_pubkey = node_1.pubkey.clone();
 
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-
     let res = source_node
         .send_payment(SendPaymentCommand {
             target_pubkey: Some(target_pubkey.clone()),
@@ -39,6 +43,7 @@ async fn test_send_payment_for_direct_channel_and_dry_run() {
             keysend: Some(true),
             udt_type_script: None,
             allow_self_payment: false,
+            hop_hints: None,
             dry_run: true,
         })
         .await;
@@ -60,18 +65,16 @@ async fn test_send_payment_for_direct_channel_and_dry_run() {
             keysend: Some(true),
             udt_type_script: None,
             allow_self_payment: false,
+            hop_hints: None,
             dry_run: false,
         })
         .await;
 
     eprintln!("res: {:?}", res);
     assert!(res.is_ok());
-    // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
     let payment_hash = res.unwrap().payment_hash;
-    source_node
-        .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
-        .await;
+
+    source_node.wait_until_success(payment_hash).await;
 
     let res = node_1
         .send_payment(SendPaymentCommand {
@@ -87,6 +90,7 @@ async fn test_send_payment_for_direct_channel_and_dry_run() {
             keysend: Some(true),
             udt_type_script: None,
             allow_self_payment: false,
+            hop_hints: None,
             dry_run: false,
         })
         .await;
@@ -95,8 +99,8 @@ async fn test_send_payment_for_direct_channel_and_dry_run() {
     assert!(res.is_ok());
 
     // sleep for a while
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
     let payment_hash = res.unwrap().payment_hash;
+    node_1.wait_until_success(payment_hash).await;
     node_1
         .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
         .await;
@@ -115,3 +119,1408 @@ async fn test_send_payment_for_direct_channel_and_dry_run() {
     assert_eq!(node_0_balance, 10000000000);
     assert_eq!(node_1_balance, 0);
 }
+
+#[tokio::test]
+async fn test_send_payment_for_pay_self() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+    // from https://github.com/nervosnetwork/fiber/issues/362
+
+    let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((1, 2), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((2, 0), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+        ],
+        3,
+        true,
+    )
+    .await;
+    let [mut node_0, node_1, node_2] = nodes.try_into().expect("3 nodes");
+
+    let node_1_channel0_balance = node_1.get_local_balance_from_channel(channels[0]);
+    let node_1_channel1_balance = node_1.get_local_balance_from_channel(channels[1]);
+    let node_2_channel1_balance = node_2.get_local_balance_from_channel(channels[1]);
+    let node_2_channel2_balance = node_2.get_local_balance_from_channel(channels[2]);
+
+    // now node_0 -> node_2 will be ok only with node_1, so the fee is larger than 0
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_2.pubkey.clone()),
+            amount: Some(60000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: false,
+            hop_hints: None,
+            dry_run: true,
+        })
+        .await;
+
+    assert!(res.unwrap().fee > 0);
+
+    // node_0 -> node_0 will be ok for dry_run if `allow_self_payment` is true
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_0.pubkey.clone()),
+            amount: Some(60000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: true,
+            hop_hints: None,
+            dry_run: false,
+        })
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+
+    let res = res.unwrap();
+    let payment_hash = res.payment_hash;
+    node_0.wait_until_success(payment_hash).await;
+    node_0
+        .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
+        .await;
+
+    let node_0_balance1 = node_0.get_local_balance_from_channel(channels[0]);
+    let node_0_balance2 = node_0.get_local_balance_from_channel(channels[2]);
+
+    assert_eq!(node_0_balance1, 10000000000 - 60000000 - res.fee);
+    assert_eq!(node_0_balance2, 60000000);
+
+    eprintln!(
+        "node1 left: {:?}, right: {:?}",
+        node_1.get_local_balance_from_channel(channels[0]),
+        node_1.get_local_balance_from_channel(channels[1])
+    );
+
+    let node_1_new_channel0_balance = node_1.get_local_balance_from_channel(channels[0]);
+    let node_1_new_channel1_balance = node_1.get_local_balance_from_channel(channels[1]);
+    let node_2_new_channel1_balance = node_2.get_local_balance_from_channel(channels[1]);
+    let node_2_new_channel2_balance = node_2.get_local_balance_from_channel(channels[2]);
+
+    let node1_fee = (node_1_new_channel0_balance - node_1_channel0_balance)
+        - (node_1_channel1_balance - node_1_new_channel1_balance);
+    assert!(node1_fee > 0);
+
+    let node2_fee = (node_2_new_channel1_balance - node_2_channel1_balance)
+        - (node_2_channel2_balance - node_2_new_channel2_balance);
+    assert!(node2_fee > 0);
+    assert_eq!(node1_fee + node2_fee, res.fee);
+
+    // node_0 -> node_2 will be ok with direct channel2,
+    // since after payself this channel now have enough balance, so the fee is 0
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_2.pubkey.clone()),
+            amount: Some(60000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: false,
+            hop_hints: None,
+            dry_run: true,
+        })
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert_eq!(res.unwrap().fee, 0);
+}
+
+#[tokio::test]
+async fn test_send_payment_for_pay_self_with_two_nodes() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+    // from https://github.com/nervosnetwork/fiber/issues/355
+
+    let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((1, 0), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+        ],
+        2,
+        true,
+    )
+    .await;
+    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
+
+    let node_1_channel0_balance = node_1.get_local_balance_from_channel(channels[0]);
+    let node_1_channel1_balance = node_1.get_local_balance_from_channel(channels[1]);
+
+    // node_0 -> node_0 will be ok for dry_run if `allow_self_payment` is true
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_0.pubkey.clone()),
+            amount: Some(60000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: true,
+            hop_hints: None,
+            dry_run: false,
+        })
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+
+    let res = res.unwrap();
+    let payment_hash = res.payment_hash;
+    node_0.wait_until_success(payment_hash).await;
+    node_0
+        .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
+        .await;
+
+    let node_0_balance1 = node_0.get_local_balance_from_channel(channels[0]);
+    let node_0_balance2 = node_0.get_local_balance_from_channel(channels[1]);
+
+    assert_eq!(node_0_balance1, 10000000000 - 60000000 - res.fee);
+    assert_eq!(node_0_balance2, 60000000);
+
+    let new_node_1_channel0_balance = node_1.get_local_balance_from_channel(channels[0]);
+    let new_node_1_channel1_balance = node_1.get_local_balance_from_channel(channels[1]);
+
+    let node1_fee = (new_node_1_channel0_balance - node_1_channel0_balance)
+        - (node_1_channel1_balance - new_node_1_channel1_balance);
+    eprintln!("fee: {:?}", res.fee);
+    assert_eq!(node1_fee, res.fee);
+}
+
+#[tokio::test]
+async fn test_send_payment_with_more_capacity_for_payself() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+    // from https://github.com/nervosnetwork/fiber/issues/362
+
+    let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            (
+                (0, 1),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (2, 0),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+        ],
+        3,
+        true,
+    )
+    .await;
+    let [mut node_0, node_1, node_2] = nodes.try_into().expect("3 nodes");
+
+    let node_1_channel0_balance = node_1.get_local_balance_from_channel(channels[0]);
+    let node_1_channel1_balance = node_1.get_local_balance_from_channel(channels[1]);
+    let node_2_channel1_balance = node_2.get_local_balance_from_channel(channels[1]);
+    let node_2_channel2_balance = node_2.get_local_balance_from_channel(channels[2]);
+
+    // node_0 -> node_0 will be ok if `allow_self_payment` is true
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_0.pubkey.clone()),
+            amount: Some(60000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: true,
+            hop_hints: None,
+            dry_run: false,
+        })
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+
+    // sleep for a while
+    let res = res.unwrap();
+    let payment_hash = res.payment_hash;
+    node_0.wait_until_success(payment_hash).await;
+    node_0
+        .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
+        .await;
+
+    let node_0_balance1 = node_0.get_local_balance_from_channel(channels[0]);
+    let node_0_balance2 = node_0.get_local_balance_from_channel(channels[2]);
+
+    eprintln!("fee: {:?}", res.fee);
+    // for node0 pay to self, only the fee will be deducted
+    assert!(node_0_balance1 + node_0_balance2 == 10000000000 + 10000000000 - res.fee);
+
+    eprintln!(
+        "node1 left: {:?}, right: {:?}",
+        node_1.get_local_balance_from_channel(channels[0]),
+        node_1.get_local_balance_from_channel(channels[1])
+    );
+
+    let node_1_new_channel0_balance = node_1.get_local_balance_from_channel(channels[0]);
+    let node_1_new_channel1_balance = node_1.get_local_balance_from_channel(channels[1]);
+    let node_2_new_channel1_balance = node_2.get_local_balance_from_channel(channels[1]);
+    let node_2_new_channel2_balance = node_2.get_local_balance_from_channel(channels[2]);
+
+    // we may route to self from
+    //     node0 -> node1 -> node2 -> node0
+    // or  node0 -> node2 -> node1 -> node0
+    // so the assertion need to be more complex
+    let node1_fee = if node_1_new_channel0_balance > node_1_channel0_balance {
+        (node_1_new_channel0_balance - node_1_channel0_balance)
+            - (node_1_channel1_balance - node_1_new_channel1_balance)
+    } else {
+        (node_1_new_channel1_balance - node_1_channel1_balance)
+            - (node_1_channel0_balance - node_1_new_channel0_balance)
+    };
+    assert!(node1_fee > 0);
+
+    let node2_fee = if node_2_new_channel1_balance > node_2_channel1_balance {
+        (node_2_new_channel1_balance - node_2_channel1_balance)
+            - (node_2_channel2_balance - node_2_new_channel2_balance)
+    } else {
+        (node_2_new_channel2_balance - node_2_channel2_balance)
+            - (node_2_channel1_balance - node_2_new_channel1_balance)
+    };
+    assert_eq!(node1_fee + node2_fee, res.fee);
+}
+
+#[tokio::test]
+async fn test_send_payment_with_route_to_self_with_hop_hints() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+
+    let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            (
+                (0, 1),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (2, 0),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+        ],
+        3,
+        true,
+    )
+    .await;
+    let [mut node_0, node_1, node_2] = nodes.try_into().expect("3 nodes");
+    eprintln!("node_0: {:?}", node_0.pubkey);
+    eprintln!("node_1: {:?}", node_1.pubkey);
+    eprintln!("node_2: {:?}", node_2.pubkey);
+
+    let node_1_channel0_balance = node_1.get_local_balance_from_channel(channels[0]);
+    let node_1_channel1_balance = node_1.get_local_balance_from_channel(channels[1]);
+    let node_2_channel1_balance = node_2.get_local_balance_from_channel(channels[1]);
+    let node_2_channel2_balance = node_2.get_local_balance_from_channel(channels[2]);
+
+    let channel_0_funding_tx = node_0.get_channel_funding_tx(&channels[0]).unwrap();
+
+    // node_0 -> node_0 will be ok if `allow_self_payment` is true
+    // use hop hints to help find_path use node1 -> node0,
+    // then the only valid route will be node0 -> node2 -> node1 -> node0
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_0.pubkey.clone()),
+            amount: Some(60000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: true,
+            hop_hints: Some(vec![HopHint {
+                pubkey: node_0.pubkey.clone(),
+                channel_funding_tx: channel_0_funding_tx,
+                inbound: true,
+            }]),
+            dry_run: false,
+        })
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+
+    let res = res.unwrap();
+    let payment_hash = res.payment_hash;
+    node_0.wait_until_success(payment_hash).await;
+    node_0
+        .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
+        .await;
+
+    let node_0_balance1 = node_0.get_local_balance_from_channel(channels[0]);
+    let node_0_balance2 = node_0.get_local_balance_from_channel(channels[2]);
+
+    eprintln!("fee: {:?}", res.fee);
+    // for node0 pay to self, only the fee will be deducted
+    assert!(node_0_balance1 + node_0_balance2 == 10000000000 + 10000000000 - res.fee);
+
+    eprintln!(
+        "node1 left: {:?}, right: {:?}",
+        node_1.get_local_balance_from_channel(channels[0]),
+        node_1.get_local_balance_from_channel(channels[1])
+    );
+
+    let node_1_new_channel0_balance = node_1.get_local_balance_from_channel(channels[0]);
+    let node_1_new_channel1_balance = node_1.get_local_balance_from_channel(channels[1]);
+    let node_2_new_channel1_balance = node_2.get_local_balance_from_channel(channels[1]);
+    let node_2_new_channel2_balance = node_2.get_local_balance_from_channel(channels[2]);
+
+    // node0 can only route to self from
+    // node0 -> node2 -> node1 -> node0
+    let node1_fee = (node_1_new_channel1_balance - node_1_channel1_balance)
+        - (node_1_channel0_balance - node_1_new_channel0_balance);
+
+    assert!(node1_fee > 0);
+
+    let node2_fee = (node_2_new_channel2_balance - node_2_channel2_balance)
+        - (node_2_channel1_balance - node_2_new_channel1_balance);
+
+    assert_eq!(node1_fee + node2_fee, res.fee);
+}
+
+#[tokio::test]
+async fn test_send_payment_with_route_to_self_with_outbound_hop_hints() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+
+    let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            (
+                (0, 1),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (2, 0),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+        ],
+        3,
+        true,
+    )
+    .await;
+    let [mut node_0, node_1, node_2] = nodes.try_into().expect("3 nodes");
+    eprintln!("node_0: {:?}", node_0.pubkey);
+    eprintln!("node_1: {:?}", node_1.pubkey);
+    eprintln!("node_2: {:?}", node_2.pubkey);
+
+    let node_1_channel0_balance = node_1.get_local_balance_from_channel(channels[0]);
+    let node_1_channel1_balance = node_1.get_local_balance_from_channel(channels[1]);
+    let node_2_channel1_balance = node_2.get_local_balance_from_channel(channels[1]);
+    let node_2_channel2_balance = node_2.get_local_balance_from_channel(channels[2]);
+
+    let channel_0_funding_tx = node_0.get_channel_funding_tx(&channels[0]).unwrap();
+
+    // node_0 -> node_0 will be ok if `allow_self_payment` is true
+    // use hop hints to help find_path use node0 -> node1,
+    // then the only valid route will be node0 -> node1 -> node2 -> node0
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_0.pubkey.clone()),
+            amount: Some(60000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: true,
+            hop_hints: Some(vec![HopHint {
+                pubkey: node_0.pubkey.clone(),
+                channel_funding_tx: channel_0_funding_tx,
+                inbound: false,
+            }]),
+            dry_run: false,
+        })
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+
+    let res = res.unwrap();
+    let payment_hash = res.payment_hash;
+    node_0.wait_until_success(payment_hash).await;
+    node_0
+        .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
+        .await;
+
+    let node_0_balance1 = node_0.get_local_balance_from_channel(channels[0]);
+    let node_0_balance2 = node_0.get_local_balance_from_channel(channels[2]);
+
+    eprintln!("fee: {:?}", res.fee);
+    // for node0 pay to self, only the fee will be deducted
+    assert!(node_0_balance1 + node_0_balance2 == 10000000000 + 10000000000 - res.fee);
+
+    eprintln!(
+        "node1 left: {:?}, right: {:?}",
+        node_1.get_local_balance_from_channel(channels[0]),
+        node_1.get_local_balance_from_channel(channels[1])
+    );
+
+    let node_1_new_channel0_balance = node_1.get_local_balance_from_channel(channels[0]);
+    let node_1_new_channel1_balance = node_1.get_local_balance_from_channel(channels[1]);
+    let node_2_new_channel1_balance = node_2.get_local_balance_from_channel(channels[1]);
+    let node_2_new_channel2_balance = node_2.get_local_balance_from_channel(channels[2]);
+
+    // node0 can only route to self from
+    // node0 -> node1 -> node2 -> node0
+    let node1_fee = (node_1_new_channel0_balance - node_1_channel0_balance)
+        - (node_1_channel1_balance - node_1_new_channel1_balance);
+
+    assert!(node1_fee > 0);
+
+    let node2_fee = (node_2_new_channel1_balance - node_2_channel1_balance)
+        - (node_2_channel2_balance - node_2_new_channel2_balance);
+
+    assert_eq!(node1_fee + node2_fee, res.fee);
+}
+
+#[tokio::test]
+async fn test_send_payment_select_channel_with_hop_hints() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+
+    let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            (
+                (0, 1),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            // there are 3 channels from node1 -> node2
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (2, 3),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+        ],
+        4,
+        true,
+    )
+    .await;
+    let [mut node_0, node_1, node_2, node_3] = nodes.try_into().expect("4 nodes");
+    eprintln!("node_0: {:?}", node_0.pubkey);
+    eprintln!("node_1: {:?}", node_1.pubkey);
+    eprintln!("node_2: {:?}", node_2.pubkey);
+    eprintln!("node_3: {:?}", node_3.pubkey);
+
+    let channel_3_funding_tx = node_0.get_channel_funding_tx(&channels[3]).unwrap();
+    eprintln!("channel_3_funding_tx: {:?}", channel_3_funding_tx);
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_3.pubkey.clone()),
+            amount: Some(60000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: true,
+            // at node_1, we must use channel_3 to reach node_2
+            hop_hints: Some(vec![HopHint {
+                pubkey: node_2.pubkey.clone(),
+                channel_funding_tx: channel_3_funding_tx,
+                inbound: true,
+            }]),
+            dry_run: false,
+        })
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+    let payment_hash = res.unwrap().payment_hash;
+    eprintln!("payment_hash: {:?}", payment_hash);
+    let payment_session = node_0
+        .get_payment_session(payment_hash)
+        .expect("get payment");
+    eprintln!("payment_session: {:?}", payment_session);
+    let used_channels: Vec<Hash256> = payment_session
+        .route
+        .nodes
+        .iter()
+        .map(|x| x.channel_outpoint.tx_hash().into())
+        .collect();
+    eprintln!("used_channels: {:?}", used_channels);
+    assert_eq!(used_channels.len(), 4);
+    assert_eq!(used_channels[1], channel_3_funding_tx);
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(2500)).await;
+
+    // try channel_2 with outbound hop hints
+    let channel_2_funding_tx = node_0.get_channel_funding_tx(&channels[2]).unwrap();
+    eprintln!("channel_2_funding_tx: {:?}", channel_2_funding_tx);
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_3.pubkey.clone()),
+            amount: Some(60000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: true,
+            // at node_1, we must use channel_2 to reach node_2
+            hop_hints: Some(vec![HopHint {
+                pubkey: node_1.pubkey.clone(),
+                channel_funding_tx: channel_2_funding_tx,
+                inbound: false,
+            }]),
+            dry_run: false,
+        })
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+    let payment_hash = res.unwrap().payment_hash;
+    eprintln!("payment_hash: {:?}", payment_hash);
+    let payment_session = node_0
+        .get_payment_session(payment_hash)
+        .expect("get payment");
+    eprintln!("payment_session: {:?}", payment_session);
+    let used_channels: Vec<Hash256> = payment_session
+        .route
+        .nodes
+        .iter()
+        .map(|x| x.channel_outpoint.tx_hash().into())
+        .collect();
+    eprintln!("used_channels: {:?}", used_channels);
+    assert_eq!(used_channels.len(), 4);
+    assert_eq!(used_channels[1], channel_2_funding_tx);
+
+    let wrong_channel_hash = Hash256::from([0u8; 32]);
+    // if we specify a wrong funding_tx, the payment will fail
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_3.pubkey.clone()),
+            amount: Some(60000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: true,
+            // at node_1, we must use channel_3 to reach node_2
+            hop_hints: Some(vec![HopHint {
+                pubkey: node_2.pubkey.clone(),
+                channel_funding_tx: wrong_channel_hash,
+                inbound: true,
+            }]),
+            dry_run: false,
+        })
+        .await;
+    eprintln!("res: {:?}", res);
+    assert!(res
+        .unwrap_err()
+        .to_string()
+        .contains("PathFind error: no path found"));
+}
+
+#[tokio::test]
+async fn test_send_payment_two_nodes_with_hop_hints_and_multiple_channels() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+
+    let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((1, 0), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((1, 0), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+        ],
+        2,
+        true,
+    )
+    .await;
+    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
+    eprintln!("node_0: {:?}", node_0.pubkey);
+    eprintln!("node_1: {:?}", node_1.pubkey);
+
+    let channel_1_funding_tx = node_0.get_channel_funding_tx(&channels[1]).unwrap();
+    let channel_3_funding_tx = node_0.get_channel_funding_tx(&channels[3]).unwrap();
+    let old_balance = node_0.get_local_balance_from_channel(channels[1]);
+    let old_node1_balance = node_1.get_local_balance_from_channel(channels[3]);
+    eprintln!("channel_1_funding_tx: {:?}", channel_1_funding_tx);
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_0.pubkey.clone()),
+            amount: Some(60000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: true,
+            hop_hints: Some(vec![
+                // node1 - channel_1 -> node2
+                HopHint {
+                    pubkey: node_0.pubkey.clone(),
+                    channel_funding_tx: channel_1_funding_tx,
+                    inbound: false,
+                },
+                // node2 - channel_3 -> node1
+                HopHint {
+                    pubkey: node_0.pubkey.clone(),
+                    channel_funding_tx: channel_3_funding_tx,
+                    inbound: true,
+                },
+            ]),
+            dry_run: false,
+        })
+        .await
+        .unwrap();
+
+    let payment_hash = res.payment_hash;
+    eprintln!("payment_hash: {:?}", payment_hash);
+    let payment_session = node_0
+        .get_payment_session(payment_hash)
+        .expect("get payment");
+    eprintln!("payment_session: {:?}", payment_session);
+    let used_channels: Vec<Hash256> = payment_session
+        .route
+        .nodes
+        .iter()
+        .map(|x| x.channel_outpoint.tx_hash().into())
+        .collect();
+    eprintln!("used_channels: {:?}", used_channels);
+    assert_eq!(used_channels.len(), 3);
+    assert_eq!(used_channels[0], channel_1_funding_tx);
+    assert_eq!(used_channels[1], channel_3_funding_tx);
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
+
+    let balance = node_0.get_local_balance_from_channel(channels[1]);
+    assert_eq!(balance, old_balance - 60000000 - res.fee);
+
+    let node_1_balance = node_1.get_local_balance_from_channel(channels[1]);
+    assert_eq!(node_1_balance, 60000000 + res.fee);
+
+    let balance = node_0.get_local_balance_from_channel(channels[3]);
+    assert_eq!(balance, 60000000);
+
+    let node_1_balance = node_1.get_local_balance_from_channel(channels[3]);
+    assert_eq!(node_1_balance, old_node1_balance - 60000000);
+}
+
+#[tokio::test]
+async fn test_network_send_payment_randomly_send_each_other() {
+    init_tracing();
+
+    let _span = tracing::info_span!("node", node = "test").entered();
+    let node_a_funding_amount = 100000000000;
+    let node_b_funding_amount = 100000000000;
+
+    let (node_a, node_b, new_channel_id) =
+        create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, true)
+            .await;
+    // Wait for the channel announcement to be broadcasted
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+    let node_a_old_balance = node_a.get_local_balance_from_channel(new_channel_id);
+    let node_b_old_balance = node_b.get_local_balance_from_channel(new_channel_id);
+
+    let node_a_pubkey = node_a.pubkey.clone();
+    let node_b_pubkey = node_b.pubkey.clone();
+
+    let mut node_a_sent = 0;
+    let mut node_b_sent = 0;
+    let mut all_sent = vec![];
+    for _i in 1..8 {
+        let rand_wait_time = rand::random::<u64>() % 1000;
+        tokio::time::sleep(tokio::time::Duration::from_millis(rand_wait_time)).await;
+
+        let rand_num = rand::random::<u64>() % 2;
+        let amount = rand::random::<u128>() % 10000;
+        eprintln!("generated ampunt: {}", amount);
+        let (source, target) = if rand_num == 0 {
+            (&node_a.network_actor, node_b_pubkey.clone())
+        } else {
+            (&node_b.network_actor, node_a_pubkey.clone())
+        };
+        let message = |rpc_reply| -> NetworkActorMessage {
+            NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+                SendPaymentCommand {
+                    target_pubkey: Some(target),
+                    amount: Some(amount),
+                    payment_hash: None,
+                    final_tlc_expiry_delta: None,
+                    tlc_expiry_limit: None,
+                    invoice: None,
+                    timeout: None,
+                    max_fee_amount: None,
+                    max_parts: None,
+                    keysend: Some(true),
+                    udt_type_script: None,
+                    allow_self_payment: false,
+                    hop_hints: None,
+                    dry_run: false,
+                },
+                rpc_reply,
+            ))
+        };
+
+        let res = call!(source, message).expect("node_a alive").unwrap();
+
+        if rand_num == 0 {
+            all_sent.push((true, amount, res.payment_hash, res.status));
+        } else {
+            all_sent.push((false, amount, res.payment_hash, res.status));
+        }
+    }
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(4000)).await;
+    for (a_sent, amount, payment_hash, create_status) in all_sent {
+        let message = |rpc_reply| -> NetworkActorMessage {
+            NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash, rpc_reply))
+        };
+        let network = if a_sent {
+            &node_a.network_actor
+        } else {
+            &node_b.network_actor
+        };
+        let res = call!(network, message).expect("node_a alive").unwrap();
+        if res.status == PaymentSessionStatus::Success {
+            assert!(matches!(
+                create_status,
+                PaymentSessionStatus::Created | PaymentSessionStatus::Inflight
+            ));
+            eprintln!(
+                "{} payment_hash: {:?} success with amount: {} create_status: {:?}",
+                if a_sent { "a -> b" } else { "b -> a" },
+                payment_hash,
+                amount,
+                create_status
+            );
+            if a_sent {
+                node_a_sent += amount;
+            } else {
+                node_b_sent += amount;
+            }
+        }
+    }
+
+    eprintln!(
+        "node_a_old_balance: {}, node_b_old_balance: {}",
+        node_a_old_balance, node_b_old_balance
+    );
+    eprintln!("node_a_sent: {}, node_b_sent: {}", node_a_sent, node_b_sent);
+    let new_node_a_balance = node_a.get_local_balance_from_channel(new_channel_id);
+    let new_node_b_balance = node_b.get_local_balance_from_channel(new_channel_id);
+
+    eprintln!(
+        "new_node_a_balance: {}, new_node_b_balance: {}",
+        new_node_a_balance, new_node_b_balance
+    );
+
+    assert_eq!(
+        node_a_old_balance + node_b_old_balance,
+        new_node_a_balance + new_node_b_balance
+    );
+    assert_eq!(
+        new_node_a_balance,
+        node_a_old_balance - node_a_sent + node_b_sent
+    );
+    assert_eq!(
+        new_node_b_balance,
+        node_b_old_balance - node_b_sent + node_a_sent
+    );
+}
+
+#[tokio::test]
+async fn test_network_three_nodes_two_channels_send_each_other() {
+    init_tracing();
+
+    let _span = tracing::info_span!("node", node = "test").entered();
+    let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            (
+                (0, 1),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+        ],
+        3,
+        true,
+    )
+    .await;
+    let [node_a, node_b, node_c] = nodes.try_into().expect("3 nodes");
+
+    // Wait for the channel announcement to be broadcasted
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+    let node_b_old_balance_channel_0 = node_b.get_local_balance_from_channel(channels[0]);
+    let node_b_old_balance_channel_1 = node_b.get_local_balance_from_channel(channels[1]);
+
+    let node_a_pubkey = node_a.pubkey.clone();
+    let node_c_pubkey = node_c.pubkey.clone();
+
+    let amount_a_to_c = 60000;
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_c_pubkey.clone()),
+                amount: Some(amount_a_to_c),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
+    };
+
+    let res = call!(node_a.network_actor, message)
+        .expect("node_a alive")
+        .unwrap();
+    let payment_hash1 = res.payment_hash;
+    let fee1 = res.fee;
+    eprintln!("payment_hash1: {:?}", payment_hash1);
+
+    let amount_c_to_a = 50000;
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_a_pubkey.clone()),
+                amount: Some(amount_c_to_a),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
+    };
+
+    let res = call!(node_c.network_actor, message)
+        .expect("node_a alive")
+        .unwrap();
+
+    let payment_hash2 = res.payment_hash;
+    let fee2 = res.fee;
+    eprintln!("payment_hash2: {:?}", payment_hash2);
+
+    node_a.wait_until_success(payment_hash1).await;
+    node_c.wait_until_success(payment_hash2).await;
+
+    let new_node_b_balance_channel_0 = node_b.get_local_balance_from_channel(channels[0]);
+    let new_node_b_balance_channel_1 = node_b.get_local_balance_from_channel(channels[1]);
+
+    let node_b_fee = new_node_b_balance_channel_0 + new_node_b_balance_channel_1
+        - node_b_old_balance_channel_0
+        - node_b_old_balance_channel_1;
+
+    eprintln!("node_b_fee: {}", node_b_fee);
+    eprintln!("fee1: {}, fee2: {}", fee1, fee2);
+    assert_eq!(node_b_fee, fee1 + fee2);
+}
+
+#[tokio::test]
+async fn test_network_three_nodes_send_each_other() {
+    init_tracing();
+
+    let _span = tracing::info_span!("node", node = "test").entered();
+    let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            (
+                (0, 1),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (2, 1),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 0),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+        ],
+        3,
+        true,
+    )
+    .await;
+    let [node_a, node_b, node_c] = nodes.try_into().expect("3 nodes");
+
+    // Wait for the channel announcement to be broadcasted
+    let node_b_old_balance_channel_0 = node_b.get_local_balance_from_channel(channels[0]);
+    let node_b_old_balance_channel_1 = node_b.get_local_balance_from_channel(channels[1]);
+    let node_b_old_balance_channel_2 = node_b.get_local_balance_from_channel(channels[2]);
+    let node_b_old_balance_channel_3 = node_b.get_local_balance_from_channel(channels[3]);
+
+    eprintln!(
+        "node_b_old_balance_channel_0: {}, node_b_old_balance_channel_1: {}",
+        node_b_old_balance_channel_0, node_b_old_balance_channel_1
+    );
+    eprintln!(
+        "node_b_old_balance_channel_2: {}, node_b_old_balance_channel_3: {}",
+        node_b_old_balance_channel_2, node_b_old_balance_channel_3
+    );
+
+    let node_a_pubkey = node_a.pubkey.clone();
+    let node_c_pubkey = node_c.pubkey.clone();
+
+    let amount_a_to_c = 60000;
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_c_pubkey.clone()),
+                amount: Some(amount_a_to_c),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
+    };
+
+    let res = call!(node_a.network_actor, message)
+        .expect("node_a alive")
+        .unwrap();
+    let payment_hash1 = res.payment_hash;
+    let fee1 = res.fee;
+    eprintln!("payment_hash1: {:?}", payment_hash1);
+
+    let amount_c_to_a = 60000;
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_a_pubkey.clone()),
+                amount: Some(amount_c_to_a),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
+    };
+
+    let res = call!(node_c.network_actor, message)
+        .expect("node_a alive")
+        .unwrap();
+
+    let payment_hash2 = res.payment_hash;
+    let fee2 = res.fee;
+    eprintln!("payment_hash2: {:?}", payment_hash2);
+
+    node_a.wait_until_success(payment_hash1).await;
+    node_c.wait_until_success(payment_hash2).await;
+
+    let new_node_b_balance_channel_0 = node_b.get_local_balance_from_channel(channels[0]);
+    let new_node_b_balance_channel_1 = node_b.get_local_balance_from_channel(channels[1]);
+    let new_node_b_balance_channel_2 = node_b.get_local_balance_from_channel(channels[2]);
+    let new_node_b_balance_channel_3 = node_b.get_local_balance_from_channel(channels[3]);
+
+    let node_b_fee = new_node_b_balance_channel_0
+        + new_node_b_balance_channel_1
+        + new_node_b_balance_channel_2
+        + new_node_b_balance_channel_3
+        - node_b_old_balance_channel_0
+        - node_b_old_balance_channel_1
+        - node_b_old_balance_channel_2
+        - node_b_old_balance_channel_3;
+
+    eprintln!("node_b_fee: {}", node_b_fee);
+    assert_eq!(node_b_fee, fee1 + fee2);
+}
+
+#[tokio::test]
+async fn test_send_payment_bench_test() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+    let (nodes, _channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            (
+                (0, 1),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+        ],
+        3,
+        true,
+    )
+    .await;
+    let [mut node_0, node_1, node_2] = nodes.try_into().expect("3 nodes");
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+    let mut all_sent = HashSet::new();
+
+    for i in 1..=10 {
+        let payment = node_0.send_payment_keysend(&node_2, 1000).await.unwrap();
+        eprintln!("payment: {:?}", payment);
+        all_sent.insert(payment.payment_hash);
+        eprintln!("send: {} payment_hash: {:?} sent", i, payment.payment_hash);
+        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+    }
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+    loop {
+        for payment_hash in all_sent.clone().iter() {
+            let status = node_0.get_payment_status(*payment_hash).await;
+            eprintln!("got payment: {:?} status: {:?}", payment_hash, status);
+            if status == PaymentSessionStatus::Success {
+                eprintln!("payment_hash: {:?} success", payment_hash);
+                all_sent.remove(payment_hash);
+            }
+            tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+        }
+        let res = node_0.node_info().await;
+        eprintln!("node0 node_info: {:?}", res);
+        let res = node_1.node_info().await;
+        eprintln!("node1 node_info: {:?}", res);
+        let res = node_2.node_info().await;
+        eprintln!("node2 node_info: {:?}", res);
+        if all_sent.is_empty() {
+            break;
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_send_payment_three_nodes_wait_succ_bench_test() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+    let (nodes, _channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            (
+                (0, 1),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+        ],
+        3,
+        true,
+    )
+    .await;
+    let [mut node_0, _node_1, node_2] = nodes.try_into().expect("3 nodes");
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+    let mut all_sent = vec![];
+
+    for i in 1..=10 {
+        let payment = node_0.send_payment_keysend(&node_2, 1000).await.unwrap();
+        all_sent.push(payment.payment_hash);
+        eprintln!(
+            "send: {} payment_hash: {:?} sentxx",
+            i, payment.payment_hash
+        );
+        tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+
+        node_0.wait_until_success(payment.payment_hash).await;
+    }
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+}
+
+#[tokio::test]
+async fn test_send_payment_three_nodes_send_each_other_bench_test() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+    let (nodes, _channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            (
+                (0, 1),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+        ],
+        3,
+        true,
+    )
+    .await;
+    let [mut node_0, _node_1, mut node_2] = nodes.try_into().expect("3 nodes");
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+    let mut all_sent = vec![];
+
+    for i in 1..=5 {
+        let payment1 = node_0.send_payment_keysend(&node_2, 1000).await.unwrap();
+        all_sent.push(payment1.payment_hash);
+        eprintln!("send: {} payment_hash: {:?} sent", i, payment1.payment_hash);
+
+        let payment2 = node_2.send_payment_keysend(&node_0, 1000).await.unwrap();
+        all_sent.push(payment2.payment_hash);
+        eprintln!("send: {} payment_hash: {:?} sent", i, payment2.payment_hash);
+        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+
+        node_0.wait_until_success(payment1.payment_hash).await;
+        node_2.wait_until_success(payment2.payment_hash).await;
+    }
+}
+
+#[tokio::test]
+async fn test_send_payment_three_nodes_bench_test() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+    let (nodes, _channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            (
+                (0, 1),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+            (
+                (1, 2),
+                (
+                    MIN_RESERVED_CKB + 10000000000,
+                    MIN_RESERVED_CKB + 10000000000,
+                ),
+            ),
+        ],
+        3,
+        true,
+    )
+    .await;
+    let [mut node_1, mut node_2, mut node_3] = nodes.try_into().expect("3 nodes");
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+    let mut all_sent = HashSet::new();
+
+    for i in 1..=4 {
+        let payment1 = node_1.send_payment_keysend(&node_3, 1000).await.unwrap();
+        all_sent.insert((1, payment1.payment_hash));
+        eprintln!("send: {} payment_hash: {:?} sent", i, payment1.payment_hash);
+
+        let payment2 = node_2.send_payment_keysend(&node_3, 1000).await.unwrap();
+        all_sent.insert((2, payment2.payment_hash));
+        eprintln!("send: {} payment_hash: {:?} sent", i, payment2.payment_hash);
+
+        let payment3 = node_2.send_payment_keysend(&node_1, 1000).await.unwrap();
+        all_sent.insert((2, payment3.payment_hash));
+        eprintln!("send: {} payment_hash: {:?} sent", i, payment3.payment_hash);
+
+        let payment4 = node_3.send_payment_keysend(&node_1, 1000).await.unwrap();
+        all_sent.insert((3, payment4.payment_hash));
+        eprintln!("send: {} payment_hash: {:?} sent", i, payment4.payment_hash);
+    }
+
+    loop {
+        tokio::time::sleep(tokio::time::Duration::from_millis(3000)).await;
+
+        for (node_index, payment_hash) in all_sent.clone().iter() {
+            let node = match node_index {
+                1 => &mut node_1,
+                2 => &mut node_2,
+                3 => &mut node_3,
+                _ => unreachable!(),
+            };
+            let status = node.get_payment_status(*payment_hash).await;
+            tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+            eprintln!("got payment: {:?} status: {:?}", payment_hash, status);
+            if status == PaymentSessionStatus::Success {
+                eprintln!("payment_hash: {:?} success", payment_hash);
+                all_sent.remove(&(*node_index, *payment_hash));
+            }
+        }
+        let res = node_1.node_info().await;
+        eprintln!("node1 node_info: {:?}", res);
+        let res = node_2.node_info().await;
+        eprintln!("node2 node_info: {:?}", res);
+        let res = node_3.node_info().await;
+        eprintln!("node3 node_info: {:?}", res);
+        if all_sent.is_empty() {
+            break;
+        }
+    }
+}
diff --git a/src/fiber/tests/test_utils.rs b/src/fiber/tests/test_utils.rs
index bfff4f2ff..1a841ab3a 100644
--- a/src/fiber/tests/test_utils.rs
+++ b/src/fiber/tests/test_utils.rs
@@ -5,6 +5,7 @@ use crate::fiber::channel::ChannelCommandWithId;
 use crate::fiber::graph::NetworkGraphStateStore;
 use crate::fiber::graph::PaymentSession;
 use crate::fiber::graph::PaymentSessionStatus;
+use crate::fiber::network::NodeInfoResponse;
 use crate::fiber::network::SendPaymentCommand;
 use crate::fiber::network::SendPaymentResponse;
 use crate::fiber::types::EcdsaSignature;
@@ -18,6 +19,7 @@ use ckb_types::{core::TransactionView, packed::Byte32};
 use ractor::{call, Actor, ActorRef};
 use rand::rngs::OsRng;
 use secp256k1::{Message, Secp256k1};
+use std::collections::HashMap;
 use std::{
     env,
     ffi::OsStr,
@@ -56,6 +58,7 @@ use crate::{
 };
 
 static RETAIN_VAR: &str = "TEST_TEMP_RETAIN";
+pub(crate) const MIN_RESERVED_CKB: u128 = 4200000000;
 
 #[derive(Debug)]
 pub struct TempDir(ManuallyDrop<OldTempDir>);
@@ -171,6 +174,7 @@ pub struct NetworkNode {
     pub base_dir: Arc<TempDir>,
     pub node_name: Option<String>,
     pub store: Store,
+    pub channels_tx_map: HashMap<Hash256, Hash256>,
     pub fiber_config: FiberConfig,
     pub listening_addrs: Vec<MultiAddr>,
     pub network_actor: ActorRef<NetworkActorMessage>,
@@ -473,9 +477,12 @@ pub(crate) async fn create_n_nodes_with_index_and_amounts_with_established_chann
         // all the other nodes submit_tx
         for k in 0..n {
             let res = nodes[k].submit_tx(funding_tx.clone()).await;
+            nodes[k].add_channel_tx(channel_id, funding_tx.clone());
             assert_eq!(res, Status::Committed);
         }
     }
+    // sleep for a while to make sure network graph is updated
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
     (nodes, channels)
 }
 
@@ -545,29 +552,102 @@ impl NetworkNode {
         };
 
         let res = call!(self.network_actor, message).expect("source_node alive");
+        eprintln!("result: {:?}", res);
         res
     }
 
+    pub async fn send_payment_keysend(
+        &mut self,
+        recipient: &NetworkNode,
+        amount: u128,
+    ) -> std::result::Result<SendPaymentResponse, String> {
+        self.send_payment(SendPaymentCommand {
+            target_pubkey: Some(recipient.pubkey.clone()),
+            amount: Some(amount),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: false,
+            dry_run: false,
+            hop_hints: None,
+        })
+        .await
+    }
+
     pub async fn assert_payment_status(
         &self,
         payment_hash: Hash256,
         expected_status: PaymentSessionStatus,
         expected_retried: Option<u32>,
     ) {
+        let status = self.get_payment_status(payment_hash).await;
+        assert_eq!(status, expected_status);
+
+        if let Some(expected_retried) = expected_retried {
+            let payment_session = self.get_payment_session(payment_hash).unwrap();
+            assert_eq!(payment_session.retried_times, expected_retried);
+        }
+    }
+
+    pub async fn get_payment_status(&self, payment_hash: Hash256) -> PaymentSessionStatus {
+        self.get_payment_result(payment_hash).await.status
+    }
+
+    pub async fn get_payment_result(&self, payment_hash: Hash256) -> SendPaymentResponse {
         let message = |rpc_reply| -> NetworkActorMessage {
             NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash, rpc_reply))
         };
-        let res = call!(self.network_actor, message)
+        call!(self.network_actor, message)
             .expect("node_a alive")
-            .unwrap();
+            .unwrap()
+    }
 
-        assert_eq!(res.status, expected_status);
-        if let Some(expected_retried) = expected_retried {
-            let payment_session = self.get_payment_session(payment_hash).unwrap();
-            assert_eq!(payment_session.retried_times, expected_retried);
+    pub async fn wait_until_success(&self, payment_hash: Hash256) {
+        loop {
+            let status = self.get_payment_status(payment_hash).await;
+            if status == PaymentSessionStatus::Success {
+                eprintln!("Payment success: {:?}\n\n", payment_hash);
+                break;
+            } else if status == PaymentSessionStatus::Failed {
+                eprintln!("Payment failed: {:?}\n\n", payment_hash);
+                // report error
+                assert_eq!(status, PaymentSessionStatus::Success);
+            }
+            tokio::time::sleep(Duration::from_millis(500)).await;
+        }
+    }
+
+    pub async fn wait_until_failed(&self, payment_hash: Hash256) {
+        loop {
+            let status = self.get_payment_status(payment_hash).await;
+            if status == PaymentSessionStatus::Failed {
+                eprintln!("Payment failed: {:?}\n\n", payment_hash);
+                break;
+            } else if status == PaymentSessionStatus::Success {
+                eprintln!("Payment success: {:?}\n\n", payment_hash);
+                // report error
+                assert_eq!(status, PaymentSessionStatus::Failed);
+            }
+            tokio::time::sleep(Duration::from_millis(500)).await;
         }
     }
 
+    pub async fn node_info(&self) -> NodeInfoResponse {
+        let message =
+            |rpc_reply| NetworkActorMessage::Command(NetworkActorCommand::NodeInfo((), rpc_reply));
+        eprintln!("query node_info ...");
+        let res = call!(self.network_actor, message)
+            .expect("node_a alive")
+            .unwrap();
+        res
+    }
+
     pub async fn update_channel_actor_state(&mut self, state: ChannelActorState) {
         let channel_id = state.id.clone();
         self.store.insert_channel_actor_state(state);
@@ -653,6 +733,7 @@ impl NetworkNode {
         let network_graph = Arc::new(TokioRwLock::new(NetworkGraph::new(
             store.clone(),
             public_key.clone(),
+            true,
         )));
 
         let network_actor = Actor::spawn_linked(
@@ -698,6 +779,7 @@ impl NetworkNode {
             node_name,
             store,
             fiber_config,
+            channels_tx_map: Default::default(),
             listening_addrs: announced_addrs,
             network_actor,
             network_graph,
@@ -718,6 +800,20 @@ impl NetworkNode {
         }
     }
 
+    pub async fn get_network_channels(&self) -> Vec<ChannelInfo> {
+        self.network_graph
+            .read()
+            .await
+            .get_channels_with_params(1000, None)
+    }
+
+    pub async fn get_network_nodes(&self) -> Vec<NodeInfo> {
+        self.network_graph
+            .read()
+            .await
+            .get_nodes_with_params(1000, None)
+    }
+
     pub async fn start(&mut self) {
         let config = self.get_node_config();
         let new = Self::new_with_config(config).await;
@@ -881,6 +977,14 @@ impl NetworkNode {
         submit_tx(self.chain_actor.clone(), tx).await
     }
 
+    pub fn add_channel_tx(&mut self, channel_id: Hash256, tx: TransactionView) {
+        self.channels_tx_map.insert(channel_id, tx.hash().into());
+    }
+
+    pub fn get_channel_funding_tx(&self, channel_id: &Hash256) -> Option<Hash256> {
+        self.channels_tx_map.get(channel_id).cloned()
+    }
+
     pub async fn trace_tx(&mut self, tx: TransactionView) -> ckb_jsonrpc_types::Status {
         trace_tx(self.chain_actor.clone(), tx).await
     }
diff --git a/src/fiber/tests/tlc_op.rs b/src/fiber/tests/tlc_op.rs
new file mode 100644
index 000000000..4bfa9b7ca
--- /dev/null
+++ b/src/fiber/tests/tlc_op.rs
@@ -0,0 +1,502 @@
+use crate::fiber::channel::TlcInfo;
+use crate::fiber::channel::{
+    CommitmentNumbers, InboundTlcStatus, OutboundTlcStatus, TLCId, TlcState, TlcStatus,
+};
+use crate::fiber::hash_algorithm::HashAlgorithm;
+use crate::fiber::types::RemoveTlcFulfill;
+use crate::fiber::types::{Hash256, NO_SHARED_SECRET};
+use crate::fiber::types::{PaymentOnionPacket, RemoveTlcReason};
+use crate::gen_rand_sha256_hash;
+use crate::now_timestamp_as_millis_u64;
+use ckb_hash::new_blake2b;
+use ckb_types::packed::Byte32;
+use ractor::{async_trait as rasync_trait, Actor, ActorProcessingErr, ActorRef};
+use std::collections::HashMap;
+
+fn sign_tlcs<'a>(tlcs: impl Iterator<Item = &'a TlcInfo>) -> Hash256 {
+    // serialize active_tls to ge a hash
+    let mut keyparts = tlcs
+        .map(|tlc| (tlc.amount, tlc.payment_hash))
+        .collect::<Vec<_>>();
+
+    keyparts.sort_by(|a, b| {
+        let a: Byte32 = a.1.into();
+        let b: Byte32 = b.1.into();
+        a.cmp(&b)
+    });
+
+    eprintln!("keyparts: {:?}", keyparts);
+    let serialized = serde_json::to_string(&keyparts).expect("Failed to serialize tls");
+
+    // Hash the serialized data using SHA-256
+    let mut hasher = new_blake2b();
+    hasher.update(serialized.to_string().as_bytes());
+    let mut result = [0u8; 32];
+    hasher.finalize(&mut result);
+
+    result.into()
+}
+
+pub struct TlcActorState {
+    pub tlc_state: TlcState,
+    pub peer_id: String,
+}
+
+impl TlcActorState {
+    pub fn get_peer(&self) -> String {
+        if self.peer_id == "peer_a" {
+            "peer_b".to_string()
+        } else {
+            "peer_a".to_string()
+        }
+    }
+}
+
+pub struct NetworkActorState {
+    network: ActorRef<NetworkActorMessage>,
+    pub peers: HashMap<String, ActorRef<TlcActorMessage>>,
+}
+
+impl NetworkActorState {
+    pub async fn add_peer(&mut self, peer_id: String) {
+        let network = self.network.clone();
+        let actor = Actor::spawn_linked(
+            Some(peer_id.clone()),
+            TlcActor::new(network.clone()),
+            peer_id.clone(),
+            network.clone().get_cell(),
+        )
+        .await
+        .expect("Failed to start tlc actor")
+        .0;
+        self.peers.insert(peer_id.clone(), actor);
+        eprintln!("add_peer: {:?} added successfully ...", peer_id);
+    }
+}
+
+pub struct TlcActor {
+    network: ActorRef<NetworkActorMessage>,
+}
+
+impl TlcActor {
+    pub fn new(network: ActorRef<NetworkActorMessage>) -> Self {
+        Self { network }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct AddTlcCommand {
+    pub amount: u128,
+    pub payment_hash: Hash256,
+    pub expiry: u64,
+    pub hash_algorithm: HashAlgorithm,
+    pub onion_packet: Option<PaymentOnionPacket>,
+    pub shared_secret: [u8; 32],
+    #[allow(dead_code)]
+    pub previous_tlc: Option<(Hash256, u64)>,
+}
+
+pub struct NetworkActor {}
+
+#[derive(Debug)]
+pub enum TlcActorMessage {
+    Debug,
+    CommandAddTlc(AddTlcCommand),
+    CommandRemoveTlc(u64),
+    PeerAddTlc(TlcInfo),
+    PeerRemoveTlc(u64),
+    PeerCommitmentSigned(Hash256),
+    PeerRevokeAndAck(Hash256),
+    //PeerRemoveTlc,
+}
+
+#[derive(Debug)]
+pub enum NetworkActorMessage {
+    RegisterPeer(String),
+    AddTlc(String, AddTlcCommand),
+    RemoveTlc(String, u64),
+    PeerMsg(String, TlcActorMessage),
+}
+
+#[rasync_trait]
+impl Actor for NetworkActor {
+    type Msg = NetworkActorMessage;
+    type State = NetworkActorState;
+    type Arguments = ();
+
+    async fn handle(
+        &self,
+        _myself: ActorRef<Self::Msg>,
+        message: Self::Msg,
+        state: &mut Self::State,
+    ) -> Result<(), ActorProcessingErr> {
+        match message {
+            NetworkActorMessage::RegisterPeer(peer_id) => {
+                state.add_peer(peer_id).await;
+            }
+            NetworkActorMessage::AddTlc(peer_id, add_tlc) => {
+                eprintln!("NetworkActorMessage::AddTlc");
+                if let Some(actor) = state.peers.get(&peer_id) {
+                    actor
+                        .send_message(TlcActorMessage::CommandAddTlc(add_tlc))
+                        .expect("send ok");
+                }
+            }
+            NetworkActorMessage::RemoveTlc(peer_id, tlc_id) => {
+                if let Some(actor) = state.peers.get(&peer_id) {
+                    actor
+                        .send_message(TlcActorMessage::CommandRemoveTlc(tlc_id))
+                        .expect("send ok");
+                }
+            }
+            NetworkActorMessage::PeerMsg(peer_id, peer_msg) => {
+                if let Some(actor) = state.peers.get(&peer_id) {
+                    eprintln!("NetworkActorMessage::PeerMsg: {:?}", peer_msg);
+                    actor.send_message(peer_msg).expect("send ok");
+                }
+            }
+        }
+        Ok(())
+    }
+
+    async fn pre_start(
+        &self,
+        myself: ActorRef<Self::Msg>,
+        _args: Self::Arguments,
+    ) -> Result<Self::State, ActorProcessingErr> {
+        eprintln!("NetworkActor pre_start");
+        Ok(NetworkActorState {
+            peers: Default::default(),
+            network: myself.clone(),
+        })
+    }
+}
+
+#[rasync_trait]
+impl Actor for TlcActor {
+    type Msg = TlcActorMessage;
+    type State = TlcActorState;
+    type Arguments = String;
+
+    async fn handle(
+        &self,
+        _myself: ActorRef<Self::Msg>,
+        message: Self::Msg,
+        state: &mut Self::State,
+    ) -> Result<(), ActorProcessingErr> {
+        match message {
+            TlcActorMessage::Debug => {
+                eprintln!("Peer {} Debug", state.peer_id);
+                for tlc in state.tlc_state.offered_tlcs.tlcs.iter() {
+                    eprintln!("offered_tlc: {:?}", tlc.log());
+                }
+                for tlc in state.tlc_state.received_tlcs.tlcs.iter() {
+                    eprintln!("received_tlc: {:?}", tlc.log());
+                }
+            }
+            TlcActorMessage::CommandAddTlc(command) => {
+                eprintln!(
+                    "Peer {} TlcActorMessage::Command_AddTlc: {:?}",
+                    state.peer_id, command
+                );
+                let next_offer_id = state.tlc_state.get_next_offering();
+                let add_tlc = TlcInfo {
+                    channel_id: gen_rand_sha256_hash(),
+                    tlc_id: TLCId::Offered(next_offer_id),
+                    amount: command.amount,
+                    payment_hash: command.payment_hash,
+                    expiry: command.expiry,
+                    hash_algorithm: command.hash_algorithm,
+                    created_at: CommitmentNumbers::default(),
+                    removed_reason: None,
+                    onion_packet: command.onion_packet,
+                    shared_secret: command.shared_secret,
+                    previous_tlc: None,
+                    status: TlcStatus::Outbound(OutboundTlcStatus::LocalAnnounced),
+                };
+                state.tlc_state.add_offered_tlc(add_tlc.clone());
+                state.tlc_state.increment_offering();
+                let peer = state.get_peer();
+                self.network
+                    .send_message(NetworkActorMessage::PeerMsg(
+                        peer.clone(),
+                        TlcActorMessage::PeerAddTlc(add_tlc),
+                    ))
+                    .expect("send ok");
+
+                // send commitment signed
+                let tlcs = state.tlc_state.commitment_signed_tlcs(false);
+                let hash = sign_tlcs(tlcs);
+                eprintln!("got hash: {:?}", hash);
+                self.network
+                    .send_message(NetworkActorMessage::PeerMsg(
+                        peer,
+                        TlcActorMessage::PeerCommitmentSigned(hash),
+                    ))
+                    .expect("send ok");
+            }
+            TlcActorMessage::CommandRemoveTlc(tlc_id) => {
+                eprintln!("Peer {} process remove tlc ....", state.peer_id);
+                state.tlc_state.set_received_tlc_removed(
+                    tlc_id,
+                    RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill {
+                        payment_preimage: Default::default(),
+                    }),
+                );
+                let peer = state.get_peer();
+                self.network
+                    .send_message(NetworkActorMessage::PeerMsg(
+                        peer.clone(),
+                        TlcActorMessage::PeerRemoveTlc(tlc_id),
+                    ))
+                    .expect("send ok");
+
+                // send commitment signed
+                let tlcs = state.tlc_state.commitment_signed_tlcs(false);
+                let hash = sign_tlcs(tlcs);
+                eprintln!("got hash: {:?}", hash);
+                self.network
+                    .send_message(NetworkActorMessage::PeerMsg(
+                        peer,
+                        TlcActorMessage::PeerCommitmentSigned(hash),
+                    ))
+                    .expect("send ok");
+            }
+            TlcActorMessage::PeerAddTlc(add_tlc) => {
+                eprintln!(
+                    "Peer {} process peer add_tlc .... with tlc_id: {:?}",
+                    state.peer_id, add_tlc.tlc_id
+                );
+                let mut tlc = add_tlc.clone();
+                tlc.flip_mut();
+                tlc.status = TlcStatus::Inbound(InboundTlcStatus::RemoteAnnounced);
+                state.tlc_state.add_received_tlc(tlc);
+                eprintln!("add peer tlc successfully: {:?}", add_tlc);
+            }
+            TlcActorMessage::PeerRemoveTlc(tlc_id) => {
+                eprintln!(
+                    "Peer {} process peer remove tlc .... with tlc_id: {}",
+                    state.peer_id, tlc_id
+                );
+                state.tlc_state.set_offered_tlc_removed(
+                    tlc_id,
+                    RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill {
+                        payment_preimage: Default::default(),
+                    }),
+                );
+            }
+            TlcActorMessage::PeerCommitmentSigned(peer_hash) => {
+                eprintln!(
+                    "\nPeer {} processed peer commitment_signed ....",
+                    state.peer_id
+                );
+                let tlcs = state.tlc_state.commitment_signed_tlcs(true);
+                let hash = sign_tlcs(tlcs);
+                assert_eq!(hash, peer_hash);
+
+                let peer = state.get_peer();
+
+                state.tlc_state.update_for_commitment_signed();
+
+                eprintln!("sending peer revoke and ack ....");
+                let tlcs = state.tlc_state.commitment_signed_tlcs(false);
+                let hash = sign_tlcs(tlcs);
+                self.network
+                    .send_message(NetworkActorMessage::PeerMsg(
+                        peer.clone(),
+                        TlcActorMessage::PeerRevokeAndAck(hash),
+                    ))
+                    .expect("send ok");
+
+                // send commitment signed from our side if necessary
+                if state.tlc_state.need_another_commitment_signed() {
+                    eprintln!("sending another commitment signed ....");
+                    let tlcs = state.tlc_state.commitment_signed_tlcs(false);
+                    let hash = sign_tlcs(tlcs);
+                    self.network
+                        .send_message(NetworkActorMessage::PeerMsg(
+                            peer,
+                            TlcActorMessage::PeerCommitmentSigned(hash),
+                        ))
+                        .expect("send ok");
+                }
+            }
+            TlcActorMessage::PeerRevokeAndAck(peer_hash) => {
+                eprintln!("Peer {} processed peer revoke and ack ....", state.peer_id);
+                let tlcs = state.tlc_state.commitment_signed_tlcs(true);
+                let hash = sign_tlcs(tlcs);
+                assert_eq!(hash, peer_hash);
+
+                state.tlc_state.update_for_revoke_and_ack();
+            }
+        }
+        Ok(())
+    }
+
+    async fn pre_start(
+        &self,
+        _myself: ActorRef<Self::Msg>,
+        args: Self::Arguments,
+    ) -> Result<Self::State, ActorProcessingErr> {
+        eprintln!("TlcActor pre_start");
+        match args {
+            peer_id => {
+                eprintln!("peer_id: {:?}", peer_id);
+                Ok(TlcActorState {
+                    tlc_state: Default::default(),
+                    peer_id,
+                })
+            }
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_tlc_actor() {
+    let (network_actor, _handle) = Actor::spawn(None, NetworkActor {}, ())
+        .await
+        .expect("Failed to start tlc actor");
+    network_actor
+        .send_message(NetworkActorMessage::RegisterPeer("peer_a".to_string()))
+        .unwrap();
+    network_actor
+        .send_message(NetworkActorMessage::RegisterPeer("peer_b".to_string()))
+        .unwrap();
+
+    network_actor
+        .send_message(NetworkActorMessage::AddTlc(
+            "peer_a".to_string(),
+            AddTlcCommand {
+                amount: 10000,
+                payment_hash: gen_rand_sha256_hash(),
+                expiry: now_timestamp_as_millis_u64() + 1000,
+                hash_algorithm: HashAlgorithm::Sha256,
+                onion_packet: None,
+                shared_secret: NO_SHARED_SECRET.clone(),
+                previous_tlc: None,
+            },
+        ))
+        .unwrap();
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+    network_actor
+        .send_message(NetworkActorMessage::AddTlc(
+            "peer_a".to_string(),
+            AddTlcCommand {
+                amount: 20000,
+                payment_hash: gen_rand_sha256_hash(),
+                expiry: now_timestamp_as_millis_u64() + 1000,
+                hash_algorithm: HashAlgorithm::Sha256,
+                onion_packet: None,
+                shared_secret: NO_SHARED_SECRET.clone(),
+                previous_tlc: None,
+            },
+        ))
+        .unwrap();
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+    network_actor
+        .send_message(NetworkActorMessage::AddTlc(
+            "peer_b".to_string(),
+            AddTlcCommand {
+                amount: 30000,
+                payment_hash: gen_rand_sha256_hash(),
+                expiry: now_timestamp_as_millis_u64() + 1000,
+                hash_algorithm: HashAlgorithm::Sha256,
+                onion_packet: None,
+                shared_secret: NO_SHARED_SECRET.clone(),
+                previous_tlc: None,
+            },
+        ))
+        .unwrap();
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+    network_actor
+        .send_message(NetworkActorMessage::AddTlc(
+            "peer_b".to_string(),
+            AddTlcCommand {
+                amount: 50000,
+                payment_hash: gen_rand_sha256_hash(),
+                expiry: now_timestamp_as_millis_u64() + 1000,
+                hash_algorithm: HashAlgorithm::Sha256,
+                onion_packet: None,
+                shared_secret: NO_SHARED_SECRET.clone(),
+                previous_tlc: None,
+            },
+        ))
+        .unwrap();
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+    // remove tlc from peer_b
+    network_actor
+        .send_message(NetworkActorMessage::RemoveTlc("peer_b".to_string(), 0))
+        .unwrap();
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+    network_actor
+        .send_message(NetworkActorMessage::PeerMsg(
+            "peer_a".to_string(),
+            TlcActorMessage::Debug,
+        ))
+        .unwrap();
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+    network_actor
+        .send_message(NetworkActorMessage::PeerMsg(
+            "peer_b".to_string(),
+            TlcActorMessage::Debug,
+        ))
+        .unwrap();
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
+}
+
+#[test]
+fn test_tlc_state_v2() {
+    let mut tlc_state = TlcState::default();
+    let mut add_tlc1 = TlcInfo {
+        amount: 10000,
+        status: TlcStatus::Outbound(OutboundTlcStatus::LocalAnnounced),
+        channel_id: gen_rand_sha256_hash(),
+        payment_hash: gen_rand_sha256_hash(),
+        expiry: now_timestamp_as_millis_u64() + 1000,
+        hash_algorithm: HashAlgorithm::Sha256,
+        onion_packet: None,
+        shared_secret: NO_SHARED_SECRET.clone(),
+        tlc_id: TLCId::Offered(0),
+        created_at: CommitmentNumbers::default(),
+        removed_reason: None,
+        previous_tlc: None,
+    };
+    let mut add_tlc2 = TlcInfo {
+        amount: 20000,
+        status: TlcStatus::Outbound(OutboundTlcStatus::LocalAnnounced),
+        channel_id: gen_rand_sha256_hash(),
+        payment_hash: gen_rand_sha256_hash(),
+        expiry: now_timestamp_as_millis_u64() + 2000,
+        hash_algorithm: HashAlgorithm::Sha256,
+        onion_packet: None,
+        shared_secret: NO_SHARED_SECRET.clone(),
+        tlc_id: TLCId::Offered(1),
+        created_at: CommitmentNumbers::default(),
+        removed_reason: None,
+        previous_tlc: None,
+    };
+    tlc_state.add_offered_tlc(add_tlc1.clone());
+    tlc_state.add_offered_tlc(add_tlc2.clone());
+
+    let mut tlc_state_2 = TlcState::default();
+    add_tlc1.flip_mut();
+    add_tlc2.flip_mut();
+    add_tlc1.status = TlcStatus::Inbound(InboundTlcStatus::RemoteAnnounced);
+    add_tlc2.status = TlcStatus::Inbound(InboundTlcStatus::RemoteAnnounced);
+    tlc_state_2.add_received_tlc(add_tlc1);
+    tlc_state_2.add_received_tlc(add_tlc2);
+
+    let hash1 = sign_tlcs(tlc_state.commitment_signed_tlcs(true));
+    eprintln!("hash1: {:?}", hash1);
+
+    let hash2 = sign_tlcs(tlc_state_2.commitment_signed_tlcs(false));
+    eprintln!("hash2: {:?}", hash2);
+    assert_eq!(hash1, hash2);
+}
diff --git a/src/fiber/tests/types.rs b/src/fiber/tests/types.rs
index 9ee86d259..c92c7eeb6 100644
--- a/src/fiber/tests/types.rs
+++ b/src/fiber/tests/types.rs
@@ -234,3 +234,16 @@ fn test_tlc_err_packet_encryption() {
         assert_eq!(decrypted_tlc_fail_detail, tlc_fail_detail);
     }
 }
+
+#[test]
+fn test_tlc_error_code() {
+    let code = TlcErrorCode::PermanentNodeFailure;
+    let str = code.as_ref().to_string();
+    let code2 = TlcErrorCode::from_str(&str).expect("parse");
+    assert_eq!(code, code2);
+
+    let code = TlcErrorCode::IncorrectOrUnknownPaymentDetails;
+    let code_int: u16 = code.into();
+    let code = TlcErrorCode::try_from(code_int).expect("invalid code");
+    assert_eq!(code, TlcErrorCode::IncorrectOrUnknownPaymentDetails);
+}
diff --git a/src/fiber/types.rs b/src/fiber/types.rs
index bb58bc404..f5b92089f 100644
--- a/src/fiber/types.rs
+++ b/src/fiber/types.rs
@@ -1,6 +1,11 @@
-use super::channel::{ChannelFlags, CHANNEL_DISABLED_FLAG, MESSAGE_OF_NODE2_FLAG};
+use super::channel::{
+    ChannelFlags, ProcessingChannelError, CHANNEL_DISABLED_FLAG, MESSAGE_OF_NODE2_FLAG,
+};
 use super::config::AnnouncedNodeName;
-use super::gen::fiber::{self as molecule_fiber, PubNonce as Byte66, UdtCellDeps, Uint128Opt};
+use super::gen::fiber::{
+    self as molecule_fiber, ChannelUpdateOpt, PaymentPreimageOpt, PubNonce as Byte66, PubkeyOpt,
+    TlcErrDataOpt, UdtCellDeps, Uint128Opt,
+};
 use super::gen::gossip::{self as molecule_gossip};
 use super::hash_algorithm::{HashAlgorithm, UnknownHashAlgorithmError};
 use super::network::get_chain_hash;
@@ -8,6 +13,11 @@ use super::r#gen::fiber::PubNonceOpt;
 use super::serde_utils::{EntityHex, SliceHex};
 use crate::ckb::config::{UdtArgInfo, UdtCellDep, UdtCfgInfos, UdtScript};
 use crate::ckb::contracts::get_udt_whitelist;
+use ckb_jsonrpc_types::CellOutput;
+use num_enum::IntoPrimitive;
+use num_enum::TryFromPrimitive;
+use std::convert::TryFrom;
+use std::fmt::Debug;
 
 use anyhow::anyhow;
 use ckb_types::{
@@ -30,6 +40,7 @@ use secp256k1::{
 use secp256k1::{Verification, XOnlyPublicKey};
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
+use std::cmp::Ordering;
 use std::fmt::Display;
 use std::marker::PhantomData;
 use std::str::FromStr;
@@ -142,16 +153,7 @@ impl AsRef<[u8]> for Hash256 {
 
 impl From<&Hash256> for MByte32 {
     fn from(hash: &Hash256) -> Self {
-        MByte32::new_builder()
-            .set(
-                hash.0
-                    .into_iter()
-                    .map(Byte::new)
-                    .collect::<Vec<_>>()
-                    .try_into()
-                    .expect("Byte32 from Hash256"),
-            )
-            .build()
+        MByte32::from_slice(hash.0.as_ref()).expect("Byte32 from Hash256")
     }
 }
 
@@ -163,13 +165,7 @@ impl From<Hash256> for MByte32 {
 
 impl From<&MByte32> for Hash256 {
     fn from(value: &MByte32) -> Self {
-        Hash256(
-            value
-                .as_bytes()
-                .to_vec()
-                .try_into()
-                .expect("Hash256 from Byte32"),
-        )
+        Hash256(value.as_slice().try_into().expect("Hash256 from Byte32"))
     }
 }
 
@@ -180,16 +176,7 @@ impl From<MByte32> for Hash256 {
 }
 
 fn u8_32_as_byte_32(value: &[u8; 32]) -> MByte32 {
-    MByte32::new_builder()
-        .set(
-            value
-                .iter()
-                .map(|v| Byte::new(*v))
-                .collect::<Vec<_>>()
-                .try_into()
-                .expect("[u8; 32] to Byte32"),
-        )
-        .build()
+    MByte32::from_slice(value.as_slice()).expect("[u8; 32] to Byte32")
 }
 
 impl ::core::fmt::LowerHex for Hash256 {
@@ -1153,7 +1140,7 @@ pub struct TlcErr {
 
 impl Display for TlcErr {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.error_code_as_str().fmt(f)
+        write!(f, "{}", self.error_code_as_str())
     }
 }
 
@@ -1214,16 +1201,103 @@ impl TlcErr {
         error_code.as_ref().to_string()
     }
 
+    pub fn error_code_as_u16(&self) -> u16 {
+        self.error_code.into()
+    }
+
     pub fn set_extra_data(&mut self, extra_data: TlcErrData) {
         self.extra_data = Some(extra_data);
     }
 
     fn serialize(&self) -> Vec<u8> {
-        deterministically_serialize(self)
+        molecule_fiber::TlcErr::from(self.clone())
+            .as_slice()
+            .to_vec()
     }
 
     fn deserialize(data: &[u8]) -> Option<Self> {
-        serde_json::from_slice(data).ok()
+        molecule_fiber::TlcErr::from_slice(data)
+            .map(TlcErr::from)
+            .ok()
+    }
+}
+
+impl TryFrom<TlcErrData> for molecule_fiber::TlcErrData {
+    type Error = Error;
+
+    fn try_from(tlc_err_data: TlcErrData) -> Result<Self, Self::Error> {
+        match tlc_err_data {
+            TlcErrData::ChannelFailed {
+                channel_outpoint,
+                channel_update,
+                node_id,
+            } => Ok(molecule_fiber::ChannelFailed::new_builder()
+                .channel_outpoint(channel_outpoint.into())
+                .channel_update(
+                    ChannelUpdateOpt::new_builder()
+                        .set(channel_update.map(|x| x.into()))
+                        .build(),
+                )
+                .node_id(node_id.into())
+                .build()
+                .into()),
+            TlcErrData::NodeFailed { node_id } => Ok(molecule_fiber::NodeFailed::new_builder()
+                .node_id(node_id.into())
+                .build()
+                .into()),
+        }
+    }
+}
+
+impl TryFrom<molecule_fiber::TlcErrData> for TlcErrData {
+    type Error = Error;
+
+    fn try_from(tlc_err_data: molecule_fiber::TlcErrData) -> Result<Self, Self::Error> {
+        match tlc_err_data.to_enum() {
+            molecule_fiber::TlcErrDataUnion::ChannelFailed(channel_failed) => {
+                Ok(TlcErrData::ChannelFailed {
+                    channel_outpoint: channel_failed.channel_outpoint().into(),
+                    channel_update: channel_failed
+                        .channel_update()
+                        .to_opt()
+                        .map(|x| x.try_into().unwrap()),
+                    node_id: channel_failed.node_id().try_into()?,
+                })
+            }
+            molecule_fiber::TlcErrDataUnion::NodeFailed(node_failed) => {
+                Ok(TlcErrData::NodeFailed {
+                    node_id: node_failed.node_id().try_into()?,
+                })
+            }
+        }
+    }
+}
+
+impl From<TlcErr> for molecule_fiber::TlcErr {
+    fn from(tlc_err: TlcErr) -> Self {
+        molecule_fiber::TlcErr::new_builder()
+            .error_code(tlc_err.error_code_as_u16().into())
+            .extra_data(
+                TlcErrDataOpt::new_builder()
+                    .set(tlc_err.extra_data.map(|data| data.try_into().unwrap()))
+                    .build(),
+            )
+            .build()
+    }
+}
+
+impl From<molecule_fiber::TlcErr> for TlcErr {
+    fn from(tlc_err: molecule_fiber::TlcErr) -> Self {
+        TlcErr {
+            error_code: {
+                let code: u16 = tlc_err.error_code().into();
+                TlcErrorCode::try_from(code).expect("tlc_errror_code failed")
+            },
+            extra_data: tlc_err
+                .extra_data()
+                .to_opt()
+                .map(|data| data.try_into().unwrap()),
+        }
     }
 }
 
@@ -1337,7 +1411,19 @@ const NODE: u16 = 0x2000;
 const UPDATE: u16 = 0x1000;
 
 #[repr(u16)]
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, AsRefStr, EnumString)]
+#[derive(
+    Debug,
+    Copy,
+    Clone,
+    Serialize,
+    Deserialize,
+    PartialEq,
+    Eq,
+    AsRefStr,
+    EnumString,
+    TryFromPrimitive,
+    IntoPrimitive,
+)]
 pub enum TlcErrorCode {
     TemporaryNodeFailure = NODE | 2,
     PermanentNodeFailure = PERM | NODE | 2,
@@ -1398,12 +1484,23 @@ impl TlcErrorCode {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub enum RemoveTlcReason {
     RemoveTlcFulfill(RemoveTlcFulfill),
     RemoveTlcFail(TlcErrPacket),
 }
 
+impl Debug for RemoveTlcReason {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            RemoveTlcReason::RemoveTlcFulfill(_fulfill) => {
+                write!(f, "RemoveTlcFulfill")
+            }
+            RemoveTlcReason::RemoveTlcFail(_fail) => write!(f, "RemoveTlcFail"),
+        }
+    }
+}
+
 impl RemoveTlcReason {
     /// Intermediate node backwards the error to the previous hop using the shared secret used in forwarding
     /// the onion packet.
@@ -1558,6 +1655,14 @@ impl TryFrom<molecule_fiber::AnnouncementSignatures> for AnnouncementSignatures
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct ForwardTlcResult {
+    pub channel_id: Hash256,
+    pub payment_hash: Hash256,
+    pub tlc_id: u64,
+    pub error_info: Option<(ProcessingChannelError, TlcErr)>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Hash)]
 pub struct NodeAnnouncement {
     // Signature to this message, may be empty the message is not signed yet.
@@ -1571,7 +1676,7 @@ pub struct NodeAnnouncement {
     // Must be a valid utf-8 string of length maximal length 32 bytes.
     // If the length is less than 32 bytes, it will be padded with 0.
     // If the length is more than 32 bytes, it should be truncated.
-    pub alias: AnnouncedNodeName,
+    pub node_name: AnnouncedNodeName,
     // All the reachable addresses.
     pub addresses: Vec<MultiAddr>,
     // chain_hash
@@ -1584,7 +1689,7 @@ pub struct NodeAnnouncement {
 
 impl NodeAnnouncement {
     pub fn new_unsigned(
-        alias: AnnouncedNodeName,
+        node_name: AnnouncedNodeName,
         addresses: Vec<MultiAddr>,
         node_id: Pubkey,
         timestamp: u64,
@@ -1595,7 +1700,7 @@ impl NodeAnnouncement {
             features: Default::default(),
             timestamp,
             node_id,
-            alias,
+            node_name,
             chain_hash: get_chain_hash(),
             addresses,
             auto_accept_min_ckb_funding_amount,
@@ -1604,14 +1709,14 @@ impl NodeAnnouncement {
     }
 
     pub fn new(
-        alias: AnnouncedNodeName,
+        node_name: AnnouncedNodeName,
         addresses: Vec<MultiAddr>,
         private_key: &Privkey,
         timestamp: u64,
         auto_accept_min_ckb_funding_amount: u64,
     ) -> NodeAnnouncement {
         let mut unsigned = NodeAnnouncement::new_unsigned(
-            alias,
+            node_name,
             addresses,
             private_key.pubkey(),
             timestamp,
@@ -1627,13 +1732,15 @@ impl NodeAnnouncement {
             features: self.features,
             timestamp: self.timestamp,
             node_id: self.node_id,
-            alias: self.alias,
+            node_name: self.node_name,
             chain_hash: self.chain_hash,
             addresses: self.addresses.clone(),
             auto_accept_min_ckb_funding_amount: self.auto_accept_min_ckb_funding_amount,
             udt_cfg_infos: get_udt_whitelist(),
         };
-        deterministically_hash(&unsigned_announcement)
+        deterministically_hash(&molecule_gossip::NodeAnnouncement::from(
+            unsigned_announcement,
+        ))
     }
 
     pub fn peer_id(&self) -> PeerId {
@@ -1764,17 +1871,11 @@ impl From<molecule_fiber::UdtCfgInfos> for UdtCfgInfos {
 
 impl From<NodeAnnouncement> for molecule_gossip::NodeAnnouncement {
     fn from(node_announcement: NodeAnnouncement) -> Self {
-        molecule_gossip::NodeAnnouncement::new_builder()
-            .signature(
-                node_announcement
-                    .signature
-                    .expect("node announcement signed")
-                    .into(),
-            )
+        let builder = molecule_gossip::NodeAnnouncement::new_builder()
             .features(node_announcement.features.pack())
             .timestamp(node_announcement.timestamp.pack())
             .node_id(node_announcement.node_id.into())
-            .alias(u8_32_as_byte_32(&node_announcement.alias.0))
+            .node_name(u8_32_as_byte_32(&node_announcement.node_name.0))
             .chain_hash(node_announcement.chain_hash.into())
             .auto_accept_min_ckb_funding_amount(
                 node_announcement.auto_accept_min_ckb_funding_amount.pack(),
@@ -1790,8 +1891,15 @@ impl From<NodeAnnouncement> for molecule_gossip::NodeAnnouncement {
                             .collect(),
                     )
                     .build(),
-            )
-            .build()
+            );
+
+        let builder = if let Some(signature) = node_announcement.signature {
+            builder.signature(signature.into())
+        } else {
+            builder
+        };
+
+        builder.build()
     }
 }
 
@@ -1808,8 +1916,8 @@ impl TryFrom<molecule_gossip::NodeAnnouncement> for NodeAnnouncement {
             auto_accept_min_ckb_funding_amount: node_announcement
                 .auto_accept_min_ckb_funding_amount()
                 .unpack(),
-            alias: AnnouncedNodeName::from_slice(node_announcement.alias().as_slice())
-                .map_err(|e| Error::AnyHow(anyhow!("Invalid alias: {}", e)))?,
+            node_name: AnnouncedNodeName::from_slice(node_announcement.node_name().as_slice())
+                .map_err(|e| Error::AnyHow(anyhow!("Invalid node_name: {}", e)))?,
             udt_cfg_infos: node_announcement.udt_cfg_infos().into(),
             addresses: node_announcement
                 .address()
@@ -1888,7 +1996,9 @@ impl ChannelAnnouncement {
             capacity: self.capacity,
             udt_type_script: self.udt_type_script.clone(),
         };
-        deterministically_hash(&unsigned_announcement)
+        deterministically_hash(&molecule_gossip::ChannelAnnouncement::from(
+            unsigned_announcement,
+        ))
     }
 
     pub fn out_point(&self) -> &OutPoint {
@@ -1898,25 +2008,7 @@ impl ChannelAnnouncement {
 
 impl From<ChannelAnnouncement> for molecule_gossip::ChannelAnnouncement {
     fn from(channel_announcement: ChannelAnnouncement) -> Self {
-        molecule_gossip::ChannelAnnouncement::new_builder()
-            .node1_signature(
-                channel_announcement
-                    .node1_signature
-                    .expect("channel announcement signed")
-                    .into(),
-            )
-            .node2_signature(
-                channel_announcement
-                    .node2_signature
-                    .expect("channel announcement signed")
-                    .into(),
-            )
-            .ckb_signature(
-                channel_announcement
-                    .ckb_signature
-                    .expect("channel announcement signed")
-                    .into(),
-            )
+        let builder = molecule_gossip::ChannelAnnouncement::new_builder()
             .features(channel_announcement.features.pack())
             .chain_hash(channel_announcement.chain_hash.into())
             .channel_outpoint(channel_announcement.channel_outpoint)
@@ -1924,8 +2016,27 @@ impl From<ChannelAnnouncement> for molecule_gossip::ChannelAnnouncement {
             .node2_id(channel_announcement.node2_id.into())
             .capacity(channel_announcement.capacity.pack())
             .udt_type_script(channel_announcement.udt_type_script.pack())
-            .ckb_key(channel_announcement.ckb_key.into())
-            .build()
+            .ckb_key(channel_announcement.ckb_key.into());
+
+        let builder = if let Some(signature) = channel_announcement.node1_signature {
+            builder.node1_signature(signature.into())
+        } else {
+            builder
+        };
+
+        let builder = if let Some(signature) = channel_announcement.node2_signature {
+            builder.node2_signature(signature.into())
+        } else {
+            builder
+        };
+
+        let builder = if let Some(signature) = channel_announcement.ckb_signature {
+            builder.ckb_signature(signature.into())
+        } else {
+            builder
+        };
+
+        builder.build()
     }
 }
 
@@ -2014,7 +2125,7 @@ impl ChannelUpdate {
             tlc_minimum_value: self.tlc_minimum_value,
             tlc_fee_proportional_millionths: self.tlc_fee_proportional_millionths,
         };
-        deterministically_hash(&unsigned_update)
+        deterministically_hash(&molecule_fiber::ChannelUpdate::from(unsigned_update))
     }
 
     pub fn is_update_of_node_1(&self) -> bool {
@@ -2037,15 +2148,9 @@ impl ChannelUpdate {
     }
 }
 
-impl From<ChannelUpdate> for molecule_gossip::ChannelUpdate {
+impl From<ChannelUpdate> for molecule_fiber::ChannelUpdate {
     fn from(channel_update: ChannelUpdate) -> Self {
-        molecule_gossip::ChannelUpdate::new_builder()
-            .signature(
-                channel_update
-                    .signature
-                    .expect("channel update signed")
-                    .into(),
-            )
+        let builder = molecule_fiber::ChannelUpdate::new_builder()
             .chain_hash(channel_update.chain_hash.into())
             .channel_outpoint(channel_update.channel_outpoint)
             .timestamp(channel_update.timestamp.pack())
@@ -2053,15 +2158,22 @@ impl From<ChannelUpdate> for molecule_gossip::ChannelUpdate {
             .channel_flags(channel_update.channel_flags.pack())
             .tlc_expiry_delta(channel_update.tlc_expiry_delta.pack())
             .tlc_minimum_value(channel_update.tlc_minimum_value.pack())
-            .tlc_fee_proportional_millionths(channel_update.tlc_fee_proportional_millionths.pack())
-            .build()
+            .tlc_fee_proportional_millionths(channel_update.tlc_fee_proportional_millionths.pack());
+
+        let builder = if let Some(signature) = channel_update.signature {
+            builder.signature(signature.into())
+        } else {
+            builder
+        };
+
+        builder.build()
     }
 }
 
-impl TryFrom<molecule_gossip::ChannelUpdate> for ChannelUpdate {
+impl TryFrom<molecule_fiber::ChannelUpdate> for ChannelUpdate {
     type Error = Error;
 
-    fn try_from(channel_update: molecule_gossip::ChannelUpdate) -> Result<Self, Self::Error> {
+    fn try_from(channel_update: molecule_fiber::ChannelUpdate) -> Result<Self, Self::Error> {
         Ok(ChannelUpdate {
             signature: Some(channel_update.signature().try_into()?),
             chain_hash: channel_update.chain_hash().into(),
@@ -2351,8 +2463,41 @@ impl BroadcastMessage {
             }
         }
     }
+
+    pub(crate) fn message_id(&self) -> BroadcastMessageID {
+        match self {
+            BroadcastMessage::NodeAnnouncement(node_announcement) => {
+                BroadcastMessageID::NodeAnnouncement(node_announcement.node_id)
+            }
+            BroadcastMessage::ChannelAnnouncement(channel_announcement) => {
+                BroadcastMessageID::ChannelAnnouncement(
+                    channel_announcement.channel_outpoint.clone(),
+                )
+            }
+            BroadcastMessage::ChannelUpdate(channel_update) => {
+                BroadcastMessageID::ChannelUpdate(channel_update.channel_outpoint.clone())
+            }
+        }
+    }
+
+    pub(crate) fn timestamp(&self) -> Option<u64> {
+        match self {
+            BroadcastMessage::NodeAnnouncement(node_announcement) => {
+                Some(node_announcement.timestamp)
+            }
+            BroadcastMessage::ChannelAnnouncement(_) => None,
+            BroadcastMessage::ChannelUpdate(channel_update) => Some(channel_update.timestamp),
+        }
+    }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ChannelOnchainInfo {
+    pub timestamp: u64,
+    pub first_output: CellOutput,
+}
+
+// Augment the broadcast message with timestamp so that we can easily obtain the cursor of the message.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum BroadcastMessageWithTimestamp {
     NodeAnnouncement(NodeAnnouncement),
@@ -2431,6 +2576,41 @@ impl BroadcastMessageWithTimestamp {
     }
 }
 
+impl Ord for BroadcastMessage {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.message_id()
+            .cmp(&other.message_id())
+            .then(self.timestamp().cmp(&other.timestamp()))
+    }
+}
+
+impl PartialOrd for BroadcastMessage {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl From<(BroadcastMessage, Option<ChannelOnchainInfo>)> for BroadcastMessageWithTimestamp {
+    fn from(
+        (broadcast_message, channel_onchain_info): (BroadcastMessage, Option<ChannelOnchainInfo>),
+    ) -> Self {
+        match broadcast_message {
+            BroadcastMessage::NodeAnnouncement(node_announcement) => {
+                BroadcastMessageWithTimestamp::NodeAnnouncement(node_announcement)
+            }
+            BroadcastMessage::ChannelAnnouncement(channel_announcement) => {
+                let timestamp = channel_onchain_info
+                    .expect("Channel onchain info is required for channel announcement")
+                    .timestamp;
+                BroadcastMessageWithTimestamp::ChannelAnnouncement(timestamp, channel_announcement)
+            }
+            BroadcastMessage::ChannelUpdate(channel_update) => {
+                BroadcastMessageWithTimestamp::ChannelUpdate(channel_update)
+            }
+        }
+    }
+}
+
 impl From<BroadcastMessageWithTimestamp> for BroadcastMessage {
     fn from(broadcast_message_with_timestamp: BroadcastMessageWithTimestamp) -> Self {
         match broadcast_message_with_timestamp {
@@ -2523,22 +2703,6 @@ impl TryFrom<molecule_gossip::BroadcastMessage> for BroadcastMessage {
     }
 }
 
-impl BroadcastMessage {
-    pub fn id(&self) -> Hash256 {
-        match self {
-            BroadcastMessage::NodeAnnouncement(node_announcement) => {
-                deterministically_hash(node_announcement).into()
-            }
-            BroadcastMessage::ChannelAnnouncement(channel_announcement) => {
-                deterministically_hash(channel_announcement).into()
-            }
-            BroadcastMessage::ChannelUpdate(channel_update) => {
-                deterministically_hash(channel_update).into()
-            }
-        }
-    }
-}
-
 /// Note that currently we only allow querying for one type of broadcast message at a time.
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum BroadcastMessageQueryFlags {
@@ -2616,6 +2780,42 @@ pub enum BroadcastMessageID {
     NodeAnnouncement(Pubkey),
 }
 
+// We need to implement Ord for BroadcastMessageID to make sure that a ChannelUpdate message is always ordered after ChannelAnnouncement,
+// so that we can use it as the sorting key in fn prune_messages_to_be_saved to simplify the logic.
+impl Ord for BroadcastMessageID {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self, other) {
+            (
+                BroadcastMessageID::ChannelAnnouncement(outpoint1),
+                BroadcastMessageID::ChannelAnnouncement(outpoint2),
+            ) => outpoint1.cmp(outpoint2),
+            (
+                BroadcastMessageID::ChannelUpdate(outpoint1),
+                BroadcastMessageID::ChannelUpdate(outpoint2),
+            ) => outpoint1.cmp(outpoint2),
+            (
+                BroadcastMessageID::NodeAnnouncement(pubkey1),
+                BroadcastMessageID::NodeAnnouncement(pubkey2),
+            ) => pubkey1.cmp(pubkey2),
+            (BroadcastMessageID::NodeAnnouncement(_), _) => Ordering::Less,
+            (BroadcastMessageID::ChannelUpdate(_), _) => Ordering::Greater,
+            (
+                BroadcastMessageID::ChannelAnnouncement(_),
+                BroadcastMessageID::NodeAnnouncement(_),
+            ) => Ordering::Greater,
+            (BroadcastMessageID::ChannelAnnouncement(_), BroadcastMessageID::ChannelUpdate(_)) => {
+                Ordering::Less
+            }
+        }
+    }
+}
+
+impl PartialOrd for BroadcastMessageID {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
 // 1 byte for message type, 36 bytes for message id
 const MESSAGE_ID_SIZE: usize = 1 + 36;
 // 8 bytes for timestamp, MESSAGE_ID_SIZE bytes for message id
@@ -2741,13 +2941,13 @@ impl Cursor {
 }
 
 impl Ord for Cursor {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> Ordering {
         self.to_bytes().cmp(&other.to_bytes())
     }
 }
 
 impl PartialOrd for Cursor {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
@@ -2801,7 +3001,7 @@ impl TryFrom<molecule_gossip::Cursor> for Cursor {
     }
 }
 
-impl From<u16> for molecule_gossip::Uint16 {
+impl From<u16> for molecule_fiber::Uint16 {
     fn from(count: u16) -> Self {
         let le_bytes = count.to_le_bytes();
         Self::new_builder()
@@ -2817,8 +3017,8 @@ impl From<u16> for molecule_gossip::Uint16 {
     }
 }
 
-impl From<molecule_gossip::Uint16> for u16 {
-    fn from(count: molecule_gossip::Uint16) -> Self {
+impl From<molecule_fiber::Uint16> for u16 {
+    fn from(count: molecule_fiber::Uint16) -> Self {
         let le_bytes = count.as_slice().try_into().expect("Uint16 to u16");
         u16::from_le_bytes(le_bytes)
     }
@@ -3265,12 +3465,8 @@ macro_rules! impl_traits {
 
 impl_traits!(FiberMessage);
 
-pub(crate) fn deterministically_serialize<T: Serialize>(v: &T) -> Vec<u8> {
-    serde_json::to_vec_pretty(v).expect("serialize value")
-}
-
-pub(crate) fn deterministically_hash<T: Serialize>(v: &T) -> [u8; 32] {
-    ckb_hash::blake2b_256(deterministically_serialize(v))
+pub(crate) fn deterministically_hash<T: Entity>(v: &T) -> [u8; 32] {
+    ckb_hash::blake2b_256(v.as_slice()).into()
 }
 
 #[serde_as]
@@ -3306,11 +3502,58 @@ impl HopData for PaymentHopData {
     }
 
     fn serialize(&self) -> Vec<u8> {
-        deterministically_serialize(self)
+        molecule_fiber::PaymentHopData::from(self.clone())
+            .as_bytes()
+            .to_vec()
     }
 
     fn deserialize(data: &[u8]) -> Option<Self> {
-        serde_json::from_slice(data).ok()
+        molecule_fiber::PaymentHopData::from_slice(data)
+            .ok()
+            .map(|x| x.into())
+    }
+}
+
+impl From<PaymentHopData> for molecule_fiber::PaymentHopData {
+    fn from(payment_hop_data: PaymentHopData) -> Self {
+        molecule_fiber::PaymentHopData::new_builder()
+            .amount(payment_hop_data.amount.pack())
+            .expiry(payment_hop_data.expiry.pack())
+            .payment_preimage(
+                PaymentPreimageOpt::new_builder()
+                    .set(payment_hop_data.payment_preimage.map(|x| x.into()))
+                    .build(),
+            )
+            .hash_algorithm(Byte::new(payment_hop_data.hash_algorithm as u8))
+            .funding_tx_hash(payment_hop_data.funding_tx_hash.into())
+            .next_hop(
+                PubkeyOpt::new_builder()
+                    .set(payment_hop_data.next_hop.map(|x| x.into()))
+                    .build(),
+            )
+            .build()
+    }
+}
+
+impl From<molecule_fiber::PaymentHopData> for PaymentHopData {
+    fn from(payment_hop_data: molecule_fiber::PaymentHopData) -> Self {
+        PaymentHopData {
+            amount: payment_hop_data.amount().unpack(),
+            expiry: payment_hop_data.expiry().unpack(),
+            payment_preimage: payment_hop_data
+                .payment_preimage()
+                .to_opt()
+                .map(|x| x.into()),
+            hash_algorithm: payment_hop_data
+                .hash_algorithm()
+                .try_into()
+                .expect("valid hash algorithm"),
+            funding_tx_hash: payment_hop_data.funding_tx_hash().into(),
+            next_hop: payment_hop_data
+                .next_hop()
+                .to_opt()
+                .map(|x| x.try_into().expect("invalid pubkey")),
+        }
     }
 }
 
diff --git a/src/invoice/store.rs b/src/invoice/store.rs
index e2018e016..32c368b80 100644
--- a/src/invoice/store.rs
+++ b/src/invoice/store.rs
@@ -15,4 +15,9 @@ pub trait InvoiceStore {
         status: CkbInvoiceStatus,
     ) -> Result<(), InvoiceError>;
     fn get_invoice_status(&self, id: &Hash256) -> Option<CkbInvoiceStatus>;
+    fn insert_payment_preimage(
+        &self,
+        payment_hash: Hash256,
+        preimage: Hash256,
+    ) -> Result<(), InvoiceError>;
 }
diff --git a/src/invoice/tests/invoice_impl.rs b/src/invoice/tests/invoice_impl.rs
index 96f78ed1b..5885ac5fc 100644
--- a/src/invoice/tests/invoice_impl.rs
+++ b/src/invoice/tests/invoice_impl.rs
@@ -390,6 +390,9 @@ fn test_invoice_timestamp() {
         .build_with_sign(|hash| Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))
         .unwrap();
 
+    // sleep 1 milisecond to make sure the timestamp is different
+    std::thread::sleep(Duration::from_millis(1));
+
     let invoice2 = InvoiceBuilder::new(Currency::Fibb)
         .amount(Some(1280))
         .payment_hash(payment_hash)
diff --git a/src/lib.rs b/src/lib.rs
index 015eeb1f0..129db97d5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -29,9 +29,9 @@ pub mod tasks;
 
 use git_version::git_version;
 
-const GIT_VERSION: &str = git_version!();
+const GIT_VERSION: &str = git_version!(fallback = "unknown");
 
-pub fn get_git_versin() -> &'static str {
+pub fn get_git_version() -> &'static str {
     GIT_VERSION
 }
 
diff --git a/src/main.rs b/src/main.rs
index d7be66dc1..aa5ad2b7e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,13 +1,9 @@
 use ckb_chain_spec::ChainSpec;
-use ckb_hash::blake2b_256;
 use ckb_resource::Resource;
 use core::default::Default;
 use fnn::actors::RootActor;
 use fnn::cch::CchMessage;
-use fnn::ckb::{
-    contracts::{get_script_by_contract, try_init_contracts_context, Contract},
-    CkbChainActor,
-};
+use fnn::ckb::{contracts::try_init_contracts_context, CkbChainActor};
 use fnn::fiber::{channel::ChannelSubscribers, graph::NetworkGraph, network::init_chain_hash};
 use fnn::store::Store;
 use fnn::tasks::{
@@ -20,7 +16,6 @@ use fnn::watchtower::{
 use fnn::NetworkServiceEvent;
 use fnn::{start_cch, start_network, start_rpc, Config};
 use ractor::Actor;
-use secp256k1::Secp256k1;
 #[cfg(debug_assertions)]
 use std::collections::HashMap;
 use std::fmt::Debug;
@@ -60,7 +55,7 @@ pub async fn main() -> Result<(), ExitMessage> {
         .try_init()
         .map_err(|err| ExitMessage(format!("failed to initialize logger: {}", err)))?;
 
-    info!("Starting node with git version {}", fnn::get_git_versin());
+    info!("Starting node with git version {}", fnn::get_git_version());
 
     let _span = info_span!("node", node = fnn::get_node_prefix()).entered();
 
@@ -95,7 +90,7 @@ pub async fn main() -> Result<(), ExitMessage> {
         Some(fiber_config) => {
             // TODO: this is not a super user friendly error message which has actionable information
             // for the user to fix the error and start the node.
-            let ckb_config = config.ckb.ok_or_else(|| {
+            let ckb_config = config.ckb.clone().ok_or_else(|| {
                 ExitMessage(
                     "service fiber requires service ckb which is not enabled in the config file"
                         .to_string(),
@@ -138,18 +133,13 @@ pub async fn main() -> Result<(), ExitMessage> {
             let network_graph = Arc::new(RwLock::new(NetworkGraph::new(
                 store.clone(),
                 node_public_key.clone().into(),
+                fiber_config.announce_private_addr(),
             )));
 
-            let secret_key = ckb_config.read_secret_key().map_err(|err| {
-                ExitMessage(format!(
-                    "failed to read the secret key for the ckb signer: {}",
-                    err
-                ))
-            })?;
-            let secp = Secp256k1::new();
-            let pubkey_hash = blake2b_256(secret_key.public_key(&secp).serialize());
-            let default_shutdown_script =
-                get_script_by_contract(Contract::Secp256k1Lock, &pubkey_hash[0..20]);
+            // we use the default funding lock script as the shutdown script for the network actor
+            let default_shutdown_script = ckb_config
+                .get_default_funding_lock_script()
+                .expect("get default funding lock script should be ok");
 
             info!("Starting fiber");
             let network_actor = start_network(
@@ -280,6 +270,7 @@ pub async fn main() -> Result<(), ExitMessage> {
         (Some(rpc_config), Some(network_graph)) => {
             let handle = start_rpc(
                 rpc_config,
+                config.ckb,
                 config.fiber,
                 network_actor,
                 cch_actor,
diff --git a/src/rpc/README.md b/src/rpc/README.md
index daaa8e202..23d007095 100644
--- a/src/rpc/README.md
+++ b/src/rpc/README.md
@@ -20,14 +20,12 @@ You may refer to the e2e test cases in the `tests/bruno/e2e` directory for examp
         * [Method `open_channel`](#channel-open_channel)
         * [Method `accept_channel`](#channel-accept_channel)
         * [Method `list_channels`](#channel-list_channels)
-        * [Method `commitment_signed`](#channel-commitment_signed)
-        * [Method `add_tlc`](#channel-add_tlc)
-        * [Method `remove_tlc`](#channel-remove_tlc)
         * [Method `shutdown_channel`](#channel-shutdown_channel)
         * [Method `update_channel`](#channel-update_channel)
-        * [Method `send_payment`](#channel-send_payment)
-        * [Method `get_payment`](#channel-get_payment)
     * [Module Dev](#module-dev)
+        * [Method `commitment_signed`](#dev-commitment_signed)
+        * [Method `add_tlc`](#dev-add_tlc)
+        * [Method `remove_tlc`](#dev-remove_tlc)
         * [Method `submit_commitment_transaction`](#dev-submit_commitment_transaction)
     * [Module Graph](#module-graph)
         * [Method `graph_nodes`](#graph-graph_nodes)
@@ -39,6 +37,9 @@ You may refer to the e2e test cases in the `tests/bruno/e2e` directory for examp
         * [Method `parse_invoice`](#invoice-parse_invoice)
         * [Method `get_invoice`](#invoice-get_invoice)
         * [Method `cancel_invoice`](#invoice-cancel_invoice)
+    * [Module Payment](#module-payment)
+        * [Method `send_payment`](#payment-send_payment)
+        * [Method `get_payment`](#payment-get_payment)
     * [Module Peer](#module-peer)
         * [Method `connect_peer`](#peer-connect_peer)
         * [Method `disconnect_peer`](#peer-disconnect_peer)
@@ -48,6 +49,7 @@ You may refer to the e2e test cases in the `tests/bruno/e2e` directory for examp
     * [Type `ChannelInfo`](#type-channelinfo)
     * [Type `ChannelState`](#type-channelstate)
     * [Type `NodeInfo`](#type-nodeinfo)
+    * [Type `PaymentSessionStatus`](#type-paymentsessionstatus)
     * [Type `RemoveTlcReason`](#type-removetlcreason)
     * [Type `UdtArgInfo`](#type-udtarginfo)
     * [Type `UdtCellDep`](#type-udtcelldep)
@@ -149,7 +151,7 @@ Attempts to open a channel with a peer.
 
 ##### Params
 
-* `peer_id` - PeerId, The peer ID to open a channel with.
+* `peer_id` - PeerId, The peer ID to open a channel with, the peer must be connected through the [connect_peer](#peer-connect_peer) rpc first.
 * `funding_amount` - u128, The amount of CKB or UDT to fund the channel with.
 * `public` - `Option<bool>`, Whether this is a public channel (will be broadcasted to network, and can be used to forward TLCs), an optional parameter, default value is true.
 * `funding_udt_type_script` - `Option<Script>`, The type script of the UDT to fund the channel with, an optional parameter.
@@ -219,54 +221,6 @@ Lists all channels.
 * `channels` - `Vec<Channel>`, The list of channels
 
 
-<a id="channel-commitment_signed"></a>
-#### Method `commitment_signed`
-
-Sends a commitment_signed message to the peer.
-
-##### Params
-
-* `channel_id` - Hash256, The channel ID of the channel to send the commitment_signed message to
-
-##### Returns
-
-* None
-
-
-<a id="channel-add_tlc"></a>
-#### Method `add_tlc`
-
-Adds a TLC to a channel.
-
-##### Params
-
-* `channel_id` - Hash256, The channel ID of the channel to add the TLC to
-* `amount` - u128, The amount of the TLC
-* `payment_hash` - Hash256, The payment hash of the TLC
-* `expiry` - u64, The expiry of the TLC
-* `hash_algorithm` - `Option<HashAlgorithm>`, The hash algorithm of the TLC
-
-##### Returns
-
-* `tlc_id` - u64, The ID of the TLC
-
-
-<a id="channel-remove_tlc"></a>
-#### Method `remove_tlc`
-
-Removes a TLC from a channel.
-
-##### Params
-
-* `channel_id` - Hash256, The channel ID of the channel to remove the TLC from
-* `tlc_id` - u64, The ID of the TLC to remove
-* `reason` - RemoveTlcReason, The reason for removing the TLC, either a 32-byte hash for preimage fulfillment or an u32 error code for removal
-
-##### Returns
-
-* None
-
-
 <a id="channel-shutdown_channel"></a>
 #### Method `shutdown_channel`
 
@@ -304,64 +258,58 @@ Updates a channel.
 * None
 
 
-<a id="channel-send_payment"></a>
-#### Method `send_payment`
+<a id="dev"></a>
+### Module `Dev`
+RPC module for development purposes, this module is not intended to be used in production.
+ This module will be disabled in release build.
 
-Sends a payment to a peer.
+
+<a id="dev-commitment_signed"></a>
+#### Method `commitment_signed`
+
+Sends a commitment_signed message to the peer.
 
 ##### Params
 
-* `target_pubkey` - `Option<Pubkey>`, the identifier of the payment target
-* `amount` - `Option<u128>`, the amount of the payment
-* `payment_hash` - `Option<Hash256>`, the hash to use within the payment's HTLC
-* `final_tlc_expiry_delta` - `Option<u64>`, the TLC expiry delta should be used to set the timelock for the final hop, in milliseconds
-* `tlc_expiry_limit` - `Option<u64>`, the TLC expiry limit for the whole payment, in milliseconds, each hop is with a default tlc delta of 1 day
- suppose the payment router is with N hops, the total tlc expiry limit is at least (N-1) days
- this is also the default value for the payment if this parameter is not provided
-* `invoice` - `Option<String>`, the encoded invoice to send to the recipient
-* `timeout` - `Option<u64>`, the payment timeout in seconds, if the payment is not completed within this time, it will be cancelled
-* `max_fee_amount` - `Option<u128>`, the maximum fee amounts in shannons that the sender is willing to pay
-* `max_parts` - `Option<u64>`, max parts for the payment, only used for multi-part payments
-* `keysend` - `Option<bool>`, keysend payment
-* `udt_type_script` - `Option<Script>`, udt type script for the payment
-* `allow_self_payment` - `Option<bool>`, allow self payment, default is false
-* `dry_run` - `Option<bool>`, dry_run for payment, used for check whether we can build valid router and the fee for this payment,
- it's useful for the sender to double check the payment before sending it to the network,
- default is false
+* `channel_id` - Hash256, The channel ID of the channel to send the commitment_signed message to
 
 ##### Returns
 
-* `payment_hash` - Hash256, The payment hash of the payment
-* `status` - PaymentSessionStatus, The status of the payment
-* `created_at` - u64, The time the payment was created at, in milliseconds from UNIX epoch
-* `last_updated_at` - u64, The time the payment was last updated at, in milliseconds from UNIX epoch
-* `failed_error` - `Option<String>`, The error message if the payment failed
-* `fee` - u128, fee paid for the payment
+* None
 
 
-<a id="channel-get_payment"></a>
-#### Method `get_payment`
+<a id="dev-add_tlc"></a>
+#### Method `add_tlc`
 
-Retrieves a payment.
+Adds a TLC to a channel.
 
 ##### Params
 
-* `payment_hash` - Hash256, The payment hash of the payment to retrieve
+* `channel_id` - Hash256, The channel ID of the channel to add the TLC to
+* `amount` - u128, The amount of the TLC
+* `payment_hash` - Hash256, The payment hash of the TLC
+* `expiry` - u64, The expiry of the TLC
+* `hash_algorithm` - `Option<HashAlgorithm>`, The hash algorithm of the TLC
 
 ##### Returns
 
-* `payment_hash` - Hash256, The payment hash of the payment
-* `status` - PaymentSessionStatus, The status of the payment
-* `created_at` - u64, The time the payment was created at, in milliseconds from UNIX epoch
-* `last_updated_at` - u64, The time the payment was last updated at, in milliseconds from UNIX epoch
-* `failed_error` - `Option<String>`, The error message if the payment failed
-* `fee` - u128, fee paid for the payment
+* `tlc_id` - u64, The ID of the TLC
 
 
-<a id="dev"></a>
-### Module `Dev`
-RPC module for development purposes, this module is not intended to be used in production.
- This module will be disabled in release build.
+<a id="dev-remove_tlc"></a>
+#### Method `remove_tlc`
+
+Removes a TLC from a channel.
+
+##### Params
+
+* `channel_id` - Hash256, The channel ID of the channel to remove the TLC from
+* `tlc_id` - u64, The ID of the TLC to remove
+* `reason` - RemoveTlcReason, The reason for removing the TLC, either a 32-byte hash for preimage fulfillment or an u32 error code for removal
+
+##### Returns
+
+* None
 
 
 <a id="dev-submit_commitment_transaction"></a>
@@ -433,13 +381,13 @@ Get the node information.
 
 * `version` - String, The version of the node software.
 * `commit_hash` - String, The commit hash of the node software.
-* `public_key` - Pubkey, The public key of the node.
+* `node_id` - Pubkey, The identity public key of the node.
 * `node_name` - `Option<String>`, The optional name of the node.
-* `peer_id` - PeerId, The peer ID of the node, serialized as a string.
 * `addresses` - `Vec<MultiAddr>`, A list of multi-addresses associated with the node.
 * `chain_hash` - Hash256, The hash of the blockchain that the node is connected to.
 * `open_channel_auto_accept_min_ckb_funding_amount` - u64, The minimum CKB funding amount for automatically accepting open channel requests, serialized as a hexadecimal string.
 * `auto_accept_channel_ckb_funding_amount` - u64, The CKB funding amount for automatically accepting channel requests, serialized as a hexadecimal string.
+* `default_funding_lock_script` - Script, The default funding lock script for the node.
 * `tlc_expiry_delta` - u64, The locktime expiry delta for Time-Locked Contracts (TLC), serialized as a hexadecimal string.
 * `tlc_min_value` - u128, The minimum value for Time-Locked Contracts (TLC), serialized as a hexadecimal string.
 * `tlc_max_value` - u128, The maximum value for Time-Locked Contracts (TLC), serialized as a hexadecimal string, `0` means no maximum value limit.
@@ -524,6 +472,72 @@ Cancels an invoice, only when invoice is in status `Open` can be canceled.
 * `status` - CkbInvoiceStatus, The invoice status
 
 
+<a id="payment"></a>
+### Module `Payment`
+RPC module for channel management.
+
+
+<a id="payment-send_payment"></a>
+#### Method `send_payment`
+
+Sends a payment to a peer.
+
+##### Params
+
+* `target_pubkey` - `Option<Pubkey>`, the identifier of the payment target
+* `amount` - `Option<u128>`, the amount of the payment
+* `payment_hash` - `Option<Hash256>`, the hash to use within the payment's HTLC
+* `final_tlc_expiry_delta` - `Option<u64>`, the TLC expiry delta should be used to set the timelock for the final hop, in milliseconds
+* `tlc_expiry_limit` - `Option<u64>`, the TLC expiry limit for the whole payment, in milliseconds, each hop is with a default tlc delta of 1 day
+ suppose the payment router is with N hops, the total tlc expiry limit is at least (N-1) days
+ this is also the default value for the payment if this parameter is not provided
+* `invoice` - `Option<String>`, the encoded invoice to send to the recipient
+* `timeout` - `Option<u64>`, the payment timeout in seconds, if the payment is not completed within this time, it will be cancelled
+* `max_fee_amount` - `Option<u128>`, the maximum fee amounts in shannons that the sender is willing to pay
+* `max_parts` - `Option<u64>`, max parts for the payment, only used for multi-part payments
+* `keysend` - `Option<bool>`, keysend payment
+* `udt_type_script` - `Option<Script>`, udt type script for the payment
+* `allow_self_payment` - `Option<bool>`, allow self payment, default is false
+* `hop_hints` - `Option<Vec>`, Optional route hints to reach the destination through private channels.
+ A hop hint is a hint for a node to use a specific channel, for example
+ (pubkey, funding_txid, inbound) where pubkey is the public key of the node,
+ funding_txid is the funding transaction hash of the channel outpoint, and
+ inbound is a boolean indicating whether to use the channel to send or receive.
+ Note: an inproper hint may cause the payment to fail, and hop_hints maybe helpful for self payment scenario
+ for helping the routing algorithm to find the correct path
+* `dry_run` - `Option<bool>`, dry_run for payment, used for check whether we can build valid router and the fee for this payment,
+ it's useful for the sender to double check the payment before sending it to the network,
+ default is false
+
+##### Returns
+
+* `payment_hash` - Hash256, The payment hash of the payment
+* `status` - PaymentSessionStatus, The status of the payment
+* `created_at` - u64, The time the payment was created at, in milliseconds from UNIX epoch
+* `last_updated_at` - u64, The time the payment was last updated at, in milliseconds from UNIX epoch
+* `failed_error` - `Option<String>`, The error message if the payment failed
+* `fee` - u128, fee paid for the payment
+
+
+<a id="payment-get_payment"></a>
+#### Method `get_payment`
+
+Retrieves a payment.
+
+##### Params
+
+* `payment_hash` - Hash256, The payment hash of the payment to retrieve
+
+##### Returns
+
+* `payment_hash` - Hash256, The payment hash of the payment
+* `status` - PaymentSessionStatus, The status of the payment
+* `created_at` - u64, The time the payment was created at, in milliseconds from UNIX epoch
+* `last_updated_at` - u64, The time the payment was last updated at, in milliseconds from UNIX epoch
+* `failed_error` - `Option<String>`, The error message if the payment failed
+* `fee` - u128, fee paid for the payment
+
+
 <a id="peer"></a>
 ### Module `Peer`
 RPC module for peer management.
@@ -670,9 +684,9 @@ The Node information.
 
 #### Fields
 
-* `alias` - String, The alias of the node.
+* `node_name` - String, The name of the node.
 * `addresses` - `Vec<MultiAddr>`, The addresses of the node.
-* `node_id` - Pubkey, The node ID.
+* `node_id` - Pubkey, The identity public key of the node.
 * `timestamp` - u64, The timestamp of the node.
 * `chain_hash` - Hash256, The chain hash of the node.
 * `auto_accept_min_ckb_funding_amount` - u64, The minimum CKB funding amount for automatically accepting open channel requests.
@@ -687,8 +701,8 @@ The Channel information.
 #### Fields
 
 * `channel_outpoint` - OutPoint, The outpoint of the channel.
-* `node1` - Pubkey, The node ID of the first node.
-* `node2` - Pubkey, The node ID of the second node.
+* `node1` - Pubkey, The identity public key of the first node.
+* `node2` - Pubkey, The identity public key of the second node.
 * `created_timestamp` - u64, The created timestamp of the channel, which is the block header timestamp of the block
  that contains the channel funding transaction.
 * `last_updated_timestamp_of_node1` - `Option<u64>`, The timestamp of the last update to channel by node 1 (e.g. updating fee rate).
@@ -699,3 +713,16 @@ The Channel information.
 * `chain_hash` - Hash256, The chain hash of the channel.
 * `udt_type_script` - `Option<Script>`, The UDT type script of the channel.
 
+<a id="#type-paymentsessionstatus"></a>
+### Type `PaymentSessionStatus`
+
+The status of a payment, will update as the payment progresses.
+
+
+#### Enum with values of
+
+* `Created` - , initial status, payment session is created, no HTLC is sent
+* `Inflight` - , the first hop AddTlc is sent successfully and waiting for the response
+* `Success` - , related HTLC is successfully settled
+* `Failed` - , related HTLC is failed
+
diff --git a/src/rpc/channel.rs b/src/rpc/channel.rs
index 474be97cf..17ab7e6b3 100644
--- a/src/rpc/channel.rs
+++ b/src/rpc/channel.rs
@@ -1,21 +1,16 @@
 use crate::fiber::{
     channel::{
-        AddTlcCommand, AwaitingChannelReadyFlags, AwaitingTxSignaturesFlags,
-        ChannelActorStateStore, ChannelCommand, ChannelCommandWithId,
-        ChannelState as RawChannelState, CloseFlags, CollaboratingFundingTxFlags,
-        NegotiatingFundingFlags, RemoveTlcCommand, ShutdownCommand, ShuttingDownFlags,
+        AwaitingChannelReadyFlags, AwaitingTxSignaturesFlags, ChannelActorStateStore,
+        ChannelCommand, ChannelCommandWithId, ChannelState as RawChannelState, CloseFlags,
+        CollaboratingFundingTxFlags, NegotiatingFundingFlags, ShutdownCommand, ShuttingDownFlags,
         SigningCommitmentFlags, UpdateCommand,
     },
-    graph::PaymentSessionStatus,
-    hash_algorithm::HashAlgorithm,
-    network::{AcceptChannelCommand, OpenChannelCommand, SendPaymentCommand},
+    network::{AcceptChannelCommand, OpenChannelCommand},
     serde_utils::{EntityHex, U128Hex, U64Hex},
-    types::{
-        Hash256, Pubkey, RemoveTlcFulfill, TlcErr, TlcErrPacket, TlcErrorCode, NO_SHARED_SECRET,
-    },
+    types::Hash256,
     NetworkActorCommand, NetworkActorMessage,
 };
-use crate::{handle_actor_call, handle_actor_cast, log_and_error};
+use crate::{handle_actor_call, log_and_error};
 use ckb_jsonrpc_types::{EpochNumberWithFraction, Script};
 use ckb_types::{
     core::{EpochNumberWithFraction as EpochNumberWithFractionCore, FeeRate},
@@ -32,13 +27,12 @@ use ractor::{call, ActorRef};
 use serde::{Deserialize, Serialize};
 use serde_with::{serde_as, DisplayFromStr};
 use std::cmp::Reverse;
-use std::str::FromStr;
 use tentacle::secio::PeerId;
 
 #[serde_as]
 #[derive(Serialize, Deserialize, Debug)]
 pub(crate) struct OpenChannelParams {
-    /// The peer ID to open a channel with.
+    /// The peer ID to open a channel with, the peer must be connected through the [connect_peer](#peer-connect_peer) rpc first.
     #[serde_as(as = "DisplayFromStr")]
     peer_id: PeerId,
 
@@ -146,13 +140,6 @@ pub(crate) struct AcceptChannelResult {
     channel_id: Hash256,
 }
 
-// TODO @quake remove this unnecessary pub(crate) struct and rpc after refactoring
-#[derive(Serialize, Deserialize, Debug)]
-pub(crate) struct CommitmentSignedParams {
-    /// The channel ID of the channel to send the commitment_signed message to
-    channel_id: Hash256,
-}
-
 #[serde_as]
 #[derive(Serialize, Deserialize)]
 pub(crate) struct ListChannelsParams {
@@ -259,54 +246,6 @@ pub(crate) struct Channel {
     created_at: u64,
 }
 
-#[serde_as]
-#[derive(Serialize, Deserialize, Debug)]
-pub(crate) struct AddTlcParams {
-    /// The channel ID of the channel to add the TLC to
-    channel_id: Hash256,
-    /// The amount of the TLC
-    #[serde_as(as = "U128Hex")]
-    amount: u128,
-    /// The payment hash of the TLC
-    payment_hash: Hash256,
-    /// The expiry of the TLC
-    #[serde_as(as = "U64Hex")]
-    expiry: u64,
-    /// The hash algorithm of the TLC
-    hash_algorithm: Option<HashAlgorithm>,
-}
-
-#[serde_as]
-#[derive(Clone, Serialize)]
-pub(crate) struct AddTlcResult {
-    /// The ID of the TLC
-    #[serde_as(as = "U64Hex")]
-    tlc_id: u64,
-}
-
-#[serde_as]
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub(crate) struct RemoveTlcParams {
-    /// The channel ID of the channel to remove the TLC from
-    channel_id: Hash256,
-    #[serde_as(as = "U64Hex")]
-    /// The ID of the TLC to remove
-    tlc_id: u64,
-    /// The reason for removing the TLC, either a 32-byte hash for preimage fulfillment or an u32 error code for removal
-    reason: RemoveTlcReason,
-}
-
-/// The reason for removing a TLC
-#[serde_as]
-#[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(untagged)]
-enum RemoveTlcReason {
-    /// The reason for removing the TLC is that it was fulfilled
-    RemoveTlcFulfill { payment_preimage: Hash256 },
-    /// The reason for removing the TLC is that it failed
-    RemoveTlcFail { error_code: String },
-}
-
 #[serde_as]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub(crate) struct ShutdownChannelParams {
@@ -340,86 +279,6 @@ pub struct UpdateChannelParams {
     tlc_fee_proportional_millionths: Option<u128>,
 }
 
-#[serde_as]
-#[derive(Serialize, Deserialize, Debug)]
-pub struct GetPaymentCommandParams {
-    /// The payment hash of the payment to retrieve
-    pub payment_hash: Hash256,
-}
-
-#[serde_as]
-#[derive(Serialize, Deserialize, Clone)]
-pub struct GetPaymentCommandResult {
-    /// The payment hash of the payment
-    pub payment_hash: Hash256,
-    /// The status of the payment
-    pub status: PaymentSessionStatus,
-    #[serde_as(as = "U64Hex")]
-    /// The time the payment was created at, in milliseconds from UNIX epoch
-    created_at: u64,
-    #[serde_as(as = "U64Hex")]
-    /// The time the payment was last updated at, in milliseconds from UNIX epoch
-    pub last_updated_at: u64,
-    /// The error message if the payment failed
-    pub failed_error: Option<String>,
-    /// fee paid for the payment
-    #[serde_as(as = "U128Hex")]
-    pub fee: u128,
-}
-
-#[serde_as]
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub(crate) struct SendPaymentCommandParams {
-    /// the identifier of the payment target
-    target_pubkey: Option<Pubkey>,
-
-    /// the amount of the payment
-    #[serde_as(as = "Option<U128Hex>")]
-    amount: Option<u128>,
-
-    /// the hash to use within the payment's HTLC
-    payment_hash: Option<Hash256>,
-
-    /// the TLC expiry delta should be used to set the timelock for the final hop, in milliseconds
-    #[serde_as(as = "Option<U64Hex>")]
-    final_tlc_expiry_delta: Option<u64>,
-
-    /// the TLC expiry limit for the whole payment, in milliseconds, each hop is with a default tlc delta of 1 day
-    /// suppose the payment router is with N hops, the total tlc expiry limit is at least (N-1) days
-    /// this is also the default value for the payment if this parameter is not provided
-    #[serde_as(as = "Option<U64Hex>")]
-    tlc_expiry_limit: Option<u64>,
-
-    /// the encoded invoice to send to the recipient
-    invoice: Option<String>,
-
-    /// the payment timeout in seconds, if the payment is not completed within this time, it will be cancelled
-    #[serde_as(as = "Option<U64Hex>")]
-    timeout: Option<u64>,
-
-    /// the maximum fee amounts in shannons that the sender is willing to pay
-    #[serde_as(as = "Option<U128Hex>")]
-    max_fee_amount: Option<u128>,
-
-    /// max parts for the payment, only used for multi-part payments
-    #[serde_as(as = "Option<U64Hex>")]
-    max_parts: Option<u64>,
-
-    /// keysend payment
-    keysend: Option<bool>,
-
-    /// udt type script for the payment
-    udt_type_script: Option<Script>,
-
-    /// allow self payment, default is false
-    allow_self_payment: Option<bool>,
-
-    /// dry_run for payment, used for check whether we can build valid router and the fee for this payment,
-    /// it's useful for the sender to double check the payment before sending it to the network,
-    /// default is false
-    dry_run: Option<bool>,
-}
-
 /// RPC module for channel management.
 #[rpc(server)]
 trait ChannelRpc {
@@ -444,21 +303,6 @@ trait ChannelRpc {
         params: ListChannelsParams,
     ) -> Result<ListChannelsResult, ErrorObjectOwned>;
 
-    /// Sends a commitment_signed message to the peer.
-    #[method(name = "commitment_signed")]
-    async fn commitment_signed(
-        &self,
-        params: CommitmentSignedParams,
-    ) -> Result<(), ErrorObjectOwned>;
-
-    /// Adds a TLC to a channel.
-    #[method(name = "add_tlc")]
-    async fn add_tlc(&self, params: AddTlcParams) -> Result<AddTlcResult, ErrorObjectOwned>;
-
-    /// Removes a TLC from a channel.
-    #[method(name = "remove_tlc")]
-    async fn remove_tlc(&self, params: RemoveTlcParams) -> Result<(), ErrorObjectOwned>;
-
     /// Shuts down a channel.
     #[method(name = "shutdown_channel")]
     async fn shutdown_channel(&self, params: ShutdownChannelParams)
@@ -467,20 +311,6 @@ trait ChannelRpc {
     /// Updates a channel.
     #[method(name = "update_channel")]
     async fn update_channel(&self, params: UpdateChannelParams) -> Result<(), ErrorObjectOwned>;
-
-    /// Sends a payment to a peer.
-    #[method(name = "send_payment")]
-    async fn send_payment(
-        &self,
-        params: SendPaymentCommandParams,
-    ) -> Result<GetPaymentCommandResult, ErrorObjectOwned>;
-
-    /// Retrieves a payment.
-    #[method(name = "get_payment")]
-    async fn get_payment(
-        &self,
-        params: GetPaymentCommandParams,
-    ) -> Result<GetPaymentCommandResult, ErrorObjectOwned>;
 }
 
 pub(crate) struct ChannelRpcServerImpl<S> {
@@ -600,91 +430,6 @@ where
         Ok(ListChannelsResult { channels })
     }
 
-    async fn commitment_signed(
-        &self,
-        params: CommitmentSignedParams,
-    ) -> Result<(), ErrorObjectOwned> {
-        let message = NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
-            ChannelCommandWithId {
-                channel_id: params.channel_id,
-                command: ChannelCommand::CommitmentSigned(),
-            },
-        ));
-        handle_actor_cast!(self.actor, message, params)
-    }
-
-    async fn add_tlc(&self, params: AddTlcParams) -> Result<AddTlcResult, ErrorObjectOwned> {
-        let message = |rpc_reply| -> NetworkActorMessage {
-            NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
-                ChannelCommandWithId {
-                    channel_id: params.channel_id,
-                    command: ChannelCommand::AddTlc(
-                        AddTlcCommand {
-                            amount: params.amount,
-                            payment_hash: params.payment_hash,
-                            expiry: params.expiry,
-                            hash_algorithm: params.hash_algorithm.unwrap_or_default(),
-                            onion_packet: None,
-                            shared_secret: NO_SHARED_SECRET.clone(),
-                            previous_tlc: None,
-                        },
-                        rpc_reply,
-                    ),
-                },
-            ))
-        };
-        handle_actor_call!(self.actor, message, params).map(|response| AddTlcResult {
-            tlc_id: response.tlc_id,
-        })
-    }
-
-    async fn remove_tlc(&self, params: RemoveTlcParams) -> Result<(), ErrorObjectOwned> {
-        let err_code = match &params.reason {
-            RemoveTlcReason::RemoveTlcFail { error_code } => {
-                let Ok(err) = TlcErrorCode::from_str(&error_code) else {
-                    return log_and_error!(params, format!("invalid error code: {}", error_code));
-                };
-                Some(err)
-            }
-            _ => None,
-        };
-        let message = |rpc_reply| -> NetworkActorMessage {
-            NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
-                ChannelCommandWithId {
-                    channel_id: params.channel_id,
-                    command: ChannelCommand::RemoveTlc(
-                        RemoveTlcCommand {
-                            id: params.tlc_id,
-                            reason: match &params.reason {
-                                RemoveTlcReason::RemoveTlcFulfill { payment_preimage } => {
-                                    crate::fiber::types::RemoveTlcReason::RemoveTlcFulfill(
-                                        RemoveTlcFulfill {
-                                            payment_preimage: *payment_preimage,
-                                        },
-                                    )
-                                }
-                                RemoveTlcReason::RemoveTlcFail { .. } => {
-                                    // TODO: maybe we should remove this PRC or move add_tlc and remove_tlc to `test` module?
-                                    crate::fiber::types::RemoveTlcReason::RemoveTlcFail(
-                                        TlcErrPacket::new(
-                                            TlcErr::new(err_code.expect("expect error code")),
-                                            // Do not encrypt the error message when removing the TLC via RPC.
-                                            // TODO: use tlc id to look up the shared secret in the store
-                                            &NO_SHARED_SECRET,
-                                        ),
-                                    )
-                                }
-                            },
-                        },
-                        rpc_reply,
-                    ),
-                },
-            ))
-        };
-
-        handle_actor_call!(self.actor, message, params)
-    }
-
     async fn shutdown_channel(
         &self,
         params: ShutdownChannelParams,
@@ -726,58 +471,4 @@ where
         };
         handle_actor_call!(self.actor, message, params)
     }
-
-    async fn send_payment(
-        &self,
-        params: SendPaymentCommandParams,
-    ) -> Result<GetPaymentCommandResult, ErrorObjectOwned> {
-        let message = |rpc_reply| -> NetworkActorMessage {
-            NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
-                SendPaymentCommand {
-                    target_pubkey: params.target_pubkey,
-                    amount: params.amount,
-                    payment_hash: params.payment_hash,
-                    final_tlc_expiry_delta: params.final_tlc_expiry_delta,
-                    tlc_expiry_limit: params.tlc_expiry_limit,
-                    invoice: params.invoice.clone(),
-                    timeout: params.timeout,
-                    max_fee_amount: params.max_fee_amount,
-                    max_parts: params.max_parts,
-                    keysend: params.keysend,
-                    udt_type_script: params.udt_type_script.clone().map(|s| s.into()),
-                    allow_self_payment: params.allow_self_payment.unwrap_or(false),
-                    dry_run: params.dry_run.unwrap_or(false),
-                },
-                rpc_reply,
-            ))
-        };
-        handle_actor_call!(self.actor, message, params).map(|response| GetPaymentCommandResult {
-            payment_hash: response.payment_hash,
-            status: response.status,
-            created_at: response.created_at,
-            last_updated_at: response.last_updated_at,
-            failed_error: response.failed_error,
-            fee: response.fee,
-        })
-    }
-
-    async fn get_payment(
-        &self,
-        params: GetPaymentCommandParams,
-    ) -> Result<GetPaymentCommandResult, ErrorObjectOwned> {
-        let message = |rpc_reply| -> NetworkActorMessage {
-            NetworkActorMessage::Command(NetworkActorCommand::GetPayment(
-                params.payment_hash,
-                rpc_reply,
-            ))
-        };
-        handle_actor_call!(self.actor, message, params).map(|response| GetPaymentCommandResult {
-            payment_hash: response.payment_hash,
-            status: response.status,
-            last_updated_at: response.last_updated_at,
-            created_at: response.created_at,
-            failed_error: response.failed_error,
-            fee: response.fee,
-        })
-    }
 }
diff --git a/src/rpc/config.rs b/src/rpc/config.rs
index aea3391ec..a7e056989 100644
--- a/src/rpc/config.rs
+++ b/src/rpc/config.rs
@@ -1,6 +1,6 @@
 use clap_serde_derive::ClapSerde;
 
-const DEFAULT_ENABLED_MODULES: &str = "cch,channel,graph,info,invoice,peer";
+const DEFAULT_ENABLED_MODULES: &str = "cch,channel,graph,payment,info,invoice,peer";
 
 #[derive(ClapSerde, Debug, Clone)]
 pub struct RpcConfig {
diff --git a/src/rpc/dev.rs b/src/rpc/dev.rs
index be9133b5b..3584e0505 100644
--- a/src/rpc/dev.rs
+++ b/src/rpc/dev.rs
@@ -1,11 +1,22 @@
-use std::{collections::HashMap, sync::Arc};
-
+use crate::{
+    fiber::{
+        channel::{AddTlcCommand, ChannelCommand, ChannelCommandWithId, RemoveTlcCommand},
+        hash_algorithm::HashAlgorithm,
+        serde_utils::{U128Hex, U64Hex},
+        types::{Hash256, RemoveTlcFulfill, TlcErr, TlcErrPacket, TlcErrorCode, NO_SHARED_SECRET},
+        NetworkActorCommand, NetworkActorMessage,
+    },
+    handle_actor_cast,
+};
 use ckb_types::core::TransactionView;
 use jsonrpsee::{
     core::async_trait,
     proc_macros::rpc,
     types::{error::CALL_EXECUTION_FAILED_CODE, ErrorObjectOwned},
 };
+use ractor::call;
+use std::str::FromStr;
+use std::{collections::HashMap, sync::Arc};
 
 use ractor::{call_t, ActorRef};
 use serde::{Deserialize, Serialize};
@@ -13,10 +24,65 @@ use serde_with::serde_as;
 use tokio::sync::RwLock;
 
 use crate::{
-    ckb::CkbChainMessage,
-    fiber::{network::DEFAULT_CHAIN_ACTOR_TIMEOUT, serde_utils::U64Hex, types::Hash256},
+    ckb::CkbChainMessage, fiber::network::DEFAULT_CHAIN_ACTOR_TIMEOUT, handle_actor_call,
+    log_and_error,
 };
 
+// TODO @quake remove this unnecessary pub(crate) struct and rpc after refactoring
+#[derive(Serialize, Deserialize, Debug)]
+pub(crate) struct CommitmentSignedParams {
+    /// The channel ID of the channel to send the commitment_signed message to
+    channel_id: Hash256,
+}
+
+#[serde_as]
+#[derive(Serialize, Deserialize, Debug)]
+pub(crate) struct AddTlcParams {
+    /// The channel ID of the channel to add the TLC to
+    channel_id: Hash256,
+    /// The amount of the TLC
+    #[serde_as(as = "U128Hex")]
+    amount: u128,
+    /// The payment hash of the TLC
+    payment_hash: Hash256,
+    /// The expiry of the TLC
+    #[serde_as(as = "U64Hex")]
+    expiry: u64,
+    /// The hash algorithm of the TLC
+    hash_algorithm: Option<HashAlgorithm>,
+}
+
+#[serde_as]
+#[derive(Clone, Serialize)]
+pub(crate) struct AddTlcResult {
+    /// The ID of the TLC
+    #[serde_as(as = "U64Hex")]
+    tlc_id: u64,
+}
+
+#[serde_as]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub(crate) struct RemoveTlcParams {
+    /// The channel ID of the channel to remove the TLC from
+    channel_id: Hash256,
+    #[serde_as(as = "U64Hex")]
+    /// The ID of the TLC to remove
+    tlc_id: u64,
+    /// The reason for removing the TLC, either a 32-byte hash for preimage fulfillment or an u32 error code for removal
+    reason: RemoveTlcReason,
+}
+
+/// The reason for removing a TLC
+#[serde_as]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+enum RemoveTlcReason {
+    /// The reason for removing the TLC is that it was fulfilled
+    RemoveTlcFulfill { payment_preimage: Hash256 },
+    /// The reason for removing the TLC is that it failed
+    RemoveTlcFail { error_code: String },
+}
+
 #[serde_as]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub(crate) struct SubmitCommitmentTransactionParams {
@@ -39,6 +105,21 @@ pub(crate) struct SubmitCommitmentTransactionResult {
 /// This module will be disabled in release build.
 #[rpc(server)]
 trait DevRpc {
+    /// Sends a commitment_signed message to the peer.
+    #[method(name = "commitment_signed")]
+    async fn commitment_signed(
+        &self,
+        params: CommitmentSignedParams,
+    ) -> Result<(), ErrorObjectOwned>;
+
+    /// Adds a TLC to a channel.
+    #[method(name = "add_tlc")]
+    async fn add_tlc(&self, params: AddTlcParams) -> Result<AddTlcResult, ErrorObjectOwned>;
+
+    /// Removes a TLC from a channel.
+    #[method(name = "remove_tlc")]
+    async fn remove_tlc(&self, params: RemoveTlcParams) -> Result<(), ErrorObjectOwned>;
+
     /// Submit a commitment transaction to the chain
     #[method(name = "submit_commitment_transaction")]
     async fn submit_commitment_transaction(
@@ -49,16 +130,19 @@ trait DevRpc {
 
 pub(crate) struct DevRpcServerImpl {
     ckb_chain_actor: ActorRef<CkbChainMessage>,
+    network_actor: ActorRef<NetworkActorMessage>,
     commitment_txs: Arc<RwLock<HashMap<(Hash256, u64), TransactionView>>>,
 }
 
 impl DevRpcServerImpl {
     pub(crate) fn new(
         ckb_chain_actor: ActorRef<CkbChainMessage>,
+        network_actor: ActorRef<NetworkActorMessage>,
         commitment_txs: Arc<RwLock<HashMap<(Hash256, u64), TransactionView>>>,
     ) -> Self {
         Self {
             ckb_chain_actor,
+            network_actor,
             commitment_txs,
         }
     }
@@ -66,6 +150,91 @@ impl DevRpcServerImpl {
 
 #[async_trait]
 impl DevRpcServer for DevRpcServerImpl {
+    async fn commitment_signed(
+        &self,
+        params: CommitmentSignedParams,
+    ) -> Result<(), ErrorObjectOwned> {
+        let message = NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: params.channel_id,
+                command: ChannelCommand::CommitmentSigned(),
+            },
+        ));
+        handle_actor_cast!(self.network_actor, message, params)
+    }
+
+    async fn add_tlc(&self, params: AddTlcParams) -> Result<AddTlcResult, ErrorObjectOwned> {
+        let message = |rpc_reply| -> NetworkActorMessage {
+            NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+                ChannelCommandWithId {
+                    channel_id: params.channel_id,
+                    command: ChannelCommand::AddTlc(
+                        AddTlcCommand {
+                            amount: params.amount,
+                            payment_hash: params.payment_hash,
+                            expiry: params.expiry,
+                            hash_algorithm: params.hash_algorithm.unwrap_or_default(),
+                            onion_packet: None,
+                            shared_secret: NO_SHARED_SECRET.clone(),
+                            previous_tlc: None,
+                        },
+                        rpc_reply,
+                    ),
+                },
+            ))
+        };
+        handle_actor_call!(self.network_actor, message, params).map(|response| AddTlcResult {
+            tlc_id: response.tlc_id,
+        })
+    }
+
+    async fn remove_tlc(&self, params: RemoveTlcParams) -> Result<(), ErrorObjectOwned> {
+        let err_code = match &params.reason {
+            RemoveTlcReason::RemoveTlcFail { error_code } => {
+                let Ok(err) = TlcErrorCode::from_str(&error_code) else {
+                    return log_and_error!(params, format!("invalid error code: {}", error_code));
+                };
+                Some(err)
+            }
+            _ => None,
+        };
+        let message = |rpc_reply| -> NetworkActorMessage {
+            NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+                ChannelCommandWithId {
+                    channel_id: params.channel_id,
+                    command: ChannelCommand::RemoveTlc(
+                        RemoveTlcCommand {
+                            id: params.tlc_id,
+                            reason: match &params.reason {
+                                RemoveTlcReason::RemoveTlcFulfill { payment_preimage } => {
+                                    crate::fiber::types::RemoveTlcReason::RemoveTlcFulfill(
+                                        RemoveTlcFulfill {
+                                            payment_preimage: *payment_preimage,
+                                        },
+                                    )
+                                }
+                                RemoveTlcReason::RemoveTlcFail { .. } => {
+                                    // TODO: maybe we should remove this PRC or move add_tlc and remove_tlc to `test` module?
+                                    crate::fiber::types::RemoveTlcReason::RemoveTlcFail(
+                                        TlcErrPacket::new(
+                                            TlcErr::new(err_code.expect("expect error code")),
+                                            // Do not encrypt the error message when removing the TLC via RPC.
+                                            // TODO: use tlc id to look up the shared secret in the store
+                                            &NO_SHARED_SECRET,
+                                        ),
+                                    )
+                                }
+                            },
+                        },
+                        rpc_reply,
+                    ),
+                },
+            ))
+        };
+
+        handle_actor_call!(self.network_actor, message, params)
+    }
+
     async fn submit_commitment_transaction(
         &self,
         params: SubmitCommitmentTransactionParams,
diff --git a/src/rpc/graph.rs b/src/rpc/graph.rs
index 6e5182fa8..9e20faec8 100644
--- a/src/rpc/graph.rs
+++ b/src/rpc/graph.rs
@@ -105,11 +105,11 @@ impl From<ConfigUdtCfgInfos> for UdtCfgInfos {
 #[serde_as]
 #[derive(Serialize, Deserialize, Clone)]
 struct NodeInfo {
-    /// The alias of the node.
-    alias: String,
+    /// The name of the node.
+    node_name: String,
     /// The addresses of the node.
     addresses: Vec<MultiAddr>,
-    /// The node ID.
+    /// The identity public key of the node.
     node_id: Pubkey,
     #[serde_as(as = "U64Hex")]
     /// The timestamp of the node.
@@ -126,7 +126,7 @@ struct NodeInfo {
 impl From<super::super::fiber::graph::NodeInfo> for NodeInfo {
     fn from(value: super::super::fiber::graph::NodeInfo) -> Self {
         NodeInfo {
-            alias: value.alias.to_string(),
+            node_name: value.node_name.to_string(),
             addresses: value.addresses,
             node_id: value.node_id,
             timestamp: value.timestamp,
@@ -162,9 +162,9 @@ struct ChannelInfo {
     /// The outpoint of the channel.
     #[serde_as(as = "EntityHex")]
     channel_outpoint: OutPoint,
-    /// The node ID of the first node.
+    /// The identity public key of the first node.
     node1: Pubkey,
-    /// The node ID of the second node.
+    /// The identity public key of the second node.
     node2: Pubkey,
     /// The created timestamp of the channel, which is the block header timestamp of the block
     /// that contains the channel funding transaction.
diff --git a/src/rpc/info.rs b/src/rpc/info.rs
index ef5648946..eaca20ba3 100644
--- a/src/rpc/info.rs
+++ b/src/rpc/info.rs
@@ -1,12 +1,13 @@
 use super::graph::UdtCfgInfos;
+use crate::ckb::CkbConfig;
 use crate::fiber::serde_utils::U32Hex;
 use crate::fiber::{
-    channel::ChannelActorStateStore,
     serde_utils::{U128Hex, U64Hex},
     types::{Hash256, Pubkey},
     NetworkActorCommand, NetworkActorMessage,
 };
 use crate::{handle_actor_call, log_and_error};
+use ckb_jsonrpc_types::Script;
 use jsonrpsee::{
     core::async_trait,
     proc_macros::rpc,
@@ -14,8 +15,8 @@ use jsonrpsee::{
 };
 use ractor::{call, ActorRef};
 use serde::{Deserialize, Serialize};
-use serde_with::{serde_as, DisplayFromStr};
-use tentacle::{multiaddr::MultiAddr, secio::PeerId};
+use serde_with::serde_as;
+use tentacle::multiaddr::MultiAddr;
 
 #[serde_as]
 #[derive(Clone, Serialize, Deserialize)]
@@ -26,16 +27,12 @@ pub(crate) struct NodeInfoResult {
     /// The commit hash of the node software.
     commit_hash: String,
 
-    /// The public key of the node.
-    public_key: Pubkey,
+    /// The identity public key of the node.
+    node_id: Pubkey,
 
     /// The optional name of the node.
     node_name: Option<String>,
 
-    /// The peer ID of the node, serialized as a string.
-    #[serde_as(as = "DisplayFromStr")]
-    peer_id: PeerId,
-
     /// A list of multi-addresses associated with the node.
     addresses: Vec<MultiAddr>,
 
@@ -50,6 +47,9 @@ pub(crate) struct NodeInfoResult {
     #[serde_as(as = "U64Hex")]
     auto_accept_channel_ckb_funding_amount: u64,
 
+    /// The default funding lock script for the node.
+    default_funding_lock_script: Script,
+
     /// The locktime expiry delta for Time-Locked Contracts (TLC), serialized as a hexadecimal string.
     #[serde_as(as = "U64Hex")]
     tlc_expiry_delta: u64,
@@ -82,14 +82,21 @@ pub(crate) struct NodeInfoResult {
     udt_cfg_infos: UdtCfgInfos,
 }
 
-pub(crate) struct InfoRpcServerImpl<S> {
+pub(crate) struct InfoRpcServerImpl {
     actor: ActorRef<NetworkActorMessage>,
-    _store: S,
+    default_funding_lock_script: Script,
 }
 
-impl<S> InfoRpcServerImpl<S> {
-    pub(crate) fn new(actor: ActorRef<NetworkActorMessage>, _store: S) -> Self {
-        InfoRpcServerImpl { actor, _store }
+impl InfoRpcServerImpl {
+    pub(crate) fn new(actor: ActorRef<NetworkActorMessage>, config: CkbConfig) -> Self {
+        let default_funding_lock_script = config
+            .get_default_funding_lock_script()
+            .expect("get default funding lock script should be ok")
+            .into();
+        InfoRpcServerImpl {
+            actor,
+            default_funding_lock_script,
+        }
     }
 }
 
@@ -102,13 +109,10 @@ trait InfoRpc {
 }
 
 #[async_trait]
-impl<S> InfoRpcServer for InfoRpcServerImpl<S>
-where
-    S: ChannelActorStateStore + Send + Sync + 'static,
-{
+impl InfoRpcServer for InfoRpcServerImpl {
     async fn node_info(&self) -> Result<NodeInfoResult, ErrorObjectOwned> {
         let version = env!("CARGO_PKG_VERSION").to_string();
-        let commit_hash = crate::get_git_versin().to_string();
+        let commit_hash = crate::get_git_version().to_string();
 
         let message =
             |rpc_reply| NetworkActorMessage::Command(NetworkActorCommand::NodeInfo((), rpc_reply));
@@ -116,14 +120,14 @@ where
         handle_actor_call!(self.actor, message, ()).map(|response| NodeInfoResult {
             version,
             commit_hash,
-            public_key: response.public_key,
+            node_id: response.node_id,
             node_name: response.node_name.map(|name| name.to_string()),
-            peer_id: response.peer_id,
             addresses: response.addresses,
             chain_hash: response.chain_hash,
             open_channel_auto_accept_min_ckb_funding_amount: response
                 .open_channel_auto_accept_min_ckb_funding_amount,
             auto_accept_channel_ckb_funding_amount: response.auto_accept_channel_ckb_funding_amount,
+            default_funding_lock_script: self.default_funding_lock_script.clone(),
             tlc_expiry_delta: response.tlc_expiry_delta,
             tlc_min_value: response.tlc_min_value,
             tlc_max_value: response.tlc_max_value,
diff --git a/src/rpc/mod.rs b/src/rpc/mod.rs
index c85d90a75..b62c81285 100644
--- a/src/rpc/mod.rs
+++ b/src/rpc/mod.rs
@@ -6,11 +6,14 @@ mod dev;
 mod graph;
 mod info;
 mod invoice;
+mod payment;
 mod peer;
 mod utils;
 
+use crate::ckb::CkbConfig;
 use crate::fiber::gossip::GossipMessageStore;
 use crate::rpc::info::InfoRpcServer;
+use crate::rpc::payment::PaymentRpcServer;
 use crate::{
     cch::CchMessage,
     fiber::{
@@ -35,6 +38,7 @@ use info::InfoRpcServerImpl;
 use invoice::{InvoiceRpcServer, InvoiceRpcServerImpl};
 use jsonrpsee::server::{Server, ServerHandle};
 use jsonrpsee::RpcModule;
+use payment::PaymentRpcServerImpl;
 use peer::{PeerRpcServer, PeerRpcServerImpl};
 use ractor::ActorRef;
 #[cfg(debug_assertions)]
@@ -86,6 +90,7 @@ pub async fn start_rpc<
         + 'static,
 >(
     config: RpcConfig,
+    ckb_config: Option<CkbConfig>,
     fiber_config: Option<FiberConfig>,
     network_actor: Option<ActorRef<NetworkActorMessage>>,
     cch_actor: Option<ActorRef<CchMessage>>,
@@ -112,7 +117,13 @@ pub async fn start_rpc<
     if let Some(network_actor) = network_actor {
         if config.is_module_enabled("info") {
             modules
-                .merge(InfoRpcServerImpl::new(network_actor.clone(), store.clone()).into_rpc())
+                .merge(
+                    InfoRpcServerImpl::new(
+                        network_actor.clone(),
+                        ckb_config.expect("ckb config should be set"),
+                    )
+                    .into_rpc(),
+                )
                 .unwrap();
         }
 
@@ -128,12 +139,19 @@ pub async fn start_rpc<
                 .unwrap();
         }
 
+        if config.is_module_enabled("payment") {
+            modules
+                .merge(PaymentRpcServerImpl::new(network_actor.clone(), store.clone()).into_rpc())
+                .unwrap();
+        }
+
         #[cfg(debug_assertions)]
         if config.is_module_enabled("dev") {
             modules
                 .merge(
                     DevRpcServerImpl::new(
                         ckb_chain_actor.expect("ckb_chain_actor should be set"),
+                        network_actor.clone(),
                         rpc_dev_module_commitment_txs
                             .expect("rpc_dev_module_commitment_txs should be set"),
                     )
diff --git a/src/rpc/payment.rs b/src/rpc/payment.rs
new file mode 100644
index 000000000..381f93dfd
--- /dev/null
+++ b/src/rpc/payment.rs
@@ -0,0 +1,245 @@
+use crate::fiber::{
+    channel::ChannelActorStateStore,
+    graph::PaymentSessionStatus as InnerPaymentSessionStatus,
+    network::{HopHint as NetworkHopHint, SendPaymentCommand},
+    serde_utils::{U128Hex, U64Hex},
+    types::{Hash256, Pubkey},
+    NetworkActorCommand, NetworkActorMessage,
+};
+use crate::{handle_actor_call, log_and_error};
+use ckb_jsonrpc_types::Script;
+use jsonrpsee::{
+    core::async_trait,
+    proc_macros::rpc,
+    types::{error::CALL_EXECUTION_FAILED_CODE, ErrorObjectOwned},
+};
+use ractor::{call, ActorRef};
+use serde::{Deserialize, Serialize};
+use serde_with::serde_as;
+
+#[serde_as]
+#[derive(Serialize, Deserialize, Debug)]
+pub struct GetPaymentCommandParams {
+    /// The payment hash of the payment to retrieve
+    pub payment_hash: Hash256,
+}
+
+/// The status of a payment, will update as the payment progresses.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum PaymentSessionStatus {
+    /// initial status, payment session is created, no HTLC is sent
+    Created,
+    /// the first hop AddTlc is sent successfully and waiting for the response
+    Inflight,
+    /// related HTLC is successfully settled
+    Success,
+    /// related HTLC is failed
+    Failed,
+}
+
+impl From<InnerPaymentSessionStatus> for PaymentSessionStatus {
+    fn from(status: InnerPaymentSessionStatus) -> Self {
+        match status {
+            InnerPaymentSessionStatus::Created => PaymentSessionStatus::Created,
+            InnerPaymentSessionStatus::Inflight => PaymentSessionStatus::Inflight,
+            InnerPaymentSessionStatus::Success => PaymentSessionStatus::Success,
+            InnerPaymentSessionStatus::Failed => PaymentSessionStatus::Failed,
+        }
+    }
+}
+
+#[serde_as]
+#[derive(Serialize, Deserialize, Clone)]
+pub struct GetPaymentCommandResult {
+    /// The payment hash of the payment
+    pub payment_hash: Hash256,
+    /// The status of the payment
+    pub status: PaymentSessionStatus,
+    #[serde_as(as = "U64Hex")]
+    /// The time the payment was created at, in milliseconds from UNIX epoch
+    created_at: u64,
+    #[serde_as(as = "U64Hex")]
+    /// The time the payment was last updated at, in milliseconds from UNIX epoch
+    pub last_updated_at: u64,
+    /// The error message if the payment failed
+    pub failed_error: Option<String>,
+    /// fee paid for the payment
+    #[serde_as(as = "U128Hex")]
+    pub fee: u128,
+}
+
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub(crate) struct SendPaymentCommandParams {
+    /// the identifier of the payment target
+    target_pubkey: Option<Pubkey>,
+
+    /// the amount of the payment
+    #[serde_as(as = "Option<U128Hex>")]
+    amount: Option<u128>,
+
+    /// the hash to use within the payment's HTLC
+    payment_hash: Option<Hash256>,
+
+    /// the TLC expiry delta should be used to set the timelock for the final hop, in milliseconds
+    #[serde_as(as = "Option<U64Hex>")]
+    final_tlc_expiry_delta: Option<u64>,
+
+    /// the TLC expiry limit for the whole payment, in milliseconds, each hop is with a default tlc delta of 1 day
+    /// suppose the payment router is with N hops, the total tlc expiry limit is at least (N-1) days
+    /// this is also the default value for the payment if this parameter is not provided
+    #[serde_as(as = "Option<U64Hex>")]
+    tlc_expiry_limit: Option<u64>,
+
+    /// the encoded invoice to send to the recipient
+    invoice: Option<String>,
+
+    /// the payment timeout in seconds, if the payment is not completed within this time, it will be cancelled
+    #[serde_as(as = "Option<U64Hex>")]
+    timeout: Option<u64>,
+
+    /// the maximum fee amounts in shannons that the sender is willing to pay
+    #[serde_as(as = "Option<U128Hex>")]
+    max_fee_amount: Option<u128>,
+
+    /// max parts for the payment, only used for multi-part payments
+    #[serde_as(as = "Option<U64Hex>")]
+    max_parts: Option<u64>,
+
+    /// keysend payment
+    keysend: Option<bool>,
+
+    /// udt type script for the payment
+    udt_type_script: Option<Script>,
+
+    /// allow self payment, default is false
+    allow_self_payment: Option<bool>,
+
+    /// Optional route hints to reach the destination through private channels.
+    /// A hop hint is a hint for a node to use a specific channel, for example
+    /// (pubkey, funding_txid, inbound) where pubkey is the public key of the node,
+    /// funding_txid is the funding transaction hash of the channel outpoint, and
+    /// inbound is a boolean indicating whether to use the channel to send or receive.
+    /// Note: an inproper hint may cause the payment to fail, and hop_hints maybe helpful for self payment scenario
+    /// for helping the routing algorithm to find the correct path
+    hop_hints: Option<Vec<HopHint>>,
+
+    /// dry_run for payment, used for check whether we can build valid router and the fee for this payment,
+    /// it's useful for the sender to double check the payment before sending it to the network,
+    /// default is false
+    dry_run: Option<bool>,
+}
+
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct HopHint {
+    /// The public key of the node
+    pub pubkey: Pubkey,
+    /// The funding transaction hash of the channel outpoint
+    pub channel_funding_tx: Hash256,
+    /// inbound or outbound to use this channel
+    pub inbound: bool,
+}
+
+impl From<HopHint> for NetworkHopHint {
+    fn from(hop_hint: HopHint) -> Self {
+        NetworkHopHint {
+            pubkey: hop_hint.pubkey,
+            channel_funding_tx: hop_hint.channel_funding_tx,
+            inbound: hop_hint.inbound,
+        }
+    }
+}
+
+/// RPC module for channel management.
+#[rpc(server)]
+trait PaymentRpc {
+    /// Sends a payment to a peer.
+    #[method(name = "send_payment")]
+    async fn send_payment(
+        &self,
+        params: SendPaymentCommandParams,
+    ) -> Result<GetPaymentCommandResult, ErrorObjectOwned>;
+
+    /// Retrieves a payment.
+    #[method(name = "get_payment")]
+    async fn get_payment(
+        &self,
+        params: GetPaymentCommandParams,
+    ) -> Result<GetPaymentCommandResult, ErrorObjectOwned>;
+}
+
+pub(crate) struct PaymentRpcServerImpl<S> {
+    actor: ActorRef<NetworkActorMessage>,
+    _store: S,
+}
+
+impl<S> PaymentRpcServerImpl<S> {
+    pub(crate) fn new(actor: ActorRef<NetworkActorMessage>, _store: S) -> Self {
+        PaymentRpcServerImpl { actor, _store }
+    }
+}
+
+#[async_trait]
+impl<S> PaymentRpcServer for PaymentRpcServerImpl<S>
+where
+    S: ChannelActorStateStore + Send + Sync + 'static,
+{
+    async fn send_payment(
+        &self,
+        params: SendPaymentCommandParams,
+    ) -> Result<GetPaymentCommandResult, ErrorObjectOwned> {
+        let message = |rpc_reply| -> NetworkActorMessage {
+            NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+                SendPaymentCommand {
+                    target_pubkey: params.target_pubkey,
+                    amount: params.amount,
+                    payment_hash: params.payment_hash,
+                    final_tlc_expiry_delta: params.final_tlc_expiry_delta,
+                    tlc_expiry_limit: params.tlc_expiry_limit,
+                    invoice: params.invoice.clone(),
+                    timeout: params.timeout,
+                    max_fee_amount: params.max_fee_amount,
+                    max_parts: params.max_parts,
+                    keysend: params.keysend,
+                    udt_type_script: params.udt_type_script.clone().map(|s| s.into()),
+                    allow_self_payment: params.allow_self_payment.unwrap_or(false),
+                    hop_hints: params
+                        .hop_hints
+                        .clone()
+                        .map(|hints| hints.into_iter().map(|hint| hint.into()).collect()),
+                    dry_run: params.dry_run.unwrap_or(false),
+                },
+                rpc_reply,
+            ))
+        };
+        handle_actor_call!(self.actor, message, params).map(|response| GetPaymentCommandResult {
+            payment_hash: response.payment_hash,
+            status: response.status.into(),
+            created_at: response.created_at,
+            last_updated_at: response.last_updated_at,
+            failed_error: response.failed_error,
+            fee: response.fee,
+        })
+    }
+
+    async fn get_payment(
+        &self,
+        params: GetPaymentCommandParams,
+    ) -> Result<GetPaymentCommandResult, ErrorObjectOwned> {
+        let message = |rpc_reply| -> NetworkActorMessage {
+            NetworkActorMessage::Command(NetworkActorCommand::GetPayment(
+                params.payment_hash,
+                rpc_reply,
+            ))
+        };
+        handle_actor_call!(self.actor, message, params).map(|response| GetPaymentCommandResult {
+            payment_hash: response.payment_hash,
+            status: response.status.into(),
+            last_updated_at: response.last_updated_at,
+            created_at: response.created_at,
+            failed_error: response.failed_error,
+            fee: response.fee,
+        })
+    }
+}
diff --git a/src/store/store.rs b/src/store/store.rs
index ce6e30020..c35f2993e 100644
--- a/src/store/store.rs
+++ b/src/store/store.rs
@@ -459,14 +459,14 @@ impl InvoiceStore for Store {
         invoice: CkbInvoice,
         preimage: Option<Hash256>,
     ) -> Result<(), InvoiceError> {
-        let hash = invoice.payment_hash();
-        if self.get_invoice(hash).is_some() {
-            return Err(InvoiceError::DuplicatedInvoice(hash.to_string()));
+        let payment_hash = invoice.payment_hash();
+        if self.get_invoice(payment_hash).is_some() {
+            return Err(InvoiceError::DuplicatedInvoice(payment_hash.to_string()));
         }
 
         let mut batch = self.batch();
         if let Some(preimage) = preimage {
-            batch.put_kv(KeyValue::CkbInvoicePreimage(*hash, preimage));
+            batch.put_kv(KeyValue::CkbInvoicePreimage(*payment_hash, preimage));
         }
         let payment_hash = *invoice.payment_hash();
         batch.put_kv(KeyValue::CkbInvoice(payment_hash, invoice));
@@ -501,6 +501,17 @@ impl InvoiceStore for Store {
         self.get(key)
             .map(|v| deserialize_from(v.as_ref(), "CkbInvoiceStatus"))
     }
+
+    fn insert_payment_preimage(
+        &self,
+        payment_hash: Hash256,
+        preimage: Hash256,
+    ) -> Result<(), InvoiceError> {
+        let mut batch = self.batch();
+        batch.put_kv(KeyValue::CkbInvoicePreimage(payment_hash, preimage));
+        batch.commit();
+        Ok(())
+    }
 }
 
 impl NetworkGraphStateStore for Store {
diff --git a/src/store/tests/store.rs b/src/store/tests/store.rs
index c383cf676..f7d392797 100644
--- a/src/store/tests/store.rs
+++ b/src/store/tests/store.rs
@@ -18,6 +18,7 @@ use crate::watchtower::*;
 use ckb_hash::new_blake2b;
 use ckb_types::packed::*;
 use ckb_types::prelude::*;
+use ckb_types::H256;
 use core::cmp::Ordering;
 use musig2::secp::MaybeScalar;
 use musig2::CompactSignature;
@@ -331,7 +332,7 @@ fn test_channel_actor_state_store() {
         local_pubkey: gen_rand_fiber_public_key(),
         remote_pubkey: gen_rand_fiber_public_key(),
         funding_tx: Some(Transaction::default()),
-        funding_tx_confirmed_at: Some((1.into(), 1)),
+        funding_tx_confirmed_at: Some((H256::default(), 1, 1)),
         is_acceptor: true,
         funding_udt_type_script: Some(Script::default()),
         to_local_amount: 100,
@@ -429,6 +430,7 @@ fn test_store_payment_session() {
         udt_type_script: None,
         preimage: None,
         allow_self_payment: false,
+        hop_hints: vec![],
         dry_run: false,
     };
     let payment_session = PaymentSession::new(payment_data.clone(), 10);
diff --git a/src/tests/mod.rs b/src/tests/mod.rs
index 63e44c98d..7f2f760d9 100644
--- a/src/tests/mod.rs
+++ b/src/tests/mod.rs
@@ -1,13 +1,13 @@
 use ckb_hash::blake2b_256;
-use ckb_sdk::{Since, SinceType};
 use ckb_types::core::TransactionView;
 use ckb_types::packed::CellOutput;
-use ckb_types::prelude::{Builder, Entity};
+use ckb_types::prelude::{Builder, Entity, Unpack};
 use ckb_types::{packed::OutPoint, prelude::Pack};
 use secp256k1::{Keypair, PublicKey, Secp256k1, SecretKey, XOnlyPublicKey};
 
 use crate::ckb::contracts::{get_cell_deps_by_contracts, get_script_by_contract, Contract};
-use crate::fiber::types::EcdsaSignature;
+use crate::fiber::channel::{MESSAGE_OF_NODE1_FLAG, MESSAGE_OF_NODE2_FLAG};
+use crate::fiber::types::{ChannelUpdate, EcdsaSignature};
 use crate::{
     fiber::{
         config::AnnouncedNodeName,
@@ -67,20 +67,11 @@ pub fn gen_node_announcement_from_privkey(sk: &Privkey) -> NodeAnnouncement {
 }
 
 pub fn create_funding_tx(x_only: &XOnlyPublicKey) -> TransactionView {
-    let version = 0u64;
-    let delay_epoch = 42;
     let capacity = 100u64;
-    let commitment_lock_script_args = [
-        &blake2b_256(x_only.serialize())[0..20],
-        (Since::new(SinceType::EpochNumberWithFraction, delay_epoch, true).value())
-            .to_le_bytes()
-            .as_slice(),
-        version.to_be_bytes().as_slice(),
-    ]
-    .concat();
+    let commitment_lock_script_args = [&blake2b_256(x_only.serialize())[0..20]].concat();
 
     TransactionView::new_advanced_builder()
-        .cell_deps(get_cell_deps_by_contracts(vec![Contract::CommitmentLock]))
+        .cell_deps(get_cell_deps_by_contracts(vec![Contract::Secp256k1Lock]))
         .output(
             CellOutput::new_builder()
                 .capacity(capacity.pack())
@@ -94,33 +85,93 @@ pub fn create_funding_tx(x_only: &XOnlyPublicKey) -> TransactionView {
         .build()
 }
 
-pub fn gen_rand_channel_announcement() -> (
-    Privkey,
-    ChannelAnnouncement,
-    TransactionView,
-    Privkey,
-    Privkey,
-) {
-    let sk1: Privkey = gen_rand_fiber_private_key();
-    let sk2: Privkey = gen_rand_fiber_private_key();
-    let sk = gen_rand_fiber_private_key();
-    let xonly = sk.x_only_pub_key();
-    let tx = create_funding_tx(&xonly);
-    let outpoint = tx.output_pts_iter().next().unwrap();
-    let mut channel_announcement = ChannelAnnouncement::new_unsigned(
-        &sk1.pubkey(),
-        &sk2.pubkey(),
-        outpoint.clone(),
-        &xonly,
-        0,
-        None,
-    );
-    let message = channel_announcement.message_to_sign();
-
-    channel_announcement.ckb_signature = Some(sk.sign_schnorr(message));
-    channel_announcement.node1_signature = Some(sk1.sign(message));
-    channel_announcement.node2_signature = Some(sk2.sign(message));
-    (sk, channel_announcement, tx, sk1, sk2)
+pub struct ChannelTestContext {
+    pub funding_tx_sk: Privkey,
+    pub node1_sk: Privkey,
+    pub node2_sk: Privkey,
+    pub funding_tx: TransactionView,
+    pub channel_announcement: ChannelAnnouncement,
+}
+
+impl ChannelTestContext {
+    pub fn gen() -> ChannelTestContext {
+        let funding_tx_sk = gen_rand_fiber_private_key();
+        let node1_sk = gen_rand_fiber_private_key();
+        let node2_sk = gen_rand_fiber_private_key();
+        let xonly = funding_tx_sk.x_only_pub_key();
+        let funding_tx = create_funding_tx(&xonly);
+        let outpoint = funding_tx.output_pts_iter().next().unwrap();
+        let capacity: u64 = funding_tx.output(0).unwrap().capacity().unpack();
+        let mut channel_announcement = ChannelAnnouncement::new_unsigned(
+            &node1_sk.pubkey(),
+            &node2_sk.pubkey(),
+            outpoint.clone(),
+            &xonly,
+            capacity as u128,
+            None,
+        );
+        let message = channel_announcement.message_to_sign();
+
+        channel_announcement.ckb_signature = Some(funding_tx_sk.sign_schnorr(message));
+        channel_announcement.node1_signature = Some(node1_sk.sign(message));
+        channel_announcement.node2_signature = Some(node2_sk.sign(message));
+
+        ChannelTestContext {
+            funding_tx_sk,
+            node1_sk,
+            node2_sk,
+            funding_tx,
+            channel_announcement,
+        }
+    }
+
+    pub fn channel_outpoint(&self) -> &OutPoint {
+        &self.channel_announcement.channel_outpoint
+    }
+
+    pub fn create_channel_update_of_node1(
+        &self,
+        channel_flags: u32,
+        tlc_expiry_delta: u64,
+        tlc_minimum_value: u128,
+        tlc_fee_proportional_millionths: u128,
+    ) -> ChannelUpdate {
+        let mut unsigned_channel_update = ChannelUpdate::new_unsigned(
+            self.channel_announcement.channel_outpoint.clone(),
+            now_timestamp_as_millis_u64(),
+            MESSAGE_OF_NODE1_FLAG,
+            channel_flags,
+            tlc_expiry_delta,
+            tlc_minimum_value,
+            tlc_fee_proportional_millionths,
+        );
+        let message = unsigned_channel_update.message_to_sign();
+        let signature = self.node1_sk.sign(message);
+        unsigned_channel_update.signature = Some(signature);
+        unsigned_channel_update
+    }
+
+    pub fn create_channel_update_of_node2(
+        &self,
+        channel_flags: u32,
+        tlc_expiry_delta: u64,
+        tlc_minimum_value: u128,
+        tlc_fee_proportional_millionths: u128,
+    ) -> ChannelUpdate {
+        let mut unsigned_channel_update = ChannelUpdate::new_unsigned(
+            self.channel_announcement.channel_outpoint.clone(),
+            now_timestamp_as_millis_u64(),
+            MESSAGE_OF_NODE2_FLAG,
+            channel_flags,
+            tlc_expiry_delta,
+            tlc_minimum_value,
+            tlc_fee_proportional_millionths,
+        );
+        let message = unsigned_channel_update.message_to_sign();
+        let signature = self.node2_sk.sign(message);
+        unsigned_channel_update.signature = Some(signature);
+        unsigned_channel_update
+    }
 }
 
 pub fn create_invalid_ecdsa_signature() -> EcdsaSignature {
diff --git a/tests/bruno/e2e/3-nodes-transfer/13-node2-add-tlc.bru b/tests/bruno/e2e/3-nodes-transfer/13-node2-add-tlc.bru
index 1cb597cc9..b8e3f5a44 100644
--- a/tests/bruno/e2e/3-nodes-transfer/13-node2-add-tlc.bru
+++ b/tests/bruno/e2e/3-nodes-transfer/13-node2-add-tlc.bru
@@ -50,6 +50,6 @@ script:pre-request {
 
 script:post-response {
   // Sleep for sometime to make sure current operation finishes before next request starts.
-  await new Promise(r => setTimeout(r, 100));
+  await new Promise(r => setTimeout(r, 1000));
   bru.setVar("N2N3_TLC_ID1", res.body.result.tlc_id);
 }
diff --git a/tests/bruno/e2e/open-use-close-a-channel/13-remove-tlc-from-NODE1.bru b/tests/bruno/e2e/open-use-close-a-channel/13-remove-tlc-from-NODE1.bru
index ea72138cc..d516771d6 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/13-remove-tlc-from-NODE1.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/13-remove-tlc-from-NODE1.bru
@@ -37,6 +37,10 @@ assert {
   res.body.result: isNull
 }
 
+script:pre-request {
+  await new Promise(r => setTimeout(r, 500));
+}
+
 script:post-response {
   // Sleep for sometime to make sure current operation finishes before next request starts.
   await new Promise(r => setTimeout(r, 100));
diff --git a/tests/bruno/e2e/open-use-close-a-channel/14-remove-tlc-from-NODE3.bru b/tests/bruno/e2e/open-use-close-a-channel/14-remove-tlc-from-NODE3.bru
index 2f9bfb1ae..8e0fc2d1a 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/14-remove-tlc-from-NODE3.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/14-remove-tlc-from-NODE3.bru
@@ -37,6 +37,10 @@ assert {
   res.body.result: isUndefined
 }
 
+script:pre-request {
+  await new Promise(r => setTimeout(r, 500));
+}
+
 script:post-response {
   console.log("step 14: ", res.body);
   // Sleep for sometime to make sure current operation finishes before next request starts.
diff --git a/tests/bruno/e2e/reestablish/09-reconnect-peer-NODE1.bru b/tests/bruno/e2e/reestablish/09-reconnect-peer-NODE1.bru
index f1d2902fb..23e302e49 100644
--- a/tests/bruno/e2e/reestablish/09-reconnect-peer-NODE1.bru
+++ b/tests/bruno/e2e/reestablish/09-reconnect-peer-NODE1.bru
@@ -34,5 +34,5 @@ assert {
 script:post-response {
   // Dialing a peer is async in tentacle. Sleep for some time to make sure
   // we're connected to the peer.
-  await new Promise(r => setTimeout(r, 1000));
+  await new Promise(r => setTimeout(r, 3000));
 }
diff --git a/tests/bruno/e2e/reestablish/12-remove-tlc-from-NODE1.bru b/tests/bruno/e2e/reestablish/10-remove-tlc-from-NODE1.bru
similarity index 77%
rename from tests/bruno/e2e/reestablish/12-remove-tlc-from-NODE1.bru
rename to tests/bruno/e2e/reestablish/10-remove-tlc-from-NODE1.bru
index 79ed9dfc1..a321eff13 100644
--- a/tests/bruno/e2e/reestablish/12-remove-tlc-from-NODE1.bru
+++ b/tests/bruno/e2e/reestablish/10-remove-tlc-from-NODE1.bru
@@ -1,7 +1,7 @@
 meta {
   name: remove tlc from NODE1
   type: http
-  seq: 12
+  seq: 10
 }
 
 post {
@@ -37,11 +37,10 @@ assert {
   res.body.result: isNull
 }
 
-script:pre-request {
-  await new Promise(r => setTimeout(r, 1000));
-}
-
 script:post-response {
+  // assert we can remove it without error, if we can't remove it means the reestablish failed
+  // for example, if the tlc is not synced yet, it's status will not be in `Committed`, so we can't remove it
+
   // Sleep for sometime to make sure current operation finishes before next request starts.
   await new Promise(r => setTimeout(r, 100));
   console.log("remove tlc response: ", res.body);
diff --git a/tests/bruno/e2e/reestablish/10-shutdown-from-NODE1.bru b/tests/bruno/e2e/reestablish/11-shutdown-from-NODE1.bru
similarity index 98%
rename from tests/bruno/e2e/reestablish/10-shutdown-from-NODE1.bru
rename to tests/bruno/e2e/reestablish/11-shutdown-from-NODE1.bru
index 36021e755..6640092a7 100644
--- a/tests/bruno/e2e/reestablish/10-shutdown-from-NODE1.bru
+++ b/tests/bruno/e2e/reestablish/11-shutdown-from-NODE1.bru
@@ -1,7 +1,7 @@
 meta {
   name: send shutdown from NODE1
   type: http
-  seq: 10
+  seq: 11
 }
 
 post {
diff --git a/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/02-open-channel.bru b/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/02-open-channel.bru
index f2f0f8ff9..2dea0ae56 100644
--- a/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/02-open-channel.bru
+++ b/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/02-open-channel.bru
@@ -23,7 +23,12 @@ body:json {
     "params": [
       {
         "peer_id": "{{NODE2_PEERID}}",
-        "funding_amount": "0xba43b7400"
+        "funding_amount": "0xba43b7400",
+        "shutdown_script": {
+          "code_hash": "0x2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b",
+          "hash_type": "data",
+          "args": "0x42"
+        }
       }
     ]
   }
diff --git a/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/05-node2-gen-invoice.bru b/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/05-node2-gen-invoice.bru
index c629c51e4..8235bc169 100644
--- a/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/05-node2-gen-invoice.bru
+++ b/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/05-node2-gen-invoice.bru
@@ -22,7 +22,7 @@ body:json {
     "method": "new_invoice",
     "params": [
       {
-        "amount": "0x2dc6c0",
+        "amount": "0x5d21dba00",
         "currency": "Fibd",
         "description": "test invoice generated by node2",
         "expiry": "0xe10",
diff --git a/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/07-node1-gen-invoice.bru b/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/07-node1-gen-invoice.bru
index cc7b57373..d8699eb48 100644
--- a/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/07-node1-gen-invoice.bru
+++ b/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/07-node1-gen-invoice.bru
@@ -22,7 +22,7 @@ body:json {
     "method": "new_invoice",
     "params": [
       {
-        "amount": "0x42",
+        "amount": "0x2e90edd00",
         "currency": "Fibd",
         "description": "test invoice generated by node1",
         "expiry": "0xe10",
diff --git a/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/15-check-balance.bru b/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/15-check-balance.bru
index 28952d167..406a3fed6 100644
--- a/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/15-check-balance.bru
+++ b/tests/bruno/e2e/watchtower/force-close-after-multiple-payments/15-check-balance.bru
@@ -1,5 +1,5 @@
 meta {
-  name: check balance
+  name: check balance, 0xba43b7400 - 0x5d21dba00 + 0x2e90edd00 - 0x1c7 (fee) = 0x8bb2c9539
   type: http
   seq: 15
 }
@@ -23,7 +23,7 @@ body:json {
     "params": [
       {
         "script": {
-          "code_hash": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a",
+          "code_hash": "0x2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b",
           "hash_type": "data",
           "args": "0x42"
         },
@@ -33,6 +33,10 @@ body:json {
   }
 }
 
+assert {
+  res.body.result.capacity: eq "0x8bb2c9539"
+}
+
 script:post-response {
   console.log("result: ", res.body);
 }
diff --git a/tests/bruno/e2e/watchtower/force-close/02-open-channel.bru b/tests/bruno/e2e/watchtower/force-close/02-open-channel.bru
index f2f0f8ff9..88deaa12b 100644
--- a/tests/bruno/e2e/watchtower/force-close/02-open-channel.bru
+++ b/tests/bruno/e2e/watchtower/force-close/02-open-channel.bru
@@ -23,7 +23,12 @@ body:json {
     "params": [
       {
         "peer_id": "{{NODE2_PEERID}}",
-        "funding_amount": "0xba43b7400"
+        "funding_amount": "0xba43b7400",
+        "shutdown_script": {
+          "code_hash": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a",
+          "hash_type": "data",
+          "args": "0x42"
+        }
       }
     ]
   }
diff --git a/tests/bruno/e2e/watchtower/force-close/13-check-balance.bru b/tests/bruno/e2e/watchtower/force-close/13-check-balance.bru
new file mode 100644
index 000000000..f0ae82619
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close/13-check-balance.bru
@@ -0,0 +1,42 @@
+meta {
+  name: check balance, 0xba43b7400 - 0x2dc6c0 - 0x1c7 (fee) == 0xba40dab79
+  type: http
+  seq: 13
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "get_cells_capacity",
+    "params": [
+      {
+        "script": {
+          "code_hash": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a",
+          "hash_type": "data",
+          "args": "0x42"
+        },
+        "script_type": "lock"
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.result.capacity: eq "0xba40dab79"
+}
+
+script:post-response {
+  console.log("result: ", res.body);
+}
diff --git a/tests/deploy/udt-init/src/main.rs b/tests/deploy/udt-init/src/main.rs
index ec3360c6a..8cb133f67 100644
--- a/tests/deploy/udt-init/src/main.rs
+++ b/tests/deploy/udt-init/src/main.rs
@@ -321,10 +321,10 @@ fn genrate_nodes_config() {
         .skip(2) // bootnode node was not always started
         .map(|(_, port)| port.to_string())
         .collect::<Vec<_>>()
-        .join("\n");
+        .join("\n")
+        + "\n";
 
     let port_file_path = nodes_dir.join(".ports");
-
     std::fs::write(port_file_path, content).expect("write ports list");
 }
 
diff --git a/tests/nodes/deployer/config.yml b/tests/nodes/deployer/config.yml
index b6997d5d9..e609b4932 100644
--- a/tests/nodes/deployer/config.yml
+++ b/tests/nodes/deployer/config.yml
@@ -14,6 +14,7 @@ rpc:
   enabled_modules:
     - cch
     - channel
+    - payment
     - graph
     - info
     - invoice
diff --git a/tests/nodes/start.sh b/tests/nodes/start.sh
index c79b82e8a..66a20cfd6 100755
--- a/tests/nodes/start.sh
+++ b/tests/nodes/start.sh
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail
 export SHELLOPTS
-export RUST_BACKTRACE=full RUST_LOG=info,fnn=debug,fnn::cch::actor::tracker=off
+export RUST_BACKTRACE=full RUST_LOG=info,fnn=debug,fnn::cch::actor::tracker=off,fnn::fiber::gossip=off,fnn::fiber::graph=off
 
 should_remove_old_state="${REMOVE_OLD_STATE:-}"
 should_clean_fiber_state="${REMOVE_OLD_FIBER:-}"
@@ -32,16 +32,13 @@ echo "Initializing finished, begin to start services ...."
 sleep 1
 
 ckb run -C "$deploy_dir/node-data" --indexer &
+cargo build
 
 # Start the dev node in the background.
 cd "$nodes_dir" || exit 1
 
 start() {
-    if [ -n "$FNN" ]; then
-        "$FNN" "$@"
-    else
-        cargo run -- "$@"
-    fi
+    ../../target/debug/fnn "$@"
 }
 
 if [ "$#" -ne 1 ]; then