diff --git a/.gitignore b/.gitignore
index acc79fb4..7d39da08 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,3 +11,4 @@
 tests/nodes/.ports
 /coverage-report
 /*.info
+.vscode
diff --git a/src/cch/actor.rs b/src/cch/actor.rs
index 01bc386b..97843d6a 100644
--- a/src/cch/actor.rs
+++ b/src/cch/actor.rs
@@ -22,7 +22,7 @@ use crate::fiber::hash_algorithm::HashAlgorithm;
 use crate::fiber::types::{Hash256, RemoveTlcFulfill, RemoveTlcReason};
 use crate::fiber::{NetworkActorCommand, NetworkActorMessage};
 use crate::invoice::Currency;
-use crate::now_timestamp;
+use crate::now_timestamp_as_millis_u64;
 
 use super::error::CchDbError;
 use super::{CchConfig, CchError, CchOrderStatus, CchOrdersDb, ReceiveBTCOrder, SendBTCOrder};
@@ -592,7 +592,8 @@ impl CchActor {
                                 payment_hash: Some(
                                     Hash256::from_str(&order.payment_hash).expect("parse Hash256"),
                                 ),
-                                expiry: now_timestamp() + self.config.ckb_final_tlc_expiry_delta,
+                                expiry: now_timestamp_as_millis_u64()
+                                    + self.config.ckb_final_tlc_expiry_delta,
                                 hash_algorithm: HashAlgorithm::Sha256,
                                 onion_packet: vec![],
                                 previous_tlc: None,
diff --git a/src/fiber/channel.rs b/src/fiber/channel.rs
index c589a766..f2e321d0 100644
--- a/src/fiber/channel.rs
+++ b/src/fiber/channel.rs
@@ -10,11 +10,15 @@ use crate::{
         types::{ChannelUpdate, TlcErr, TlcErrPacket, TlcErrorCode},
     },
     invoice::{CkbInvoice, CkbInvoiceStatus, InvoiceStore},
+    now_timestamp_as_millis_u64,
 };
 use ckb_hash::{blake2b_256, new_blake2b};
 use ckb_sdk::{Since, SinceType};
 use ckb_types::{
-    core::{EpochNumberWithFraction, FeeRate, TransactionBuilder, TransactionView},
+    core::{
+        Capacity, CapacityError, EpochNumberWithFraction, FeeRate, TransactionBuilder,
+        TransactionView,
+    },
     packed::{Bytes, CellInput, CellOutput, OutPoint, Script, Transaction},
     prelude::{AsTransactionBuilder, IntoTransactionView, Pack, Unpack},
 };
@@ -52,7 +56,6 @@ use crate::{
         FundingRequest,
     },
     fiber::{
-        config::{DEFAULT_UDT_MINIMAL_CKB_AMOUNT, MIN_OCCUPIED_CAPACITY},
         fee::{calculate_commitment_tx_fee, shutdown_tx_size},
         network::{emit_service_event, sign_network_message},
         types::{AnnouncementSignatures, Shutdown},
@@ -61,8 +64,9 @@ use crate::{
 };
 
 use super::{
-    config::{DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT, MIN_UDT_OCCUPIED_CAPACITY},
-    fee::{calculate_shutdown_tx_fee, default_minimal_ckb_amount},
+    config::DEFAULT_MIN_SHUTDOWN_FEE,
+    config::{MAX_PAYMENT_TLC_EXPIRY_LIMIT, MIN_TLC_EXPIRY_DELTA},
+    fee::calculate_shutdown_tx_fee,
     hash_algorithm::HashAlgorithm,
     key::blake2b_hash_with_salt,
     network::FiberMessageWithPeerId,
@@ -396,7 +400,9 @@ where
                             .expect(ASSUME_NETWORK_ACTOR_ALIVE);
                     }
                 }
+                self.try_to_forward_pending_tlc(state).await;
                 self.try_to_settle_down_tlc(state);
+                self.try_to_send_remove_tlcs(state).await;
                 Ok(())
             }
             FiberChannelMessage::TxSignatures(tx_signatures) => {
@@ -467,72 +473,52 @@ where
                 let flags = flags | AwaitingChannelReadyFlags::THEIR_CHANNEL_READY;
                 state.update_state(ChannelState::AwaitingChannelReady(flags));
                 state.maybe_channel_is_ready(&self.network).await;
-
                 Ok(())
             }
             FiberChannelMessage::AddTlc(add_tlc) => {
                 let tlc_id = add_tlc.tlc_id;
                 let tlc_count = state.tlcs.len();
-                match self
-                    .handle_add_tlc_peer_message(state, add_tlc.clone())
-                    .await
-                {
-                    Ok((added_tlc_id, peeled_packet_bytes)) => {
-                        if let Some(forward_packet_bytes) = peeled_packet_bytes {
-                            // `handle_forward_onion_packet` will handle the case where forwarding TLC fails
-                            // `remove_tlc` will be sent to the peer and proper error handling will be done
-                            self.handle_forward_onion_packet(
-                                state,
-                                forward_packet_bytes,
-                                added_tlc_id.into(),
-                            )
-                            .await?;
-                        }
-                        Ok(())
-                    }
-                    Err(e) => {
-                        // we assume that TLC was not inserted into our state,
-                        // so we can safely send RemoveTlc message to the peer
-                        // note this new add_tlc may be trying to add a duplicate tlc,
-                        // so we use tlc count to make sure no new tlc was added
-                        // and only send RemoveTlc message to peer if the TLC is not in our state
-                        error!("Error handling AddTlc message: {:?}", e);
-                        assert!(tlc_count == state.tlcs.len());
-                        let error_detail = self.get_tlc_detail_error(state, &e).await;
-                        if state.get_received_tlc(tlc_id).is_none() {
-                            self.network
-                                .send_message(NetworkActorMessage::new_command(
-                                    NetworkActorCommand::SendFiberMessage(
-                                        FiberMessageWithPeerId::new(
-                                            state.get_remote_peer_id(),
-                                            FiberMessage::remove_tlc(RemoveTlc {
-                                                channel_id: state.get_id(),
-                                                tlc_id,
-                                                reason: RemoveTlcReason::RemoveTlcFail(
-                                                    TlcErrPacket::new(error_detail),
-                                                ),
-                                            }),
-                                        ),
-                                    ),
-                                ))
-                                .expect(ASSUME_NETWORK_ACTOR_ALIVE);
-                        }
-                        Err(e)
+                if let Err(e) = self.handle_add_tlc_peer_message(state, add_tlc).await {
+                    // we assume that TLC was not inserted into our state,
+                    // so we can safely send RemoveTlc message to the peer
+                    // note this new add_tlc may be trying to add a duplicate tlc,
+                    // so we use tlc count to make sure no new tlc was added
+                    // and only send RemoveTlc message to peer if the TLC is not in our state
+                    error!("Error handling AddTlc message: {:?}", e);
+                    assert!(tlc_count == state.tlcs.len());
+                    let error_detail = self.get_tlc_detail_error(state, &e).await;
+                    if state.get_received_tlc(tlc_id).is_none() {
+                        eprintln!("Sending RemoveTlc message to peer due to error: {:?}", e);
+                        self.network
+                            .send_message(NetworkActorMessage::new_command(
+                                NetworkActorCommand::SendFiberMessage(FiberMessageWithPeerId::new(
+                                    state.get_remote_peer_id(),
+                                    FiberMessage::remove_tlc(RemoveTlc {
+                                        channel_id: state.get_id(),
+                                        tlc_id,
+                                        reason: RemoveTlcReason::RemoveTlcFail(TlcErrPacket::new(
+                                            error_detail,
+                                        )),
+                                    }),
+                                )),
+                            ))
+                            .expect(ASSUME_NETWORK_ACTOR_ALIVE);
                     }
+                    return Err(e);
                 }
+                Ok(())
             }
             FiberChannelMessage::RemoveTlc(remove_tlc) => {
                 state.check_for_tlc_update(None)?;
                 let channel_id = state.get_id();
 
-                let tlc_details = state.remove_tlc_with_reason(
-                    TLCId::Offered(remove_tlc.tlc_id),
-                    &remove_tlc.reason,
-                )?;
+                let remove_reason = remove_tlc.reason.clone();
+                let tlc_details = state
+                    .remove_tlc_with_reason(TLCId::Offered(remove_tlc.tlc_id), &remove_reason)?;
                 if let (
                     Some(ref udt_type_script),
                     RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill { payment_preimage }),
-                ) = (state.funding_udt_type_script.clone(), &remove_tlc.reason)
+                ) = (state.funding_udt_type_script.clone(), &remove_reason)
                 {
                     let mut tlc = tlc_details.tlc.clone();
                     tlc.payment_preimage = Some(*payment_preimage);
@@ -544,39 +530,14 @@ where
                             script: udt_type_script.clone(),
                         });
                 }
-                if let Some((previous_channel_id, previous_tlc)) = tlc_details.tlc.previous_tlc {
-                    assert!(previous_tlc.is_received());
-                    info!(
-                        "begin to remove tlc from previous channel: {:?}",
-                        &previous_tlc
-                    );
-                    assert!(previous_channel_id != state.get_id());
-                    let (send, recv) = oneshot::channel::<Result<(), String>>();
-                    let port = RpcReplyPort::from(send);
-                    self.network
-                        .send_message(NetworkActorMessage::new_command(
-                            NetworkActorCommand::ControlFiberChannel(ChannelCommandWithId {
-                                channel_id: previous_channel_id,
-                                command: ChannelCommand::RemoveTlc(
-                                    RemoveTlcCommand {
-                                        id: previous_tlc.into(),
-                                        reason: remove_tlc.reason.clone(),
-                                    },
-                                    port,
-                                ),
-                            }),
-                        ))
-                        .expect(ASSUME_NETWORK_ACTOR_ALIVE);
-                    let res = recv.await.expect("remove tlc replied");
-                    info!("remove tlc from previous channel: {:?}", &res);
-                } else {
+                if tlc_details.tlc.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_details.tlc.payment_hash,
-                                remove_tlc,
+                                remove_reason,
                             ),
                         ))
                         .expect("myself alive");
@@ -691,6 +652,8 @@ where
         let error_code = match error {
             ProcessingChannelError::PeelingOnionPacketError(_) => TlcErrorCode::InvalidOnionPayload,
             ProcessingChannelError::TlcForwardFeeIsTooLow => TlcErrorCode::FeeInsufficient,
+            ProcessingChannelError::TlcExpirySoon => TlcErrorCode::ExpiryTooSoon,
+            ProcessingChannelError::TlcExpiryTooFar => TlcErrorCode::ExpiryTooFar,
             ProcessingChannelError::FinalInvoiceInvalid(status) => match status {
                 CkbInvoiceStatus::Expired => TlcErrorCode::InvoiceExpired,
                 CkbInvoiceStatus::Cancelled => TlcErrorCode::InvoiceCancelled,
@@ -701,7 +664,7 @@ where
                 TlcErrorCode::IncorrectOrUnknownPaymentDetails
             }
             ProcessingChannelError::FinalIncorrectHTLCAmount => {
-                TlcErrorCode::FinalIncorrectHtlcAmount
+                TlcErrorCode::FinalIncorrectTlcAmount
             }
             ProcessingChannelError::TlcAmountIsTooLow => TlcErrorCode::AmountBelowMinimum,
             ProcessingChannelError::TlcNumberExceedLimit
@@ -739,6 +702,55 @@ where
         )
     }
 
+    async fn try_to_forward_pending_tlc(&self, state: &mut ChannelActorState) {
+        let tlc_infos = state.get_tlcs_for_forwarding();
+        for info in tlc_infos {
+            assert!(info.tlc.is_received());
+            let onion_packet = info.tlc.onion_packet;
+            let _ = self
+                .handle_forward_onion_packet(state, onion_packet, info.tlc.id.into())
+                .await;
+        }
+    }
+
+    async fn try_to_send_remove_tlcs(&self, state: &mut ChannelActorState) {
+        let tlc_infos = state.get_tlcs_for_sending_remove_tlcs();
+        eprintln!("try to send remove tlcs: {:?}", tlc_infos);
+        for tlc_info in tlc_infos {
+            assert!(tlc_info.is_offered());
+            let remove_reason = tlc_info.removed_at.expect("expect remove_at").1;
+            if let Some((previous_channel_id, previous_tlc)) = tlc_info.tlc.previous_tlc {
+                assert!(previous_tlc.is_received());
+                info!(
+                    "begin to remove tlc from previous channel: {:?}",
+                    &previous_tlc
+                );
+                assert!(previous_channel_id != state.get_id());
+                let (send, recv) = oneshot::channel::<Result<(), String>>();
+                let port = RpcReplyPort::from(send);
+                self.network
+                    .send_message(NetworkActorMessage::new_command(
+                        NetworkActorCommand::ControlFiberChannel(ChannelCommandWithId {
+                            channel_id: previous_channel_id,
+                            command: ChannelCommand::RemoveTlc(
+                                RemoveTlcCommand {
+                                    id: previous_tlc.into(),
+                                    reason: remove_reason.clone(),
+                                },
+                                port,
+                            ),
+                        }),
+                    ))
+                    .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+                let res = recv.await.expect("remove tlc replied");
+                info!("remove tlc from previous channel: {:?}", &res);
+            } else {
+                unreachable!("remove tlc without previous tlc");
+            }
+            state.set_offered_tlc_removed(tlc_info.tlc.id.into());
+        }
+    }
+
     fn try_to_settle_down_tlc(&self, state: &mut ChannelActorState) {
         let tlcs = state.get_tlcs_for_settle_down();
         let mut update_invoice_payment_hash = false;
@@ -802,8 +814,9 @@ where
         &self,
         state: &mut ChannelActorState,
         add_tlc: AddTlc,
-    ) -> Result<(TLCId, Option<Vec<u8>>), ProcessingChannelError> {
+    ) -> Result<(), ProcessingChannelError> {
         state.check_for_tlc_update(Some(add_tlc.amount))?;
+        state.check_tlc_expiry(add_tlc.expiry)?;
 
         // check the onion_packet is valid or not, if not, we should return an error.
         // If there is a next hop, we should send the AddTlc message to the next hop.
@@ -892,7 +905,8 @@ where
             }
         }
 
-        let tlc = state.create_inbounding_tlc(add_tlc.clone(), preimage)?;
+        let tlc =
+            state.create_inbounding_tlc(add_tlc.clone(), preimage, peeled_packet_bytes.clone())?;
         state.insert_tlc(tlc.clone())?;
         if let Some(payment_hash) = update_invoice_payment_hash {
             self.store
@@ -914,7 +928,7 @@ where
         // The peer may falsely believe that we have already processed this message,
         // while we have crashed. We need a way to make sure that the peer will resend
         // this message, and our processing of this message is idempotent.
-        Ok((tlc.id, peeled_packet_bytes))
+        Ok(())
     }
 
     async fn handle_forward_onion_packet(
@@ -958,6 +972,7 @@ where
                 .expect(ASSUME_NETWORK_ACTOR_ALIVE);
             let _ = recv.await.expect("RemoveTlc command replied");
         }
+        state.set_received_tlc_forwarded(added_tlc_id);
         Ok(())
     }
 
@@ -1085,6 +1100,7 @@ where
     ) -> Result<u64, ProcessingChannelError> {
         debug!("handle add tlc command : {:?}", &command);
         state.check_for_tlc_update(Some(command.amount))?;
+        state.check_tlc_expiry(command.expiry)?;
         let tlc = state.create_outbounding_tlc(command);
         state.insert_tlc(tlc.clone())?;
 
@@ -1231,6 +1247,12 @@ where
         }
 
         if let Some(delta) = tlc_expiry_delta {
+            if delta < MIN_TLC_EXPIRY_DELTA {
+                return Err(ProcessingChannelError::InvalidParameter(format!(
+                    "TLC expiry delta is too small, expect larger than {}",
+                    MIN_TLC_EXPIRY_DELTA
+                )));
+            }
             updated |= state.update_our_tlc_expiry_delta(delta);
         }
 
@@ -1493,27 +1515,6 @@ where
         Ok(())
     }
 
-    fn get_funding_and_reserved_amount(
-        &self,
-        funding_amount: u128,
-        udt_type_script: &Option<Script>,
-    ) -> Result<(u128, u64), ProcessingChannelError> {
-        match udt_type_script {
-            Some(_) => Ok((funding_amount, DEFAULT_UDT_MINIMAL_CKB_AMOUNT)),
-            _ => {
-                let reserved_ckb_amount = DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT;
-                if funding_amount < reserved_ckb_amount.into() {
-                    return Err(ProcessingChannelError::InvalidParameter(format!(
-                        "The value of the channel should be greater than the reserved amount: {}",
-                        reserved_ckb_amount
-                    )));
-                }
-                let funding_amount = funding_amount - reserved_ckb_amount as u128;
-                Ok((funding_amount, reserved_ckb_amount))
-            }
-        }
-    }
-
     fn get_invoice_status(&self, invoice: &CkbInvoice) -> CkbInvoiceStatus {
         match self
             .store
@@ -1619,15 +1620,7 @@ where
                     *max_tlc_value_in_flight,
                     *max_tlc_number_in_flight,
                 );
-
-                state.check_ckb_params(vec![
-                    "local_reserved_ckb_amount",
-                    "remote_reserved_ckb_amount",
-                    "commitment_fee_rate",
-                    "commitment_delay_epoch",
-                    "funding_fee_rate",
-                    "max_tlc_number_in_flight",
-                ])?;
+                state.check_accept_channel_parameters()?;
 
                 let commitment_number = INITIAL_COMMITMENT_NUMBER;
 
@@ -1696,15 +1689,18 @@ where
                     commitment_fee_rate.unwrap_or(DEFAULT_COMMITMENT_FEE_RATE);
                 let funding_fee_rate = funding_fee_rate.unwrap_or(DEFAULT_FEE_RATE);
 
-                let (funding_amount, reserved_ckb_amount) =
-                    self.get_funding_and_reserved_amount(funding_amount, &funding_udt_type_script)?;
+                let (to_local_amount, reserved_ckb_amount) = get_funding_and_reserved_amount(
+                    funding_amount,
+                    &shutdown_script,
+                    &funding_udt_type_script,
+                )?;
 
                 let mut channel = ChannelActorState::new_outbound_channel(
                     public_channel_info,
                     &seed,
                     self.get_local_pubkey(),
                     self.get_remote_pubkey(),
-                    funding_amount,
+                    to_local_amount,
                     reserved_ckb_amount,
                     commitment_fee_rate,
                     commitment_delay_epoch
@@ -1721,13 +1717,7 @@ where
                     max_tlc_number_in_flight.unwrap_or(DEFAULT_MAX_TLC_NUMBER_IN_FLIGHT),
                 );
 
-                channel.check_ckb_params(vec![
-                    "commitment_fee_rate",
-                    "commitment_delay_epoch",
-                    "funding_fee_rate",
-                    "local_reserved_ckb_amount",
-                    "max_tlc_number_in_flight",
-                ])?;
+                channel.check_open_channel_parameters()?;
 
                 let channel_flags = if public {
                     ChannelFlags::PUBLIC
@@ -2081,8 +2071,8 @@ pub struct ChannelActorState {
     // The remote and local lock script for close channel, they are setup during the channel establishment.
     #[serde_as(as = "Option<EntityHex>")]
     pub remote_shutdown_script: Option<Script>,
-    #[serde_as(as = "Option<EntityHex>")]
-    pub local_shutdown_script: Option<Script>,
+    #[serde_as(as = "EntityHex")]
+    pub local_shutdown_script: Script,
 
     pub previous_remote_nonce: Option<PubNonce>,
     pub remote_nonce: Option<PubNonce>,
@@ -2185,6 +2175,8 @@ pub enum ProcessingChannelError {
     RepeatedProcessing(String),
     #[error("Invalid parameter: {0}")]
     InvalidParameter(String),
+    #[error("Capacity error: {0}")]
+    CapacityError(#[from] CapacityError),
     #[error("Failed to spawn actor: {0}")]
     SpawnErr(#[from] SpawnErr),
     #[error("Musig2 VerifyError: {0}")]
@@ -2209,6 +2201,10 @@ pub enum ProcessingChannelError {
     TlcValueInflightExceedLimit,
     #[error("The tlc amount below minimal")]
     TlcAmountIsTooLow,
+    #[error("The tlc expiry soon")]
+    TlcExpirySoon,
+    #[error("The tlc expiry too far")]
+    TlcExpiryTooFar,
 }
 
 bitflags! {
@@ -2364,6 +2360,57 @@ pub fn get_commitment_point(commitment_seed: &[u8; 32], commitment_number: u64)
     Privkey::from(&get_commitment_secret(commitment_seed, commitment_number)).pubkey()
 }
 
+pub(crate) fn get_funding_and_reserved_amount(
+    total_amount: u128,
+    shutdown_script: &Script,
+    udt_type_script: &Option<Script>,
+) -> Result<(u128, u64), ProcessingChannelError> {
+    let reserved_capacity = reserved_capacity(shutdown_script, udt_type_script)?.as_u64();
+    if udt_type_script.is_none() {
+        if total_amount < reserved_capacity as u128 {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "The funding amount ({}) should be greater than or equal to {}",
+                total_amount, reserved_capacity
+            )));
+        }
+        if total_amount >= u64::MAX as u128 {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "The funding amount ({}) should be less than {}",
+                total_amount,
+                u64::MAX
+            )));
+        }
+        Ok((total_amount - reserved_capacity as u128, reserved_capacity))
+    } else {
+        Ok((total_amount, reserved_capacity))
+    }
+}
+
+pub(crate) fn reserved_capacity(
+    shutdown_script: &Script,
+    udt_type_script: &Option<Script>,
+) -> Result<Capacity, CapacityError> {
+    occupied_capacity(shutdown_script, udt_type_script)?
+        .safe_add(Capacity::shannons(DEFAULT_MIN_SHUTDOWN_FEE))
+}
+
+pub(crate) fn occupied_capacity(
+    shutdown_script: &Script,
+    udt_type_script: &Option<Script>,
+) -> Result<Capacity, CapacityError> {
+    let cell_output = CellOutput::new_builder()
+        .lock(shutdown_script.clone())
+        .type_(udt_type_script.clone().pack())
+        .build();
+
+    if udt_type_script.is_some() {
+        // 16 bytes for udt data
+        cell_output.occupied_capacity(Capacity::bytes(16)?)
+    } else {
+        cell_output.occupied_capacity(Capacity::bytes(0)?)
+    }
+}
+
 impl From<&ChannelActorState> for Musig2SignContext {
     fn from(value: &ChannelActorState) -> Self {
         Musig2SignContext {
@@ -2741,7 +2788,7 @@ impl ChannelActorState {
             id: channel_id,
             tlc_ids: Default::default(),
             tlcs: Default::default(),
-            local_shutdown_script: Some(local_shutdown_script),
+            local_shutdown_script: local_shutdown_script,
             local_channel_public_keys: local_base_pubkeys,
             signer,
             remote_channel_public_keys: Some(remote_pubkeys),
@@ -2773,7 +2820,7 @@ impl ChannelActorState {
         seed: &[u8],
         local_pubkey: Pubkey,
         remote_pubkey: Pubkey,
-        value: u128,
+        to_local_amount: u128,
         local_reserved_ckb_amount: u64,
         commitment_fee_rate: u64,
         commitment_delay_epoch: u64,
@@ -2795,7 +2842,7 @@ impl ChannelActorState {
             funding_tx_confirmed_at: None,
             funding_udt_type_script,
             is_acceptor: false,
-            to_local_amount: value,
+            to_local_amount,
             to_remote_amount: 0,
             commitment_fee_rate,
             commitment_delay_epoch,
@@ -2812,7 +2859,7 @@ impl ChannelActorState {
             remote_nonce: None,
             commitment_numbers: Default::default(),
             remote_commitment_points: vec![],
-            local_shutdown_script: Some(shutdown_script),
+            local_shutdown_script: shutdown_script,
             remote_shutdown_script: None,
             local_shutdown_info: None,
             remote_shutdown_info: None,
@@ -2825,105 +2872,103 @@ impl ChannelActorState {
         }
     }
 
-    fn check_reserved_ckb_amount(
-        &self,
-        field: &'static str,
-        reserved_ckb_amount: u64,
-    ) -> ProcessingChannelResult {
-        let minimal_reserved_amount =
-            default_minimal_ckb_amount(self.funding_udt_type_script.is_some());
-        if reserved_ckb_amount < minimal_reserved_amount {
+    // TODO: this fn is duplicated with NetworkActorState::check_open_channel_parameters, but is not easy to refactor, just keep it for now.
+    fn check_open_channel_parameters(&self) -> ProcessingChannelResult {
+        let udt_type_script = &self.funding_udt_type_script;
+
+        // reserved_ckb_amount
+        let occupied_capacity =
+            occupied_capacity(&self.local_shutdown_script, udt_type_script)?.as_u64();
+        if self.local_reserved_ckb_amount < occupied_capacity {
             return Err(ProcessingChannelError::InvalidParameter(format!(
-                "The {} should be greater than {}",
-                field, minimal_reserved_amount
+                "Reserved CKB amount {} is less than {}",
+                self.local_reserved_ckb_amount, occupied_capacity,
             )));
         }
-        Ok(())
-    }
 
-    fn check_ckb_params(&self, check_fields: Vec<&'static str>) -> ProcessingChannelResult {
-        for field in check_fields {
-            match field {
-                "local_reserved_ckb_amount" => {
-                    return self.check_reserved_ckb_amount(field, self.local_reserved_ckb_amount);
-                }
-                "remote_reserved_ckb_amount" => {
-                    return self.check_reserved_ckb_amount(field, self.remote_reserved_ckb_amount);
-                }
-                "funding_fee_rate" => {
-                    if self.funding_fee_rate < DEFAULT_FEE_RATE {
-                        return Err(ProcessingChannelError::InvalidParameter(format!(
-                            "Funding fee rate is less than {}",
-                            DEFAULT_FEE_RATE,
-                        )));
-                    }
-                }
-                "commitment_fee_rate" => {
-                    if self.commitment_fee_rate < DEFAULT_COMMITMENT_FEE_RATE {
-                        return Err(ProcessingChannelError::InvalidParameter(format!(
-                            "Commitment fee rate is less than {}",
-                            DEFAULT_COMMITMENT_FEE_RATE,
-                        )));
-                    }
+        // funding_fee_rate
+        if self.funding_fee_rate < DEFAULT_FEE_RATE {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Funding fee rate is less than {}",
+                DEFAULT_FEE_RATE,
+            )));
+        }
 
-                    let commitment_fee = calculate_commitment_tx_fee(
-                        self.commitment_fee_rate,
-                        &self.funding_udt_type_script,
-                    );
+        // commitment_fee_rate
+        if self.commitment_fee_rate < DEFAULT_COMMITMENT_FEE_RATE {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Commitment fee rate is less than {}",
+                DEFAULT_COMMITMENT_FEE_RATE,
+            )));
+        }
+        let commitment_fee = calculate_commitment_tx_fee(self.commitment_fee_rate, udt_type_script);
+        let reserved_fee = self.local_reserved_ckb_amount - occupied_capacity;
+        if commitment_fee * 2 > reserved_fee {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Commitment fee {} which caculated by commitment fee rate {} is larger than half of reserved fee {}",
+                commitment_fee, self.commitment_fee_rate, reserved_fee
+            )));
+        }
 
-                    let expected_minimal_reserved_ckb_amount = commitment_fee * 2;
-                    debug!(
-                        "expected_minimal_reserved_ckb_amount: {}, reserved_ckb_amount: {}",
-                        expected_minimal_reserved_ckb_amount, self.local_reserved_ckb_amount
-                    );
-                    if self.local_reserved_ckb_amount < expected_minimal_reserved_ckb_amount {
-                        return Err(ProcessingChannelError::InvalidParameter(format!(
-                        "Commitment fee rate is: {}, expect more CKB amount as reserved ckb amount expected to larger than {}, \
-                        or you can set a lower commitment fee rate",
-                        self.commitment_fee_rate, expected_minimal_reserved_ckb_amount
-                    )));
-                    }
-                }
-                "commitment_delay_epoch" => {
-                    let epoch = EpochNumberWithFraction::from_full_value_unchecked(
-                        self.commitment_delay_epoch,
-                    );
-                    if !epoch.is_well_formed() {
-                        return Err(ProcessingChannelError::InvalidParameter(format!(
-                            "Commitment delay epoch {} is not a valid value",
-                            self.commitment_delay_epoch,
-                        )));
-                    }
+        // commitment_delay_epoch
+        let epoch = EpochNumberWithFraction::from_full_value_unchecked(self.commitment_delay_epoch);
+        if !epoch.is_well_formed() {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Commitment delay epoch {} is not a valid value",
+                self.commitment_delay_epoch,
+            )));
+        }
 
-                    let min = EpochNumberWithFraction::new(MIN_COMMITMENT_DELAY_EPOCHS, 0, 1);
-                    if epoch < min {
-                        return Err(ProcessingChannelError::InvalidParameter(format!(
-                            "Commitment delay epoch {} is less than the minimal value {}",
-                            epoch, min
-                        )));
-                    }
+        let min = EpochNumberWithFraction::new(MIN_COMMITMENT_DELAY_EPOCHS, 0, 1);
+        if epoch < min {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Commitment delay epoch {} is less than the minimal value {}",
+                epoch, min
+            )));
+        }
 
-                    let max = EpochNumberWithFraction::new(MAX_COMMITMENT_DELAY_EPOCHS, 0, 1);
-                    if epoch > max {
-                        return Err(ProcessingChannelError::InvalidParameter(format!(
-                            "Commitment delay epoch {} is greater than the maximal value {}",
-                            epoch, max
-                        )));
-                    }
-                }
-                "max_tlc_number_in_flight" => {
-                    if self.max_tlc_number_in_flight > SYS_MAX_TLC_NUMBER_IN_FLIGHT {
-                        return Err(ProcessingChannelError::InvalidParameter(format!(
-                            "max_tlc_number_in_flight can not exceed {}",
-                            SYS_MAX_TLC_NUMBER_IN_FLIGHT,
-                        )));
-                    }
-                }
-                _ => {
-                    unimplemented!("Check field {} is not implemented", field);
-                }
-            }
+        let max = EpochNumberWithFraction::new(MAX_COMMITMENT_DELAY_EPOCHS, 0, 1);
+        if epoch > max {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Commitment delay epoch {} is greater than the maximal value {}",
+                epoch, max
+            )));
+        }
+
+        // max_tlc_number_in_flight
+        if self.max_tlc_number_in_flight > SYS_MAX_TLC_NUMBER_IN_FLIGHT {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Max TLC number in flight {} is greater than the system maximal value {}",
+                self.max_tlc_number_in_flight, SYS_MAX_TLC_NUMBER_IN_FLIGHT
+            )));
+        }
+
+        Ok(())
+    }
+
+    fn check_accept_channel_parameters(&self) -> Result<(), ProcessingChannelError> {
+        let udt_type_script = &self.funding_udt_type_script;
+
+        // reserved_ckb_amount
+        let occupied_capacity =
+            occupied_capacity(&self.get_remote_shutdown_script(), udt_type_script)?.as_u64();
+        if self.remote_reserved_ckb_amount < occupied_capacity {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Reserved CKB amount {} is less than {}",
+                self.remote_reserved_ckb_amount, occupied_capacity,
+            )));
+        }
+
+        // commitment_fee_rate
+        let commitment_fee = calculate_commitment_tx_fee(self.commitment_fee_rate, udt_type_script);
+        let reserved_fee = self.remote_reserved_ckb_amount - occupied_capacity;
+        if commitment_fee * 2 > reserved_fee {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Commitment fee {} which caculated by commitment fee rate {} is larger than half of reserved fee {}",
+                commitment_fee, self.commitment_fee_rate, reserved_fee
+            )));
         }
+
         Ok(())
     }
 
@@ -2945,15 +2990,16 @@ impl ChannelActorState {
             (self.get_remote_shutdown_script(), close_script.clone()),
         );
 
+        let occupied_capacity =
+            occupied_capacity(close_script, &self.funding_udt_type_script)?.as_u64();
         let available_max_fee = if self.funding_udt_type_script.is_none() {
-            self.to_local_amount as u64 + self.local_reserved_ckb_amount - MIN_OCCUPIED_CAPACITY
+            (self.to_local_amount as u64 + self.local_reserved_ckb_amount)
+                .saturating_sub(occupied_capacity)
         } else {
-            self.local_reserved_ckb_amount - MIN_UDT_OCCUPIED_CAPACITY
+            self.local_reserved_ckb_amount
+                .saturating_sub(occupied_capacity)
         };
-        debug!(
-            "verify_shutdown_fee fee: {} available_max_fee: {}",
-            fee, available_max_fee,
-        );
+
         if fee > available_max_fee {
             return Err(ProcessingChannelError::InvalidParameter(format!(
                 "Local balance is not enough to pay the fee, expect fee {} <= available_max_fee {}",
@@ -3280,7 +3326,38 @@ impl ChannelActorState {
         self.tlcs
             .values()
             .filter(|tlc| {
-                !tlc.is_offered() && tlc.creation_confirmed_at.is_some() && tlc.removed_at.is_none()
+                tlc.is_received()
+                    && tlc.creation_confirmed_at.is_some()
+                    && tlc.removed_at.is_none()
+                    && tlc.tlc.onion_packet.is_empty()
+            })
+            .cloned()
+            .collect()
+    }
+
+    fn get_tlcs_for_forwarding(&self) -> Vec<DetailedTLCInfo> {
+        self.tlcs
+            .values()
+            .filter(|tlc| {
+                tlc.is_received()
+                    && tlc.creation_confirmed_at.is_some()
+                    && tlc.removed_at.is_none()
+                    && tlc.tlc.previous_tlc.is_none()
+                    && tlc.relay_status == TlcRelayStatus::WaitingForward
+                    && !tlc.tlc.onion_packet.is_empty()
+            })
+            .cloned()
+            .collect()
+    }
+
+    fn get_tlcs_for_sending_remove_tlcs(&self) -> Vec<DetailedTLCInfo> {
+        self.tlcs
+            .values()
+            .filter(|tlc| {
+                tlc.is_offered()
+                    && tlc.removed_at.is_some()
+                    && tlc.tlc.previous_tlc.is_some()
+                    && tlc.relay_status == TlcRelayStatus::WaitingRemove
             })
             .cloned()
             .collect()
@@ -3483,6 +3560,18 @@ impl ChannelActorState {
         self.tlcs.get(&TLCId::Received(tlc_id))
     }
 
+    pub fn set_received_tlc_forwarded(&mut self, tlc_id: u64) {
+        if let Some(tlc) = self.tlcs.get_mut(&TLCId::Received(tlc_id)) {
+            tlc.relay_status = TlcRelayStatus::WaitingRemove;
+        }
+    }
+
+    pub fn set_offered_tlc_removed(&mut self, tlc_id: u64) {
+        if let Some(tlc) = self.tlcs.get_mut(&TLCId::Offered(tlc_id)) {
+            tlc.relay_status = TlcRelayStatus::Removed;
+        }
+    }
+
     pub fn insert_tlc(&mut self, tlc: TLC) -> Result<DetailedTLCInfo, ProcessingChannelError> {
         let payment_hash = tlc.payment_hash;
         if let Some(tlc) = self
@@ -3550,12 +3639,27 @@ impl ChannelActorState {
             self.to_local_amount,
             self.to_remote_amount
         );
+
+        let relay_status = if !tlc.onion_packet.is_empty() {
+            if tlc.is_received() {
+                TlcRelayStatus::WaitingForward
+            } else {
+                if tlc.previous_tlc.is_none() {
+                    TlcRelayStatus::NoForward
+                } else {
+                    TlcRelayStatus::WaitingRemove
+                }
+            }
+        } else {
+            TlcRelayStatus::NoForward
+        };
         let detailed_tlc = DetailedTLCInfo {
             tlc: tlc.clone(),
             created_at: self.get_current_commitment_numbers(),
             creation_confirmed_at: None,
             removed_at: None,
             removal_confirmed_at: None,
+            relay_status,
         };
         self.tlcs.insert(tlc.id, detailed_tlc.clone());
         if tlc.is_offered() {
@@ -3663,10 +3767,7 @@ impl ChannelActorState {
     }
 
     pub fn get_local_shutdown_script(&self) -> Script {
-        self.local_shutdown_script
-            .as_ref()
-            .expect("local_shutdown_script should be set in current state")
-            .clone()
+        self.local_shutdown_script.clone()
     }
 
     pub fn get_remote_shutdown_script(&self) -> Script {
@@ -3983,15 +4084,43 @@ impl ChannelActorState {
                 self.get_local_shutdown_script(),
             ),
         );
+        let occupied_capacity = match occupied_capacity(
+            &self.get_remote_shutdown_script(),
+            &self.funding_udt_type_script,
+        ) {
+            Ok(capacity) => capacity.as_u64(),
+            Err(_) => return false,
+        };
         let remote_available_max_fee = if self.funding_udt_type_script.is_none() {
-            self.to_remote_amount as u64 + self.remote_reserved_ckb_amount - MIN_OCCUPIED_CAPACITY
+            (self.to_remote_amount as u64 + self.remote_reserved_ckb_amount)
+                .saturating_sub(occupied_capacity)
         } else {
-            self.remote_reserved_ckb_amount - MIN_UDT_OCCUPIED_CAPACITY
+            self.remote_reserved_ckb_amount
+                .saturating_sub(occupied_capacity)
         };
         return fee <= remote_available_max_fee;
     }
 
-    pub fn check_for_tlc_update(&self, add_tlc_amount: Option<u128>) -> ProcessingChannelResult {
+    fn check_tlc_expiry(&self, expiry: u64) -> ProcessingChannelResult {
+        let current_time = now_timestamp_as_millis_u64();
+        if current_time >= expiry {
+            debug!(
+                "TLC expiry {} is already passed, current time: {}",
+                expiry, current_time
+            );
+            return Err(ProcessingChannelError::TlcExpirySoon);
+        }
+        if expiry >= current_time + MAX_PAYMENT_TLC_EXPIRY_LIMIT {
+            debug!(
+                "TLC expiry {} is too far in the future, current time: {}",
+                expiry, current_time
+            );
+            return Err(ProcessingChannelError::TlcExpiryTooFar);
+        }
+        Ok(())
+    }
+
+    fn check_for_tlc_update(&self, add_tlc_amount: Option<u128>) -> ProcessingChannelResult {
         match self.state {
             ChannelState::ChannelReady() => {}
             ChannelState::ShuttingDown(_) if add_tlc_amount.is_none() => {}
@@ -4065,6 +4194,7 @@ impl ChannelActorState {
         &self,
         message: AddTlc,
         payment_preimage: Option<Hash256>,
+        onion_packet: Option<Vec<u8>>,
     ) -> Result<TLC, ProcessingChannelError> {
         if self.get_received_tlc(message.tlc_id).is_some() {
             return Err(ProcessingChannelError::InvalidParameter(format!(
@@ -4086,7 +4216,7 @@ impl ChannelActorState {
             expiry: message.expiry,
             payment_preimage,
             hash_algorithm: message.hash_algorithm,
-            onion_packet: message.onion_packet,
+            onion_packet: onion_packet.unwrap_or_default(),
             previous_tlc: None,
         })
     }
@@ -4209,12 +4339,8 @@ impl ChannelActorState {
                     shutdown_tx_size(
                         &self.funding_udt_type_script,
                         (
-                            self.local_shutdown_script
-                                .clone()
-                                .expect("local shutdown script exists"),
-                            self.remote_shutdown_script
-                                .clone()
-                                .expect("remote shutdown script exists")
+                            self.get_local_shutdown_script(),
+                            self.get_remote_shutdown_script()
                         )
                     )
                 );
@@ -4251,11 +4377,6 @@ impl ChannelActorState {
             )));
         }
 
-        self.check_reserved_ckb_amount(
-            "remote_reserved_ckb_amount",
-            accept_channel.reserved_ckb_amount,
-        )?;
-
         self.update_state(ChannelState::NegotiatingFunding(
             NegotiatingFundingFlags::INIT_SENT,
         ));
@@ -4271,6 +4392,7 @@ impl ChannelActorState {
             accept_channel.second_per_commitment_point,
         ];
         self.remote_shutdown_script = Some(accept_channel.shutdown_script.clone());
+        self.check_accept_channel_parameters()?;
 
         match accept_channel.channel_announcement_nonce {
             Some(ref nonce) if self.is_public() => {
@@ -5693,8 +5815,16 @@ pub struct TLC {
     /// Which hash algorithm is applied on the preimage
     pub hash_algorithm: HashAlgorithm,
     /// The onion packet which encodes the routing information for the payment.
+    /// Note: this is the onion_packet need to be forwarded to the next hop when current TLC is a middle hop.
     pub onion_packet: Vec<u8>,
     /// The previous tlc id if this tlc is a part of a multi-tlc payment.
+    /// Note: this is used to track the tlc chain for a multi-tlc payment,
+    ///       we need to know previous when removing tlc backwardly.
+    ///
+    /// Node A ---------> Node B ------------> Node C ----------> Node D
+    ///  tlc_1 <---> (tlc_1) (tlc_2) <---> (tlc_2) (tlc_3) <----> tlc_3
+    ///                ^^^^                 ^^^^
+    ///
     pub previous_tlc: Option<(Hash256, TLCId)>,
 }
 
@@ -5736,6 +5866,14 @@ impl TLC {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+enum TlcRelayStatus {
+    NoForward,
+    WaitingForward,
+    WaitingRemove,
+    Removed,
+}
+
 /// A tlc output in a commitment transaction, including both the tlc output
 /// and the commitment_number that it first appeared (will appear) in the
 /// commitment transaction.
@@ -5761,6 +5899,8 @@ pub struct DetailedTLCInfo {
     // The initial commitment number of the party (the offerer) that
     // has confirmed the removal of this tlc.
     removal_confirmed_at: Option<CommitmentNumbers>,
+    // indicates the status of the tlc relaying.
+    relay_status: TlcRelayStatus,
 }
 
 impl DetailedTLCInfo {
@@ -5768,6 +5908,10 @@ impl DetailedTLCInfo {
         self.tlc.is_offered()
     }
 
+    fn is_received(&self) -> bool {
+        self.tlc.is_received()
+    }
+
     fn get_commitment_numbers(&self, local: bool) -> CommitmentNumbers {
         let am_i_sending_the_tlc = {
             if self.is_offered() {
diff --git a/src/fiber/config.rs b/src/fiber/config.rs
index fe14ec63..ea347153 100644
--- a/src/fiber/config.rs
+++ b/src/fiber/config.rs
@@ -11,33 +11,29 @@ use std::{fs, path::PathBuf, str::FromStr};
 use tentacle::secio::{PublicKey, SecioKeyPair};
 
 pub const CKB_SHANNONS: u64 = 100_000_000; // 1 CKB = 10 ^ 8 shannons
-pub const DEFAULT_MIN_INBOUND_LIQUIDITY: u64 = 100 * CKB_SHANNONS; // 100 CKB for minimal inbound liquidity
-pub const DEFAULT_MIN_SHUTDOWN_FEE: u64 = CKB_SHANNONS; // 1 CKB prepared for shutdown transaction fee
-pub const MIN_OCCUPIED_CAPACITY: u64 = 61 * CKB_SHANNONS; // 61 CKB for occupied capacity
-pub const MIN_UDT_OCCUPIED_CAPACITY: u64 = 142 * CKB_SHANNONS; // 142 CKB for UDT occupied capacity
+pub const DEFAULT_MIN_SHUTDOWN_FEE: u64 = 1 * CKB_SHANNONS; // 1 CKB prepared for shutdown transaction fee
 
 /// By default, listen to any tcp port allocated by the kernel.
 pub const DEFAULT_LISTENING_ADDR: &str = "/ip4/0.0.0.0/tcp/0";
 
-/// 62 CKB minimal channel amount, at any time a partner should keep at least
-/// `DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT` CKB in the channel,
-/// to make sure he can build a valid shutdown transaction and pay proper fee.
-pub const DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT: u64 =
-    MIN_OCCUPIED_CAPACITY + DEFAULT_MIN_SHUTDOWN_FEE;
+const MIN_OCCUPIED_CAPACITY: u64 = 61 * CKB_SHANNONS; // 61 CKB for occupied capacity
 
-/// 143 CKB for minimal UDT amount
-pub const DEFAULT_UDT_MINIMAL_CKB_AMOUNT: u64 =
-    MIN_UDT_OCCUPIED_CAPACITY + DEFAULT_MIN_SHUTDOWN_FEE;
+/// Default ckb funding amount when auto accepting an open channel request.
+pub const DEFAULT_AUTO_ACCEPT_CHANNEL_CKB_FUNDING_AMOUNT: u64 =
+    MIN_OCCUPIED_CAPACITY + DEFAULT_MIN_SHUTDOWN_FEE;
 
-/// 162 CKB to open a channel which maybe automatically acceptted.
-/// 100 CKB for minimal inbound liquidity, 61 CKB for occupied capacity, 1 CKB for shutdown fee
-/// The other party may auto accept the channel if the amount is greater than this.
-pub const DEFAULT_CHANNEL_MIN_AUTO_CKB_AMOUNT: u64 =
-    DEFAULT_MIN_INBOUND_LIQUIDITY + MIN_OCCUPIED_CAPACITY + DEFAULT_MIN_SHUTDOWN_FEE;
+/// Default minimum ckb funding amount for auto accepting an open channel request.
+pub const DEFAULT_OPEN_CHANNEL_AUTO_ACCEPT_MIN_CKB_FUNDING_AMOUNT: u64 = 100 * CKB_SHANNONS;
 
 /// The expiry delta to forward a tlc, in milliseconds, default to 1 day.
 pub const DEFAULT_TLC_EXPIRY_DELTA: u64 = 24 * 60 * 60 * 1000;
 
+/// The minimal expiry delta to forward a tlc, in milliseconds. 15 minutes.
+pub const MIN_TLC_EXPIRY_DELTA: u64 = 15 * 60 * 1000; // 15 minutes
+
+/// The maximum expiry delta for a payment, in milliseconds. 2 days
+pub const MAX_PAYMENT_TLC_EXPIRY_LIMIT: u64 = 2 * 24 * 60 * 60 * 1000; // 2 days
+
 /// The minimal value of a tlc. 0 means no minimal value.
 pub const DEFAULT_TLC_MIN_VALUE: u128 = 0;
 
@@ -113,12 +109,12 @@ pub struct FiberConfig {
     #[arg(name = "FIBER_SCRIPTS", long = "fiber-scripts", env, value_parser, num_args = 0.., value_delimiter = ',')]
     pub scripts: Vec<FiberScript>,
 
-    /// minimum ckb funding amount for auto accepting an open channel requests, aunit: shannons [default: 16200000000 shannons]
+    /// minimum ckb funding amount for auto accepting an open channel requests, unit: shannons [default: 10000000000 shannons]
     #[arg(
         name = "FIBER_OPEN_CHANNEL_AUTO_ACCEPT_MIN_CKB_FUNDING_AMOUNT",
         long = "fiber-open-channel-auto-accept-min-ckb-funding-amount",
         env,
-        help = "minimum ckb funding amount for auto accepting an open channel requests, unit: shannons [default: 16200000000 shannons]"
+        help = "minimum ckb funding amount for auto accepting an open channel requests, unit: shannons [default: 10000000000 shannons]"
     )]
     pub open_channel_auto_accept_min_ckb_funding_amount: Option<u64>,
     /// whether to accept open channel requests with ckb funding amount automatically, unit: shannons [default: 6200000000 shannons], if this is set to zero, it means to disable auto accept
@@ -318,12 +314,12 @@ impl FiberConfig {
 
     pub fn open_channel_auto_accept_min_ckb_funding_amount(&self) -> u64 {
         self.open_channel_auto_accept_min_ckb_funding_amount
-            .unwrap_or(DEFAULT_CHANNEL_MIN_AUTO_CKB_AMOUNT)
+            .unwrap_or(DEFAULT_OPEN_CHANNEL_AUTO_ACCEPT_MIN_CKB_FUNDING_AMOUNT)
     }
 
     pub fn auto_accept_channel_ckb_funding_amount(&self) -> u64 {
         self.auto_accept_channel_ckb_funding_amount
-            .unwrap_or(DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT)
+            .unwrap_or(DEFAULT_AUTO_ACCEPT_CHANNEL_CKB_FUNDING_AMOUNT)
     }
 
     pub fn tlc_expiry_delta(&self) -> u64 {
diff --git a/src/fiber/fee.rs b/src/fiber/fee.rs
index 2aa3dcd2..16384150 100644
--- a/src/fiber/fee.rs
+++ b/src/fiber/fee.rs
@@ -1,5 +1,4 @@
 use super::channel::FUNDING_CELL_WITNESS_LEN;
-use super::config::{DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT, DEFAULT_UDT_MINIMAL_CKB_AMOUNT};
 use crate::ckb::contracts::{get_cell_deps, get_script_by_contract, Contract};
 use ckb_types::core::TransactionBuilder;
 use ckb_types::packed::{Bytes, Script};
@@ -12,14 +11,6 @@ use ckb_types::{
 use molecule::prelude::Entity;
 use tracing::debug;
 
-pub(crate) fn default_minimal_ckb_amount(is_udt: bool) -> u64 {
-    if is_udt {
-        DEFAULT_UDT_MINIMAL_CKB_AMOUNT
-    } else {
-        DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT
-    }
-}
-
 fn commitment_tx_size(udt_type_script: &Option<Script>) -> usize {
     // when there is pending htlcs, the commitment lock args will be 56 bytes, otherwise 46 bytes.
     // to simplify the calculation, we use hardcoded 56 bytes here.
diff --git a/src/fiber/graph.rs b/src/fiber/graph.rs
index 0a48929f..2adb7b8c 100644
--- a/src/fiber/graph.rs
+++ b/src/fiber/graph.rs
@@ -10,7 +10,7 @@ use crate::fiber::path::NodeHeapElement;
 use crate::fiber::serde_utils::EntityHex;
 use crate::fiber::types::PaymentHopData;
 use crate::invoice::CkbInvoice;
-use crate::now_timestamp;
+use crate::now_timestamp_as_millis_u64;
 use ckb_jsonrpc_types::JsonBytes;
 use ckb_types::packed::{OutPoint, Script};
 use serde::{Deserialize, Serialize};
@@ -136,11 +136,11 @@ pub struct ChannelUpdateInfo {
     /// Whether the channel can be currently used for payments (in this one direction).
     pub enabled: bool,
     /// The difference in htlc expiry values that you must have when routing through this channel (in milliseconds).
-    pub htlc_expiry_delta: u64,
+    pub tlc_expiry_delta: u64,
     /// The minimum value, which must be relayed to the next hop via the channel
-    pub htlc_minimum_value: u128,
+    pub tlc_minimum_value: u128,
     /// The maximum value which may be relayed to the next hop via the channel.
-    pub htlc_maximum_value: u128,
+    pub tlc_maximum_value: u128,
     pub fee_rate: u64,
     /// Most recent update for the channel received from the network
     /// Mostly redundant with the data we store in fields explicitly.
@@ -431,9 +431,9 @@ where
                 .expect("Duration since unix epoch")
                 .as_millis() as u64,
             enabled: !disabled,
-            htlc_expiry_delta: update.tlc_expiry_delta,
-            htlc_minimum_value: update.tlc_minimum_value,
-            htlc_maximum_value: update.tlc_maximum_value,
+            tlc_expiry_delta: update.tlc_expiry_delta,
+            tlc_minimum_value: update.tlc_minimum_value,
+            tlc_maximum_value: update.tlc_maximum_value,
             fee_rate: update.tlc_fee_proportional_millionths as u64,
             last_update_message: update.clone(),
         });
@@ -547,6 +547,7 @@ where
         let preimage = payment_data.preimage;
         let payment_hash = payment_data.payment_hash;
         let udt_type_script = payment_data.udt_type_script;
+        let final_tlc_expiry_delta = payment_data.final_tlc_expiry_delta;
         let invoice = payment_data
             .invoice
             .map(|x| x.parse::<CkbInvoice>().expect("parse CKB invoice"));
@@ -563,7 +564,7 @@ where
         let allow_self_payment = payment_data.allow_self_payment;
         if source == target && !allow_self_payment {
             return Err(PathFindError::PathFind(
-                "source and target are the same and allow_self_payment is not enable".to_string(),
+                "allow_self_payment is not enable, can not pay to self".to_string(),
             ));
         }
 
@@ -573,6 +574,8 @@ where
             amount,
             payment_data.max_fee_amount,
             udt_type_script,
+            final_tlc_expiry_delta,
+            payment_data.tlc_expiry_limit,
             allow_self_payment,
         )?;
         assert!(!route.is_empty());
@@ -580,6 +583,8 @@ where
         let mut current_amount = amount;
         let mut current_expiry = 0;
         let mut hops_data = vec![];
+        let current_time = now_timestamp_as_millis_u64();
+
         for i in (0..route.len()).rev() {
             let is_last = i == route.len() - 1;
             let (next_hop, next_channel_outpoint) = if is_last {
@@ -591,7 +596,7 @@ where
                 )
             };
             let (fee, expiry) = if is_last {
-                (0, 0)
+                (0, current_time + final_tlc_expiry_delta)
             } else {
                 let channel_info = self
                     .get_channel(&route[i].channel_outpoint)
@@ -601,7 +606,7 @@ where
                     .expect("channel_update is none");
                 let fee_rate = channel_update.fee_rate;
                 let fee = calculate_tlc_forward_fee(current_amount, fee_rate as u128);
-                let expiry = channel_update.htlc_expiry_delta;
+                let expiry = channel_update.tlc_expiry_delta;
                 (fee, expiry)
             };
 
@@ -616,8 +621,8 @@ where
                 channel_outpoint: next_channel_outpoint,
                 preimage: if is_last { preimage } else { None },
             });
-            current_amount += fee;
             current_expiry += expiry;
+            current_amount += fee;
         }
         // Add the first hop as the instruction for the current node, so the logic for send HTLC can be reused.
         hops_data.push(PaymentHopData {
@@ -653,6 +658,8 @@ where
         amount: u128,
         max_fee_amount: Option<u128>,
         udt_type_script: Option<Script>,
+        fianl_tlc_expiry_delta: u64,
+        tlc_expiry_limit: u64,
         allow_self: bool,
     ) -> Result<Vec<PathEdge>, PathFindError> {
         let started_time = std::time::Instant::now();
@@ -679,7 +686,7 @@ where
 
         if source == target && !allow_self {
             return Err(PathFindError::PathFind(
-                "source and target are the same".to_string(),
+                "allow_self_payment is not enable, can not pay self".to_string(),
             ));
         }
 
@@ -705,7 +712,7 @@ where
             fee_charged: 0,
             probability: 1.0,
             next_hop: None,
-            incoming_htlc_expiry: 0,
+            incoming_tlc_expiry: fianl_tlc_expiry_delta,
         });
 
         while let Some(cur_hop) = nodes_heap.pop() {
@@ -742,22 +749,27 @@ where
                     }
                 }
                 // check to make sure the current hop can send the amount
-                // if `htlc_maximum_value` equals 0, it means there is no limit
+                // if `tlc_maximum_value` equals 0, it means there is no limit
                 if amount_to_send > channel_info.capacity()
-                    || (channel_update.htlc_maximum_value != 0
-                        && amount_to_send > channel_update.htlc_maximum_value)
+                    || (channel_update.tlc_maximum_value != 0
+                        && amount_to_send > channel_update.tlc_maximum_value)
                 {
                     continue;
                 }
-                if amount_to_send < channel_update.htlc_minimum_value {
+                if amount_to_send < channel_update.tlc_minimum_value {
+                    continue;
+                }
+
+                let expiry_delta = if from == source {
+                    0
+                } else {
+                    channel_update.tlc_expiry_delta
+                };
+
+                let incoming_htlc_expiry = cur_hop.incoming_tlc_expiry + expiry_delta;
+                if incoming_htlc_expiry > tlc_expiry_limit {
                     continue;
                 }
-                let incoming_htlc_expiry = cur_hop.incoming_htlc_expiry
-                    + if from == source {
-                        0
-                    } else {
-                        channel_update.htlc_expiry_delta
-                    };
 
                 let probability = cur_hop.probability
                     * self.history.eval_probability(
@@ -772,7 +784,7 @@ where
                     continue;
                 }
                 let agg_weight =
-                    self.edge_weight(amount_to_send, fee, channel_update.htlc_expiry_delta);
+                    self.edge_weight(amount_to_send, fee, channel_update.tlc_expiry_delta);
                 let weight = cur_hop.weight + agg_weight;
                 let distance = self.calculate_distance_based_probability(probability, weight);
 
@@ -786,7 +798,7 @@ where
                     weight,
                     distance,
                     amount_received: amount_to_send,
-                    incoming_htlc_expiry,
+                    incoming_tlc_expiry: incoming_htlc_expiry,
                     fee_charged: fee,
                     probability,
                     next_hop: Some((cur_hop.node_id, channel_info.out_point())),
@@ -949,7 +961,7 @@ pub struct PaymentSession {
 
 impl PaymentSession {
     pub fn new(request: SendPaymentData, try_limit: u32) -> Self {
-        let now = now_timestamp();
+        let now = now_timestamp_as_millis_u64();
         Self {
             request,
             retried_times: 0,
@@ -970,7 +982,7 @@ impl PaymentSession {
 
     fn set_status(&mut self, status: PaymentSessionStatus) {
         self.status = status;
-        self.last_updated_at = now_timestamp();
+        self.last_updated_at = now_timestamp_as_millis_u64();
     }
 
     pub fn set_inflight_status(&mut self, channel_outpoint: OutPoint, tlc_id: u64) {
diff --git a/src/fiber/graph_syncer.rs b/src/fiber/graph_syncer.rs
index 397f639d..9d65b694 100644
--- a/src/fiber/graph_syncer.rs
+++ b/src/fiber/graph_syncer.rs
@@ -7,6 +7,8 @@ use tracing::{debug, error};
 
 use anyhow::anyhow;
 
+use crate::now_timestamp_as_millis_u64;
+
 use super::{
     network::GraphSyncerExitStatus, NetworkActorCommand, NetworkActorEvent, NetworkActorMessage,
     ASSUME_NETWORK_ACTOR_ALIVE,
@@ -56,7 +58,7 @@ impl GraphSyncer {
         ending_height: u64,
         starting_time: u64,
     ) -> Self {
-        let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_millis() as u64;
+        let now = now_timestamp_as_millis_u64();
         Self {
             network,
             peer_id,
diff --git a/src/fiber/history.rs b/src/fiber/history.rs
index cb16fc2d..5a5ce490 100644
--- a/src/fiber/history.rs
+++ b/src/fiber/history.rs
@@ -7,7 +7,7 @@ use super::{
     graph::{NetworkGraphStateStore, SessionRouteNode},
     types::{Pubkey, TlcErr},
 };
-use crate::fiber::types::TlcErrorCode;
+use crate::{fiber::types::TlcErrorCode, now_timestamp_as_millis_u64};
 use ckb_types::packed::OutPoint;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -15,19 +15,19 @@ use tracing::{debug, error};
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct TimedResult {
-    pub fail_time: u128,
+    pub fail_time: u64,
     pub fail_amount: u128,
-    pub success_time: u128,
+    pub success_time: u64,
     pub success_amount: u128,
 }
 
-const DEFAULT_MIN_FAIL_RELAX_INTERVAL: u128 = 60 * 1000;
+const DEFAULT_MIN_FAIL_RELAX_INTERVAL: u64 = 60 * 1000;
 
 // FIXME: this is a magic number from lnd, it's used to scale the amount to calculate the probability
 // lnd use 300_000_000 mili satoshis, we use shannons as the unit in fiber
 // we need to find a better way to set this value for UDT
 const DEFAULT_BIMODAL_SCALE_SHANNONS: f64 = 800_000_000.0;
-pub(crate) const DEFAULT_BIMODAL_DECAY_TIME: u128 = 6 * 60 * 60 * 1000; // 6 hours
+pub(crate) const DEFAULT_BIMODAL_DECAY_TIME: u64 = 6 * 60 * 60 * 1000; // 6 hours
 
 // The direction of the channel,
 // Forward means from node_a to node_b
@@ -41,7 +41,7 @@ pub enum Direction {
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub(crate) struct InternalPairResult {
     pub(crate) success: bool,
-    pub(crate) time: u128,
+    pub(crate) time: u64,
     pub(crate) amount: u128,
 }
 
@@ -72,7 +72,7 @@ impl InternalResult {
         node_1: Pubkey,
         node_2: Pubkey,
         channel: OutPoint,
-        time: u128,
+        time: u64,
         amount: u128,
         success: bool,
     ) {
@@ -86,8 +86,22 @@ impl InternalResult {
     }
 
     pub fn add_fail_pair(&mut self, from: Pubkey, target: Pubkey, channel: OutPoint) {
-        self.add(from, target, channel.clone(), current_time(), 0, false);
-        self.add(target, from, channel, current_time(), 0, false)
+        self.add(
+            from,
+            target,
+            channel.clone(),
+            now_timestamp_as_millis_u64(),
+            0,
+            false,
+        );
+        self.add(
+            target,
+            from,
+            channel,
+            now_timestamp_as_millis_u64(),
+            0,
+            false,
+        )
     }
 
     pub fn add_fail_pair_balanced(
@@ -97,7 +111,14 @@ impl InternalResult {
         channel: OutPoint,
         amount: u128,
     ) {
-        self.add(from, target, channel, current_time(), amount, false);
+        self.add(
+            from,
+            target,
+            channel,
+            now_timestamp_as_millis_u64(),
+            amount,
+            false,
+        );
     }
 
     pub fn fail_node(&mut self, nodes: &[SessionRouteNode], index: usize) {
@@ -135,7 +156,7 @@ impl InternalResult {
                 nodes[i].pubkey,
                 nodes[i + 1].pubkey,
                 nodes[i].channel_outpoint.clone(),
-                current_time(),
+                now_timestamp_as_millis_u64(),
                 nodes[i].amount,
                 true,
             );
@@ -194,8 +215,7 @@ impl InternalResult {
             }
         } else if index == len - 1 {
             match error_code {
-                TlcErrorCode::FinalIncorrectExpiryDelta
-                | TlcErrorCode::FinalIncorrectHtlcAmount => {
+                TlcErrorCode::FinalIncorrectExpiryDelta | TlcErrorCode::FinalIncorrectTlcAmount => {
                     if len == 2 {
                         need_to_retry = false;
                         self.fail_node(nodes, len - 1);
@@ -240,7 +260,7 @@ impl InternalResult {
                 TlcErrorCode::PermanentChannelFailure => {
                     self.fail_pair(nodes, index);
                 }
-                TlcErrorCode::FeeInsufficient | TlcErrorCode::IncorrectHtlcExpiry => {
+                TlcErrorCode::FeeInsufficient | TlcErrorCode::IncorrectTlcExpiry => {
                     need_to_retry = false;
                     if index == 1 {
                         self.fail_node(nodes, 1);
@@ -276,7 +296,7 @@ pub(crate) struct PaymentHistory<S> {
     pub inner: HashMap<(OutPoint, Direction), TimedResult>,
     pub failed_nodes: HashMap<Pubkey, u128>,
     // The minimum interval between two failed payments in milliseconds
-    pub min_fail_relax_interval: u128,
+    pub min_fail_relax_interval: u64,
     pub bimodal_scale_msat: f64,
     // this filed is used to check whether from is the source Node
     // will be used after enabling the direct channel related logic
@@ -289,7 +309,7 @@ impl<S> PaymentHistory<S>
 where
     S: ChannelActorStateStore + NetworkGraphStateStore + Clone + Send + Sync + 'static,
 {
-    pub(crate) fn new(source: Pubkey, min_fail_relax_interval: Option<u128>, store: S) -> Self {
+    pub(crate) fn new(source: Pubkey, min_fail_relax_interval: Option<u64>, store: S) -> Self {
         let mut s = PaymentHistory {
             source,
             inner: HashMap::new(),
@@ -336,7 +356,7 @@ where
         direction: Direction,
         amount: u128,
         success: bool,
-        time: u128,
+        time: u64,
     ) {
         let min_fail_relax_interval = self.min_fail_relax_interval;
         let result = if let Some(current) = self.get_mut_result(channel.clone(), direction) {
@@ -435,14 +455,14 @@ where
 
     // The factor approaches 0 for success_time a long time in the past,
     // is 1 when the success_time is now.
-    fn time_factor(&self, time: u128) -> f64 {
-        let time_ago = (current_time() - time).max(0);
+    fn time_factor(&self, time: u64) -> f64 {
+        let time_ago = (now_timestamp_as_millis_u64() - time).max(0);
         let exponent = -(time_ago as f64) / (DEFAULT_BIMODAL_DECAY_TIME as f64);
         let factor = exponent.exp();
         factor
     }
 
-    pub(crate) fn cannot_send(&self, fail_amount: u128, time: u128, capacity: u128) -> u128 {
+    pub(crate) fn cannot_send(&self, fail_amount: u128, time: u64, capacity: u128) -> u128 {
         let mut fail_amount = fail_amount;
 
         if fail_amount > capacity {
@@ -454,7 +474,7 @@ where
         cannot_send
     }
 
-    pub(crate) fn can_send(&self, amount: u128, time: u128) -> u128 {
+    pub(crate) fn can_send(&self, amount: u128, time: u64) -> u128 {
         let factor = self.time_factor(time);
         let can_send = (amount as f64 * factor) as u128;
         can_send
@@ -471,7 +491,7 @@ where
         let mut prob = 1.0;
         if let Some(result) = self.get_result(channel, direction) {
             if result.fail_time != 0 {
-                let time_ago = (current_time() - result.fail_time).min(0);
+                let time_ago = (now_timestamp_as_millis_u64() - result.fail_time).min(0);
                 let exponent = -(time_ago as f64) / (DEFAULT_BIMODAL_DECAY_TIME as f64);
                 prob -= exponent.exp();
             }
diff --git a/src/fiber/network.rs b/src/fiber/network.rs
index 674a74fd..1d43c8fb 100644
--- a/src/fiber/network.rs
+++ b/src/fiber/network.rs
@@ -46,14 +46,15 @@ use tokio_util::task::TaskTracker;
 use tracing::{debug, error, info, trace, warn};
 
 use super::channel::{
-    AcceptChannelParameter, ChannelActor, ChannelActorMessage, ChannelActorStateStore,
-    ChannelCommand, ChannelCommandWithId, ChannelEvent, ChannelInitializationParameter,
-    ChannelState, ChannelSubscribers, OpenChannelParameter, ProcessingChannelError,
-    ProcessingChannelResult, PublicChannelInfo, ShuttingDownFlags, DEFAULT_COMMITMENT_FEE_RATE,
-    DEFAULT_FEE_RATE,
+    get_funding_and_reserved_amount, occupied_capacity, AcceptChannelParameter, ChannelActor,
+    ChannelActorMessage, ChannelActorStateStore, ChannelCommand, ChannelCommandWithId,
+    ChannelEvent, ChannelInitializationParameter, ChannelState, ChannelSubscribers,
+    OpenChannelParameter, ProcessingChannelError, ProcessingChannelResult, PublicChannelInfo,
+    ShuttingDownFlags, DEFAULT_COMMITMENT_FEE_RATE, DEFAULT_FEE_RATE, MAX_COMMITMENT_DELAY_EPOCHS,
+    MIN_COMMITMENT_DELAY_EPOCHS, SYS_MAX_TLC_NUMBER_IN_FLIGHT,
 };
-use super::config::AnnouncedNodeName;
-use super::fee::{calculate_commitment_tx_fee, default_minimal_ckb_amount};
+use super::config::{AnnouncedNodeName, MIN_TLC_EXPIRY_DELTA};
+use super::fee::calculate_commitment_tx_fee;
 use super::graph::{NetworkGraph, NetworkGraphStateStore, SessionRoute};
 use super::graph_syncer::{GraphSyncer, GraphSyncerMessage};
 use super::key::blake2b_hash_with_salt;
@@ -63,8 +64,8 @@ use super::types::{
     FiberQueryInformation, GetBroadcastMessages, GetBroadcastMessagesResult, Hash256,
     NodeAnnouncement, NodeAnnouncementQuery, OpenChannel, PaymentHopData, Privkey, Pubkey,
     QueryBroadcastMessagesWithinTimeRange, QueryBroadcastMessagesWithinTimeRangeResult,
-    QueryChannelsWithinBlockRange, QueryChannelsWithinBlockRangeResult, RemoveTlc, RemoveTlcReason,
-    TlcErr, TlcErrData, TlcErrPacket, TlcErrorCode,
+    QueryChannelsWithinBlockRange, QueryChannelsWithinBlockRangeResult, RemoveTlcReason, TlcErr,
+    TlcErrData, TlcErrPacket, TlcErrorCode,
 };
 use super::{FiberConfig, ASSUME_NETWORK_ACTOR_ALIVE};
 
@@ -74,6 +75,7 @@ use crate::ckb::{CkbChainMessage, FundingRequest, FundingTx, TraceTxRequest, Tra
 use crate::fiber::channel::{
     AddTlcCommand, AddTlcResponse, TxCollaborationCommand, TxUpdateCommand,
 };
+use crate::fiber::config::{DEFAULT_TLC_EXPIRY_DELTA, MAX_PAYMENT_TLC_EXPIRY_LIMIT};
 use crate::fiber::graph::{ChannelInfo, PaymentSession, PaymentSessionStatus};
 use crate::fiber::serde_utils::EntityHex;
 use crate::fiber::types::{
@@ -288,8 +290,10 @@ pub struct SendPaymentCommand {
     pub payment_hash: Option<Hash256>,
     // the encoded invoice to send to the recipient
     pub invoice: Option<String>,
-    // The htlc expiry delta that should be used to set the timelock for the final hop
-    pub final_htlc_expiry_delta: Option<u64>,
+    // the TLC expiry delta that should be used to set the timelock for the final hop
+    pub final_tlc_expiry_delta: Option<u64>,
+    // the TLC expiry for whole payment, in milliseconds
+    pub tlc_expiry_limit: Option<u64>,
     // the payment timeout in seconds, if the payment is not completed within this time, it will be cancelled
     pub timeout: Option<u64>,
     // the maximum fee amounts in shannons that the sender is willing to pay, default is 1000 shannons CKB.
@@ -314,7 +318,8 @@ pub struct SendPaymentData {
     pub amount: u128,
     pub payment_hash: Hash256,
     pub invoice: Option<String>,
-    pub final_htlc_expiry_delta: Option<u64>,
+    pub final_tlc_expiry_delta: u64,
+    pub tlc_expiry_limit: u64,
     pub timeout: Option<u64>,
     pub max_fee_amount: Option<u128>,
     pub max_parts: Option<u64>,
@@ -327,7 +332,7 @@ pub struct SendPaymentData {
 }
 
 impl SendPaymentData {
-    pub fn new(command: SendPaymentCommand, source: Pubkey) -> Result<SendPaymentData, String> {
+    pub fn new(command: SendPaymentCommand) -> Result<SendPaymentData, String> {
         let invoice = command
             .invoice
             .as_ref()
@@ -367,10 +372,6 @@ impl SendPaymentData {
             "target_pubkey",
         )?;
 
-        if !command.allow_self_payment && target == source {
-            return Err("allow_self_payment is not enable, can not pay self".to_string());
-        }
-
         let amount = validate_field(
             command.amount,
             invoice.as_ref().and_then(|i| i.amount()),
@@ -387,6 +388,38 @@ impl SendPaymentData {
             Err(e) => return Err(e),
         };
 
+        // check htlc expiry delta and limit are both valid if it is set
+        let final_tlc_expiry_delta = command
+            .final_tlc_expiry_delta
+            .or_else(|| {
+                invoice
+                    .as_ref()
+                    .and_then(|i| i.final_tlc_minimum_expiry_delta().copied())
+            })
+            .unwrap_or(DEFAULT_TLC_EXPIRY_DELTA);
+        if final_tlc_expiry_delta < MIN_TLC_EXPIRY_DELTA
+            || final_tlc_expiry_delta > MAX_PAYMENT_TLC_EXPIRY_LIMIT
+        {
+            return Err(format!(
+                "invalid final_tlc_expiry_delta, expect between {} and {}",
+                MIN_TLC_EXPIRY_DELTA, MAX_PAYMENT_TLC_EXPIRY_LIMIT
+            ));
+        }
+
+        let tlc_expiry_limit = command
+            .tlc_expiry_limit
+            .unwrap_or(MAX_PAYMENT_TLC_EXPIRY_LIMIT);
+
+        if tlc_expiry_limit < final_tlc_expiry_delta || tlc_expiry_limit < MIN_TLC_EXPIRY_DELTA {
+            return Err("tlc_expiry_limit is too small".to_string());
+        }
+        if tlc_expiry_limit > MAX_PAYMENT_TLC_EXPIRY_LIMIT {
+            return Err(format!(
+                "tlc_expiry_limit is too large, expect it to less than {}",
+                MAX_PAYMENT_TLC_EXPIRY_LIMIT
+            ));
+        }
+
         let keysend = command.keysend.unwrap_or(false);
         let (payment_hash, preimage) = if !keysend {
             (
@@ -419,7 +452,8 @@ impl SendPaymentData {
             amount,
             payment_hash,
             invoice: command.invoice,
-            final_htlc_expiry_delta: command.final_htlc_expiry_delta,
+            final_tlc_expiry_delta,
+            tlc_expiry_limit,
             timeout: command.timeout,
             max_fee_amount: command.max_fee_amount,
             max_parts: command.max_parts,
@@ -563,7 +597,7 @@ pub enum NetworkActorEvent {
     GraphSyncerExited(PeerId, GraphSyncerExitStatus),
 
     // A tlc remove message is received. (payment_hash, remove_tlc)
-    TlcRemoveReceived(Hash256, RemoveTlc),
+    TlcRemoveReceived(Hash256, RemoveTlcReason),
 
     /// Network service events to be sent to outside observers.
     /// These events may be both present at `NetworkActorEvent` and
@@ -669,8 +703,8 @@ where
                             is_udt_type_auto_accept(udt_type_script, open_channel.funding_amount)
                         } else {
                             state.auto_accept_channel_ckb_funding_amount > 0
-                                && open_channel.all_ckb_amount()
-                                    >= state.open_channel_auto_accept_min_ckb_funding_amount
+                                && open_channel.funding_amount
+                                    >= state.open_channel_auto_accept_min_ckb_funding_amount as u128
                         };
                         if auto_accept {
                             let accept_channel = AcceptChannelCommand {
@@ -1122,12 +1156,6 @@ where
             ) => {
                 assert_ne!(new, old, "new and old channel id must be different");
                 if let Some(session) = state.get_peer_session(&peer_id) {
-                    state.check_accept_channel_ckb_parameters(
-                        local_reserved_ckb_amount,
-                        remote_reserved_ckb_amount,
-                        funding_fee_rate,
-                        &udt_funding_script,
-                    )?;
                     if let Some(channel) = state.channels.remove(&old) {
                         debug!("Channel accepted: {:?} -> {:?}", old, new);
                         state.channels.insert(new, channel);
@@ -1260,9 +1288,9 @@ where
                 }
                 state.maybe_finish_sync();
             }
-            NetworkActorEvent::TlcRemoveReceived(payment_hash, remove_tlc) => {
+            NetworkActorEvent::TlcRemoveReceived(payment_hash, remove_tlc_reason) => {
                 // When a node is restarted, RemoveTLC will also be resent if necessary
-                self.on_remove_tlc_event(state, payment_hash, remove_tlc.reason)
+                self.on_remove_tlc_event(state, payment_hash, remove_tlc_reason)
                     .await;
             }
         }
@@ -2190,7 +2218,7 @@ where
                 amount: info.amount,
                 preimage: None,
                 payment_hash: Some(info.payment_hash),
-                expiry: info.expiry.into(),
+                expiry: info.expiry,
                 hash_algorithm: info.tlc_hash_algorithm,
                 onion_packet: peeled_packet.next.map(|next| next.data).unwrap_or_default(),
                 previous_tlc,
@@ -2449,11 +2477,10 @@ where
         state: &mut NetworkActorState<S>,
         payment_request: SendPaymentCommand,
     ) -> Result<SendPaymentResponse, Error> {
-        let payment_data = SendPaymentData::new(payment_request.clone(), state.get_public_key())
-            .map_err(|e| {
-                error!("Failed to validate payment request: {:?}", e);
-                Error::InvalidParameter(format!("Failed to validate payment request: {:?}", e))
-            })?;
+        let payment_data = SendPaymentData::new(payment_request.clone()).map_err(|e| {
+            error!("Failed to validate payment request: {:?}", e);
+            Error::InvalidParameter(format!("Failed to validate payment request: {:?}", e))
+        })?;
 
         // for dry run, we only build the route and return the hops info,
         // will not store the payment session and send the onion packet
@@ -3020,9 +3047,16 @@ where
                 ));
             }
         }
-        // NOTE: here we only check the amount is valid, we will also check more in the `pre_start` from channel creation
-        let (_funding_amount, _reserved_ckb_amount) =
-            self.get_funding_and_reserved_amount(funding_amount, &funding_udt_type_script)?;
+
+        if let Some(_delta) = tlc_expiry_delta.filter(|&d| d < MIN_TLC_EXPIRY_DELTA) {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "TLC expiry delta is too small, expect larger than {}",
+                MIN_TLC_EXPIRY_DELTA
+            )));
+        }
+
+        let shutdown_script =
+            shutdown_script.unwrap_or_else(|| self.default_shutdown_script.clone());
 
         let seed = self.generate_channel_seed();
         let (tx, rx) = oneshot::channel::<Hash256>();
@@ -3045,8 +3079,7 @@ where
                     tlc_fee_proportional_millionths.unwrap_or(self.tlc_fee_proportional_millionths),
                 )),
                 funding_udt_type_script,
-                shutdown_script: shutdown_script
-                    .unwrap_or_else(|| self.default_shutdown_script.clone()),
+                shutdown_script,
                 channel_id_sender: tx,
                 commitment_fee_rate,
                 commitment_delay_epoch,
@@ -3089,8 +3122,11 @@ where
                     &peer_id
                 )))?;
 
-        let (funding_amount, reserved_ckb_amount) = self.get_funding_and_reserved_amount(
+        let shutdown_script =
+            shutdown_script.unwrap_or_else(|| self.default_shutdown_script.clone());
+        let (funding_amount, reserved_ckb_amount) = get_funding_and_reserved_amount(
             funding_amount,
+            &shutdown_script,
             &open_channel.funding_udt_type_script,
         )?;
 
@@ -3123,8 +3159,7 @@ where
                 )),
                 seed,
                 open_channel,
-                shutdown_script: shutdown_script
-                    .unwrap_or_else(|| self.default_shutdown_script.clone()),
+                shutdown_script,
                 channel_id_sender: Some(tx),
             }),
             network.clone().get_cell(),
@@ -3221,75 +3256,24 @@ where
         self.peer_pubkey_map.get(peer_id).cloned()
     }
 
-    fn get_funding_and_reserved_amount(
-        &self,
-        funding_amount: u128,
-        udt_type_script: &Option<Script>,
-    ) -> Result<(u128, u64), ProcessingChannelError> {
-        let reserved_ckb_amount = default_minimal_ckb_amount(udt_type_script.is_some());
-        if udt_type_script.is_none() {
-            if funding_amount < reserved_ckb_amount.into() {
-                return Err(ProcessingChannelError::InvalidParameter(format!(
-                    "The funding amount should be greater than the reserved amount: {}",
-                    reserved_ckb_amount
-                )));
-            }
-            if funding_amount >= u64::MAX as u128 {
-                return Err(ProcessingChannelError::InvalidParameter(format!(
-                    "The funding amount should be less than {:?}",
-                    u64::MAX
-                )));
-            }
-        }
-        let funding_amount = if udt_type_script.is_some() {
-            funding_amount
-        } else {
-            funding_amount - reserved_ckb_amount as u128
-        };
-        Ok((funding_amount, reserved_ckb_amount))
-    }
-
-    fn check_accept_channel_ckb_parameters(
-        &self,
-        remote_reserved_ckb_amount: u64,
-        local_reserved_ckb_amount: u64,
-        funding_fee_rate: u64,
-        udt_type_script: &Option<Script>,
-    ) -> crate::Result<()> {
-        let reserved_ckb_amount = default_minimal_ckb_amount(udt_type_script.is_some());
-        if remote_reserved_ckb_amount < reserved_ckb_amount
-            || local_reserved_ckb_amount < reserved_ckb_amount
-        {
-            return Err(Error::InvalidParameter(format!(
-                "Reserved CKB amount is less than the minimal amount: {}",
-                reserved_ckb_amount
-            )));
-        }
-
-        if funding_fee_rate < DEFAULT_FEE_RATE {
-            return Err(Error::InvalidParameter(format!(
-                "Funding fee rate is less than {}",
-                DEFAULT_FEE_RATE
-            )));
-        }
-        Ok(())
-    }
-
-    fn check_open_ckb_parameters(
+    // TODO: this fn is duplicated with ChannelActorState::check_open_channel_parameters, but is not easy to refactor, just keep it for now.
+    fn check_open_channel_parameters(
         &self,
         open_channel: &OpenChannel,
     ) -> Result<(), ProcessingChannelError> {
-        let reserved_ckb_amount = open_channel.reserved_ckb_amount;
         let udt_type_script = &open_channel.funding_udt_type_script;
 
-        let minimal_reserved_ckb_amount = default_minimal_ckb_amount(udt_type_script.is_some());
-        if reserved_ckb_amount < minimal_reserved_ckb_amount {
+        // reserved_ckb_amount
+        let occupied_capacity =
+            occupied_capacity(&open_channel.shutdown_script, udt_type_script)?.as_u64();
+        if open_channel.reserved_ckb_amount < occupied_capacity {
             return Err(ProcessingChannelError::InvalidParameter(format!(
-                "Remote reserved CKB amount {} is less than the minimal amount: {}",
-                reserved_ckb_amount, minimal_reserved_ckb_amount,
+                "Reserved CKB amount {} is less than {}",
+                open_channel.reserved_ckb_amount, occupied_capacity,
             )));
         }
 
+        // funding_fee_rate
         if open_channel.funding_fee_rate < DEFAULT_FEE_RATE {
             return Err(ProcessingChannelError::InvalidParameter(format!(
                 "Funding fee rate is less than {}",
@@ -3297,28 +3281,54 @@ where
             )));
         }
 
+        // commitment_fee_rate
         if open_channel.commitment_fee_rate < DEFAULT_COMMITMENT_FEE_RATE {
             return Err(ProcessingChannelError::InvalidParameter(format!(
                 "Commitment fee rate is less than {}",
                 DEFAULT_COMMITMENT_FEE_RATE,
             )));
         }
+        let commitment_fee =
+            calculate_commitment_tx_fee(open_channel.commitment_fee_rate, udt_type_script);
+        let reserved_fee = open_channel.reserved_ckb_amount - occupied_capacity;
+        if commitment_fee * 2 > reserved_fee {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Commitment fee {} which caculated by commitment fee rate {} is larger than half of reserved fee {}",
+                commitment_fee, open_channel.commitment_fee_rate, reserved_fee
+            )));
+        }
 
-        let commitment_fee = calculate_commitment_tx_fee(
-            open_channel.commitment_fee_rate,
-            &open_channel.funding_udt_type_script,
-        );
+        // commitment_delay_epoch
+        let epoch =
+            EpochNumberWithFraction::from_full_value_unchecked(open_channel.commitment_delay_epoch);
+        if !epoch.is_well_formed() {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Commitment delay epoch {} is not a valid value",
+                open_channel.commitment_delay_epoch,
+            )));
+        }
 
-        let expected_minimal_reserved_ckb_amount = commitment_fee * 2;
-        debug!(
-            "expected_minimal_reserved_ckb_amount: {}, reserved_ckb_amount: {}",
-            expected_minimal_reserved_ckb_amount, reserved_ckb_amount
-        );
-        if reserved_ckb_amount < expected_minimal_reserved_ckb_amount {
+        let min = EpochNumberWithFraction::new(MIN_COMMITMENT_DELAY_EPOCHS, 0, 1);
+        if epoch < min {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Commitment delay epoch {} is less than the minimal value {}",
+                epoch, min
+            )));
+        }
+
+        let max = EpochNumberWithFraction::new(MAX_COMMITMENT_DELAY_EPOCHS, 0, 1);
+        if epoch > max {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Commitment delay epoch {} is greater than the maximal value {}",
+                epoch, max
+            )));
+        }
+
+        // max_tlc_number_in_flight
+        if open_channel.max_tlc_number_in_flight > SYS_MAX_TLC_NUMBER_IN_FLIGHT {
             return Err(ProcessingChannelError::InvalidParameter(format!(
-                "Commitment fee rate is: {}, expect more CKB amount as reserved ckb amount expected to larger than {}, \
-                or you can set a lower commitment fee rate",
-                open_channel.commitment_fee_rate, expected_minimal_reserved_ckb_amount
+                "Max TLC number in flight {} is greater than the system maximal value {}",
+                open_channel.max_tlc_number_in_flight, SYS_MAX_TLC_NUMBER_IN_FLIGHT
             )));
         }
 
@@ -3707,7 +3717,7 @@ where
         peer_id: PeerId,
         open_channel: OpenChannel,
     ) -> ProcessingChannelResult {
-        self.check_open_ckb_parameters(&open_channel)?;
+        self.check_open_channel_parameters(&open_channel)?;
 
         if let Some(udt_type_script) = &open_channel.funding_udt_type_script {
             if !check_udt_script(udt_type_script) {
diff --git a/src/fiber/path.rs b/src/fiber/path.rs
index 6842501f..0077f96b 100644
--- a/src/fiber/path.rs
+++ b/src/fiber/path.rs
@@ -26,7 +26,7 @@ pub(crate) struct NodeHeapElement {
     pub probability: f64,
 
     // The expected aboslute expiry timestamp (in milliseconds) for the incoming HTLC of this Node
-    pub incoming_htlc_expiry: u64,
+    pub incoming_tlc_expiry: u64,
 
     // next_hop is the edge this route comes from
     pub next_hop: Option<(Pubkey, OutPoint)>,
@@ -60,7 +60,7 @@ impl PartialEq for NodeHeapElement {
             && self.amount_received == other.amount_received
             && self.fee_charged == other.fee_charged
             && self.probability == other.probability
-            && self.incoming_htlc_expiry == other.incoming_htlc_expiry
+            && self.incoming_tlc_expiry == other.incoming_tlc_expiry
             && self.next_hop == other.next_hop
     }
 }
diff --git a/src/fiber/tests/channel.rs b/src/fiber/tests/channel.rs
index fe0b24eb..167443d7 100644
--- a/src/fiber/tests/channel.rs
+++ b/src/fiber/tests/channel.rs
@@ -1,8 +1,9 @@
+use crate::fiber::config::MAX_PAYMENT_TLC_EXPIRY_LIMIT;
 use crate::fiber::graph::PaymentSessionStatus;
 use crate::fiber::network::SendPaymentCommand;
-use crate::fiber::tests::test_utils::gen_rand_public_key;
-use crate::fiber::tests::test_utils::gen_sha256_hash;
-
+use crate::fiber::tests::test_utils::{
+    gen_rand_public_key, gen_sha256_hash, NetworkNodeConfigBuilder,
+};
 use crate::{
     ckb::contracts::{get_cell_deps, Contract},
     fiber::{
@@ -11,14 +12,14 @@ use crate::{
             ChannelCommand, ChannelCommandWithId, InMemorySigner, RemoveTlcCommand,
             ShutdownCommand, DEFAULT_COMMITMENT_FEE_RATE,
         },
-        config::DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT,
+        config::DEFAULT_AUTO_ACCEPT_CHANNEL_CKB_FUNDING_AMOUNT,
         graph::NetworkGraphStateStore,
         hash_algorithm::HashAlgorithm,
         network::{AcceptChannelCommand, OpenChannelCommand},
         types::{Hash256, Privkey, RemoveTlcFulfill, RemoveTlcReason},
         NetworkActorCommand, NetworkActorMessage,
     },
-    now_timestamp, NetworkServiceEvent,
+    now_timestamp_as_millis_u64, NetworkServiceEvent,
 };
 use ckb_jsonrpc_types::Status;
 use ckb_types::{
@@ -138,7 +139,7 @@ async fn test_open_and_accept_channel() {
         NetworkActorMessage::Command(NetworkActorCommand::AcceptChannel(
             AcceptChannelCommand {
                 temp_channel_id: open_channel_result.channel_id,
-                funding_amount: DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT as u128,
+                funding_amount: DEFAULT_AUTO_ACCEPT_CHANNEL_CKB_FUNDING_AMOUNT as u128,
                 shutdown_script: None,
             },
             rpc_reply,
@@ -314,7 +315,8 @@ async fn test_network_send_payment_normal_keysend_workflow() {
                 target_pubkey: Some(node_b_pubkey),
                 amount: Some(10000),
                 payment_hash: None,
-                final_htlc_expiry_delta: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
                 invoice: None,
                 timeout: None,
                 max_fee_amount: None,
@@ -334,7 +336,7 @@ async fn test_network_send_payment_normal_keysend_workflow() {
     assert_eq!(res.status, PaymentSessionStatus::Inflight);
     let payment_hash = res.payment_hash;
 
-    tokio::time::sleep(tokio::time::Duration::from_millis(3000)).await;
+    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
 
     let message = |rpc_reply| -> NetworkActorMessage {
         NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash, rpc_reply))
@@ -342,6 +344,8 @@ async fn test_network_send_payment_normal_keysend_workflow() {
     let res = call!(node_a.network_actor, message)
         .expect("node_a alive")
         .unwrap();
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
     assert_eq!(res.status, PaymentSessionStatus::Success);
     assert_eq!(res.failed_error, None);
 
@@ -352,9 +356,10 @@ async fn test_network_send_payment_normal_keysend_workflow() {
                 target_pubkey: Some(node_b_pubkey),
                 amount: Some(10000),
                 payment_hash: None,
-                final_htlc_expiry_delta: None,
+                final_tlc_expiry_delta: None,
                 invoice: None,
                 timeout: None,
+                tlc_expiry_limit: None,
                 max_fee_amount: None,
                 max_parts: None,
                 keysend: Some(true),
@@ -396,7 +401,9 @@ async fn test_network_send_payment_keysend_with_payment_hash() {
                 target_pubkey: Some(node_b_pubkey),
                 amount: Some(10000),
                 payment_hash: Some(payment_hash),
-                final_htlc_expiry_delta: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
+
                 invoice: None,
                 timeout: None,
                 max_fee_amount: None,
@@ -440,7 +447,8 @@ async fn test_network_send_payment_final_incorrect_hash() {
                 target_pubkey: Some(node_b_pubkey),
                 amount: Some(10000),
                 payment_hash: Some(payment_hash),
-                final_htlc_expiry_delta: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
                 invoice: None,
                 timeout: None,
                 max_fee_amount: None,
@@ -498,7 +506,8 @@ async fn test_network_send_payment_target_not_found() {
                 target_pubkey: Some(node_b_pubkey),
                 amount: Some(10000),
                 payment_hash: Some(gen_sha256_hash()),
-                final_htlc_expiry_delta: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
                 invoice: None,
                 timeout: None,
                 max_fee_amount: None,
@@ -537,7 +546,8 @@ async fn test_network_send_payment_amount_is_too_large() {
                 target_pubkey: Some(node_b_pubkey),
                 amount: Some(100000000000 + 5),
                 payment_hash: Some(gen_sha256_hash()),
-                final_htlc_expiry_delta: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
                 invoice: None,
                 timeout: None,
                 max_fee_amount: None,
@@ -580,10 +590,11 @@ async fn test_network_send_payment_with_dry_run() {
                 target_pubkey: Some(node_b_pubkey),
                 amount: Some(100000000000 + 5),
                 payment_hash: Some(gen_sha256_hash()),
-                final_htlc_expiry_delta: None,
+                final_tlc_expiry_delta: None,
                 invoice: None,
                 timeout: None,
                 max_fee_amount: None,
+                tlc_expiry_limit: None,
                 max_parts: None,
                 keysend: None,
                 udt_type_script: None,
@@ -606,10 +617,11 @@ async fn test_network_send_payment_with_dry_run() {
                 target_pubkey: Some(gen_rand_public_key()),
                 amount: Some(1000 + 5),
                 payment_hash: Some(gen_sha256_hash()),
-                final_htlc_expiry_delta: None,
+                final_tlc_expiry_delta: None,
                 invoice: None,
                 timeout: None,
                 max_fee_amount: None,
+                tlc_expiry_limit: None,
                 max_parts: None,
                 keysend: None,
                 udt_type_script: None,
@@ -647,10 +659,11 @@ async fn test_send_payment_with_3_nodes() {
                 target_pubkey: Some(node_c_pubkey),
                 amount: Some(1000000 + 5),
                 payment_hash: None,
-                final_htlc_expiry_delta: None,
+                final_tlc_expiry_delta: None,
                 invoice: None,
                 timeout: None,
                 max_fee_amount: None,
+                tlc_expiry_limit: None,
                 max_parts: None,
                 keysend: Some(true),
                 udt_type_script: None,
@@ -692,7 +705,7 @@ async fn test_send_payment_fail_with_3_nodes_invalid_hash() {
     .await;
 
     // sleep for 2 seconds to make sure the channel is established
-    tokio::time::sleep(tokio::time::Duration::from_millis(5000)).await;
+    tokio::time::sleep(tokio::time::Duration::from_millis(3000)).await;
 
     let node_c_pubkey = node_c.pubkey.clone();
     let message = |rpc_reply| -> NetworkActorMessage {
@@ -701,10 +714,11 @@ async fn test_send_payment_fail_with_3_nodes_invalid_hash() {
                 target_pubkey: Some(node_c_pubkey),
                 amount: Some(1000000 + 5),
                 payment_hash: Some(gen_sha256_hash()), // this payment hash is not from node_c
-                final_htlc_expiry_delta: None,
+                final_tlc_expiry_delta: None,
                 invoice: None,
                 timeout: None,
                 max_fee_amount: None,
+                tlc_expiry_limit: None,
                 max_parts: None,
                 keysend: None,
                 udt_type_script: None,
@@ -721,7 +735,7 @@ async fn test_send_payment_fail_with_3_nodes_invalid_hash() {
     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))
     };
@@ -735,6 +749,138 @@ async fn test_send_payment_fail_with_3_nodes_invalid_hash() {
     );
 }
 
+#[tokio::test]
+async fn test_network_send_payment_dry_run_can_still_query() {
+    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(5000)).await;
+
+    let payment_hash = gen_sha256_hash();
+    let node_b_pubkey = node_b.pubkey.clone();
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_b_pubkey),
+                amount: Some(10000),
+                payment_hash: Some(payment_hash),
+                final_tlc_expiry_delta: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                tlc_expiry_limit: None,
+                max_parts: None,
+                keysend: None,
+                udt_type_script: None,
+                allow_self_payment: false,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
+    };
+    let res = call!(node_a.network_actor, message).expect("node_a alive");
+    assert!(res.is_ok());
+
+    // sleep for a while to make sure the payment session is created
+    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_b_pubkey),
+                amount: Some(10000),
+                payment_hash: Some(payment_hash),
+                final_tlc_expiry_delta: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                tlc_expiry_limit: None,
+                max_parts: None,
+                keysend: None,
+                udt_type_script: None,
+                allow_self_payment: false,
+                dry_run: true,
+            },
+            rpc_reply,
+        ))
+    };
+    let res = call!(node_a.network_actor, message).expect("node_a alive");
+    eprintln!("{:?}", res);
+    assert!(res.is_ok());
+}
+
+#[tokio::test]
+async fn test_network_send_payment_dry_run_will_not_create_payment_session() {
+    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(5000)).await;
+
+    let payment_hash = gen_sha256_hash();
+    let node_b_pubkey = node_b.pubkey.clone();
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_b_pubkey),
+                amount: Some(10000),
+                payment_hash: Some(payment_hash),
+                final_tlc_expiry_delta: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                tlc_expiry_limit: None,
+                max_parts: None,
+                keysend: None,
+                udt_type_script: None,
+                allow_self_payment: false,
+                dry_run: true,
+            },
+            rpc_reply,
+        ))
+    };
+    let res = call!(node_a.network_actor, message).expect("node_a alive");
+    assert!(res.is_ok());
+
+    // make sure we can send the same payment after dry run query
+    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_b_pubkey),
+                amount: Some(10000),
+                payment_hash: Some(payment_hash),
+                final_tlc_expiry_delta: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                tlc_expiry_limit: None,
+                max_parts: None,
+                keysend: None,
+                udt_type_script: None,
+                allow_self_payment: false,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
+    };
+    let res = call!(node_a.network_actor, message).expect("node_a alive");
+    eprintln!("{:?}", res);
+    assert!(res.is_ok());
+}
+
 #[tokio::test]
 async fn test_stash_broadcast_messages() {
     init_tracing();
@@ -858,7 +1004,7 @@ async fn do_test_channel_commitment_tx_after_add_tlc(algorithm: HashAlgorithm) {
                         amount: tlc_amount,
                         hash_algorithm: algorithm,
                         payment_hash: Some(digest.into()),
-                        expiry: now_timestamp() + DEFAULT_EXPIRY_DELTA,
+                        expiry: now_timestamp_as_millis_u64() + DEFAULT_EXPIRY_DELTA,
                         preimage: None,
                         onion_packet: vec![],
                         previous_tlc: None,
@@ -1120,7 +1266,7 @@ async fn do_test_remove_tlc_with_wrong_hash_algorithm(
                         amount: tlc_amount,
                         hash_algorithm: correct_algorithm,
                         payment_hash: Some(digest.into()),
-                        expiry: now_timestamp() + DEFAULT_EXPIRY_DELTA,
+                        expiry: now_timestamp_as_millis_u64() + DEFAULT_EXPIRY_DELTA,
                         preimage: None,
                         onion_packet: vec![],
                         previous_tlc: None,
@@ -1169,7 +1315,7 @@ async fn do_test_remove_tlc_with_wrong_hash_algorithm(
                         amount: tlc_amount,
                         hash_algorithm: wrong_algorithm,
                         payment_hash: Some(digest.into()),
-                        expiry: now_timestamp() + DEFAULT_EXPIRY_DELTA,
+                        expiry: now_timestamp_as_millis_u64() + DEFAULT_EXPIRY_DELTA,
                         preimage: None,
                         onion_packet: vec![],
                         previous_tlc: None,
@@ -1209,6 +1355,66 @@ async fn do_test_remove_tlc_with_wrong_hash_algorithm(
     assert!(remove_tlc_result.is_err());
 }
 
+#[tokio::test]
+async fn do_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);
+    let tlc_amount = 1000000000;
+
+    // add tlc command with expiry soon
+    let add_tlc_command = AddTlcCommand {
+        amount: tlc_amount,
+        hash_algorithm: HashAlgorithm::CkbHash,
+        payment_hash: Some(digest.into()),
+        expiry: now_timestamp_as_millis_u64() + 10,
+        preimage: None,
+        onion_packet: vec![],
+        previous_tlc: None,
+    };
+
+    std::thread::sleep(std::time::Duration::from_millis(400));
+    let add_tlc_result = call!(node_a.network_actor, |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: new_channel_id,
+                command: ChannelCommand::AddTlc(add_tlc_command, rpc_reply),
+            },
+        ))
+    })
+    .expect("node_b alive");
+    assert!(add_tlc_result.is_err());
+
+    // add tlc command with expiry in the future too long
+    let add_tlc_command = AddTlcCommand {
+        amount: tlc_amount,
+        hash_algorithm: HashAlgorithm::CkbHash,
+        payment_hash: Some(digest.into()),
+        expiry: now_timestamp_as_millis_u64() + MAX_PAYMENT_TLC_EXPIRY_LIMIT + 10,
+        preimage: None,
+        onion_packet: vec![],
+        previous_tlc: None,
+    };
+
+    let add_tlc_result = call!(node_a.network_actor, |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: new_channel_id,
+                command: ChannelCommand::AddTlc(add_tlc_command, rpc_reply),
+            },
+        ))
+    })
+    .expect("node_b alive");
+
+    assert!(add_tlc_result.is_err());
+}
+
 #[tokio::test]
 async fn test_remove_tlc_with_wrong_hash_algorithm() {
     let supported_algorithms = HashAlgorithm::supported_algorithms();
@@ -1243,7 +1449,7 @@ async fn do_test_channel_with_simple_update_operation(algorithm: HashAlgorithm)
                         amount: tlc_amount,
                         hash_algorithm: algorithm,
                         payment_hash: Some(digest.into()),
-                        expiry: now_timestamp() + DEFAULT_EXPIRY_DELTA,
+                        expiry: now_timestamp_as_millis_u64() + DEFAULT_EXPIRY_DELTA,
                         preimage: None,
                         onion_packet: vec![],
                         previous_tlc: None,
@@ -1377,7 +1583,7 @@ async fn test_open_channel_with_invalid_ckb_amount_range() {
     assert!(open_channel_result
         .err()
         .unwrap()
-        .contains("The funding amount should be less than 18446744073709551615"));
+        .contains("The funding amount (21267647932558653966460912964485513215) should be less than 18446744073709551615"));
 }
 
 #[tokio::test]
@@ -1909,3 +2115,144 @@ async fn test_connect_to_peers_with_mutual_channel_on_restart_version_2() {
     )
     .await;
 }
+
+#[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;
+
+    // test open channel with large size shutdown script
+    let message = |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::OpenChannel(
+            OpenChannelCommand {
+                peer_id: node_b.peer_id.clone(),
+                public: false,
+                shutdown_script: Some(Script::new_builder().args(vec![0u8; 40].pack()).build()),
+                funding_amount: (81 + 1) * 100000000 - 1,
+                funding_udt_type_script: None,
+                commitment_fee_rate: None,
+                commitment_delay_epoch: None,
+                funding_fee_rate: None,
+                tlc_expiry_delta: None,
+                tlc_min_value: None,
+                tlc_max_value: None,
+                tlc_fee_proportional_millionths: None,
+                max_tlc_number_in_flight: None,
+                max_tlc_value_in_flight: None,
+            },
+            rpc_reply,
+        ))
+    };
+
+    let open_channel_result = call!(node_a.network_actor, message).expect("node_a alive");
+
+    assert!(open_channel_result
+        .err()
+        .unwrap()
+        .contains("The funding amount (8199999999) should be greater than or equal to 8200000000"));
+}
+
+#[tokio::test]
+#[should_panic(expected = "Waiting for event timeout")]
+async fn test_accept_channel_with_large_size_shutdown_script_should_fail() {
+    let mut nodes = NetworkNode::new_n_interconnected_nodes_with_config(2, |i| {
+        NetworkNodeConfigBuilder::new()
+            .node_name(Some(format!("node-{}", i)))
+            .base_dir_prefix(&format!("fnn-test-node-{}-", i))
+            .fiber_config_updater(|config| {
+                // enable auto accept channel with default value
+                config.auto_accept_channel_ckb_funding_amount = Some(6200000000);
+                config.open_channel_auto_accept_min_ckb_funding_amount = Some(16200000000);
+            })
+            .build()
+    })
+    .await;
+
+    let mut node_a = nodes.pop().unwrap();
+    let mut node_b = nodes.pop().unwrap();
+
+    // test auto accept channel with large size shutdown script
+    let message = |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::OpenChannel(
+            OpenChannelCommand {
+                peer_id: node_b.peer_id.clone(),
+                public: false,
+                shutdown_script: Some(Script::new_builder().args(vec![0u8; 40].pack()).build()),
+                funding_amount: (81 + 1 + 90) * 100000000,
+                funding_udt_type_script: None,
+                commitment_fee_rate: None,
+                commitment_delay_epoch: None,
+                funding_fee_rate: None,
+                tlc_expiry_delta: None,
+                tlc_min_value: None,
+                tlc_max_value: None,
+                tlc_fee_proportional_millionths: None,
+                max_tlc_number_in_flight: None,
+                max_tlc_value_in_flight: None,
+            },
+            rpc_reply,
+        ))
+    };
+
+    let open_channel_result = call!(node_a.network_actor, message)
+        .expect("node_a alive")
+        .expect("open channel success");
+
+    node_b
+        .expect_event(|event| match event {
+            NetworkServiceEvent::ChannelPendingToBeAccepted(peer_id, channel_id) => {
+                println!("A channel ({:?}) to {:?} create", channel_id, peer_id);
+                assert_eq!(channel_id, &open_channel_result.channel_id);
+                assert_eq!(peer_id, &node_a.peer_id);
+                true
+            }
+            _ => false,
+        })
+        .await;
+
+    // should fail
+    node_a
+        .expect_event(|event| match event {
+            NetworkServiceEvent::ChannelReady(peer_id, channel_id, _funding_tx_hash) => {
+                println!(
+                    "A channel ({:?}) to {:?} is now ready",
+                    &channel_id, &peer_id
+                );
+                assert_eq!(peer_id, &node_b.peer_id);
+                true
+            }
+            _ => false,
+        })
+        .await;
+}
+
+#[tokio::test]
+async fn test_shutdown_channel_with_large_size_shutdown_script_should_fail() {
+    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 message = |rpc_reply| {
+        NetworkActorMessage::Command(NetworkActorCommand::ControlFiberChannel(
+            ChannelCommandWithId {
+                channel_id: new_channel_id,
+                command: ChannelCommand::Shutdown(
+                    ShutdownCommand {
+                        close_script: Script::new_builder().args(vec![0u8; 21].pack()).build(),
+                        fee_rate: FeeRate::from_u64(DEFAULT_COMMITMENT_FEE_RATE),
+                        force: false,
+                    },
+                    rpc_reply,
+                ),
+            },
+        ))
+    };
+
+    let shutdown_channel_result = call!(node_b.network_actor, message).expect("node_b alive");
+    assert!(shutdown_channel_result
+        .err()
+        .unwrap()
+        .contains("Local balance is not enough to pay the fee"));
+}
diff --git a/src/fiber/tests/graph.rs b/src/fiber/tests/graph.rs
index c8a45ab5..04e4d0e8 100644
--- a/src/fiber/tests/graph.rs
+++ b/src/fiber/tests/graph.rs
@@ -1,5 +1,7 @@
+use crate::fiber::config::{DEFAULT_TLC_EXPIRY_DELTA, MAX_PAYMENT_TLC_EXPIRY_LIMIT};
 use crate::fiber::graph::{PathFindError, SessionRoute};
 use crate::fiber::types::Pubkey;
+use crate::now_timestamp_as_millis_u64;
 use crate::{
     fiber::{
         graph::{ChannelInfo, NetworkGraph, NodeInfo, PathEdge},
@@ -137,7 +139,7 @@ impl MockNetworkGraph {
             version: 0,
             message_flags: if node_a_is_node1 { 1 } else { 0 },
             channel_flags: 0,
-            tlc_expiry_delta: 144,
+            tlc_expiry_delta: 11,
             tlc_fee_proportional_millionths: fee_rate.unwrap_or(0),
             tlc_maximum_value: max_htlc_value.unwrap_or(10000),
             tlc_minimum_value: min_htlc_value.unwrap_or(0),
@@ -151,7 +153,7 @@ impl MockNetworkGraph {
                 version: 0,
                 message_flags: if node_a_is_node1 { 0 } else { 1 },
                 channel_flags: 0,
-                tlc_expiry_delta: 144,
+                tlc_expiry_delta: 22,
                 tlc_fee_proportional_millionths: fee_rate,
                 tlc_maximum_value: max_htlc_value.unwrap_or(10000),
                 tlc_minimum_value: min_htlc_value.unwrap_or(0),
@@ -210,8 +212,16 @@ impl MockNetworkGraph {
     ) -> Result<Vec<PathEdge>, PathFindError> {
         let source = self.keys[source].into();
         let target = self.keys[target].into();
-        self.graph
-            .find_path(source, target, amount, Some(max_fee), None, false)
+        self.graph.find_path(
+            source,
+            target,
+            amount,
+            Some(max_fee),
+            None,
+            DEFAULT_TLC_EXPIRY_DELTA,
+            MAX_PAYMENT_TLC_EXPIRY_LIMIT,
+            false,
+        )
     }
 
     pub fn find_path_udt(
@@ -230,6 +240,8 @@ impl MockNetworkGraph {
             amount,
             Some(max_fee),
             Some(udt_type_script),
+            DEFAULT_TLC_EXPIRY_DELTA,
+            MAX_PAYMENT_TLC_EXPIRY_LIMIT,
             false,
         )
     }
@@ -517,7 +529,8 @@ fn test_graph_build_router_is_ok_with_fee_rate() {
         amount: 1000,
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: None,
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: None,
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -556,7 +569,8 @@ fn test_graph_build_router_fee_rate_optimize() {
         amount: 1000,
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: None,
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: None,
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -566,6 +580,7 @@ fn test_graph_build_router_fee_rate_optimize() {
         allow_self_payment: false,
         dry_run: false,
     });
+    eprintln!("route: {:?}", route);
     assert!(route.is_ok());
     let route = route.unwrap();
     let amounts = route.iter().map(|x| x.amount).collect::<Vec<_>>();
@@ -587,7 +602,8 @@ fn test_graph_build_router_no_fee_with_direct_pay() {
         amount: 1000,
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: None,
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: None,
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -606,7 +622,7 @@ fn test_graph_build_router_no_fee_with_direct_pay() {
 #[test]
 fn test_graph_find_path_err() {
     let mut network = MockNetworkGraph::new(6);
-    let (node1, _node5) = (network.keys[1], network.keys[5]);
+    let node1 = network.keys[1];
 
     network.add_edge(1, 2, Some(1000), Some(4));
     let route = network.find_path(1, 1, 100, 1000);
@@ -619,6 +635,8 @@ fn test_graph_find_path_err() {
         100,
         Some(1000),
         None,
+        DEFAULT_TLC_EXPIRY_DELTA,
+        MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         false,
     );
     assert!(route.is_err());
@@ -629,6 +647,68 @@ fn test_graph_find_path_err() {
         100,
         Some(1000),
         None,
+        DEFAULT_TLC_EXPIRY_DELTA,
+        MAX_PAYMENT_TLC_EXPIRY_LIMIT,
+        false,
+    );
+    assert!(route.is_err());
+}
+
+#[test]
+fn test_graph_find_path_node_order() {
+    let mut network = MockNetworkGraph::new(6);
+    let node1 = network.keys[1];
+    let node2 = network.keys[2];
+    let node3 = network.keys[3];
+
+    network.add_edge(1, 2, Some(1000), Some(4));
+    network.add_edge(2, 3, Some(1000), Some(4));
+
+    let route = network.graph.find_path(
+        node1.into(),
+        node3.into(),
+        100,
+        Some(1000),
+        None,
+        DEFAULT_TLC_EXPIRY_DELTA,
+        MAX_PAYMENT_TLC_EXPIRY_LIMIT,
+        false,
+    );
+    assert!(route.is_ok());
+    // check the order of nodes in router is node1 -> node2 -> node3
+    let route = route.unwrap();
+    assert_eq!(route.len(), 2);
+    assert_eq!(route[0].target, node2.into());
+    assert_eq!(route[1].target, node3.into());
+}
+
+#[test]
+fn test_graph_build_route_with_expiry_limit() {
+    let mut network = MockNetworkGraph::new(6);
+    let (node1, node2) = (network.keys[1], network.keys[2]);
+
+    network.add_edge(1, 2, Some(1000), Some(4));
+
+    let route = network.graph.find_path(
+        node1.into(),
+        node2.into(),
+        100,
+        Some(1000),
+        None,
+        DEFAULT_TLC_EXPIRY_DELTA,
+        MAX_PAYMENT_TLC_EXPIRY_LIMIT,
+        false,
+    );
+    assert!(route.is_ok());
+
+    let route = network.graph.find_path(
+        node1.into(),
+        node2.into(),
+        100,
+        Some(1000),
+        None,
+        DEFAULT_TLC_EXPIRY_DELTA,
+        100,
         false,
     );
     assert!(route.is_err());
@@ -647,7 +727,8 @@ fn test_graph_build_route_three_nodes() {
         amount: 100,
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: Some(10),
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -686,7 +767,8 @@ fn test_graph_build_route_exceed_max_htlc_value() {
         amount: 100, // Exceeds max_htlc_value of 50
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: Some(10),
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -713,7 +795,8 @@ fn test_graph_build_route_below_min_htlc_value() {
         amount: 10, // Below min_htlc_value of 50
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: Some(10),
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -759,7 +842,8 @@ fn test_graph_mark_failed_channel() {
         amount: 100,
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: Some(10),
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -780,7 +864,8 @@ fn test_graph_mark_failed_channel() {
         amount: 100,
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: Some(10),
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -811,7 +896,8 @@ fn test_graph_session_router() {
         amount: 100,
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: Some(10),
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -850,7 +936,8 @@ fn test_graph_mark_failed_node() {
         amount: 100,
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: Some(10),
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -868,7 +955,9 @@ fn test_graph_mark_failed_node() {
         amount: 100,
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
+
         timeout: Some(10),
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -888,7 +977,9 @@ fn test_graph_mark_failed_node() {
         amount: 100,
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
+
         timeout: Some(10),
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -906,7 +997,8 @@ fn test_graph_mark_failed_node() {
         amount: 100,
         payment_hash: Hash256::default(),
         invoice: None,
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: Some(10),
         max_fee_amount: Some(1000),
         max_parts: None,
@@ -933,7 +1025,8 @@ fn test_graph_payment_self_default_is_false() {
         target_pubkey: Some(node0.into()),
         amount: Some(100),
         payment_hash: Some(Hash256::default()),
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: None,
         timeout: Some(10),
         max_fee_amount: Some(1000),
@@ -943,26 +1036,13 @@ fn test_graph_payment_self_default_is_false() {
         allow_self_payment: false,
         dry_run: false,
     };
-    let payment_data = SendPaymentData::new(command, node0.into());
-    let error = payment_data.unwrap_err().to_string();
-    assert!(error.contains("can not pay self"));
+    let payment_data = SendPaymentData::new(command);
+    assert!(payment_data.is_ok());
 
-    let route = network.graph.build_route(SendPaymentData {
-        target_pubkey: node0.into(),
-        amount: 100,
-        payment_hash: Hash256::default(),
-        invoice: None,
-        final_htlc_expiry_delta: Some(100),
-        timeout: Some(10),
-        max_fee_amount: Some(1000),
-        max_parts: None,
-        keysend: false,
-        udt_type_script: None,
-        preimage: None,
-        allow_self_payment: false,
-        dry_run: false,
-    });
+    let route = network.graph.build_route(payment_data.unwrap());
     assert!(route.is_err());
+    let message = route.unwrap_err().to_string();
+    assert!(message.contains("allow_self_payment is not enable, can not pay to self"));
 }
 
 #[test]
@@ -974,13 +1054,13 @@ fn test_graph_payment_pay_single_path() {
     network.add_edge(4, 5, Some(500), Some(2));
     network.add_edge(5, 6, Some(500), Some(2));
 
-    let node0 = network.keys[0];
     // node0 is the source node
     let command = SendPaymentCommand {
         target_pubkey: Some(network.keys[6].into()),
         amount: Some(100),
         payment_hash: Some(Hash256::default()),
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: None,
         timeout: Some(10),
         max_fee_amount: Some(1000),
@@ -990,7 +1070,7 @@ fn test_graph_payment_pay_single_path() {
         allow_self_payment: true,
         dry_run: false,
     };
-    let payment_data = SendPaymentData::new(command, node0.into());
+    let payment_data = SendPaymentData::new(command);
     assert!(payment_data.is_ok());
     let payment_data = payment_data.unwrap();
 
@@ -1011,7 +1091,8 @@ fn test_graph_payment_pay_self_with_one_node() {
         target_pubkey: Some(network.keys[0].into()),
         amount: Some(100),
         payment_hash: Some(Hash256::default()),
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: None,
         timeout: Some(10),
         max_fee_amount: Some(1000),
@@ -1021,12 +1102,11 @@ fn test_graph_payment_pay_self_with_one_node() {
         allow_self_payment: true,
         dry_run: false,
     };
-    let payment_data = SendPaymentData::new(command, node0.into());
+    let payment_data = SendPaymentData::new(command);
     assert!(payment_data.is_ok());
     let payment_data = payment_data.unwrap();
 
     let route = network.graph.build_route(payment_data);
-    eprintln!("final result {:?}", route);
     assert!(route.is_ok());
     let route = route.unwrap();
     assert_eq!(route[1].next_hop, Some(node0.into()));
@@ -1059,14 +1139,13 @@ fn test_graph_build_route_with_double_edge_node() {
         Some(200),
     );
 
-    let node0 = network.keys[0];
-
     // node0 is the source node
     let command = SendPaymentCommand {
         target_pubkey: Some(network.keys[0].into()),
         amount: Some(100),
         payment_hash: Some(Hash256::default()),
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: None,
         timeout: Some(10),
         max_fee_amount: Some(1000),
@@ -1076,7 +1155,7 @@ fn test_graph_build_route_with_double_edge_node() {
         allow_self_payment: true,
         dry_run: false,
     };
-    let payment_data = SendPaymentData::new(command, node0.into()).unwrap();
+    let payment_data = SendPaymentData::new(command).unwrap();
     let route = network.graph.build_route(payment_data);
     assert!(route.is_ok());
 }
@@ -1118,7 +1197,8 @@ fn test_graph_build_route_with_other_node_maybe_better() {
         target_pubkey: Some(network.keys[0].into()),
         amount: Some(100),
         payment_hash: Some(Hash256::default()),
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: None,
         timeout: Some(10),
         max_fee_amount: Some(1000),
@@ -1128,7 +1208,7 @@ fn test_graph_build_route_with_other_node_maybe_better() {
         allow_self_payment: true,
         dry_run: false,
     };
-    let payment_data = SendPaymentData::new(command, node0.into()).unwrap();
+    let payment_data = SendPaymentData::new(command).unwrap();
     let route = network.graph.build_route(payment_data);
     assert!(route.is_ok());
     let route = route.unwrap();
@@ -1145,14 +1225,13 @@ fn test_graph_payment_pay_self_will_ok() {
     network.add_edge(4, 5, Some(500), Some(2));
     network.add_edge(5, 6, Some(500), Some(2));
 
-    let node0 = network.keys[0];
-
     // node0 is the source node
     let command = SendPaymentCommand {
         target_pubkey: Some(network.keys[0].into()),
         amount: Some(100),
         payment_hash: Some(Hash256::default()),
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: None,
         timeout: Some(10),
         max_fee_amount: Some(1000),
@@ -1162,7 +1241,7 @@ fn test_graph_payment_pay_self_will_ok() {
         allow_self_payment: true,
         dry_run: false,
     };
-    let payment_data = SendPaymentData::new(command, node0.into());
+    let payment_data = SendPaymentData::new(command);
     assert!(payment_data.is_ok());
     let payment_data = payment_data.unwrap();
 
@@ -1202,7 +1281,6 @@ fn test_graph_build_route_with_path_limits() {
         );
     }
 
-    let node0 = network.keys[0];
     let node99 = network.keys[99];
 
     // node0 is the source node
@@ -1210,7 +1288,8 @@ fn test_graph_build_route_with_path_limits() {
         target_pubkey: Some(node99.into()),
         amount: Some(100),
         payment_hash: Some(Hash256::default()),
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: None,
         timeout: Some(10),
         max_fee_amount: Some(10000000),
@@ -1220,7 +1299,7 @@ fn test_graph_build_route_with_path_limits() {
         allow_self_payment: true,
         dry_run: false,
     };
-    let payment_data = SendPaymentData::new(command, node0.into()).unwrap();
+    let payment_data = SendPaymentData::new(command).unwrap();
     let route = network.graph.build_route(payment_data);
     assert!(route.is_ok());
     let route = route.unwrap();
@@ -1252,7 +1331,6 @@ fn test_graph_build_route_with_path_limit_fail_with_fee_not_enough() {
         );
     }
 
-    let node0 = network.keys[0];
     let node99 = network.keys[99];
 
     // node0 is the source node
@@ -1260,7 +1338,8 @@ fn test_graph_build_route_with_path_limit_fail_with_fee_not_enough() {
         target_pubkey: Some(node99.into()),
         amount: Some(100),
         payment_hash: Some(Hash256::default()),
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: None,
         timeout: Some(10),
         max_fee_amount: Some(1000),
@@ -1270,7 +1349,47 @@ fn test_graph_build_route_with_path_limit_fail_with_fee_not_enough() {
         allow_self_payment: true,
         dry_run: false,
     };
-    let payment_data = SendPaymentData::new(command, node0.into()).unwrap();
+    let payment_data = SendPaymentData::new(command).unwrap();
     let route = network.graph.build_route(payment_data);
     assert!(route.is_err());
 }
+
+#[test]
+fn test_graph_payment_expiry_is_in_right_order() {
+    let mut network = MockNetworkGraph::new(5);
+    network.add_edge(0, 1, Some(500), Some(2));
+    network.add_edge(1, 2, Some(500), Some(2));
+    network.add_edge(2, 3, Some(500), Some(2));
+
+    let node3 = network.keys[3];
+
+    let command = SendPaymentCommand {
+        target_pubkey: Some(node3.into()),
+        amount: Some(100),
+        payment_hash: Some(Hash256::default()),
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
+        invoice: None,
+        timeout: Some(10),
+        max_fee_amount: Some(1000),
+        max_parts: None,
+        keysend: Some(false),
+        udt_type_script: None,
+        allow_self_payment: false,
+        dry_run: false,
+    };
+    let payment_data = SendPaymentData::new(command);
+    assert!(payment_data.is_ok());
+
+    let route = network.graph.build_route(payment_data.unwrap());
+    assert!(route.is_ok());
+    let route = route.unwrap();
+    let expiries = route.iter().map(|e| e.expiry).collect::<Vec<_>>();
+    // we set 11 as tlc expiry delta in the test
+    assert_eq!(expiries.len(), 4);
+    assert_eq!(expiries[0] - expiries[1], 11);
+    assert_eq!(expiries[1] - expiries[2], 11);
+    assert_eq!(expiries[3], 0);
+    let expected_timestamp = now_timestamp_as_millis_u64() + DEFAULT_TLC_EXPIRY_DELTA;
+    assert!(expiries[2] <= expected_timestamp);
+}
diff --git a/src/fiber/tests/history.rs b/src/fiber/tests/history.rs
index 4c10808a..438da557 100644
--- a/src/fiber/tests/history.rs
+++ b/src/fiber/tests/history.rs
@@ -4,6 +4,7 @@ use crate::fiber::history::{Direction, DEFAULT_BIMODAL_DECAY_TIME};
 use crate::fiber::history::{InternalPairResult, InternalResult};
 use crate::fiber::history::{PaymentHistory, TimedResult};
 use crate::fiber::tests::test_utils::{generate_pubkey, MemoryStore};
+use crate::now_timestamp_as_millis_u64;
 use crate::store::Store;
 use ckb_types::packed::OutPoint;
 use molecule::prelude::Entity;
@@ -507,7 +508,7 @@ fn test_history_probability() {
     let prob = history.eval_probability(from, target, &channel_outpoint, 10, 100);
     assert_eq!(prob, 1.0);
 
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_millis();
+    let now = now_timestamp_as_millis_u64();
     let result = TimedResult {
         success_time: now,
         success_amount: 5,
@@ -633,7 +634,7 @@ fn test_history_small_fail_amount_probability() {
     let result = TimedResult {
         success_time: 3,
         success_amount: 50000000,
-        fail_time: std::time::UNIX_EPOCH.elapsed().unwrap().as_millis(),
+        fail_time: now_timestamp_as_millis_u64(),
         fail_amount: 10,
     };
     history.add_result(channel_outpoint.clone(), direction, result);
@@ -654,7 +655,7 @@ fn test_history_channel_probability_range() {
     let prob = history.eval_probability(from, target, &channel_outpoint, 50000000, 100000000);
     assert_eq!(prob, 1.0);
 
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_millis();
+    let now = now_timestamp_as_millis_u64();
     let result = TimedResult {
         success_time: now,
         success_amount: 10000000,
@@ -694,7 +695,7 @@ fn test_history_eval_probability_range() {
     let prob = history.eval_probability(from, target, &channel_outpoint, 50000000, 100000000);
     assert_eq!(prob, 1.0);
 
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_millis();
+    let now = now_timestamp_as_millis_u64();
     let result = TimedResult {
         success_time: now,
         success_amount: 10000000,
@@ -719,7 +720,7 @@ fn test_history_eval_probability_range() {
     }
 
     history.reset();
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_millis();
+    let now = now_timestamp_as_millis_u64();
     let result = TimedResult {
         success_time: now,
         success_amount: 10000000,
@@ -736,7 +737,7 @@ fn test_history_eval_probability_range() {
     }
 
     prev_prob = 0.0;
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_millis();
+    let now = now_timestamp_as_millis_u64();
     for time in (60 * 1000..DEFAULT_BIMODAL_DECAY_TIME * 2).step_by(1 * 60 * 60 * 1000) {
         history.reset();
         let result = TimedResult {
@@ -804,19 +805,19 @@ fn test_history_can_send_with_time() {
     use crate::fiber::history::DEFAULT_BIMODAL_DECAY_TIME;
 
     let history = PaymentHistory::new(generate_pubkey().into(), None, MemoryStore::default());
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_millis();
+    let now = now_timestamp_as_millis_u64();
     let res = history.can_send(100, now);
     assert_eq!(res, 100);
 
-    let before = now - DEFAULT_BIMODAL_DECAY_TIME as u128 / 3;
+    let before = now - DEFAULT_BIMODAL_DECAY_TIME / 3;
     let res = history.can_send(100, before);
     assert_eq!(res, 71);
 
-    let before = now - DEFAULT_BIMODAL_DECAY_TIME as u128;
+    let before = now - DEFAULT_BIMODAL_DECAY_TIME;
     let res = history.can_send(100, before);
     assert_eq!(res, 36);
 
-    let before = now - DEFAULT_BIMODAL_DECAY_TIME as u128 * 3;
+    let before = now - DEFAULT_BIMODAL_DECAY_TIME * 3;
     let res = history.can_send(100, before);
     assert_eq!(res, 4);
 }
@@ -826,19 +827,19 @@ fn test_history_can_not_send_with_time() {
     use crate::fiber::history::DEFAULT_BIMODAL_DECAY_TIME;
 
     let history = PaymentHistory::new(generate_pubkey().into(), None, MemoryStore::default());
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_millis();
+    let now = now_timestamp_as_millis_u64();
     let res = history.cannot_send(90, now, 100);
     assert_eq!(res, 90);
 
-    let before = now - DEFAULT_BIMODAL_DECAY_TIME as u128 / 3;
+    let before = now - DEFAULT_BIMODAL_DECAY_TIME / 3;
     let res = history.cannot_send(90, before, 100);
     assert_eq!(res, 93);
 
-    let before = now - DEFAULT_BIMODAL_DECAY_TIME as u128;
+    let before = now - DEFAULT_BIMODAL_DECAY_TIME;
     let res = history.cannot_send(90, before, 100);
     assert_eq!(res, 97);
 
-    let before = now - DEFAULT_BIMODAL_DECAY_TIME as u128 * 3;
+    let before = now - DEFAULT_BIMODAL_DECAY_TIME * 3;
     let res = history.cannot_send(90, before, 100);
     assert_eq!(res, 100);
 }
diff --git a/src/fiber/tests/network.rs b/src/fiber/tests/network.rs
index c379c3e1..c17059cc 100644
--- a/src/fiber/tests/network.rs
+++ b/src/fiber/tests/network.rs
@@ -1,7 +1,9 @@
 use super::test_utils::{init_tracing, NetworkNode};
+use crate::fiber::config::DEFAULT_TLC_EXPIRY_DELTA;
 use crate::fiber::network::SendPaymentData;
 use crate::fiber::tests::test_utils::gen_rand_keypair;
 use crate::fiber::tests::test_utils::generate_pubkey;
+use crate::fiber::tests::test_utils::rand_sha256_hash;
 use crate::invoice::InvoiceBuilder;
 use crate::{
     fiber::{
@@ -654,7 +656,9 @@ fn test_send_payment_validate_payment_hash() {
         target_pubkey: Some(generate_pubkey()),
         amount: Some(10000),
         payment_hash: None,
-        final_htlc_expiry_delta: None,
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
+
         invoice: None,
         timeout: None,
         max_fee_amount: None,
@@ -665,7 +669,7 @@ fn test_send_payment_validate_payment_hash() {
         dry_run: false,
     };
 
-    let result = SendPaymentData::new(send_command, generate_pubkey().into());
+    let result = SendPaymentData::new(send_command);
     assert!(result.is_err());
     assert!(result.unwrap_err().contains("payment_hash is missing"));
 }
@@ -676,7 +680,9 @@ fn test_send_payment_validate_amount() {
         target_pubkey: Some(generate_pubkey()),
         amount: None,
         payment_hash: None,
-        final_htlc_expiry_delta: None,
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
+
         invoice: None,
         timeout: None,
         max_fee_amount: None,
@@ -687,7 +693,7 @@ fn test_send_payment_validate_amount() {
         dry_run: false,
     };
 
-    let result = SendPaymentData::new(send_command, generate_pubkey().into());
+    let result = SendPaymentData::new(send_command);
     assert!(result.is_err());
     assert!(result.unwrap_err().contains("amount is missing"));
 }
@@ -709,7 +715,9 @@ fn test_send_payment_validate_invoice() {
         .expiry_time(Duration::from_secs(1024))
         .payee_pub_key(public_key)
         .add_attr(Attribute::FinalHtlcTimeout(5))
-        .add_attr(Attribute::FinalHtlcMinimumExpiryDelta(12))
+        .add_attr(Attribute::FinalHtlcMinimumExpiryDelta(
+            DEFAULT_TLC_EXPIRY_DELTA,
+        ))
         .add_attr(Attribute::Description("description".to_string()))
         .build_with_sign(|hash| Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))
         .unwrap();
@@ -719,7 +727,8 @@ fn test_send_payment_validate_invoice() {
         target_pubkey: Some(generate_pubkey()),
         amount: None,
         payment_hash: None,
-        final_htlc_expiry_delta: None,
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: Some(invoice_encoded.clone()),
         timeout: None,
         max_fee_amount: None,
@@ -730,7 +739,7 @@ fn test_send_payment_validate_invoice() {
         dry_run: false,
     };
 
-    let result = SendPaymentData::new(send_command, generate_pubkey().into());
+    let result = SendPaymentData::new(send_command);
     assert!(result.is_err());
     assert!(result
         .unwrap_err()
@@ -740,7 +749,8 @@ fn test_send_payment_validate_invoice() {
         target_pubkey: None,
         amount: Some(10),
         payment_hash: None,
-        final_htlc_expiry_delta: None,
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: Some(invoice_encoded.clone()),
         timeout: None,
         max_fee_amount: None,
@@ -752,7 +762,7 @@ fn test_send_payment_validate_invoice() {
     };
 
     // keysend is set with invoice, should be error
-    let result = SendPaymentData::new(send_command, generate_pubkey().into());
+    let result = SendPaymentData::new(send_command);
     assert!(result.is_err());
     assert!(result
         .unwrap_err()
@@ -762,7 +772,8 @@ fn test_send_payment_validate_invoice() {
         target_pubkey: None,
         amount: None,
         payment_hash: None,
-        final_htlc_expiry_delta: None,
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: Some(invoice_encoded.clone()),
         timeout: None,
         max_fee_amount: None,
@@ -773,7 +784,7 @@ fn test_send_payment_validate_invoice() {
         dry_run: false,
     };
 
-    let result = SendPaymentData::new(send_command, generate_pubkey().into());
+    let result = SendPaymentData::new(send_command);
     assert!(result.is_err());
 
     // normal invoice send payment
@@ -781,7 +792,8 @@ fn test_send_payment_validate_invoice() {
         target_pubkey: None,
         amount: None,
         payment_hash: None,
-        final_htlc_expiry_delta: None,
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: Some(invoice_encoded.clone()),
         timeout: None,
         max_fee_amount: None,
@@ -792,7 +804,7 @@ fn test_send_payment_validate_invoice() {
         dry_run: false,
     };
 
-    let result = SendPaymentData::new(send_command, generate_pubkey().into());
+    let result = SendPaymentData::new(send_command);
     assert!(result.is_ok());
 
     // normal keysend send payment
@@ -800,7 +812,8 @@ fn test_send_payment_validate_invoice() {
         target_pubkey: Some(generate_pubkey()),
         amount: Some(10),
         payment_hash: None,
-        final_htlc_expiry_delta: None,
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
         invoice: None,
         timeout: None,
         max_fee_amount: None,
@@ -811,6 +824,90 @@ fn test_send_payment_validate_invoice() {
         dry_run: false,
     };
 
-    let result = SendPaymentData::new(send_command, generate_pubkey().into());
+    let result = SendPaymentData::new(send_command);
     assert!(result.is_ok());
+
+    // invoice with invalid final_tlc_expiry_delta
+    let send_command = SendPaymentCommand {
+        target_pubkey: None,
+        amount: None,
+        payment_hash: None,
+        final_tlc_expiry_delta: Some(11),
+        tlc_expiry_limit: None,
+        invoice: Some(invoice_encoded.clone()),
+        timeout: None,
+        max_fee_amount: None,
+        max_parts: None,
+        keysend: None,
+        udt_type_script: None,
+        allow_self_payment: false,
+        dry_run: false,
+    };
+
+    let result = SendPaymentData::new(send_command);
+    assert!(result.is_err());
+    assert!(result
+        .unwrap_err()
+        .contains("invalid final_tlc_expiry_delta"));
+
+    // invoice with invalid final_tlc_expiry_delta
+    let invoice = InvoiceBuilder::new(Currency::Fibb)
+        .amount(Some(1280))
+        .payment_hash(gen_payment_hash)
+        .fallback_address("address".to_string())
+        .expiry_time(Duration::from_secs(1024))
+        .payee_pub_key(public_key)
+        .add_attr(Attribute::FinalHtlcTimeout(5))
+        .add_attr(Attribute::FinalHtlcMinimumExpiryDelta(11))
+        .add_attr(Attribute::Description("description".to_string()))
+        .build_with_sign(|hash| Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))
+        .unwrap();
+    let invoice_encoded = invoice.to_string();
+    let send_command = SendPaymentCommand {
+        target_pubkey: None,
+        amount: None,
+        payment_hash: None,
+        final_tlc_expiry_delta: None,
+        tlc_expiry_limit: None,
+        invoice: Some(invoice_encoded.clone()),
+        timeout: None,
+        max_fee_amount: None,
+        max_parts: None,
+        keysend: None,
+        udt_type_script: None,
+        allow_self_payment: false,
+        dry_run: false,
+    };
+
+    let result = SendPaymentData::new(send_command);
+    assert!(result.is_err());
+    assert!(result
+        .unwrap_err()
+        .contains("invalid final_tlc_expiry_delta"));
+}
+
+#[test]
+fn test_send_payment_validate_htlc_expiry_delta() {
+    let send_command = SendPaymentCommand {
+        target_pubkey: Some(generate_pubkey()),
+        amount: Some(1000),
+        payment_hash: Some(rand_sha256_hash()),
+        final_tlc_expiry_delta: Some(100),
+        tlc_expiry_limit: None,
+        invoice: None,
+        timeout: None,
+        max_fee_amount: None,
+        max_parts: None,
+        keysend: None,
+        udt_type_script: None,
+        allow_self_payment: false,
+        dry_run: false,
+    };
+
+    let result = SendPaymentData::new(send_command);
+    eprintln!("{:?}", result);
+    assert!(result.is_err());
+    assert!(result
+        .unwrap_err()
+        .contains("invalid final_tlc_expiry_delta"));
 }
diff --git a/src/fiber/tests/path.rs b/src/fiber/tests/path.rs
index 8177ceee..42425538 100644
--- a/src/fiber/tests/path.rs
+++ b/src/fiber/tests/path.rs
@@ -20,7 +20,7 @@ fn test_node_heap() {
         fee_charged: 0,
         probability: 0.0,
         next_hop: None,
-        incoming_htlc_expiry: 0,
+        incoming_tlc_expiry: 0,
     };
     let node2 = NodeHeapElement {
         node_id: public_key2.into(),
@@ -30,7 +30,7 @@ fn test_node_heap() {
         fee_charged: 0,
         probability: 0.0,
         next_hop: None,
-        incoming_htlc_expiry: 0,
+        incoming_tlc_expiry: 0,
     };
     assert!(heap.is_empty());
     heap.push(node1.clone());
@@ -60,7 +60,7 @@ fn test_node_heap_probability() {
         fee_charged: 0,
         probability: 0.0,
         next_hop: None,
-        incoming_htlc_expiry: 0,
+        incoming_tlc_expiry: 0,
     };
     let node2 = NodeHeapElement {
         node_id: public_key2.into(),
@@ -70,7 +70,7 @@ fn test_node_heap_probability() {
         fee_charged: 0,
         probability: 0.5,
         next_hop: None,
-        incoming_htlc_expiry: 0,
+        incoming_tlc_expiry: 0,
     };
     heap.push(node1.clone());
     heap.push(node2.clone());
@@ -97,7 +97,7 @@ fn test_node_heap_distance() {
         fee_charged: 0,
         probability: 0.0,
         next_hop: None,
-        incoming_htlc_expiry: 0,
+        incoming_tlc_expiry: 0,
     };
     let node2 = NodeHeapElement {
         node_id: public_key2.into(),
@@ -107,7 +107,7 @@ fn test_node_heap_distance() {
         fee_charged: 0,
         probability: 0.0,
         next_hop: None,
-        incoming_htlc_expiry: 0,
+        incoming_tlc_expiry: 0,
     };
     heap.push(node1.clone());
     heap.push(node2.clone());
@@ -134,7 +134,7 @@ fn test_node_heap_push_or_fix() {
         fee_charged: 0,
         probability: 0.0,
         next_hop: None,
-        incoming_htlc_expiry: 0,
+        incoming_tlc_expiry: 0,
     };
     let node2 = NodeHeapElement {
         node_id: public_key2.into(),
@@ -144,7 +144,7 @@ fn test_node_heap_push_or_fix() {
         fee_charged: 0,
         probability: 0.0,
         next_hop: None,
-        incoming_htlc_expiry: 0,
+        incoming_tlc_expiry: 0,
     };
 
     heap.push(node1.clone());
@@ -159,7 +159,7 @@ fn test_node_heap_push_or_fix() {
         fee_charged: 0,
         probability: 0.0,
         next_hop: None,
-        incoming_htlc_expiry: 0,
+        incoming_tlc_expiry: 0,
     };
 
     heap.push_or_fix(node1_update.clone());
diff --git a/src/fiber/types.rs b/src/fiber/types.rs
index 6c88e4f0..441e3ee0 100644
--- a/src/fiber/types.rs
+++ b/src/fiber/types.rs
@@ -565,14 +565,6 @@ pub struct OpenChannel {
 }
 
 impl OpenChannel {
-    pub fn all_ckb_amount(&self) -> u64 {
-        if self.funding_udt_type_script.is_none() {
-            self.funding_amount as u64 + self.reserved_ckb_amount
-        } else {
-            self.reserved_ckb_amount
-        }
-    }
-
     pub fn is_public(&self) -> bool {
         self.channel_flags.contains(ChannelFlags::PUBLIC)
     }
@@ -1300,16 +1292,15 @@ pub enum TlcErrorCode {
     UnknownNextPeer = PERM | 10,
     AmountBelowMinimum = UPDATE | 11,
     FeeInsufficient = UPDATE | 12,
-    // TODO: htlc expiry check
-    IncorrectHtlcExpiry = UPDATE | 13,
-    ExpiryTooSoon = UPDATE | 14,
+    IncorrectTlcExpiry = UPDATE | 13,
+    ExpiryTooSoon = PERM | 14,
     IncorrectOrUnknownPaymentDetails = PERM | 15,
     InvoiceExpired = PERM | 16,
     InvoiceCancelled = PERM | 17,
     FinalIncorrectExpiryDelta = 18,
-    FinalIncorrectHtlcAmount = 19,
+    FinalIncorrectTlcAmount = 19,
     ChannelDisabled = UPDATE | 20,
-    ExpiryTooFar = 21,
+    ExpiryTooFar = PERM | 21,
     InvalidOnionPayload = PERM | 22,
     MppTimeout = 23,
     InvalidOnionBlinding = BADONION | PERM | 24,
@@ -1336,9 +1327,11 @@ impl TlcErrorCode {
         match self {
             TlcErrorCode::IncorrectOrUnknownPaymentDetails
             | TlcErrorCode::FinalIncorrectExpiryDelta
-            | TlcErrorCode::FinalIncorrectHtlcAmount
+            | TlcErrorCode::FinalIncorrectTlcAmount
             | TlcErrorCode::InvoiceExpired
             | TlcErrorCode::InvoiceCancelled
+            | TlcErrorCode::ExpiryTooFar
+            | TlcErrorCode::ExpiryTooSoon
             | TlcErrorCode::MppTimeout => true,
             _ => false,
         }
diff --git a/src/invoice/invoice_impl.rs b/src/invoice/invoice_impl.rs
index 5075259f..0d15a823 100644
--- a/src/invoice/invoice_impl.rs
+++ b/src/invoice/invoice_impl.rs
@@ -310,7 +310,7 @@ impl CkbInvoice {
     attr_getter!(expiry_time, ExpiryTime, Duration);
     attr_getter!(description, Description, String);
     attr_getter!(
-        final_htlc_minimum_expiry_delta,
+        final_tlc_minimum_expiry_delta,
         FinalHtlcMinimumExpiryDelta,
         u64
     );
diff --git a/src/lib.rs b/src/lib.rs
index 841eae78..be17235e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -36,7 +36,7 @@ pub fn get_node_prefix() -> &'static str {
     INSTANCE.get_or_init(|| std::env::var("LOG_PREFIX").unwrap_or_else(|_| "".to_string()))
 }
 
-pub fn now_timestamp() -> u64 {
+pub fn now_timestamp_as_millis_u64() -> u64 {
     std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)
         .expect("Duration since unix epoch")
diff --git a/src/rpc/README.md b/src/rpc/README.md
index 53ecb90e..d62baebe 100644
--- a/src/rpc/README.md
+++ b/src/rpc/README.md
@@ -293,7 +293,8 @@ Sends a payment to a peer.
 * `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_htlc_expiry_delta` - `Option<u64>`, the htlc expiry delta should be used to set the timelock for the final hop
+* `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
 * `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
@@ -424,7 +425,6 @@ Generates a new invoice.
 * `payment_preimage` - Hash256, The payment preimage of the invoice.
 * `expiry` - `Option<u64>`, The expiry time of the invoice.
 * `fallback_address` - `Option<String>`, The fallback address of the invoice.
-* `final_cltv` - `Option<u64>`, The final CLTV of the invoice.
 * `final_expiry_delta` - `Option<u64>`, The final HTLC timeout of the invoice.
 * `udt_type_script` - `Option<Script>`, The UDT type script of the invoice.
 * `hash_algorithm` - `Option<HashAlgorithm>`, The hash algorithm of the invoice.
diff --git a/src/rpc/channel.rs b/src/rpc/channel.rs
index 884f98ef..dec68fa5 100644
--- a/src/rpc/channel.rs
+++ b/src/rpc/channel.rs
@@ -287,9 +287,13 @@ pub(crate) struct SendPaymentCommandParams {
     /// the hash to use within the payment's HTLC
     payment_hash: Option<Hash256>,
 
-    /// the htlc expiry delta should be used to set the timelock for the final hop
+    /// the TLC expiry delta should be used to set the timelock for the final hop, in milliseconds
     #[serde_as(as = "Option<U64Hex>")]
-    final_htlc_expiry_delta: Option<u64>,
+    final_tlc_expiry_delta: Option<u64>,
+
+    /// the TLC expiry limit for the whole payment, in milliseconds
+    #[serde_as(as = "Option<U64Hex>")]
+    tlc_expiry_limit: Option<u64>,
 
     /// the encoded invoice to send to the recipient
     invoice: Option<String>,
@@ -625,7 +629,8 @@ where
                     target_pubkey: params.target_pubkey,
                     amount: params.amount,
                     payment_hash: params.payment_hash,
-                    final_htlc_expiry_delta: params.final_htlc_expiry_delta,
+                    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,
diff --git a/src/rpc/invoice.rs b/src/rpc/invoice.rs
index d3d604d6..fabc5d97 100644
--- a/src/rpc/invoice.rs
+++ b/src/rpc/invoice.rs
@@ -1,3 +1,4 @@
+use crate::fiber::config::MIN_TLC_EXPIRY_DELTA;
 use crate::fiber::hash_algorithm::HashAlgorithm;
 use crate::fiber::serde_utils::{U128Hex, U64Hex};
 use crate::fiber::types::{Hash256, Privkey};
@@ -29,9 +30,6 @@ pub(crate) struct NewInvoiceParams {
     expiry: Option<u64>,
     /// The fallback address of the invoice.
     fallback_address: Option<String>,
-    /// The final CLTV of the invoice.
-    #[serde_as(as = "Option<U64Hex>")]
-    final_cltv: Option<u64>,
     /// The final HTLC timeout of the invoice.
     #[serde_as(as = "Option<U64Hex>")]
     final_expiry_delta: Option<u64>,
@@ -180,6 +178,16 @@ where
             invoice_builder = invoice_builder.fallback_address(fallback_address);
         };
         if let Some(final_expiry_delta) = params.final_expiry_delta {
+            if final_expiry_delta < MIN_TLC_EXPIRY_DELTA {
+                return Err(ErrorObjectOwned::owned(
+                    CALL_EXECUTION_FAILED_CODE,
+                    format!(
+                        "final_expiry_delta must be greater than or equal to {}",
+                        MIN_TLC_EXPIRY_DELTA
+                    ),
+                    Some(params),
+                ));
+            }
             invoice_builder = invoice_builder.final_expiry_delta(final_expiry_delta);
         };
         if let Some(udt_type_script) = &params.udt_type_script {
diff --git a/src/tests/store.rs b/src/tests/store.rs
index 4720b8d5..4eccbed2 100644
--- a/src/tests/store.rs
+++ b/src/tests/store.rs
@@ -1,4 +1,6 @@
 use crate::fiber::config::AnnouncedNodeName;
+use crate::fiber::config::DEFAULT_TLC_EXPIRY_DELTA;
+use crate::fiber::config::MAX_PAYMENT_TLC_EXPIRY_LIMIT;
 use crate::fiber::graph::ChannelInfo;
 use crate::fiber::graph::NetworkGraphStateStore;
 use crate::fiber::graph::NodeInfo;
@@ -221,7 +223,8 @@ fn test_store_payment_session() {
         amount: 100,
         payment_hash,
         invoice: None,
-        final_htlc_expiry_delta: Some(100),
+        final_tlc_expiry_delta: DEFAULT_TLC_EXPIRY_DELTA,
+        tlc_expiry_limit: MAX_PAYMENT_TLC_EXPIRY_LIMIT,
         timeout: Some(10),
         max_fee_amount: Some(1000),
         max_parts: None,
diff --git a/tests/bruno/e2e/3-nodes-transfer/11-node3-gen-invoice.bru b/tests/bruno/e2e/3-nodes-transfer/11-node3-gen-invoice.bru
index 15d87811..7a57b1d9 100644
--- a/tests/bruno/e2e/3-nodes-transfer/11-node3-gen-invoice.bru
+++ b/tests/bruno/e2e/3-nodes-transfer/11-node3-gen-invoice.bru
@@ -26,7 +26,7 @@ body:json {
         "currency": "Fibd",
         "description": "test invoice generated by node3",
         "expiry": "0xe10",
-        "final_expiry_delta": "0x28",
+        "final_expiry_delta": "0xDFFA0",
         "payment_preimage": "{{payment_preimage}}"
       }
     ]
diff --git a/tests/bruno/e2e/3-nodes-transfer/12-node1-add-tlc.bru b/tests/bruno/e2e/3-nodes-transfer/12-node1-add-tlc.bru
index 1edd4d1f..06f57d29 100644
--- a/tests/bruno/e2e/3-nodes-transfer/12-node1-add-tlc.bru
+++ b/tests/bruno/e2e/3-nodes-transfer/12-node1-add-tlc.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{N1N2_CHANNEL_ID}}",
         "amount": "{{payment_amount}}",
         "payment_hash": "{{payment_hash}}",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -37,6 +37,9 @@ assert {
 }
 
 script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+
   let hash_algorithm = bru.getEnvVar("HASH_ALGORITHM");
   if (hash_algorithm !== null) {
     let body = req.getBody();
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 851e9902..1cb597cc 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
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{N2N3_CHANNEL_ID}}",
         "amount": "{{payment_amount}}",
         "payment_hash": "{{payment_hash}}",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -37,6 +37,9 @@ assert {
 }
 
 script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+
   let hash_algorithm = bru.getEnvVar("HASH_ALGORITHM");
   if (hash_algorithm !== null) {
     let body = req.getBody();
diff --git a/tests/bruno/e2e/3-nodes-transfer/16-node3-gen-invoice.bru b/tests/bruno/e2e/3-nodes-transfer/16-node3-gen-invoice.bru
index 1986e446..dd4d87c3 100644
--- a/tests/bruno/e2e/3-nodes-transfer/16-node3-gen-invoice.bru
+++ b/tests/bruno/e2e/3-nodes-transfer/16-node3-gen-invoice.bru
@@ -26,7 +26,7 @@ body:json {
         "currency": "Fibd",
         "description": "test invoice generated by node3",
         "expiry": "0xe10",
-        "final_expiry_delta": "0x28",
+        "final_expiry_delta": "0xDFFA0",
         "payment_preimage": "{{payment_preimage}}"
       }
     ]
diff --git a/tests/bruno/e2e/3-nodes-transfer/17-node1-add-tlc.bru b/tests/bruno/e2e/3-nodes-transfer/17-node1-add-tlc.bru
index 47cc87ed..8a731e7e 100644
--- a/tests/bruno/e2e/3-nodes-transfer/17-node1-add-tlc.bru
+++ b/tests/bruno/e2e/3-nodes-transfer/17-node1-add-tlc.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{N1N2_CHANNEL_ID}}",
         "amount": "{{payment_amount}}",
         "payment_hash": "{{payment_hash}}",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -37,6 +37,9 @@ assert {
 }
 
 script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+
   let hash_algorithm = bru.getEnvVar("HASH_ALGORITHM");
   if (hash_algorithm !== null) {
     let body = req.getBody();
diff --git a/tests/bruno/e2e/3-nodes-transfer/18-node2-add-tlc.bru b/tests/bruno/e2e/3-nodes-transfer/18-node2-add-tlc.bru
index 46d77221..e43af9dc 100644
--- a/tests/bruno/e2e/3-nodes-transfer/18-node2-add-tlc.bru
+++ b/tests/bruno/e2e/3-nodes-transfer/18-node2-add-tlc.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{N2N3_CHANNEL_ID}}",
         "amount": "{{payment_amount}}",
         "payment_hash": "{{payment_hash}}",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -37,6 +37,9 @@ assert {
 }
 
 script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+
   let hash_algorithm = bru.getEnvVar("HASH_ALGORITHM");
   if (hash_algorithm !== null) {
     let body = req.getBody();
diff --git a/tests/bruno/e2e/cross-chain-hub/07-node1-add-tlc.bru b/tests/bruno/e2e/cross-chain-hub/07-node1-add-tlc.bru
index ade936c6..da62b44e 100644
--- a/tests/bruno/e2e/cross-chain-hub/07-node1-add-tlc.bru
+++ b/tests/bruno/e2e/cross-chain-hub/07-node1-add-tlc.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{N1N3_CHANNEL_ID}}",
         "amount": "0x4e20",
         "payment_hash": "{{PAYMENT_HASH}}",
-        "expiry": "0x20000000000",
+        "expiry": "{{expiry}}",
         "hash_algorithm": "sha256"
       }
     ]
@@ -37,6 +37,11 @@ assert {
   res.body.result.tlc_id: isDefined
 }
 
+script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
 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/invoice-ops/1-gen-invoice.bru b/tests/bruno/e2e/invoice-ops/1-gen-invoice.bru
index a4a63dac..8bb43dfa 100644
--- a/tests/bruno/e2e/invoice-ops/1-gen-invoice.bru
+++ b/tests/bruno/e2e/invoice-ops/1-gen-invoice.bru
@@ -39,7 +39,7 @@ body:json {
         "currency": "Fibd",
         "description": "test invoice",
         "expiry": "0xe10",
-        "final_expiry_delta": "0x28",
+        "final_expiry_delta": "0xDFFA0",
         "payment_preimage": "{{payment_preimage}}"
       }
     ]
diff --git a/tests/bruno/e2e/invoice-ops/2-gen-invoice-duplicate.bru b/tests/bruno/e2e/invoice-ops/2-gen-invoice-duplicate.bru
index 38f6e77a..14001eeb 100644
--- a/tests/bruno/e2e/invoice-ops/2-gen-invoice-duplicate.bru
+++ b/tests/bruno/e2e/invoice-ops/2-gen-invoice-duplicate.bru
@@ -30,7 +30,7 @@ body:json {
         "currency": "Fibd",
         "description": "test invoice",
         "expiry": "0xe10",
-        "final_expiry_delta": "0x28",
+        "final_expiry_delta": "0xDFFA0",
         "payment_preimage": "{{payment_preimage}}"
       }
     ]
diff --git a/tests/bruno/e2e/open-use-close-a-channel/07-add-tlc-from-NODE3.bru b/tests/bruno/e2e/open-use-close-a-channel/07-add-tlc-from-NODE3.bru
index 8c5234fc..4bdfb0f2 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/07-add-tlc-from-NODE3.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/07-add-tlc-from-NODE3.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{CHANNEL_ID}}",
         "amount": "0x5f5e100",
         "payment_hash": "0x266cec97cbede2cfbce73666f08deed9560bdf7841a7a5a51b3a3f09da249e21",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -36,6 +36,11 @@ assert {
   res.body.result.tlc_id: isDefined
 }
 
+script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
 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/08-add-tlc-from-NODE1.bru b/tests/bruno/e2e/open-use-close-a-channel/08-add-tlc-from-NODE1.bru
index 78df2759..e2fcd601 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/08-add-tlc-from-NODE1.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/08-add-tlc-from-NODE1.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{CHANNEL_ID}}",
         "amount": "0xbebc200",
         "payment_hash": "0xcb7bce98a778f130d34da522623d7e56705bddfe0dc4781bd2331211134a19a8",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -36,6 +36,11 @@ assert {
   res.body.result: isUndefined
 }
 
+script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
 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/09-add-tlc-from-NODE3.bru b/tests/bruno/e2e/open-use-close-a-channel/09-add-tlc-from-NODE3.bru
index 3fbc333a..a036524a 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/09-add-tlc-from-NODE3.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/09-add-tlc-from-NODE3.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{CHANNEL_ID}}",
         "amount": "0x11e1a300",
         "payment_hash": "0x29449e2cc6f56a691253fe88e3a378171c81573b09247010b4f1cb8c806e1e09",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -36,6 +36,11 @@ assert {
   res.body.result.tlc_id: isDefined
 }
 
+script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
 script:post-response {
   console.log("step 9 response: ", res.body);
   // Sleep for sometime to make sure current operation finishes before next request starts.
diff --git a/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-amount-err.bru b/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-amount-err.bru
index 61d1222b..8fc54e04 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-amount-err.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-amount-err.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{CHANNEL_ID}}",
         "amount": "0x0",
         "payment_hash": "0xcb7bce98a778f130d34da522623d7e56705bddfe0dc4781bd2331211134a19a5",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -36,6 +36,11 @@ assert {
   res.body.result: isUndefined
 }
 
+script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
 script:post-response {
   console.log("step 10 response: ", res.body);
   // Sleep for sometime to make sure current operation finishes before next request starts.
diff --git a/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-balance-err.bru b/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-balance-err.bru
index 7317fbe8..09bc2d1b 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-balance-err.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-balance-err.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{CHANNEL_ID}}",
         "amount": "0xbebc200",
         "payment_hash": "0xcb7bce98a778f130d34da522623d7e56705bddfe0dc4781bd2331211134a19a6",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -36,6 +36,11 @@ assert {
   res.body.result: isUndefined
 }
 
+script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
 script:post-response {
   console.log("step 10 response: ", res.body);
   // Sleep for sometime to make sure current operation finishes before next request starts.
diff --git a/tests/bruno/e2e/open-use-close-a-channel/11-add-tlc-from-NODE3.bru b/tests/bruno/e2e/open-use-close-a-channel/11-add-tlc-from-NODE3.bru
index 1b07cdbe..4105d4c2 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/11-add-tlc-from-NODE3.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/11-add-tlc-from-NODE3.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{CHANNEL_ID}}",
         "amount": "0x11e1a300",
         "payment_hash": "0x29449e2cc6f56a691253fe88e3a378171c81573b09247010b4f1cb8c806e1e38",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -36,6 +36,11 @@ assert {
   res.body.result.tlc_id: isDefined
 }
 
+script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
 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/12-add-tlc-from-NODE3.bru b/tests/bruno/e2e/open-use-close-a-channel/12-add-tlc-from-NODE3.bru
index a243a17d..24ebd0be 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/12-add-tlc-from-NODE3.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/12-add-tlc-from-NODE3.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{CHANNEL_ID}}",
         "amount": "0x11e1a300",
         "payment_hash": "0x29449e2cc6f56a691253fe88e3a378171c81573b09247010b4f1cb8c806e1e12",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -36,6 +36,11 @@ assert {
   res.body.result.tlc_id: isDefined
 }
 
+script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
 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/reestablish/07-add-tlc-from-NODE3.bru b/tests/bruno/e2e/reestablish/07-add-tlc-from-NODE3.bru
index c8efda0f..0ed357f2 100644
--- a/tests/bruno/e2e/reestablish/07-add-tlc-from-NODE3.bru
+++ b/tests/bruno/e2e/reestablish/07-add-tlc-from-NODE3.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{CHANNEL_ID}}",
         "amount": "0x5f5e100",
         "payment_hash": "0x266cec97cbede2cfbce73666f08deed9560bdf7841a7a5a51b3a3f09da249e21",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -36,6 +36,11 @@ assert {
   res.body.result.tlc_id: isDefined
 }
 
+script:pre-request {
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
 script:post-response {
   bru.setVar("TLC_ID1", res.body.result.tlc_id);
 }
diff --git a/tests/bruno/e2e/router-pay/11-node3-gen-invoice.bru b/tests/bruno/e2e/router-pay/11-node3-gen-invoice.bru
index 15d87811..7a57b1d9 100644
--- a/tests/bruno/e2e/router-pay/11-node3-gen-invoice.bru
+++ b/tests/bruno/e2e/router-pay/11-node3-gen-invoice.bru
@@ -26,7 +26,7 @@ body:json {
         "currency": "Fibd",
         "description": "test invoice generated by node3",
         "expiry": "0xe10",
-        "final_expiry_delta": "0x28",
+        "final_expiry_delta": "0xDFFA0",
         "payment_preimage": "{{payment_preimage}}"
       }
     ]
diff --git a/tests/bruno/e2e/router-pay/14-node3-gen-invoice-later.bru b/tests/bruno/e2e/router-pay/14-node3-gen-invoice-later.bru
index f62cf864..d7ae3b9f 100644
--- a/tests/bruno/e2e/router-pay/14-node3-gen-invoice-later.bru
+++ b/tests/bruno/e2e/router-pay/14-node3-gen-invoice-later.bru
@@ -26,7 +26,7 @@ body:json {
         "currency": "Fibd",
         "description": "test invoice generated by node3",
         "expiry": "0xe10",
-        "final_expiry_delta": "0x28",
+        "final_expiry_delta": "0xDFFA0",
         "payment_preimage": "{{payment_preimage}}"
       }
     ]
diff --git a/tests/bruno/e2e/router-pay/22-node3-gen-expiring-invoice.bru b/tests/bruno/e2e/router-pay/22-node3-gen-expiring-invoice.bru
index a321dfac..d49d9bef 100644
--- a/tests/bruno/e2e/router-pay/22-node3-gen-expiring-invoice.bru
+++ b/tests/bruno/e2e/router-pay/22-node3-gen-expiring-invoice.bru
@@ -26,7 +26,7 @@ body:json {
         "currency": "Fibd",
         "description": "test invoice generated by node3",
         "expiry": "0x2",
-        "final_expiry_delta": "0x28",
+        "final_expiry_delta": "0xDFFA0",
         "payment_preimage": "{{payment_preimage}}"
       }
     ]
diff --git a/tests/bruno/e2e/router-pay/24-node1-gen-invoice-for-self.bru b/tests/bruno/e2e/router-pay/24-node1-gen-invoice-for-self.bru
index 46e06ca2..9b91a9db 100644
--- a/tests/bruno/e2e/router-pay/24-node1-gen-invoice-for-self.bru
+++ b/tests/bruno/e2e/router-pay/24-node1-gen-invoice-for-self.bru
@@ -26,7 +26,7 @@ body:json {
         "currency": "Fibd",
         "description": "test invoice generated by node1",
         "expiry": "0xe10",
-        "final_expiry_delta": "0x28",
+        "final_expiry_delta": "0xDFFA0",
         "payment_preimage": "{{payment_preimage}}"
       }
     ]
diff --git a/tests/bruno/e2e/udt-router-pay/11-node3-gen-invoice.bru b/tests/bruno/e2e/udt-router-pay/11-node3-gen-invoice.bru
index 65dff4e2..0b01bbe5 100644
--- a/tests/bruno/e2e/udt-router-pay/11-node3-gen-invoice.bru
+++ b/tests/bruno/e2e/udt-router-pay/11-node3-gen-invoice.bru
@@ -26,7 +26,7 @@ body:json {
         "currency": "Fibd",
         "description": "test invoice generated by node3",
         "expiry": "0xe10",
-        "final_expiry_delta": "0x28",
+        "final_expiry_delta": "0xDFFA0",
         "payment_preimage": "{{payment_preimage}}",
         "udt_type_script": {
             "code_hash": "{{UDT_CODE_HASH}}",
diff --git a/tests/bruno/e2e/udt-router-pay/13-node3-gen-invoice-later.bru b/tests/bruno/e2e/udt-router-pay/13-node3-gen-invoice-later.bru
index 99633888..d63ea12a 100644
--- a/tests/bruno/e2e/udt-router-pay/13-node3-gen-invoice-later.bru
+++ b/tests/bruno/e2e/udt-router-pay/13-node3-gen-invoice-later.bru
@@ -26,7 +26,7 @@ body:json {
         "currency": "Fibd",
         "description": "test invoice generated by node3",
         "expiry": "0xe10",
-        "final_expiry_delta": "0x28",
+        "final_expiry_delta": "0xDFFA0",
         "payment_preimage": "{{payment_preimage}}",
         "udt_type_script": {
             "code_hash": "{{UDT_CODE_HASH}}",
diff --git a/tests/bruno/e2e/udt/07-node2-gen-invoice.bru b/tests/bruno/e2e/udt/07-node2-gen-invoice.bru
index 3f68bea8..47562c64 100644
--- a/tests/bruno/e2e/udt/07-node2-gen-invoice.bru
+++ b/tests/bruno/e2e/udt/07-node2-gen-invoice.bru
@@ -39,7 +39,7 @@ body:json {
         "currency": "Fibd",
         "description": "test invoice generated by node2",
         "expiry": "0xe10",
-        "final_expiry_delta": "0x28",
+        "final_expiry_delta": "0xDFFA0",
         "payment_preimage": "{{payment_preimage}}",
         "udt_type_script": {
             "code_hash": "{{UDT_CODE_HASH}}",
diff --git a/tests/bruno/e2e/udt/08-node1-add-tlc.bru b/tests/bruno/e2e/udt/08-node1-add-tlc.bru
index 48c2b6ad..a3c80de1 100644
--- a/tests/bruno/e2e/udt/08-node1-add-tlc.bru
+++ b/tests/bruno/e2e/udt/08-node1-add-tlc.bru
@@ -25,7 +25,7 @@ body:json {
         "channel_id": "{{N1N2_CHANNEL_ID}}",
         "amount": "{{payment_amount}}",
         "payment_hash": "{{payment_hash}}",
-        "expiry": "0x20000000000"
+        "expiry": "{{expiry}}"
       }
     ]
   }
@@ -37,8 +37,8 @@ assert {
 }
 
 script:pre-request {
-  console.log("sending node1 AddTlc:", bru.getVar("payment_hash"));
-  console.log("amount: ", bru.getVar("payment_amount"));
+  let expiry = "0x" + (Date.now() + 1000 * 60 * 60 * 24).toString(16);
+  bru.setVar("expiry", expiry);
 }
 
 script:post-response {