diff --git a/src/fiber/channel.rs b/src/fiber/channel.rs
index 680d3545f..a1f926b3f 100644
--- a/src/fiber/channel.rs
+++ b/src/fiber/channel.rs
@@ -39,7 +39,7 @@ use crate::{
     now_timestamp_as_millis_u64, NetworkServiceEvent,
 };
 use ckb_hash::{blake2b_256, new_blake2b};
-use ckb_sdk::{Since, SinceType};
+use ckb_sdk::{util::blake160, Since, SinceType};
 use ckb_types::{
     core::{
         Capacity, CapacityError, EpochNumberWithFraction, FeeRate, TransactionBuilder,
@@ -1304,9 +1304,18 @@ where
     ) -> ProcessingChannelResult {
         state.check_for_tlc_update(None, true, false)?;
         state.check_remove_tlc_with_reason(TLCId::Received(command.id), &command.reason)?;
-        state
+        let payment_hash = state
             .tlc_state
             .set_received_tlc_removed(command.id, command.reason.clone());
+        if let RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill { payment_preimage }) =
+            command.reason
+        {
+            self.store
+                .insert_payment_preimage(payment_hash, payment_preimage)
+                .map_err(|_| {
+                    ProcessingChannelError::InternalError("insert preimage failed".to_string())
+                })?;
+        }
         let msg = FiberMessageWithPeerId::new(
             state.get_remote_peer_id(),
             FiberMessage::remove_tlc(RemoveTlc {
@@ -2888,12 +2897,12 @@ impl TlcState {
         self.received_tlcs.add_tlc(tlc);
     }
 
-    pub fn set_received_tlc_removed(&mut self, tlc_id: u64, reason: RemoveTlcReason) {
-        if let Some(tlc) = self.get_mut(&TLCId::Received(tlc_id)) {
-            assert_eq!(tlc.inbound_status(), InboundTlcStatus::Committed);
-            tlc.removed_reason = Some(reason);
-            tlc.status = TlcStatus::Inbound(InboundTlcStatus::LocalRemoved);
-        }
+    pub fn set_received_tlc_removed(&mut self, tlc_id: u64, reason: RemoveTlcReason) -> Hash256 {
+        let tlc = self.get_mut(&TLCId::Received(tlc_id)).expect("get tlc");
+        assert_eq!(tlc.inbound_status(), InboundTlcStatus::Committed);
+        tlc.removed_reason = Some(reason);
+        tlc.status = TlcStatus::Inbound(InboundTlcStatus::LocalRemoved);
+        tlc.payment_hash
     }
 
     pub fn set_offered_tlc_removed(&mut self, tlc_id: u64, reason: RemoveTlcReason) -> Hash256 {
@@ -3057,6 +3066,38 @@ pub struct SettlementData {
     pub to_remote_output: CellOutput,
     #[serde_as(as = "EntityHex")]
     pub to_remote_output_data: Bytes,
+    pub tlcs: Vec<SettlementTlc>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct SettlementTlc {
+    pub tlc_id: TLCId,
+    pub hash_algorithm: HashAlgorithm,
+    pub payment_amount: u128,
+    pub payment_hash: Hash256,
+    pub expiry: u64,
+    pub local_key: Privkey,
+    pub remote_key: Pubkey,
+}
+
+impl SettlementTlc {
+    pub fn to_witness(&self, for_remote: bool) -> Vec<u8> {
+        let mut vec = Vec::new();
+        let offered_flag = if self.tlc_id.is_offered() { 0u8 } else { 1u8 };
+        vec.push(((self.hash_algorithm as u8) << 1) + offered_flag);
+        vec.extend_from_slice(&self.payment_amount.to_le_bytes());
+        vec.extend_from_slice(&self.payment_hash.as_ref()[0..20]);
+        if self.tlc_id.is_offered() ^ for_remote {
+            vec.extend_from_slice(blake160(&self.remote_key.serialize()).as_ref());
+            vec.extend_from_slice(blake160(&self.local_key.pubkey().serialize()).as_ref());
+        } else {
+            vec.extend_from_slice(blake160(&self.local_key.pubkey().serialize()).as_ref());
+            vec.extend_from_slice(blake160(&self.remote_key.serialize()).as_ref());
+        }
+        let since = Since::new(SinceType::Timestamp, self.expiry / 1000, false);
+        vec.extend_from_slice(&since.value().to_le_bytes());
+        vec
+    }
 }
 
 #[serde_as]
@@ -4891,15 +4932,10 @@ impl ChannelActorState {
     // will have the second pubkey.
     // This tlc must have valid local_committed_at and remote_committed_at fields.
     pub fn get_tlc_pubkeys(&self, tlc: &TlcInfo) -> (Pubkey, Pubkey) {
-        let is_offered = tlc.is_offered();
         let CommitmentNumbers {
             local: local_commitment_number,
             remote: remote_commitment_number,
         } = tlc.get_commitment_numbers();
-        debug!(
-            "Local commitment number: {}, remote commitment number: {}",
-            local_commitment_number, remote_commitment_number
-        );
         let local_pubkey = derive_tlc_pubkey(
             &self.get_local_channel_public_keys().tlc_base_key,
             &self.get_local_commitment_point(remote_commitment_number),
@@ -4908,58 +4944,42 @@ impl ChannelActorState {
             &self.get_remote_channel_public_keys().tlc_base_key,
             &self.get_remote_commitment_point(local_commitment_number),
         );
-
-        if is_offered {
-            (local_pubkey, remote_pubkey)
-        } else {
-            (remote_pubkey, local_pubkey)
-        }
+        (local_pubkey, remote_pubkey)
     }
 
-    fn get_active_received_tlc_with_pubkeys(
-        &self,
-        for_remote: bool,
-    ) -> Vec<(TlcInfo, Pubkey, Pubkey)> {
-        self.get_active_received_tlcs(for_remote)
-            .into_iter()
-            .map(move |tlc| {
-                let (k1, k2) = self.get_tlc_pubkeys(&tlc);
-                (tlc, k1, k2)
-            })
-            .collect()
-    }
+    fn get_tlc_keys(&self, tlc: &TlcInfo) -> (Privkey, Pubkey) {
+        let CommitmentNumbers {
+            local: local_commitment_number,
+            remote: remote_commitment_number,
+        } = tlc.get_commitment_numbers();
 
-    fn get_active_offered_tlc_with_pubkeys(
-        &self,
-        for_remote: bool,
-    ) -> Vec<(TlcInfo, Pubkey, Pubkey)> {
-        self.get_active_offered_tlcs(for_remote)
-            .into_iter()
-            .map(move |tlc| {
-                let (k1, k2) = self.get_tlc_pubkeys(&tlc);
-                (tlc, k1, k2)
-            })
-            .collect()
+        (
+            self.signer.derive_tlc_key(remote_commitment_number),
+            derive_tlc_pubkey(
+                &self.get_remote_channel_public_keys().tlc_base_key,
+                &self.get_remote_commitment_point(local_commitment_number),
+            ),
+        )
     }
 
-    fn get_active_htlcs(&self, for_remote: bool) -> Vec<u8> {
+    fn get_active_tlcs(&self, for_remote: bool) -> Vec<u8> {
         // Build a sorted array of TLC so that both party can generate the same commitment transaction.
         let tlcs = {
             let (mut received_tlcs, mut offered_tlcs) = (
-                self.get_active_received_tlc_with_pubkeys(for_remote),
-                self.get_active_offered_tlc_with_pubkeys(for_remote),
+                self.get_active_received_tlcs(for_remote),
+                self.get_active_offered_tlcs(for_remote),
             );
             let (mut a, mut b) = if for_remote {
                 (received_tlcs, offered_tlcs)
             } else {
-                for (tlc, _, _) in received_tlcs.iter_mut().chain(offered_tlcs.iter_mut()) {
+                for tlc in received_tlcs.iter_mut().chain(offered_tlcs.iter_mut()) {
                     // Need to flip these fields for the counterparty.
                     tlc.flip_mut();
                 }
                 (offered_tlcs, received_tlcs)
             };
-            a.sort_by(|x, y| u64::from(x.0.tlc_id).cmp(&u64::from(y.0.tlc_id)));
-            b.sort_by(|x, y| u64::from(x.0.tlc_id).cmp(&u64::from(y.0.tlc_id)));
+            a.sort_by(|x, y| u64::from(x.tlc_id).cmp(&u64::from(y.tlc_id)));
+            b.sort_by(|x, y| u64::from(x.tlc_id).cmp(&u64::from(y.tlc_id)));
             [a, b].concat()
         };
 
@@ -4967,14 +4987,20 @@ impl ChannelActorState {
             Vec::new()
         } else {
             let mut result = vec![tlcs.len() as u8];
-            for (tlc, local, remote) in tlcs {
+            for tlc in tlcs {
+                let (local_key, remote_key) = self.get_tlc_pubkeys(&tlc);
                 result.extend_from_slice(&tlc.get_htlc_type().to_le_bytes());
                 result.extend_from_slice(&tlc.amount.to_le_bytes());
                 result.extend_from_slice(&tlc.get_hash());
-                result.extend_from_slice(&local.serialize());
-                result.extend_from_slice(&remote.serialize());
+                if tlc.is_offered() ^ for_remote {
+                    result.extend_from_slice(blake160(&remote_key.serialize()).as_ref());
+                    result.extend_from_slice(blake160(&local_key.serialize()).as_ref());
+                } else {
+                    result.extend_from_slice(blake160(&local_key.serialize()).as_ref());
+                    result.extend_from_slice(blake160(&remote_key.serialize()).as_ref());
+                }
                 result.extend_from_slice(
-                    &Since::new(SinceType::Timestamp, tlc.expiry, false)
+                    &Since::new(SinceType::Timestamp, tlc.expiry / 1000, false)
                         .value()
                         .to_le_bytes(),
                 );
@@ -4983,6 +5009,40 @@ impl ChannelActorState {
         }
     }
 
+    fn get_active_tlcs_for_settlement(&self, for_remote: bool) -> Vec<SettlementTlc> {
+        let (mut received_tlcs, mut offered_tlcs) = (
+            self.get_active_received_tlcs(for_remote),
+            self.get_active_offered_tlcs(for_remote),
+        );
+        let (mut a, mut b) = if for_remote {
+            (received_tlcs, offered_tlcs)
+        } else {
+            for tlc in received_tlcs.iter_mut().chain(offered_tlcs.iter_mut()) {
+                // Need to flip these fields for the counterparty.
+                tlc.flip_mut();
+            }
+            (offered_tlcs, received_tlcs)
+        };
+        a.sort_by(|x, y| u64::from(x.tlc_id).cmp(&u64::from(y.tlc_id)));
+        b.sort_by(|x, y| u64::from(x.tlc_id).cmp(&u64::from(y.tlc_id)));
+        [a, b]
+            .concat()
+            .into_iter()
+            .map(|tlc| {
+                let (local_key, remote_key) = self.get_tlc_keys(&tlc);
+                SettlementTlc {
+                    tlc_id: tlc.tlc_id,
+                    hash_algorithm: tlc.hash_algorithm,
+                    payment_amount: tlc.amount,
+                    payment_hash: tlc.payment_hash,
+                    expiry: tlc.expiry,
+                    local_key,
+                    remote_key,
+                }
+            })
+            .collect()
+    }
+
     fn any_tlc_pending(&self) -> bool {
         self.tlc_state
             .all_tlcs()
@@ -5334,6 +5394,7 @@ impl ChannelActorState {
                 to_local_output_data,
                 to_remote_output,
                 to_remote_output_data,
+                tlcs: self.get_active_tlcs_for_settlement(false),
             }
         };
 
@@ -6012,6 +6073,7 @@ impl ChannelActorState {
                 to_local_output_data,
                 to_remote_output,
                 to_remote_output_data,
+                tlcs: self.get_active_tlcs_for_settlement(true),
             }
         };
 
@@ -6349,6 +6411,7 @@ impl ChannelActorState {
                 to_local_output_data,
                 to_remote_output,
                 to_remote_output_data,
+                tlcs: vec![],
             }
         };
         Ok(settlement_data)
@@ -6642,9 +6705,7 @@ impl ChannelActorState {
     // for the remote party (we build this commitment transaction
     // normally because we want to send a partial signature to remote).
     // The function returns a tuple, the first element is the commitment transaction itself,
-    // and the second element is the message to be signed by the each party,
-    // so as to consume the funding cell. The last element is the witnesses for the
-    // commitment transaction.
+    // and the second element is the settlement transaction.
     fn build_commitment_and_settlement_tx(
         &self,
         for_remote: bool,
@@ -6693,7 +6754,7 @@ impl ChannelActorState {
     fn build_commitment_transaction_output(&self, for_remote: bool) -> (CellOutput, Bytes) {
         let x_only_aggregated_pubkey = self.get_commitment_lock_script_xonly(for_remote);
         let version = self.get_current_commitment_number(for_remote);
-        let htlcs = self.get_active_htlcs(for_remote);
+        let tlcs = self.get_active_tlcs(for_remote);
 
         let mut commitment_lock_script_args = [
             &blake2b_256(x_only_aggregated_pubkey)[0..20],
@@ -6701,8 +6762,8 @@ impl ChannelActorState {
             version.to_be_bytes().as_slice(),
         ]
         .concat();
-        if !htlcs.is_empty() {
-            commitment_lock_script_args.extend_from_slice(&blake2b_256(&htlcs)[0..20]);
+        if !tlcs.is_empty() {
+            commitment_lock_script_args.extend_from_slice(&blake2b_256(&tlcs)[0..20]);
         }
 
         let commitment_lock_script =
@@ -7077,16 +7138,16 @@ pub struct PartiallySignedCommitmentTransaction {
     pub commitment_tx_partial_signature: PartialSignature,
 }
 
+/// for xudt compatibility issue,
+/// refer to: https://github.com/nervosnetwork/fiber-scripts/pull/5
+pub const XUDT_COMPATIBLE_WITNESS: [u8; 16] = [16, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0];
+
 pub fn create_witness_for_funding_cell(
     lock_key_xonly: [u8; 32],
     signature: CompactSignature,
 ) -> [u8; FUNDING_CELL_WITNESS_LEN] {
     let mut witness = Vec::with_capacity(FUNDING_CELL_WITNESS_LEN);
-
-    // for xudt compatibility issue,
-    // refer to: https://github.com/nervosnetwork/fiber-scripts/pull/5
-    let empty_witness_args = [16, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0];
-    witness.extend_from_slice(&empty_witness_args);
+    witness.extend_from_slice(&XUDT_COMPATIBLE_WITNESS);
     witness.extend_from_slice(lock_key_xonly.as_slice());
     witness.extend_from_slice(signature.serialize().as_slice());
     witness
@@ -7099,10 +7160,7 @@ pub fn create_witness_for_commitment_cell(
     signature: CompactSignature,
 ) -> [u8; COMMITMENT_CELL_WITNESS_LEN] {
     let mut witness = Vec::with_capacity(COMMITMENT_CELL_WITNESS_LEN);
-    // for xudt compatibility issue,
-    // refer to: https://github.com/nervosnetwork/fiber-scripts/pull/5
-    let empty_witness_args = [16, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0];
-    witness.extend_from_slice(&empty_witness_args);
+    witness.extend_from_slice(&XUDT_COMPATIBLE_WITNESS);
     witness.extend_from_slice(&[0xFE]);
     witness.extend_from_slice(lock_key_xonly.as_slice());
     witness.extend_from_slice(signature.serialize().as_slice());
@@ -7111,6 +7169,19 @@ pub fn create_witness_for_commitment_cell(
         .expect("Witness length should be correct")
 }
 
+pub fn create_witness_for_commitment_cell_with_pending_tlcs(
+    index: u8,
+    pending_tlcs: &[u8],
+) -> Vec<u8> {
+    let mut witness = Vec::new();
+    witness.extend_from_slice(&XUDT_COMPATIBLE_WITNESS);
+    witness.extend_from_slice(&[index]);
+    witness.extend_from_slice(&[(pending_tlcs.len() / 85) as u8]);
+    witness.extend_from_slice(pending_tlcs);
+    witness.extend_from_slice(&[0u8; 65]);
+    witness
+}
+
 // The common musig2 configuration that is used both by signing and verifying.
 #[derive(Debug)]
 struct Musig2CommonContext {
diff --git a/src/fiber/fee.rs b/src/fiber/fee.rs
index 69d1739f5..413317641 100644
--- a/src/fiber/fee.rs
+++ b/src/fiber/fee.rs
@@ -11,7 +11,7 @@ use ckb_types::{
 use molecule::prelude::Entity;
 
 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.
+    // when there is pending tlcs, the commitment lock args will be 56 bytes, otherwise 46 bytes.
     // to simplify the calculation, we use hardcoded 56 bytes here.
     let commitment_lock_script = get_script_by_contract(Contract::CommitmentLock, &[0u8; 56]);
     let cell_deps = get_cell_deps(vec![Contract::FundingLock], udt_type_script);
diff --git a/src/fiber/tests/channel.rs b/src/fiber/tests/channel.rs
index cac8a429c..05f9bb26e 100644
--- a/src/fiber/tests/channel.rs
+++ b/src/fiber/tests/channel.rs
@@ -1,5 +1,5 @@
 use super::test_utils::{init_tracing, NetworkNode};
-use crate::fiber::channel::UpdateCommand;
+use crate::fiber::channel::{UpdateCommand, XUDT_COMPATIBLE_WITNESS};
 use crate::fiber::config::MAX_PAYMENT_TLC_EXPIRY_LIMIT;
 use crate::fiber::graph::{ChannelInfo, PaymentSessionStatus};
 use crate::fiber::network::{DebugEvent, SendPaymentCommand};
@@ -4162,9 +4162,8 @@ async fn test_revoke_old_commitment_transaction() {
         .output_data(revocation_data.output_data)
         .build();
 
-    let empty_witness_args = [16, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0];
     let witness = [
-        empty_witness_args.to_vec(),
+        XUDT_COMPATIBLE_WITNESS.to_vec(),
         vec![0xFF],
         revocation_data.commitment_number.to_be_bytes().to_vec(),
         revocation_data.x_only_aggregated_pubkey.to_vec(),
diff --git a/src/invoice/store.rs b/src/invoice/store.rs
index 32c368b80..7b8936970 100644
--- a/src/invoice/store.rs
+++ b/src/invoice/store.rs
@@ -20,4 +20,6 @@ pub trait InvoiceStore {
         payment_hash: Hash256,
         preimage: Hash256,
     ) -> Result<(), InvoiceError>;
+    /// Search for the stored preimage with the given payment hash prefix, usually the first 20 bytes of the payment hash.
+    fn search_payment_preimage(&self, payment_hash_prefix: &[u8]) -> Option<Hash256>;
 }
diff --git a/src/store/store.rs b/src/store/store.rs
index 0150b008a..e37d8d469 100644
--- a/src/store/store.rs
+++ b/src/store/store.rs
@@ -436,6 +436,13 @@ impl InvoiceStore for Store {
         batch.commit();
         Ok(())
     }
+
+    fn search_payment_preimage(&self, payment_hash_prefix: &[u8]) -> Option<Hash256> {
+        let prefix = [&[CKB_INVOICE_PREIMAGE_PREFIX], payment_hash_prefix].concat();
+        let mut iter = self.prefix_iterator(prefix.as_slice());
+        iter.next()
+            .map(|(_key, value)| deserialize_from(value.as_ref(), "Hash256"))
+    }
 }
 
 impl NetworkGraphStateStore for Store {
diff --git a/src/store/tests/store.rs b/src/store/tests/store.rs
index 58e804182..c3232cecd 100644
--- a/src/store/tests/store.rs
+++ b/src/store/tests/store.rs
@@ -93,6 +93,10 @@ fn test_store_invoice() {
         .unwrap();
     assert_eq!(store.get_invoice(hash), Some(invoice.clone()));
     assert_eq!(store.get_invoice_preimage(hash), Some(preimage));
+    assert_eq!(
+        store.search_payment_preimage(&hash.as_ref()[0..20]),
+        Some(preimage)
+    );
 
     let invalid_hash = gen_rand_sha256_hash();
     assert_eq!(store.get_invoice_preimage(&invalid_hash), None);
@@ -241,6 +245,7 @@ fn test_store_wacthtower() {
         to_local_output_data: Bytes::default(),
         to_remote_output: CellOutput::default(),
         to_remote_output_data: Bytes::default(),
+        tlcs: vec![],
     };
 
     store.insert_watch_channel(channel_id, funding_tx_lock.clone(), settlement_data.clone());
diff --git a/src/watchtower/actor.rs b/src/watchtower/actor.rs
index 7d06ebccd..5ed34e43d 100644
--- a/src/watchtower/actor.rs
+++ b/src/watchtower/actor.rs
@@ -1,12 +1,12 @@
 use anyhow::anyhow;
-use ckb_hash::new_blake2b;
+use ckb_hash::{blake2b_256, new_blake2b};
 use ckb_jsonrpc_types::{Either, Status};
 use ckb_sdk::{
-    rpc::ckb_indexer::{CellType, Order, ScriptType, SearchKey, SearchMode, Tx},
+    rpc::ckb_indexer::{Cell, CellType, Order, ScriptType, SearchKey, SearchMode, Tx},
     traits::{CellCollector, CellQueryOptions, DefaultCellCollector, ValueRangeOption},
     transaction::builder::FeeCalculator,
     util::blake160,
-    CkbRpcClient, RpcError,
+    CkbRpcClient, RpcError, Since, SinceType,
 };
 use ckb_types::{
     self,
@@ -24,7 +24,15 @@ use crate::{
         contracts::{get_cell_deps, get_script_by_contract, Contract},
         CkbConfig,
     },
-    fiber::channel::{create_witness_for_commitment_cell, RevocationData, SettlementData},
+    fiber::{
+        channel::{
+            create_witness_for_commitment_cell,
+            create_witness_for_commitment_cell_with_pending_tlcs, RevocationData, SettlementData,
+            SettlementTlc, XUDT_COMPATIBLE_WITNESS,
+        },
+        types::Hash256,
+    },
+    invoice::InvoiceStore,
     NetworkServiceEvent,
 };
 
@@ -36,7 +44,7 @@ pub struct WatchtowerActor<S> {
     store: S,
 }
 
-impl<S: WatchtowerStore> WatchtowerActor<S> {
+impl<S: InvoiceStore + WatchtowerStore> WatchtowerActor<S> {
     pub fn new(store: S) -> Self {
         Self { store }
     }
@@ -55,7 +63,7 @@ pub struct WatchtowerState {
 #[ractor::async_trait]
 impl<S> Actor for WatchtowerActor<S>
 where
-    S: WatchtowerStore + Send + Sync + 'static,
+    S: InvoiceStore + WatchtowerStore + Send + Sync + 'static,
 {
     type Msg = WatchtowerMessage;
     type State = WatchtowerState;
@@ -126,7 +134,7 @@ where
 
 impl<S> WatchtowerActor<S>
 where
-    S: WatchtowerStore,
+    S: InvoiceStore + WatchtowerStore,
 {
     fn periodic_check(&self, state: &WatchtowerState) {
         for channel_data in self.store.get_watch_channels() {
@@ -247,8 +255,10 @@ where
                                                                         channel_data
                                                                             .remote_settlement_data
                                                                             .clone(),
+                                                                        true,
                                                                         secret_key,
                                                                         &mut cell_collector,
+                                                                        &self.store,
                                                                     );
                                                                 }
                                                             }
@@ -260,10 +270,12 @@ where
                                                                     .local_settlement_data
                                                                     .clone()
                                                                     .expect(
-                                                                        "remote settlement data",
+                                                                        "local settlement data",
                                                                     ),
+                                                                false,
                                                                 secret_key,
                                                                 &mut cell_collector,
+                                                                &self.store,
                                                             );
                                                         }
                                                     } else {
@@ -304,9 +316,8 @@ fn build_revocation_tx(
     secret_key: SecretKey,
     cell_collector: &mut DefaultCellCollector,
 ) -> Result<TransactionView, Box<dyn std::error::Error>> {
-    let empty_witness_args = [16, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0];
     let witness = [
-        empty_witness_args.to_vec(),
+        XUDT_COMPATIBLE_WITNESS.to_vec(),
         vec![0xFF],
         revocation_data.commitment_number.to_be_bytes().to_vec(),
         revocation_data.x_only_aggregated_pubkey.to_vec(),
@@ -384,18 +395,34 @@ fn build_revocation_tx(
     Err(Box::new(RpcError::Other(anyhow!("Not enough capacity"))))
 }
 
-fn try_settle_commitment_tx(
+fn try_settle_commitment_tx<S: InvoiceStore>(
     commitment_lock: Script,
     ckb_client: CkbRpcClient,
     settlement_data: SettlementData,
+    for_remote: bool,
     secret_key: SecretKey,
     cell_collector: &mut DefaultCellCollector,
+    store: &S,
 ) {
-    let current_epoch = match ckb_client.get_tip_header() {
-        Ok(tip_header) => {
-            let tip_header: HeaderView = tip_header.into();
-            tip_header.epoch()
-        }
+    let (current_epoch, current_time) = match ckb_client.get_tip_header() {
+        Ok(tip_header) => match ckb_client.get_block_median_time(tip_header.hash.clone()) {
+            Ok(Some(median_time)) => {
+                let tip_header: HeaderView = tip_header.into();
+                let epoch = tip_header.epoch();
+                (epoch, median_time.value())
+            }
+            Ok(None) => {
+                error!(
+                    "Cannot find median time: {:?}, ckb rpc bug?",
+                    tip_header.hash
+                );
+                return;
+            }
+            Err(err) => {
+                error!("Failed to get median time: {:?}", err);
+                return;
+            }
+        },
         Err(err) => {
             error!("Failed to get tip header: {:?}", err);
             return;
@@ -419,51 +446,147 @@ fn try_settle_commitment_tx(
     match ckb_client.get_cells(search_key, Order::Desc, 100u32.into(), None) {
         Ok(cells) => {
             for cell in cells.objects {
-                let cell_output: CellOutput = cell.output.into();
+                let cell_output: CellOutput = cell.output.clone().into();
                 let commitment_tx_out_point =
                     OutPoint::new(cell.out_point.tx_hash.pack(), cell.out_point.index.value());
                 let lock_script_args = cell_output.lock().args().raw_data();
-                let since = u64::from_le_bytes(
-                    lock_script_args[20..28].try_into().expect("u64 from slice"),
-                );
-                let header: HeaderView = match ckb_client.get_header_by_number(cell.block_number) {
-                    Ok(Some(header)) => header.into(),
-                    Ok(None) => {
-                        error!("Cannot find header: {}", cell.block_number);
-                        continue;
+                if lock_script_args.len() > 36 {
+                    info!(
+                        "Found a force closed commitment tx with pending tlcs: {:#x}",
+                        cell.out_point.tx_hash
+                    );
+
+                    let commitment_tx_hash = cell.out_point.tx_hash.clone();
+                    match ckb_client.get_transaction(commitment_tx_hash.clone()) {
+                        Ok(Some(tx_with_status)) => {
+                            if tx_with_status.tx_status.status != Status::Committed {
+                                error!("Cannot find the commitment tx: {:?}, status is {:?}, maybe ckb indexer bug?", tx_with_status.tx_status.status, commitment_tx_hash);
+                            } else if let Some(tx) = tx_with_status.transaction {
+                                match tx.inner {
+                                    Either::Left(tx) => {
+                                        let tx: Transaction = tx.inner.into();
+                                        let pending_tlcs =
+                                            tx.witnesses().into_iter().find_map(|witness| {
+                                                let witness = witness.raw_data();
+                                                if witness.len() > 18
+                                                    && witness[0..16] == XUDT_COMPATIBLE_WITNESS
+                                                {
+                                                    let unlock_type = witness[16];
+                                                    let pending_tlc_count = witness[17];
+                                                    if unlock_type < 0xFE
+                                                        && unlock_type < pending_tlc_count
+                                                        && witness.len()
+                                                            > 18 + 85 * pending_tlc_count as usize
+                                                    {
+                                                        let remain = [
+                                                            &witness[18..(18
+                                                                + 85 * unlock_type as usize)],
+                                                            &witness[(18
+                                                                + 85 * (unlock_type + 1) as usize)
+                                                                ..(18
+                                                                    + 85 * pending_tlc_count
+                                                                        as usize)],
+                                                        ]
+                                                        .concat()
+                                                        .to_vec();
+
+                                                        Some(remain)
+                                                    } else {
+                                                        None
+                                                    }
+                                                } else {
+                                                    None
+                                                }
+                                            });
+
+                                        match build_settlement_tx_for_pending_tlcs(
+                                            cell,
+                                            settlement_data.clone(),
+                                            for_remote,
+                                            pending_tlcs,
+                                            secret_key,
+                                            cell_collector,
+                                            current_time,
+                                            store,
+                                        ) {
+                                            Ok(Some(tx)) => match ckb_client
+                                                .send_transaction(tx.data().into(), None)
+                                            {
+                                                Ok(tx_hash) => {
+                                                    info!("Settlement tx for pending tlcs: {:?} sent, tx_hash: {:#x}", tx, tx_hash);
+                                                }
+                                                Err(err) => {
+                                                    error!("Failed to send settlement tx for pending tlcs: {:?}, error: {:?}", tx, err);
+                                                }
+                                            },
+                                            Ok(None) => {
+                                                info!("No need to settle the commitment tx: {:#x} with pending tlcs", commitment_tx_hash);
+                                            }
+                                            Err(err) => {
+                                                error!("Failed to build settlement tx for pending tlcs: {:?}", err);
+                                            }
+                                        }
+                                    }
+                                    Either::Right(_) => {
+                                        // unreachable, ignore
+                                    }
+                                }
+                            }
+                        }
+                        Ok(None) => {
+                            error!(
+                                "Cannot find the commitment tx: {:?}, maybe ckb indexer bug?",
+                                commitment_tx_hash
+                            );
+                        }
+                        Err(err) => {
+                            error!("Failed to get commitment tx: {:?}", err);
+                        }
                     }
-                    Err(err) => {
-                        error!("Failed to get header: {:?}", err);
+                } else {
+                    let since = u64::from_le_bytes(
+                        lock_script_args[20..28].try_into().expect("u64 from slice"),
+                    );
+                    let header: HeaderView =
+                        match ckb_client.get_header_by_number(cell.block_number) {
+                            Ok(Some(header)) => header.into(),
+                            Ok(None) => {
+                                error!("Cannot find header: {}", cell.block_number);
+                                continue;
+                            }
+                            Err(err) => {
+                                error!("Failed to get header: {:?}", err);
+                                continue;
+                            }
+                        };
+                    let since_epoch = EpochNumberWithFraction::from_full_value(since);
+                    if header.epoch().to_rational() + since_epoch.to_rational()
+                        > current_epoch.to_rational()
+                    {
                         continue;
                     }
-                };
-                let since_epoch = EpochNumberWithFraction::from_full_value(since);
-                if header.epoch().to_rational() + since_epoch.to_rational()
-                    > current_epoch.to_rational()
-                {
-                    continue;
-                }
-                info!(
-                    "Found a force closed commitment tx: {:#x}",
-                    cell.out_point.tx_hash
-                );
-                match build_settlement_tx(
-                    commitment_tx_out_point,
-                    since,
-                    settlement_data.clone(),
-                    secret_key,
-                    cell_collector,
-                ) {
-                    Ok(tx) => match ckb_client.send_transaction(tx.data().into(), None) {
-                        Ok(tx_hash) => {
-                            info!("Settlement tx: {:?} sent, tx_hash: {:#x}", tx, tx_hash);
-                        }
+                    info!(
+                        "Found a force closed commitment tx without pending tlcs: {:#x}",
+                        cell.out_point.tx_hash
+                    );
+                    match build_settlement_tx(
+                        commitment_tx_out_point,
+                        since,
+                        settlement_data.clone(),
+                        secret_key,
+                        cell_collector,
+                    ) {
+                        Ok(tx) => match ckb_client.send_transaction(tx.data().into(), None) {
+                            Ok(tx_hash) => {
+                                info!("Settlement tx: {:?} sent, tx_hash: {:#x}", tx, tx_hash);
+                            }
+                            Err(err) => {
+                                error!("Failed to send settlement tx: {:?}, error: {:?}", tx, err);
+                            }
+                        },
                         Err(err) => {
-                            error!("Failed to send settlement tx: {:?}, error: {:?}", tx, err);
+                            error!("Failed to build settlement tx: {:?}", err);
                         }
-                    },
-                    Err(err) => {
-                        error!("Failed to build settlement tx: {:?}", err);
                     }
                 }
             }
@@ -481,7 +604,6 @@ fn build_settlement_tx(
     secret_key: SecretKey,
     cell_collector: &mut DefaultCellCollector,
 ) -> Result<TransactionView, Box<dyn std::error::Error>> {
-    // TODO use 0x00 ~ 0xFD to get back the funds
     let pubkey = PublicKey::from_secret_key(&Secp256k1::new(), &secret_key);
     let args = blake160(pubkey.serialize().as_ref());
     let fee_provider_lock_script = get_script_by_contract(Contract::Secp256k1Lock, args.as_bytes());
@@ -504,6 +626,7 @@ fn build_settlement_tx(
         to_local_output_data,
         to_remote_output,
         to_remote_output_data,
+        tlcs: _tlcs,
     } = settlement_data;
 
     let mut tx_builder = Transaction::default()
@@ -595,3 +718,401 @@ fn sign_tx(
 
     Ok(tx.as_advanced_builder().set_witnesses(witnesses).build())
 }
+
+fn sign_tx_with_settlement(
+    tx: TransactionView,
+    change_secret_key: SecretKey,
+    settlement_secret_key: SecretKey,
+) -> Result<TransactionView, Box<dyn std::error::Error>> {
+    let tx = tx.data();
+
+    let message = tx.calc_tx_hash();
+    let secp256k1_message = Message::from_digest_slice(&message.raw_data())?;
+    let secp256k1 = Secp256k1::new();
+    let signature = secp256k1.sign_ecdsa_recoverable(&secp256k1_message, &settlement_secret_key);
+    let (recov_id, data) = signature.serialize_compact();
+    let mut signature_bytes = [0u8; 65];
+    signature_bytes[0..64].copy_from_slice(&data[0..64]);
+    signature_bytes[64] = recov_id.to_i32() as u8;
+    let mut settlement_witness = tx
+        .witnesses()
+        .get(0)
+        .expect("get witness at index 0")
+        .raw_data()
+        .to_vec();
+    // a trick to avoid the signature place holder offset check
+    let witness_len = settlement_witness.len();
+    let signature_start = witness_len
+        - if settlement_witness[witness_len - 65..witness_len] == vec![0u8; 65] {
+            65
+        } else {
+            65 + 32
+        };
+    settlement_witness.splice(signature_start..signature_start + 65, signature_bytes);
+
+    let witness = tx.witnesses().get(1).expect("get witness at index 1");
+    let mut blake2b = new_blake2b();
+    blake2b.update(tx.calc_tx_hash().as_slice());
+    blake2b.update(&(witness.item_count() as u64).to_le_bytes());
+    blake2b.update(&witness.raw_data());
+    let mut message = vec![0u8; 32];
+    blake2b.finalize(&mut message);
+    let secp256k1_message = Message::from_digest_slice(&message)?;
+    let secp256k1 = Secp256k1::new();
+    let signature = secp256k1.sign_ecdsa_recoverable(&secp256k1_message, &change_secret_key);
+    let (recov_id, data) = signature.serialize_compact();
+    let mut signature_bytes = [0u8; 65];
+    signature_bytes[0..64].copy_from_slice(&data[0..64]);
+    signature_bytes[64] = recov_id.to_i32() as u8;
+    let change_witness = WitnessArgs::new_builder()
+        .lock(Some(ckb_types::bytes::Bytes::from(signature_bytes.to_vec())).pack())
+        .build()
+        .as_bytes();
+
+    let witnesses = vec![settlement_witness.pack(), change_witness.pack()];
+
+    Ok(tx.as_advanced_builder().set_witnesses(witnesses).build())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_settlement_tx_for_pending_tlcs<S: InvoiceStore>(
+    commitment_tx_cell: Cell,
+    settlement_data: SettlementData,
+    for_remote: bool,
+    pending_tlcs: Option<Vec<u8>>,
+    secret_key: SecretKey,
+    cell_collector: &mut DefaultCellCollector,
+    current_time: u64,
+    store: &S,
+) -> Result<Option<TransactionView>, Box<dyn std::error::Error>> {
+    let settlement_tlc: Option<(usize, SettlementTlc, Option<Hash256>)> = match pending_tlcs.clone()
+    {
+        Some(pending_tlcs) => pending_tlcs
+            .chunks(85)
+            .enumerate()
+            .find_map(|(index, tlc)| {
+                let tlc = Tlc(tlc);
+                settlement_data.tlcs.iter().find_map(|settlement_tlc| {
+                    let pubkey_hash = blake2b_256(settlement_tlc.local_key.pubkey().serialize());
+                    if settlement_tlc.tlc_id.is_offered() {
+                        if pubkey_hash.starts_with(tlc.local_pubkey_hash())
+                            && tlc.expiry() < current_time
+                        {
+                            Some((index, settlement_tlc.clone(), None))
+                        } else if pubkey_hash.starts_with(tlc.remote_pubkey_hash()) {
+                            store
+                                .search_payment_preimage(tlc.payment_hash())
+                                .map(|preimage| (index, settlement_tlc.clone(), Some(preimage)))
+                        } else {
+                            None
+                        }
+                    } else if pubkey_hash.starts_with(tlc.remote_pubkey_hash())
+                        && tlc.expiry() < current_time
+                    {
+                        Some((index, settlement_tlc.clone(), None))
+                    } else if pubkey_hash.starts_with(tlc.local_pubkey_hash()) {
+                        store
+                            .search_payment_preimage(tlc.payment_hash())
+                            .map(|preimage| (index, settlement_tlc.clone(), Some(preimage)))
+                    } else {
+                        None
+                    }
+                })
+            }),
+        None => settlement_data
+            .tlcs
+            .iter()
+            .enumerate()
+            .find_map(|(index, settlement_tlc)| {
+                if settlement_tlc.tlc_id.is_offered() {
+                    if settlement_tlc.expiry < current_time {
+                        if for_remote {
+                            Some((index, settlement_tlc.clone(), None))
+                        } else {
+                            None
+                        }
+                    } else if for_remote {
+                        None
+                    } else {
+                        store
+                            .get_invoice_preimage(&settlement_tlc.payment_hash)
+                            .map(|preimage| (index, settlement_tlc.clone(), Some(preimage)))
+                    }
+                } else if settlement_tlc.expiry < current_time {
+                    if for_remote {
+                        None
+                    } else {
+                        Some((index, settlement_tlc.clone(), None))
+                    }
+                } else if for_remote {
+                    store
+                        .get_invoice_preimage(&settlement_tlc.payment_hash)
+                        .map(|preimage| (index, settlement_tlc.clone(), Some(preimage)))
+                } else {
+                    None
+                }
+            }),
+    };
+    if let Some((index, tlc, preimage)) = settlement_tlc {
+        let pubkey = PublicKey::from_secret_key(&Secp256k1::new(), &secret_key);
+        let args = blake160(pubkey.serialize().as_ref());
+        let fee_provider_lock_script =
+            get_script_by_contract(Contract::Secp256k1Lock, args.as_bytes());
+
+        let change_output = CellOutput::new_builder()
+            .lock(fee_provider_lock_script.clone())
+            .build();
+        let placeholder_witness_for_change = WitnessArgs::new_builder()
+            .lock(Some(ckb_types::bytes::Bytes::from(vec![0u8; 65])).pack())
+            .build();
+
+        let old_pending_tlcs = pending_tlcs.unwrap_or_else(|| {
+            settlement_data
+                .tlcs
+                .iter()
+                .flat_map(|tlc| tlc.to_witness(for_remote))
+                .collect()
+        });
+        let old_pending_tlcs_size = old_pending_tlcs.len() / 85;
+        let new_pending_tlcs = if old_pending_tlcs_size > 1 {
+            [
+                &[old_pending_tlcs_size as u8 - 1],
+                &old_pending_tlcs[..85 * index],
+                &old_pending_tlcs[85 * (index + 1)..],
+            ]
+            .concat()
+        } else {
+            vec![]
+        };
+        let mut witness_for_commitment_cell = create_witness_for_commitment_cell_with_pending_tlcs(
+            index as u8,
+            old_pending_tlcs.as_slice(),
+        );
+        if let Some(preiamge) = preimage {
+            witness_for_commitment_cell.extend_from_slice(preiamge.as_ref());
+        }
+        let cell_output: CellOutput = commitment_tx_cell.output.clone().into();
+        let mut new_commitment_lock_script_args =
+            cell_output.lock().args().raw_data()[0..36].to_vec();
+        if !new_pending_tlcs.is_empty() {
+            new_commitment_lock_script_args
+                .extend_from_slice(&blake2b_256(&new_pending_tlcs)[0..20]);
+        }
+        if cell_output.type_().is_none() {
+            let capacity: u64 = cell_output.capacity().unpack();
+            let new_capacity = (capacity as u128 - tlc.payment_amount) as u64;
+            let new_commitment_output = cell_output
+                .clone()
+                .as_builder()
+                .lock(
+                    cell_output
+                        .lock()
+                        .as_builder()
+                        .args(new_commitment_lock_script_args.pack())
+                        .build(),
+                )
+                .capacity(new_capacity.pack())
+                .build();
+            let settlement_output = CellOutput::new_builder()
+                .lock(fee_provider_lock_script.clone())
+                .capacity((tlc.payment_amount as u64).pack())
+                .build();
+
+            let input = {
+                if preimage.is_none() {
+                    // TODO: ckb is using seconds as timestamp, we may need to change the expiry unit to seconds in the future
+                    let since = Since::new(SinceType::Timestamp, tlc.expiry / 1000, false).value();
+                    CellInput::new_builder()
+                        .previous_output(commitment_tx_cell.out_point.clone().into())
+                        .since(since.pack())
+                        .build()
+                } else {
+                    CellInput::new_builder()
+                        .previous_output(commitment_tx_cell.out_point.clone().into())
+                        .build()
+                }
+            };
+            let mut tx_builder = Transaction::default()
+                .as_advanced_builder()
+                .cell_deps(get_cell_deps(
+                    vec![Contract::CommitmentLock, Contract::Secp256k1Lock],
+                    &None,
+                ))
+                .input(input)
+                .output(new_commitment_output.clone())
+                .output_data(Bytes::default())
+                .output(settlement_output.clone())
+                .output_data(Bytes::default())
+                .witness(witness_for_commitment_cell.pack())
+                .witness(placeholder_witness_for_change.as_bytes().pack());
+
+            // TODO: move it to config or use https://github.com/nervosnetwork/ckb/pull/4477
+            let fee_calculator = FeeCalculator::new(1000);
+
+            let mut query = CellQueryOptions::new_lock(fee_provider_lock_script);
+            query.script_search_mode = Some(SearchMode::Exact);
+            query.secondary_script_len_range = Some(ValueRangeOption::new_exact(0));
+            query.data_len_range = Some(ValueRangeOption::new_exact(0));
+            let (cells, _total_capacity) = cell_collector.collect_live_cells(&query, true)?;
+
+            let settlement_output_occupied_capacity = settlement_output
+                .occupied_capacity(Capacity::shannons(0))
+                .expect("capacity does not overflow")
+                .as_u64();
+
+            let mut inputs_capacity = capacity;
+            for cell in cells {
+                let input_capacity: u64 = cell.output.capacity().unpack();
+                inputs_capacity += input_capacity;
+                tx_builder = tx_builder.input(
+                    CellInput::new_builder()
+                        .previous_output(cell.out_point)
+                        .build(),
+                );
+                let fee = fee_calculator
+                    .fee(tx_builder.clone().build().data().serialized_size_in_block() as u64);
+                if inputs_capacity >= new_capacity + settlement_output_occupied_capacity + fee {
+                    let adjusted_settlement_output = change_output
+                        .as_builder()
+                        .capacity((inputs_capacity - new_capacity - fee).pack())
+                        .build();
+                    let outputs = vec![new_commitment_output, adjusted_settlement_output];
+                    let tx = tx_builder.set_outputs(outputs).build();
+                    let tx = sign_tx_with_settlement(tx, secret_key, tlc.local_key.0)?;
+                    return Ok(Some(tx));
+                }
+            }
+
+            Err(Box::new(RpcError::Other(anyhow!("Not enough capacity"))))
+        } else {
+            let amount = u128::from_le_bytes(
+                commitment_tx_cell.output_data.unwrap().as_bytes()[0..16]
+                    .try_into()
+                    .unwrap(),
+            );
+            let new_amount = amount - tlc.payment_amount;
+            let new_commitment_output = cell_output
+                .clone()
+                .as_builder()
+                .lock(
+                    cell_output
+                        .lock()
+                        .as_builder()
+                        .args(new_commitment_lock_script_args.pack())
+                        .build(),
+                )
+                .build();
+            let new_commitment_output_data = new_amount.to_le_bytes().to_vec().pack();
+            let settlement_output = CellOutput::new_builder()
+                .lock(fee_provider_lock_script.clone())
+                .type_(cell_output.type_().clone())
+                .build();
+            let settlement_output_data = tlc.payment_amount.to_le_bytes().to_vec().pack();
+            let settlement_output_occupied_capacity = settlement_output
+                .occupied_capacity(
+                    Capacity::bytes(settlement_output_data.raw_data().len()).unwrap(),
+                )
+                .expect("capacity does not overflow")
+                .as_u64();
+            let settlement_output = settlement_output
+                .as_builder()
+                .capacity(settlement_output_occupied_capacity.pack())
+                .build();
+
+            let input = {
+                if preimage.is_none() {
+                    // TODO: ckb is using seconds as timestamp, we may need to change the expiry unit to seconds in the future
+                    let since = Since::new(SinceType::Timestamp, tlc.expiry / 1000, false).value();
+                    CellInput::new_builder()
+                        .previous_output(commitment_tx_cell.out_point.clone().into())
+                        .since(since.pack())
+                        .build()
+                } else {
+                    CellInput::new_builder()
+                        .previous_output(commitment_tx_cell.out_point.clone().into())
+                        .build()
+                }
+            };
+            let mut tx_builder = Transaction::default()
+                .as_advanced_builder()
+                .cell_deps(get_cell_deps(
+                    vec![Contract::CommitmentLock, Contract::Secp256k1Lock],
+                    &commitment_tx_cell.output.type_.map(|script| script.into()),
+                ))
+                .input(input)
+                .output(new_commitment_output.clone())
+                .output_data(new_commitment_output_data)
+                .output(settlement_output.clone())
+                .output_data(settlement_output_data.clone())
+                .output(change_output.clone())
+                .output_data(Bytes::default())
+                .witness(witness_for_commitment_cell.pack())
+                .witness(placeholder_witness_for_change.as_bytes().pack());
+
+            // TODO: move it to config or use https://github.com/nervosnetwork/ckb/pull/4477
+            let fee_calculator = FeeCalculator::new(1000);
+
+            let mut query = CellQueryOptions::new_lock(fee_provider_lock_script);
+            query.script_search_mode = Some(SearchMode::Exact);
+            query.secondary_script_len_range = Some(ValueRangeOption::new_exact(0));
+            query.data_len_range = Some(ValueRangeOption::new_exact(0));
+            let (cells, _total_capacity) = cell_collector.collect_live_cells(&query, true)?;
+            let mut inputs_capacity = 0u64;
+            let change_output_occupied_capacity = change_output
+                .occupied_capacity(Capacity::shannons(0))
+                .expect("capacity does not overflow")
+                .as_u64();
+            for cell in cells {
+                let input_capacity: u64 = cell.output.capacity().unpack();
+                inputs_capacity += input_capacity;
+                tx_builder = tx_builder.input(
+                    CellInput::new_builder()
+                        .previous_output(cell.out_point)
+                        .build(),
+                );
+                let fee = fee_calculator
+                    .fee(tx_builder.clone().build().data().serialized_size_in_block() as u64);
+                if inputs_capacity
+                    >= change_output_occupied_capacity + settlement_output_occupied_capacity + fee
+                {
+                    let new_change_output = change_output
+                        .as_builder()
+                        .capacity(
+                            (inputs_capacity - settlement_output_occupied_capacity - fee).pack(),
+                        )
+                        .build();
+                    let outputs = vec![new_commitment_output, settlement_output, new_change_output];
+                    let tx = tx_builder.set_outputs(outputs).build();
+                    let tx = sign_tx_with_settlement(tx, secret_key, tlc.local_key.0)?;
+                    return Ok(Some(tx));
+                }
+            }
+
+            Err(Box::new(RpcError::Other(anyhow!("Not enough capacity"))))
+        }
+    } else {
+        Ok(None)
+    }
+}
+
+#[derive(Debug)]
+struct Tlc<'a>(&'a [u8]);
+
+impl<'a> Tlc<'a> {
+    pub fn payment_hash(&self) -> &'a [u8] {
+        &self.0[17..37]
+    }
+
+    pub fn remote_pubkey_hash(&self) -> &'a [u8] {
+        &self.0[37..57]
+    }
+
+    pub fn local_pubkey_hash(&self) -> &'a [u8] {
+        &self.0[57..77]
+    }
+
+    pub fn expiry(&self) -> u64 {
+        let expiry = u64::from_le_bytes(self.0[77..85].try_into().unwrap());
+        Since::from_raw_value(expiry).extract_metric().unwrap().1
+    }
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/01-connect-peer.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/01-connect-peer.bru
new file mode 100644
index 000000000..7029e544a
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/01-connect-peer.bru
@@ -0,0 +1,38 @@
+meta {
+  name: connect peer
+  type: http
+  seq: 1
+}
+
+post {
+  url: {{NODE2_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "connect_peer",
+    "params": [
+      {"address": "{{NODE1_ADDR}}"}
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result: isNull
+}
+
+script:post-response {
+  // Dialing a peer is async in tentacle. Sleep for some time to make sure
+  // we're connected to the peer.
+  await new Promise(r => setTimeout(r, 1000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/02-get-node1-funding-script.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/02-get-node1-funding-script.bru
new file mode 100644
index 000000000..631fea4b7
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/02-get-node1-funding-script.bru
@@ -0,0 +1,29 @@
+meta {
+  name: get node1 funding script
+  type: http
+  seq: 2
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "node_info",
+    "params": []
+  }
+}
+
+script:post-response {
+  bru.setVar("NODE1_FUNDING_SCRIPT", res.body.result.default_funding_lock_script);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/03-get-node2-funding-script.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/03-get-node2-funding-script.bru
new file mode 100644
index 000000000..938e0c141
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/03-get-node2-funding-script.bru
@@ -0,0 +1,29 @@
+meta {
+  name: get node2 funding script
+  type: http
+  seq: 3
+}
+
+post {
+  url: {{NODE2_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "node_info",
+    "params": []
+  }
+}
+
+script:post-response {
+  bru.setVar("NODE2_FUNDING_SCRIPT", res.body.result.default_funding_lock_script);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/04-get-node1-balance.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/04-get-node1-balance.bru
new file mode 100644
index 000000000..4abc6cdb4
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/04-get-node1-balance.bru
@@ -0,0 +1,53 @@
+meta {
+  name: get node1 balance
+  type: http
+  seq: 4
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "get_cells",
+    "params": [
+      {
+        "script_type": "lock",
+        "filter": {
+          "script": {
+            "code_hash": "{{UDT_CODE_HASH}}",
+            "hash_type": "data1",
+            "args": "0x32e555f3ff8e135cece1351a6a2971518392c1e30375c1e006ad0ce8eac07947"
+          }
+        }
+      },
+      "asc",
+      "0x64"
+    ]
+  }
+}
+
+script:pre-request {
+  let script = bru.getVar("NODE1_FUNDING_SCRIPT");
+  let body = req.getBody();
+  body.params[0].script = script;
+  req.setBody(body);
+}
+
+script:post-response {
+  let capacity = res.body.result.objects.reduce((acc, cell) => {
+    const hexBytes = cell.output_data.slice(2).match(/../g).reverse().join('');
+    return acc + BigInt(`0x${hexBytes}`);
+  }, BigInt(0));
+  bru.setVar("NODE1_BALANCE", capacity);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/05-get-node2-balance.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/05-get-node2-balance.bru
new file mode 100644
index 000000000..641db4cfc
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/05-get-node2-balance.bru
@@ -0,0 +1,53 @@
+meta {
+  name: get node2 balance
+  type: http
+  seq: 5
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "get_cells",
+    "params": [
+      {
+        "script_type": "lock",
+        "filter": {
+          "script": {
+            "code_hash": "{{UDT_CODE_HASH}}",
+            "hash_type": "data1",
+            "args": "0x32e555f3ff8e135cece1351a6a2971518392c1e30375c1e006ad0ce8eac07947"
+          }
+        }
+      },
+      "asc",
+      "0x64"
+    ]
+  }
+}
+
+script:pre-request {
+  let script = bru.getVar("NODE2_FUNDING_SCRIPT");
+  let body = req.getBody();
+  body.params[0].script = script;
+  req.setBody(body);
+}
+
+script:post-response {
+  let capacity = res.body.result.objects.reduce((acc, cell) => {
+    const hexBytes = cell.output_data.slice(2).match(/../g).reverse().join('');
+    return acc + BigInt(`0x${hexBytes}`);
+  }, BigInt(0));
+  bru.setVar("NODE2_BALANCE", capacity);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/06-open-channel.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/06-open-channel.bru
new file mode 100644
index 000000000..265248977
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/06-open-channel.bru
@@ -0,0 +1,45 @@
+meta {
+  name: Node1 open a channel to Node2 with amount 99 ckb
+  type: http
+  seq: 6
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "open_channel",
+    "params": [
+      {
+        "peer_id": "{{NODE2_PEERID}}",
+        "funding_amount": "0x3B9ACA00",
+        "tlc_fee_proportional_millionths": "0x4B0",
+        "funding_udt_type_script": {
+            "code_hash": "{{UDT_CODE_HASH}}",
+            "hash_type": "data1",
+            "args": "0x32e555f3ff8e135cece1351a6a2971518392c1e30375c1e006ad0ce8eac07947"
+          }
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result.temporary_channel_id: isDefined
+}
+
+script:post-response {
+  await new Promise(r => setTimeout(r, 2000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/07-get-auto-accept-channel.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/07-get-auto-accept-channel.bru
new file mode 100644
index 000000000..ba5f3252a
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/07-get-auto-accept-channel.bru
@@ -0,0 +1,41 @@
+meta {
+  name: get auto accepted channel id from Node2
+  type: http
+  seq: 7
+}
+
+post {
+  url: {{NODE2_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "list_channels",
+    "params": [
+      {
+        "peer_id": "{{NODE1_PEERID}}"
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result.channels: isDefined
+}
+
+script:post-response {
+  console.log(res.body.result);
+  // Sleep for sometime to make sure current operation finishes before next request starts.
+  await new Promise(r => setTimeout(r, 2000));
+  bru.setVar("CHANNEL_ID", res.body.result.channels[0].channel_id);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/08-generate-blocks-for-funding-tx.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/08-generate-blocks-for-funding-tx.bru
new file mode 100644
index 000000000..c106a0005
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/08-generate-blocks-for-funding-tx.bru
@@ -0,0 +1,33 @@
+meta {
+  name: generate a few blocks
+  type: http
+  seq: 8
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x1"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
+
+script:post-response {
+  await new Promise(r => setTimeout(r, 5000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/09-node1-add-tlc1.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/09-node1-add-tlc1.bru
new file mode 100644
index 000000000..84960051b
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/09-node1-add-tlc1.bru
@@ -0,0 +1,49 @@
+meta {
+  name: node1 add tlc1, 3000000 shannons
+  type: http
+  seq: 9
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "add_tlc",
+    "params": [
+      {
+        "channel_id": "{{CHANNEL_ID}}",
+        "amount": "0x2dc6c0",
+        "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "expiry": "{{expiry}}"
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result: isDefined
+}
+
+script:pre-request {
+  // 10 seconds expiry
+  let expiry = "0x" + (Date.now() + 1000 * 10).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
+script:post-response {
+  console.log("generated result: ", res.body.result);
+  // Sleep for sometime to make sure current operation finishes before next request starts.
+  await new Promise(r => setTimeout(r, 1000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/10-node3-gen-invoice.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/10-node3-gen-invoice.bru
new file mode 100644
index 000000000..aceb1430a
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/10-node3-gen-invoice.bru
@@ -0,0 +1,66 @@
+meta {
+  name: generate a invoice on node3, only use its payment_hash and payment_preimage for test
+  type: http
+  seq: 10
+}
+
+post {
+  url: {{NODE3_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "new_invoice",
+    "params": [
+      {
+        "amount": "0x613ae6500",
+        "currency": "Fibd",
+        "description": "test invoice generated by node3",
+        "expiry": "0xe10",
+        "final_expiry_delta": "0xDFFA0",
+        "payment_preimage": "{{payment_preimage}}"
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result: isDefined
+}
+
+script:pre-request {
+  // generate random preimage
+  function generateRandomPreimage() {
+    let hash = '0x';
+    for (let i = 0; i < 64; i++) {
+        hash += Math.floor(Math.random() * 16).toString(16);
+    }
+    return hash;
+  }
+  const payment_preimage = generateRandomPreimage();
+  bru.setVar("payment_preimage", payment_preimage);
+  let hash_algorithm = bru.getEnvVar("HASH_ALGORITHM");
+  if (hash_algorithm !== null) {
+    let body = req.getBody();
+    body.params[0].hash_algorithm = hash_algorithm;
+    req.setBody(body);
+  }
+}
+
+script:post-response {
+  // Sleep for sometime to make sure current operation finishes before next request starts.
+  await new Promise(r => setTimeout(r, 100));
+  console.log("generated result: ", res.body.result);
+  bru.setVar("payment_hash", res.body.result.invoice.data.payment_hash);
+  bru.setVar("payment_amount", res.body.result.invoice.amount);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/11-node1-add-tlc2.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/11-node1-add-tlc2.bru
new file mode 100644
index 000000000..709d42a8e
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/11-node1-add-tlc2.bru
@@ -0,0 +1,49 @@
+meta {
+  name: node1 add tlc2, 6000000 shannons
+  type: http
+  seq: 11
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "add_tlc",
+    "params": [
+      {
+        "channel_id": "{{CHANNEL_ID}}",
+        "amount": "0x5b8d80",
+        "payment_hash": "{{payment_hash}}",
+        "expiry": "{{expiry}}"
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result: isDefined
+}
+
+script:pre-request {
+  // 10 seconds expiry
+  let expiry = "0x" + (Date.now() + 1000 * 10).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
+script:post-response {
+  console.log("generated result: ", res.body.result);
+  // Sleep for sometime to make sure current operation finishes before next request starts.
+  await new Promise(r => setTimeout(r, 1000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/12-force-close.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/12-force-close.bru
new file mode 100644
index 000000000..e1cb31ed7
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/12-force-close.bru
@@ -0,0 +1,40 @@
+meta {
+  name: Node1 force close channel
+  type: http
+  seq: 12
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "shutdown_channel",
+    "params": [
+      {
+        "channel_id": "{{CHANNEL_ID}}",
+        "close_script": {
+          "code_hash": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a",
+          "hash_type": "data",
+          "args": "0x0101010101010101010101010101010101010101"
+        },
+        "fee_rate": "0x3FC",
+        "force": true
+      }
+    ]
+  }
+}
+
+script:post-response {
+  console.log(res.body);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/13-node2-remove-tlc.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/13-node2-remove-tlc.bru
new file mode 100644
index 000000000..091616eb9
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/13-node2-remove-tlc.bru
@@ -0,0 +1,42 @@
+meta {
+  name: Node2 remove tlc
+  type: http
+  seq: 13
+}
+
+post {
+  url: {{NODE2_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "remove_tlc",
+    "params": [
+      {
+        "channel_id": "{{CHANNEL_ID}}",
+        "tlc_id": "0x1",
+        "reason": {
+          "payment_preimage": "{{payment_preimage}}"
+        }
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result: isNull
+}
+
+script:post-response {
+  console.log(res.body);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/14-get-force-closed-commitment-tx-hash.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/14-get-force-closed-commitment-tx-hash.bru
new file mode 100644
index 000000000..704c87e84
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/14-get-force-closed-commitment-tx-hash.bru
@@ -0,0 +1,40 @@
+meta {
+  name: get force closed commitment tx hash
+  type: http
+  seq: 14
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "list_channels",
+    "params": [
+      {
+        "peer_id": "{{NODE2_PEERID}}",
+        "include_closed": true
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result.channels: isDefined
+}
+
+script:post-response {
+  console.log(res.body.result);
+  bru.setVar("TX_HASH", res.body.result.channels[0].latest_commitment_transaction_hash);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/15-generate-blocks-for-commitment-tx.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/15-generate-blocks-for-commitment-tx.bru
new file mode 100644
index 000000000..16f7ec2dc
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/15-generate-blocks-for-commitment-tx.bru
@@ -0,0 +1,34 @@
+meta {
+  name: generate a few blocks for commitment tx
+  type: http
+  seq: 15
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x1"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
+
+script:post-response {
+  // Wait for the commitment tx to be included in a block
+  await new Promise(r => setTimeout(r, 1000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/16-generate-blocks-for-onchain-timestamp-updates.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/16-generate-blocks-for-onchain-timestamp-updates.bru
new file mode 100644
index 000000000..1ab073220
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/16-generate-blocks-for-onchain-timestamp-updates.bru
@@ -0,0 +1,39 @@
+meta {
+  name: generate a few blocks for onchain timestamp updates
+  type: http
+  seq: 16
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x10"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
+
+script:pre-request {
+  // wait 10 seconds for the onchain timestamp to be updated
+  await new Promise(r => setTimeout(r, 10000));
+}
+
+script:post-response {
+  // Wait for the settlement tx1 to be generated
+  await new Promise(r => setTimeout(r, 5000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/17-generate-blocks-for-settlement-tx1-committed.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/17-generate-blocks-for-settlement-tx1-committed.bru
new file mode 100644
index 000000000..8018c62ad
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/17-generate-blocks-for-settlement-tx1-committed.bru
@@ -0,0 +1,34 @@
+meta {
+  name: generate a few blocks for settlement tx1 committed
+  type: http
+  seq: 17
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x1"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
+
+script:post-response {
+  // Wait for the settlement tx2 to be generated
+  await new Promise(r => setTimeout(r, 5000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/18-generate-blocks-for-settlement-tx2-committed.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/18-generate-blocks-for-settlement-tx2-committed.bru
new file mode 100644
index 000000000..bfbb0d300
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/18-generate-blocks-for-settlement-tx2-committed.bru
@@ -0,0 +1,34 @@
+meta {
+  name: generate a few blocks for settlement tx2 committed
+  type: http
+  seq: 18
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x10"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
+
+script:post-response {
+  // Wait for the final settlement tx to be generated
+  await new Promise(r => setTimeout(r, 5000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/19-generate-blocks-for-final-settlement-tx-committed.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/19-generate-blocks-for-final-settlement-tx-committed.bru
new file mode 100644
index 000000000..05530009a
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/19-generate-blocks-for-final-settlement-tx-committed.bru
@@ -0,0 +1,29 @@
+meta {
+  name: generate a few blocks for final settlement tx to be committed
+  type: http
+  seq: 19
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x1"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/20-check-commitment-tx.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/20-check-commitment-tx.bru
new file mode 100644
index 000000000..c90059877
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/20-check-commitment-tx.bru
@@ -0,0 +1,39 @@
+meta {
+  name: check submitted commitment tx should be settled
+  type: http
+  seq: 20
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "get_live_cell",
+    "params": [
+      {
+        "index": "0x0",
+        "tx_hash": "{{TX_HASH}}"
+      },
+      false
+    ]
+  }
+}
+
+assert {
+  res.body.result.status: eq "unknown"
+}
+
+script:post-response {
+  console.log("generated result: ", res.body);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/21-check-balance-node1.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/21-check-balance-node1.bru
new file mode 100644
index 000000000..045033ced
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/21-check-balance-node1.bru
@@ -0,0 +1,57 @@
+meta {
+  name: check balance, the difference should be the tlc2 (6000000)
+  type: http
+  seq: 21
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "get_cells",
+    "params": [
+      {
+        "script_type": "lock",
+        "filter": {
+          "script": {
+            "code_hash": "{{UDT_CODE_HASH}}",
+            "hash_type": "data1",
+            "args": "0x32e555f3ff8e135cece1351a6a2971518392c1e30375c1e006ad0ce8eac07947"
+          }
+        }
+      },
+      "asc",
+      "0x64"
+    ]
+  }
+}
+
+script:pre-request {
+  let script = bru.getVar("NODE1_FUNDING_SCRIPT");
+  let body = req.getBody();
+  body.params[0].script = script;
+  req.setBody(body);
+}
+
+script:post-response {
+  let capacity = res.body.result.objects.reduce((acc, cell) => {
+    const hexBytes = cell.output_data.slice(2).match(/../g).reverse().join('');
+    return acc + BigInt(`0x${hexBytes}`);
+  }, BigInt(0));
+  bru.setVar("NODE1_NEW_BALANCE", capacity);
+}
+
+assert {
+  Number(BigInt(bru.getVar("NODE1_BALANCE")) - BigInt(bru.getVar("NODE1_NEW_BALANCE"))): eq 6000000
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/22-check-balance-node2.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/22-check-balance-node2.bru
new file mode 100644
index 000000000..f313c80ec
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs-and-udt/22-check-balance-node2.bru
@@ -0,0 +1,57 @@
+meta {
+  name: check balance, the difference should be the tlc2 (6000000)
+  type: http
+  seq: 22
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "get_cells",
+    "params": [
+      {
+        "script_type": "lock",
+        "filter": {
+          "script": {
+            "code_hash": "{{UDT_CODE_HASH}}",
+            "hash_type": "data1",
+            "args": "0x32e555f3ff8e135cece1351a6a2971518392c1e30375c1e006ad0ce8eac07947"
+          }
+        }
+      },
+      "asc",
+      "0x64"
+    ]
+  }
+}
+
+script:pre-request {
+  let script = bru.getVar("NODE2_FUNDING_SCRIPT");
+  let body = req.getBody();
+  body.params[0].script = script;
+  req.setBody(body);
+}
+
+script:post-response {
+  let capacity = res.body.result.objects.reduce((acc, cell) => {
+    const hexBytes = cell.output_data.slice(2).match(/../g).reverse().join('');
+    return acc + BigInt(`0x${hexBytes}`);
+  }, BigInt(0));
+  bru.setVar("NODE2_NEW_BALANCE", capacity);
+}
+
+assert {
+  Number(BigInt(bru.getVar("NODE2_NEW_BALANCE")) - BigInt(bru.getVar("NODE2_BALANCE"))): eq 6000000
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/01-connect-peer.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/01-connect-peer.bru
new file mode 100644
index 000000000..7029e544a
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/01-connect-peer.bru
@@ -0,0 +1,38 @@
+meta {
+  name: connect peer
+  type: http
+  seq: 1
+}
+
+post {
+  url: {{NODE2_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "connect_peer",
+    "params": [
+      {"address": "{{NODE1_ADDR}}"}
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result: isNull
+}
+
+script:post-response {
+  // Dialing a peer is async in tentacle. Sleep for some time to make sure
+  // we're connected to the peer.
+  await new Promise(r => setTimeout(r, 1000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/02-get-node1-funding-script.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/02-get-node1-funding-script.bru
new file mode 100644
index 000000000..631fea4b7
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/02-get-node1-funding-script.bru
@@ -0,0 +1,29 @@
+meta {
+  name: get node1 funding script
+  type: http
+  seq: 2
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "node_info",
+    "params": []
+  }
+}
+
+script:post-response {
+  bru.setVar("NODE1_FUNDING_SCRIPT", res.body.result.default_funding_lock_script);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/03-get-node2-funding-script.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/03-get-node2-funding-script.bru
new file mode 100644
index 000000000..938e0c141
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/03-get-node2-funding-script.bru
@@ -0,0 +1,29 @@
+meta {
+  name: get node2 funding script
+  type: http
+  seq: 3
+}
+
+post {
+  url: {{NODE2_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "node_info",
+    "params": []
+  }
+}
+
+script:post-response {
+  bru.setVar("NODE2_FUNDING_SCRIPT", res.body.result.default_funding_lock_script);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/04-get-node1-balance.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/04-get-node1-balance.bru
new file mode 100644
index 000000000..2542ac262
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/04-get-node1-balance.bru
@@ -0,0 +1,40 @@
+meta {
+  name: get node1 balance
+  type: http
+  seq: 4
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "get_cells_capacity",
+    "params": [
+      {
+        "script_type": "lock"
+      }
+    ]
+  }
+}
+
+script:pre-request {
+  let script = bru.getVar("NODE1_FUNDING_SCRIPT");
+  let body = req.getBody();
+  body.params[0].script = script;
+  req.setBody(body);
+}
+
+script:post-response {
+  bru.setVar("NODE1_BALANCE", res.body.result.capacity);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/05-get-node2-balance.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/05-get-node2-balance.bru
new file mode 100644
index 000000000..c9823bf60
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/05-get-node2-balance.bru
@@ -0,0 +1,40 @@
+meta {
+  name: get node2 balance
+  type: http
+  seq: 5
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "get_cells_capacity",
+    "params": [
+      {
+        "script_type": "lock"
+      }
+    ]
+  }
+}
+
+script:pre-request {
+  let script = bru.getVar("NODE2_FUNDING_SCRIPT");
+  let body = req.getBody();
+  body.params[0].script = script;
+  req.setBody(body);
+}
+
+script:post-response {
+  bru.setVar("NODE2_BALANCE", res.body.result.capacity);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/06-open-channel.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/06-open-channel.bru
new file mode 100644
index 000000000..8e47baa57
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/06-open-channel.bru
@@ -0,0 +1,40 @@
+meta {
+  name: Node1 open a channel to Node2 with amount 99 ckb
+  type: http
+  seq: 6
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "open_channel",
+    "params": [
+      {
+        "peer_id": "{{NODE2_PEERID}}",
+        "funding_amount": "0x24e160300"
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result.temporary_channel_id: isDefined
+}
+
+script:post-response {
+  await new Promise(r => setTimeout(r, 2000));
+    bru.setVar("N1N2_TEMP_CHANNEL_ID", res.body.result.temporary_channel_id);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/07-accept-channel.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/07-accept-channel.bru
new file mode 100644
index 000000000..e4460e677
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/07-accept-channel.bru
@@ -0,0 +1,41 @@
+meta {
+  name: node2 accept channel
+  type: http
+  seq: 7
+}
+
+post {
+  url: {{NODE2_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "accept_channel",
+    "params": [
+      {
+        "temporary_channel_id": "{{N1N2_TEMP_CHANNEL_ID}}",
+        "funding_amount": "0x1718c7e00"
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+}
+
+script:post-response {
+  // Sleep for sometime to make sure current operation finishes before next request starts.
+  await new Promise(r => setTimeout(r, 1000));
+  console.log("accept channel result: ", res.body);
+  bru.setVar("CHANNEL_ID", res.body.result.channel_id);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/08-generate-blocks-for-funding-tx.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/08-generate-blocks-for-funding-tx.bru
new file mode 100644
index 000000000..c106a0005
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/08-generate-blocks-for-funding-tx.bru
@@ -0,0 +1,33 @@
+meta {
+  name: generate a few blocks
+  type: http
+  seq: 8
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x1"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
+
+script:post-response {
+  await new Promise(r => setTimeout(r, 5000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/09-node1-add-tlc1.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/09-node1-add-tlc1.bru
new file mode 100644
index 000000000..84960051b
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/09-node1-add-tlc1.bru
@@ -0,0 +1,49 @@
+meta {
+  name: node1 add tlc1, 3000000 shannons
+  type: http
+  seq: 9
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "add_tlc",
+    "params": [
+      {
+        "channel_id": "{{CHANNEL_ID}}",
+        "amount": "0x2dc6c0",
+        "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "expiry": "{{expiry}}"
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result: isDefined
+}
+
+script:pre-request {
+  // 10 seconds expiry
+  let expiry = "0x" + (Date.now() + 1000 * 10).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
+script:post-response {
+  console.log("generated result: ", res.body.result);
+  // Sleep for sometime to make sure current operation finishes before next request starts.
+  await new Promise(r => setTimeout(r, 1000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/10-node3-gen-invoice.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/10-node3-gen-invoice.bru
new file mode 100644
index 000000000..aceb1430a
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/10-node3-gen-invoice.bru
@@ -0,0 +1,66 @@
+meta {
+  name: generate a invoice on node3, only use its payment_hash and payment_preimage for test
+  type: http
+  seq: 10
+}
+
+post {
+  url: {{NODE3_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "new_invoice",
+    "params": [
+      {
+        "amount": "0x613ae6500",
+        "currency": "Fibd",
+        "description": "test invoice generated by node3",
+        "expiry": "0xe10",
+        "final_expiry_delta": "0xDFFA0",
+        "payment_preimage": "{{payment_preimage}}"
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result: isDefined
+}
+
+script:pre-request {
+  // generate random preimage
+  function generateRandomPreimage() {
+    let hash = '0x';
+    for (let i = 0; i < 64; i++) {
+        hash += Math.floor(Math.random() * 16).toString(16);
+    }
+    return hash;
+  }
+  const payment_preimage = generateRandomPreimage();
+  bru.setVar("payment_preimage", payment_preimage);
+  let hash_algorithm = bru.getEnvVar("HASH_ALGORITHM");
+  if (hash_algorithm !== null) {
+    let body = req.getBody();
+    body.params[0].hash_algorithm = hash_algorithm;
+    req.setBody(body);
+  }
+}
+
+script:post-response {
+  // Sleep for sometime to make sure current operation finishes before next request starts.
+  await new Promise(r => setTimeout(r, 100));
+  console.log("generated result: ", res.body.result);
+  bru.setVar("payment_hash", res.body.result.invoice.data.payment_hash);
+  bru.setVar("payment_amount", res.body.result.invoice.amount);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/11-node1-add-tlc2.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/11-node1-add-tlc2.bru
new file mode 100644
index 000000000..709d42a8e
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/11-node1-add-tlc2.bru
@@ -0,0 +1,49 @@
+meta {
+  name: node1 add tlc2, 6000000 shannons
+  type: http
+  seq: 11
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "add_tlc",
+    "params": [
+      {
+        "channel_id": "{{CHANNEL_ID}}",
+        "amount": "0x5b8d80",
+        "payment_hash": "{{payment_hash}}",
+        "expiry": "{{expiry}}"
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result: isDefined
+}
+
+script:pre-request {
+  // 10 seconds expiry
+  let expiry = "0x" + (Date.now() + 1000 * 10).toString(16);
+  bru.setVar("expiry", expiry);
+}
+
+script:post-response {
+  console.log("generated result: ", res.body.result);
+  // Sleep for sometime to make sure current operation finishes before next request starts.
+  await new Promise(r => setTimeout(r, 1000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/12-force-close.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/12-force-close.bru
new file mode 100644
index 000000000..e1cb31ed7
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/12-force-close.bru
@@ -0,0 +1,40 @@
+meta {
+  name: Node1 force close channel
+  type: http
+  seq: 12
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "shutdown_channel",
+    "params": [
+      {
+        "channel_id": "{{CHANNEL_ID}}",
+        "close_script": {
+          "code_hash": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a",
+          "hash_type": "data",
+          "args": "0x0101010101010101010101010101010101010101"
+        },
+        "fee_rate": "0x3FC",
+        "force": true
+      }
+    ]
+  }
+}
+
+script:post-response {
+  console.log(res.body);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/13-node2-remove-tlc.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/13-node2-remove-tlc.bru
new file mode 100644
index 000000000..091616eb9
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/13-node2-remove-tlc.bru
@@ -0,0 +1,42 @@
+meta {
+  name: Node2 remove tlc
+  type: http
+  seq: 13
+}
+
+post {
+  url: {{NODE2_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "remove_tlc",
+    "params": [
+      {
+        "channel_id": "{{CHANNEL_ID}}",
+        "tlc_id": "0x1",
+        "reason": {
+          "payment_preimage": "{{payment_preimage}}"
+        }
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result: isNull
+}
+
+script:post-response {
+  console.log(res.body);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/14-get-force-closed-commitment-tx-hash.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/14-get-force-closed-commitment-tx-hash.bru
new file mode 100644
index 000000000..704c87e84
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/14-get-force-closed-commitment-tx-hash.bru
@@ -0,0 +1,40 @@
+meta {
+  name: get force closed commitment tx hash
+  type: http
+  seq: 14
+}
+
+post {
+  url: {{NODE1_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": "42",
+    "jsonrpc": "2.0",
+    "method": "list_channels",
+    "params": [
+      {
+        "peer_id": "{{NODE2_PEERID}}",
+        "include_closed": true
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result.channels: isDefined
+}
+
+script:post-response {
+  console.log(res.body.result);
+  bru.setVar("TX_HASH", res.body.result.channels[0].latest_commitment_transaction_hash);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/15-generate-blocks-for-commitment-tx.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/15-generate-blocks-for-commitment-tx.bru
new file mode 100644
index 000000000..16f7ec2dc
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/15-generate-blocks-for-commitment-tx.bru
@@ -0,0 +1,34 @@
+meta {
+  name: generate a few blocks for commitment tx
+  type: http
+  seq: 15
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x1"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
+
+script:post-response {
+  // Wait for the commitment tx to be included in a block
+  await new Promise(r => setTimeout(r, 1000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/16-generate-blocks-for-onchain-timestamp-updates.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/16-generate-blocks-for-onchain-timestamp-updates.bru
new file mode 100644
index 000000000..1ab073220
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/16-generate-blocks-for-onchain-timestamp-updates.bru
@@ -0,0 +1,39 @@
+meta {
+  name: generate a few blocks for onchain timestamp updates
+  type: http
+  seq: 16
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x10"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
+
+script:pre-request {
+  // wait 10 seconds for the onchain timestamp to be updated
+  await new Promise(r => setTimeout(r, 10000));
+}
+
+script:post-response {
+  // Wait for the settlement tx1 to be generated
+  await new Promise(r => setTimeout(r, 5000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/17-generate-blocks-for-settlement-tx1-committed.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/17-generate-blocks-for-settlement-tx1-committed.bru
new file mode 100644
index 000000000..8018c62ad
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/17-generate-blocks-for-settlement-tx1-committed.bru
@@ -0,0 +1,34 @@
+meta {
+  name: generate a few blocks for settlement tx1 committed
+  type: http
+  seq: 17
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x1"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
+
+script:post-response {
+  // Wait for the settlement tx2 to be generated
+  await new Promise(r => setTimeout(r, 5000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/18-generate-blocks-for-settlement-tx2-committed.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/18-generate-blocks-for-settlement-tx2-committed.bru
new file mode 100644
index 000000000..bfbb0d300
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/18-generate-blocks-for-settlement-tx2-committed.bru
@@ -0,0 +1,34 @@
+meta {
+  name: generate a few blocks for settlement tx2 committed
+  type: http
+  seq: 18
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x10"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
+
+script:post-response {
+  // Wait for the final settlement tx to be generated
+  await new Promise(r => setTimeout(r, 5000));
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/19-generate-blocks-for-final-settlement-tx-committed.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/19-generate-blocks-for-final-settlement-tx-committed.bru
new file mode 100644
index 000000000..05530009a
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/19-generate-blocks-for-final-settlement-tx-committed.bru
@@ -0,0 +1,29 @@
+meta {
+  name: generate a few blocks for final settlement tx to be committed
+  type: http
+  seq: 19
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "generate_epochs",
+    "params": ["0x1"]
+  }
+}
+
+assert {
+  res.status: eq 200
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/20-check-commitment-tx.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/20-check-commitment-tx.bru
new file mode 100644
index 000000000..c90059877
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/20-check-commitment-tx.bru
@@ -0,0 +1,39 @@
+meta {
+  name: check submitted commitment tx should be settled
+  type: http
+  seq: 20
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "get_live_cell",
+    "params": [
+      {
+        "index": "0x0",
+        "tx_hash": "{{TX_HASH}}"
+      },
+      false
+    ]
+  }
+}
+
+assert {
+  res.body.result.status: eq "unknown"
+}
+
+script:post-response {
+  console.log("generated result: ", res.body);
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/21-check-balance-node1.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/21-check-balance-node1.bru
new file mode 100644
index 000000000..97fa26565
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/21-check-balance-node1.bru
@@ -0,0 +1,40 @@
+meta {
+  name: check balance, the difference should be the tlc2 (6000000) + fee (it may vary, max 5000)
+  type: http
+  seq: 21
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "get_cells_capacity",
+    "params": [
+      {
+        "script_type": "lock"
+      }
+    ]
+  }
+}
+
+script:pre-request {
+  let script = bru.getVar("NODE1_FUNDING_SCRIPT");
+  let body = req.getBody();
+  body.params[0].script = script;
+  req.setBody(body);
+}
+
+assert {
+  Number(BigInt(bru.getVar("NODE1_BALANCE")) - BigInt(res.body.result.capacity)): lt 6005000
+}
diff --git a/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/22-check-balance-node2.bru b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/22-check-balance-node2.bru
new file mode 100644
index 000000000..72fa585d9
--- /dev/null
+++ b/tests/bruno/e2e/watchtower/force-close-with-pending-tlcs/22-check-balance-node2.bru
@@ -0,0 +1,40 @@
+meta {
+  name: check balance, the difference should be the tlc2 (6000000) - fee (it may vary, max 5000)
+  type: http
+  seq: 22
+}
+
+post {
+  url: {{CKB_RPC_URL}}
+  body: json
+  auth: none
+}
+
+headers {
+  Content-Type: application/json
+  Accept: application/json
+}
+
+body:json {
+  {
+    "id": 42,
+    "jsonrpc": "2.0",
+    "method": "get_cells_capacity",
+    "params": [
+      {
+        "script_type": "lock"
+      }
+    ]
+  }
+}
+
+script:pre-request {
+  let script = bru.getVar("NODE2_FUNDING_SCRIPT");
+  let body = req.getBody();
+  body.params[0].script = script;
+  req.setBody(body);
+}
+
+assert {
+  Number(BigInt(res.body.result.capacity) - BigInt(bru.getVar("NODE2_BALANCE"))): gt 5995000
+}
diff --git a/tests/deploy/contracts/auth b/tests/deploy/contracts/auth
index 726e4d8bc..e59d00fba 100755
Binary files a/tests/deploy/contracts/auth and b/tests/deploy/contracts/auth differ
diff --git a/tests/deploy/contracts/commitment-lock b/tests/deploy/contracts/commitment-lock
index ac0713869..90e092cf7 100755
Binary files a/tests/deploy/contracts/commitment-lock and b/tests/deploy/contracts/commitment-lock differ
diff --git a/tests/deploy/contracts/funding-lock b/tests/deploy/contracts/funding-lock
index ec974f329..c139a6820 100755
Binary files a/tests/deploy/contracts/funding-lock and b/tests/deploy/contracts/funding-lock differ
diff --git a/tests/deploy/init-dev-chain.sh b/tests/deploy/init-dev-chain.sh
index 250ebc52a..57d2c4995 100755
--- a/tests/deploy/init-dev-chain.sh
+++ b/tests/deploy/init-dev-chain.sh
@@ -58,27 +58,27 @@ if ! [[ -d "$data_dir" ]]; then
         fi
     done
 
-    # Transfer some money to the node 1.
+    # Transfer some money to the node 1/2/3.
     # The address of node 1 can be seen with the following command:
     # echo | HOME=/tmp ckb-cli account import --local-only --privkey-path "$$nodes_dir/1/ckb/key"
-    ckb-cli wallet transfer --to-address $(cat "$nodes_dir/1/ckb/wallet") --capacity 5000000000 --fee-rate 2000 --privkey-path "$nodes_dir/deployer/ckb/key"
+    for i in {1..3}; do
+        ckb-cli wallet transfer --to-address $(cat "$nodes_dir/1/ckb/wallet") --capacity 1000000000 --fee-rate 2000 --privkey-path "$nodes_dir/deployer/ckb/key"
+        sleep 1
+        "$script_dir/generate-blocks.sh" 4
+        sleep 1
 
-    sleep 1
-    "$script_dir/generate-blocks.sh" 4
-    sleep 1
+        # Transfer some money to the node 2.
+        ckb-cli wallet transfer --to-address $(cat "$nodes_dir/2/ckb/wallet") --capacity 1000000000 --fee-rate 2000 --privkey-path "$nodes_dir/deployer/ckb/key"
+        sleep 1
+        "$script_dir/generate-blocks.sh" 4
+        sleep 1
 
-    # Transfer some money to the node 2.
-    ckb-cli wallet transfer --to-address $(cat "$nodes_dir/2/ckb/wallet") --capacity 5000000000 --fee-rate 2000 --privkey-path "$nodes_dir/deployer/ckb/key"
-    sleep 1
-    "$script_dir/generate-blocks.sh" 4
-    sleep 1
-
-    # Transfer some money to the node 3.
-    ckb-cli wallet transfer --to-address $(cat "$nodes_dir/3/ckb/wallet") --capacity 5000000000 --fee-rate 2000 --privkey-path "$nodes_dir/deployer/ckb/key"
-    sleep 1
-    # Generate a few blocks so that above transaction is confirmed.
-    echo "begin to generate blocks for wallet updating..."
-    "$script_dir/generate-blocks.sh" 4
+        # Transfer some money to the node 3.
+        ckb-cli wallet transfer --to-address $(cat "$nodes_dir/3/ckb/wallet") --capacity 1000000000 --fee-rate 2000 --privkey-path "$nodes_dir/deployer/ckb/key"
+        sleep 1
+        "$script_dir/generate-blocks.sh" 4
+        sleep 1
+    done
 
     # Also deploy the contracts.
     echo "deploy.sh..."