diff --git a/src/ckb/channel.rs b/src/ckb/channel.rs
index 923b0f73..1caf52fc 100644
--- a/src/ckb/channel.rs
+++ b/src/ckb/channel.rs
@@ -2,7 +2,7 @@ use bitflags::bitflags;
 use ckb_hash::{blake2b_256, new_blake2b};
 use ckb_sdk::Since;
 use ckb_types::{
-    core::{TransactionBuilder, TransactionView},
+    core::{FeeRate, TransactionBuilder, TransactionView},
     packed::{Bytes, CellInput, CellOutput, OutPoint, Script, Transaction},
     prelude::{AsTransactionBuilder, IntoTransactionView, Pack, Unpack},
 };
@@ -28,15 +28,19 @@ use tokio::sync::oneshot;
 use std::{borrow::Borrow, collections::BTreeMap};
 
 use crate::{
-    ckb::types::Shutdown,
+    ckb::{
+        config::{DEFAULT_UDT_MINIMAL_CKB_AMOUNT, MIN_OCCUPIED_CAPACITY},
+        types::Shutdown,
+    },
     ckb_chain::{
         contracts::{get_cell_deps, get_script_by_contract, Contract},
-        FundingRequest, FundingUdtInfo,
+        FundingRequest,
     },
     NetworkServiceEvent,
 };
 
 use super::{
+    config::{DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT, MIN_UDT_OCCUPIED_CAPACITY},
     key::blake2b_hash_with_salt,
     network::CFNMessageWithPeerId,
     serde_utils::EntityHex,
@@ -90,7 +94,7 @@ pub enum ChannelCommand {
 #[derive(Debug)]
 pub enum TxCollaborationCommand {
     TxUpdate(TxUpdateCommand),
-    TxComplete(TxCompleteCommand),
+    TxComplete(),
 }
 
 #[derive(Debug)]
@@ -110,7 +114,7 @@ pub struct RemoveTlcCommand {
 #[derive(Debug)]
 pub struct ShutdownCommand {
     pub close_script: Script,
-    pub fee: u128,
+    pub fee_rate: FeeRate,
 }
 
 fn get_random_preimage() -> Hash256 {
@@ -125,37 +129,45 @@ pub struct ChannelCommandWithId {
     pub command: ChannelCommand,
 }
 
-pub const DEFAULT_FEE_RATE: u64 = 0;
-pub const DEFAULT_COMMITMENT_FEE_RATE: u64 = 0;
+pub const DEFAULT_FEE_RATE: u64 = 1_000;
+pub const DEFAULT_COMMITMENT_FEE_RATE: u64 = 1_000;
 pub const DEFAULT_MAX_TLC_VALUE_IN_FLIGHT: u128 = u128::MAX;
 pub const DEFAULT_MAX_ACCEPT_TLCS: u64 = u64::MAX;
 pub const DEFAULT_MIN_TLC_VALUE: u128 = 0;
 pub const DEFAULT_TO_LOCAL_DELAY_BLOCKS: u64 = 10;
-pub const DEFAULT_UDT_MINIMAL_CKB_AMOUNT: u64 = 200 * 100_000_000; // 200 CKB
 
 #[derive(Debug)]
 pub struct TxUpdateCommand {
     pub transaction: Transaction,
 }
 
-#[derive(Debug)]
-pub struct TxCompleteCommand {}
+pub struct OpenChannelParameter {
+    pub funding_amount: u128,
+    pub seed: [u8; 32],
+    pub funding_udt_type_script: Option<Script>,
+    pub channel_id_sender: oneshot::Sender<Hash256>,
+    pub commitment_fee_rate: Option<u64>,
+    pub funding_fee_rate: Option<u64>,
+}
+
+pub struct AcceptChannelParameter {
+    pub funding_amount: u128,
+    pub reserved_ckb_amount: u64,
+    pub seed: [u8; 32],
+    pub open_channel: OpenChannel,
+    pub channel_id_sender: Option<oneshot::Sender<Hash256>>,
+}
 
 pub enum ChannelInitializationParameter {
     /// To open a new channel to another peer, the funding amount,
     /// the temporary channel id a unique channel seed to generate
     /// channel secrets must be given.
-    OpenChannel(u128, [u8; 32], Option<Script>, oneshot::Sender<Hash256>),
+    OpenChannel(OpenChannelParameter),
     /// To accept a new channel from another peer, the funding amount,
     /// a unique channel seed to generate unique channel id,
     /// original OpenChannel message and an oneshot
     /// channel to receive the new channel ID must be given.
-    AcceptChannel(
-        u128,
-        [u8; 32],
-        OpenChannel,
-        Option<oneshot::Sender<Hash256>>,
-    ),
+    AcceptChannel(AcceptChannelParameter),
     /// Reestablish a channel with given channel id.
     ReestablishChannel(Hash256),
 }
@@ -199,8 +211,9 @@ impl<S> ChannelActor<S> {
                             state.to_remote_amount,
                             state.get_funding_lock_script(),
                             state.funding_udt_type_script.clone(),
-                            state.local_ckb_amount,
-                            state.remote_ckb_amount,
+                            state.local_reserved_ckb_amount,
+                            state.remote_reserved_ckb_amount,
+                            state.funding_fee_rate,
                         ),
                     ))
                     .expect(ASSUME_NETWORK_ACTOR_ALIVE);
@@ -360,7 +373,7 @@ impl<S> ChannelActor<S> {
                     }
                 };
                 state.remote_shutdown_script = Some(shutdown.close_script);
-                state.remote_shutdown_fee = Some(shutdown.fee);
+                state.remote_shutdown_fee_rate = Some(shutdown.fee_rate.as_u64());
 
                 let flags = flags | ShuttingDownFlags::THEIR_SHUTDOWN_SENT;
                 state.update_state(ChannelState::ShuttingDown(flags));
@@ -529,8 +542,8 @@ impl<S> ChannelActor<S> {
         state: &mut ChannelActorState,
         command: AddTlcCommand,
     ) -> Result<u64, ProcessingChannelError> {
+        debug!("handle add tlc command : {:?}", &command);
         state.check_state_for_tlc_update()?;
-
         let tlc = state.create_outbounding_tlc(command);
         state.insert_tlc(tlc)?;
 
@@ -614,6 +627,8 @@ impl<S> ChannelActor<S> {
                 ));
             }
         };
+
+        state.verify_shutdown_fee_rate(command.fee_rate)?;
         self.network
             .send_message(NetworkActorMessage::new_command(
                 NetworkActorCommand::SendCFNMessage(CFNMessageWithPeerId {
@@ -621,13 +636,13 @@ impl<S> ChannelActor<S> {
                     message: CFNMessage::Shutdown(Shutdown {
                         channel_id: state.get_id(),
                         close_script: command.close_script.clone(),
-                        fee: command.fee,
+                        fee_rate: command.fee_rate,
                     }),
                 }),
             ))
             .expect(ASSUME_NETWORK_ACTOR_ALIVE);
         state.local_shutdown_script = Some(command.close_script.clone());
-        state.local_shutdown_fee = Some(command.fee);
+        state.local_shutdown_fee_rate = Some(command.fee_rate.as_u64());
         let flags = flags | ShuttingDownFlags::OUR_SHUTDOWN_SENT;
         state.update_state(ChannelState::ShuttingDown(flags));
         debug!(
@@ -648,7 +663,7 @@ impl<S> ChannelActor<S> {
     ) -> Result<(), ProcessingChannelError> {
         debug!("Handling tx collaboration command: {:?}", &command);
         let is_complete_command = match command {
-            TxCollaborationCommand::TxComplete(_) => true,
+            TxCollaborationCommand::TxComplete() => true,
             _ => false,
         };
         let is_waiting_for_remote = match state.state {
@@ -721,7 +736,7 @@ impl<S> ChannelActor<S> {
                     &self.network,
                 )?;
             }
-            TxCollaborationCommand::TxComplete(_) => {
+            TxCollaborationCommand::TxComplete() => {
                 state.check_tx_complete_preconditions()?;
                 let cfn_msg = CFNMessage::TxComplete(TxComplete {
                     channel_id: state.get_id(),
@@ -836,6 +851,27 @@ impl<S> ChannelActor<S> {
         }
         Ok(())
     }
+
+    fn get_funding_and_reserved_amount(
+        &self,
+        funding_amount: u128,
+        udt_type_script: &Option<Script>,
+    ) -> Result<(u128, u64), ProcessingChannelError> {
+        match udt_type_script {
+            Some(_) => Ok((funding_amount, DEFAULT_UDT_MINIMAL_CKB_AMOUNT)),
+            _ => {
+                let reserved_ckb_amount = DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT;
+                if funding_amount < reserved_ckb_amount.into() {
+                    return Err(ProcessingChannelError::InvalidParameter(format!(
+                        "The value of the channel should be greater than the reserve amount: {}",
+                        reserved_ckb_amount
+                    )));
+                }
+                let funding_amount = funding_amount - reserved_ckb_amount as u128;
+                Ok((funding_amount, reserved_ckb_amount))
+            }
+        }
+    }
 }
 
 #[rasync_trait]
@@ -854,12 +890,13 @@ where
     ) -> Result<Self::State, ActorProcessingErr> {
         // startup the event processing
         match args {
-            ChannelInitializationParameter::AcceptChannel(
-                my_funding_amount,
+            ChannelInitializationParameter::AcceptChannel(AcceptChannelParameter {
+                funding_amount: my_funding_amount,
+                reserved_ckb_amount: my_reserved_ckb_amount,
                 seed,
                 open_channel,
-                oneshot_channel,
-            ) => {
+                channel_id_sender,
+            }) => {
                 let peer_id = self.peer_id.clone();
                 debug!(
                     "Accepting channel {:?} to peer {:?}",
@@ -870,8 +907,11 @@ where
                 let OpenChannel {
                     channel_id,
                     chain_hash,
+                    commitment_fee_rate,
+                    funding_fee_rate,
                     funding_udt_type_script,
                     funding_amount,
+                    reserved_ckb_amount,
                     to_local_delay,
                     first_per_commitment_point,
                     second_per_commitment_point,
@@ -889,10 +929,14 @@ where
                 let mut state = ChannelActorState::new_inbound_channel(
                     *channel_id,
                     my_funding_amount,
+                    my_reserved_ckb_amount,
+                    *commitment_fee_rate,
+                    *funding_fee_rate,
                     funding_udt_type_script.clone(),
                     &seed,
                     peer_id.clone(),
                     *funding_amount,
+                    *reserved_ckb_amount,
                     *to_local_delay,
                     counterpart_pubkeys,
                     next_local_nonce.clone(),
@@ -900,11 +944,14 @@ where
                     *second_per_commitment_point,
                 );
 
+                state.check_reserve_amount(my_reserved_ckb_amount, *reserved_ckb_amount)?;
+
                 let commitment_number = INITIAL_COMMITMENT_NUMBER;
 
                 let accept_channel = AcceptChannel {
                     channel_id: *channel_id,
                     funding_amount: my_funding_amount,
+                    reserved_ckb_amount: my_reserved_ckb_amount,
                     max_tlc_value_in_flight: DEFAULT_MAX_TLC_VALUE_IN_FLIGHT,
                     max_accept_tlcs: DEFAULT_MAX_ACCEPT_TLCS,
                     to_local_delay: *to_local_delay,
@@ -946,24 +993,49 @@ where
                 state.update_state(ChannelState::NegotiatingFunding(
                     NegotiatingFundingFlags::INIT_SENT,
                 ));
-                if let Some(sender) = oneshot_channel {
+                if let Some(sender) = channel_id_sender {
                     sender.send(state.get_id()).expect("Receive not dropped");
                 }
                 Ok(state)
             }
-            ChannelInitializationParameter::OpenChannel(
+            ChannelInitializationParameter::OpenChannel(OpenChannelParameter {
                 funding_amount,
                 seed,
                 funding_udt_type_script,
-                tx,
-            ) => {
+                channel_id_sender,
+                commitment_fee_rate,
+                funding_fee_rate,
+            }) => {
                 let peer_id = self.peer_id.clone();
                 info!("Trying to open a channel to {:?}", &peer_id);
 
+                let commitment_fee_rate =
+                    commitment_fee_rate.unwrap_or(DEFAULT_COMMITMENT_FEE_RATE);
+                if commitment_fee_rate < DEFAULT_COMMITMENT_FEE_RATE {
+                    return Err(Box::new(ProcessingChannelError::InvalidParameter(format!(
+                        "The commitment fee rate is too low, expect {} >= {}",
+                        commitment_fee_rate, DEFAULT_COMMITMENT_FEE_RATE
+                    ))));
+                }
+
+                let funding_fee_rate = funding_fee_rate.unwrap_or(DEFAULT_FEE_RATE);
+                if funding_fee_rate < DEFAULT_FEE_RATE {
+                    return Err(Box::new(ProcessingChannelError::InvalidParameter(format!(
+                        "The funding fee rate is too low, expect {} >= {}",
+                        funding_fee_rate, DEFAULT_FEE_RATE
+                    ))));
+                }
+
+                let (funding_amount, reserved_ckb_amount) =
+                    self.get_funding_and_reserved_amount(funding_amount, &funding_udt_type_script)?;
+
                 let mut channel = ChannelActorState::new_outbound_channel(
                     &seed,
                     self.peer_id.clone(),
                     funding_amount,
+                    reserved_ckb_amount,
+                    commitment_fee_rate,
+                    funding_fee_rate,
                     funding_udt_type_script.clone(),
                     LockTime::new(DEFAULT_TO_LOCAL_DELAY_BLOCKS),
                 );
@@ -974,8 +1046,9 @@ where
                     channel_id: channel.get_id(),
                     funding_udt_type_script,
                     funding_amount: channel.to_local_amount,
-                    funding_fee_rate: DEFAULT_FEE_RATE,
-                    commitment_fee_rate: DEFAULT_COMMITMENT_FEE_RATE,
+                    reserved_ckb_amount: channel.local_reserved_ckb_amount,
+                    funding_fee_rate,
+                    commitment_fee_rate,
                     max_tlc_value_in_flight: DEFAULT_MAX_TLC_VALUE_IN_FLIGHT,
                     max_accept_tlcs: DEFAULT_MAX_ACCEPT_TLCS,
                     min_tlc_value: DEFAULT_MIN_TLC_VALUE,
@@ -1050,7 +1123,9 @@ where
                     ))
                     .expect(ASSUME_NETWORK_ACTOR_ALIVE);
 
-                tx.send(channel.get_id()).expect("Receive not dropped");
+                channel_id_sender
+                    .send(channel.get_id())
+                    .expect("Receive not dropped");
                 Ok(channel)
             }
             ChannelInitializationParameter::ReestablishChannel(channel_id) => {
@@ -1312,14 +1387,21 @@ pub struct ChannelActorState {
     // This value will only change after we have resolved a tlc.
     pub to_remote_amount: u128,
 
-    // only used for UDT scenario:
-    // `to_local_amount` and `to_remote_amount` are the amount of UDT,
-    // while `local_ckb_amount` and `remote_ckb_amount` are the amount of CKB
-    // of the underlying cells that bear the UDT.
-    // We keep track of the CKB amount from partners in the channel in
-    // order to construct closing/commitment transactions.
-    pub local_ckb_amount: u64,
-    pub remote_ckb_amount: u64,
+    // these two amounts used to keep the minimal ckb amount for the two parties
+    // TLC operations will not affect these two amounts, only used to keep the commitment transactions
+    // to be valid, so that any party can close the channel at any time.
+    // Note: the values are different for the UDT scenario
+    pub local_reserved_ckb_amount: u64,
+    pub remote_reserved_ckb_amount: u64,
+
+    // The commitment fee rate is used to calculate the fee for the commitment transactions.
+    // The side who starting a shutdown command need to pay at least this fee for building shutdown transaction,
+    // the other side may choose to pay less fee rate if the current fee is enough.
+    pub commitment_fee_rate: u64,
+
+    // The fee rate used for funding transaction, the initiator may set it as `funding_fee_rate` option,
+    // if it's not set, DEFAULT_FEE_RATE will be used as default value, two sides will use the same fee rate
+    pub funding_fee_rate: u64,
 
     // Signer is used to sign the commitment transactions.
     pub signer: InMemorySigner,
@@ -1357,9 +1439,9 @@ pub struct ChannelActorState {
     pub remote_commitment_points: Vec<Pubkey>,
     pub remote_channel_parameters: Option<ChannelParametersOneParty>,
     pub local_shutdown_signature: Option<PartialSignature>,
-    pub local_shutdown_fee: Option<u128>,
+    pub local_shutdown_fee_rate: Option<u64>,
+    pub remote_shutdown_fee_rate: Option<u64>,
     pub remote_shutdown_signature: Option<PartialSignature>,
-    pub remote_shutdown_fee: Option<u128>,
 
     // A flag to indicate whether the channel is reestablishing, we won't process any messages until the channel is reestablished.
     pub reestablishing: bool,
@@ -1539,10 +1621,14 @@ impl ChannelActorState {
     pub fn new_inbound_channel<'a>(
         temp_channel_id: Hash256,
         local_value: u128,
+        local_reserved_ckb_amount: u64,
+        commitment_fee_rate: u64,
+        funding_fee_rate: u64,
         funding_udt_type_script: Option<Script>,
         seed: &[u8],
         peer_id: PeerId,
         remote_value: u128,
+        remote_reserved_ckb_amount: u64,
         remote_delay: LockTime,
         remote_pubkeys: ChannelBasePublicKeys,
         remote_nonce: PubNonce,
@@ -1569,10 +1655,12 @@ impl ChannelActorState {
             is_acceptor: true,
             funding_udt_type_script,
             to_local_amount: local_value,
+            to_remote_amount: remote_value,
+            commitment_fee_rate,
+            funding_fee_rate,
             id: channel_id,
             tlc_ids: Default::default(),
             tlcs: Default::default(),
-            to_remote_amount: remote_value,
             local_shutdown_script: None,
             local_channel_parameters: ChannelParametersOneParty {
                 pubkeys: local_base_pubkeys,
@@ -1588,11 +1676,11 @@ impl ChannelActorState {
             remote_nonce: Some(remote_nonce),
             remote_commitment_points: vec![first_commitment_point, second_commitment_point],
             local_shutdown_signature: None,
-            local_shutdown_fee: None,
+            local_shutdown_fee_rate: None,
             remote_shutdown_signature: None,
-            remote_shutdown_fee: None,
-            local_ckb_amount: DEFAULT_UDT_MINIMAL_CKB_AMOUNT,
-            remote_ckb_amount: DEFAULT_UDT_MINIMAL_CKB_AMOUNT,
+            remote_shutdown_fee_rate: None,
+            local_reserved_ckb_amount,
+            remote_reserved_ckb_amount,
 
             reestablishing: false,
             #[cfg(debug_assertions)]
@@ -1604,6 +1692,9 @@ impl ChannelActorState {
         seed: &[u8],
         peer_id: PeerId,
         value: u128,
+        local_reserved_ckb_amount: u64,
+        commitment_fee_rate: u64,
+        funding_fee_rate: u64,
         funding_udt_type_script: Option<Script>,
         to_local_delay: LockTime,
     ) -> Self {
@@ -1618,10 +1709,12 @@ impl ChannelActorState {
             funding_udt_type_script,
             is_acceptor: false,
             to_local_amount: value,
+            to_remote_amount: 0,
+            commitment_fee_rate,
+            funding_fee_rate,
             id: temp_channel_id,
             tlc_ids: Default::default(),
             tlcs: Default::default(),
-            to_remote_amount: 0,
             signer,
             local_channel_parameters: ChannelParametersOneParty {
                 pubkeys: local_pubkeys,
@@ -1632,13 +1725,13 @@ impl ChannelActorState {
             commitment_numbers: Default::default(),
             remote_commitment_points: vec![],
             local_shutdown_script: None,
-            local_shutdown_fee: None,
+            local_shutdown_fee_rate: None,
             remote_shutdown_script: None,
-            remote_shutdown_fee: None,
+            remote_shutdown_fee_rate: None,
             local_shutdown_signature: None,
             remote_shutdown_signature: None,
-            local_ckb_amount: DEFAULT_UDT_MINIMAL_CKB_AMOUNT,
-            remote_ckb_amount: DEFAULT_UDT_MINIMAL_CKB_AMOUNT,
+            local_reserved_ckb_amount,
+            remote_reserved_ckb_amount: 0,
 
             reestablishing: false,
             #[cfg(debug_assertions)]
@@ -1646,6 +1739,29 @@ impl ChannelActorState {
         }
     }
 
+    /// This function will be only called when the channel is accepted
+    fn check_reserve_amount(
+        &self,
+        local_reserved_amount: u64,
+        remote_reserved_amount: u64,
+    ) -> Result<(), ProcessingChannelError> {
+        let udt_type_script = &self.funding_udt_type_script;
+        let reserved_ckb_amount = if udt_type_script.is_some() {
+            DEFAULT_UDT_MINIMAL_CKB_AMOUNT
+        } else {
+            DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT
+        };
+        if local_reserved_amount < reserved_ckb_amount
+            || remote_reserved_amount < reserved_ckb_amount
+        {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "The reserve amount should be greater than the minimal reserve amount: {}",
+                reserved_ckb_amount
+            )));
+        }
+        Ok(())
+    }
+
     pub fn get_local_balance(&self) -> u128 {
         self.to_local_amount
     }
@@ -1916,6 +2032,12 @@ impl ChannelActorState {
                     )));
             }
         };
+        if tlc.amount == 0 {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Expect the amount of tlc with id {:?} is larger than zero",
+                tlc.id
+            )));
+        }
         if tlc.is_offered() {
             // TODO: We should actually also consider all our fulfilled tlcs here.
             // Because this is also the amount that we can actually spend.
@@ -1926,7 +2048,9 @@ impl ChannelActorState {
             if sent_tlc_value + tlc.amount > self.to_local_amount {
                 return Err(ProcessingChannelError::InvalidParameter(format!(
                     "Adding tlc {:?} with amount {} exceeds local balance {}",
-                    tlc.id, tlc.amount, self.to_local_amount
+                    tlc.id,
+                    tlc.amount,
+                    self.to_local_amount - sent_tlc_value
                 )));
             }
         } else {
@@ -1939,7 +2063,9 @@ impl ChannelActorState {
             if received_tlc_value + tlc.amount > self.to_remote_amount {
                 return Err(ProcessingChannelError::InvalidParameter(format!(
                     "Adding tlc {:?} with amount {} exceeds remote balance {}",
-                    tlc.id, tlc.amount, self.to_remote_amount
+                    tlc.id,
+                    tlc.amount,
+                    self.to_remote_amount - received_tlc_value
                 )));
             }
         }
@@ -1995,7 +2121,8 @@ impl ChannelActorState {
                     }
                     Some((current_remove_reason, current_removed_at)) => {
                         return Err(ProcessingChannelError::InvalidParameter(
-                            format!("Illegally removing the same tlc: {:?} was previously removed at {:?} for {:?}, and trying to remove it again at {:?} for {:?}", tlc_id,  current_removed_at, reason, removed_at, current_remove_reason)));
+                            format!("Illegally removing the same tlc: {:?} was previously removed at {:?} for {:?}, and trying to remove it again at {:?} for {:?}",
+                                tlc_id,  current_removed_at, reason, removed_at, current_remove_reason)));
                     }
                     None => {
                         debug!(
@@ -2092,15 +2219,15 @@ impl ChannelActorState {
         get_script_by_contract(Contract::FundingLock, args.as_slice())
     }
 
-    pub fn get_funding_request(&self, fee_rate: u64) -> FundingRequest {
+    pub fn get_funding_request(&self) -> FundingRequest {
         FundingRequest {
-            udt_info: self.funding_udt_type_script.as_ref().map(|script| {
-                FundingUdtInfo::new(script, self.local_ckb_amount, self.remote_ckb_amount)
-            }),
             script: self.get_funding_lock_script(),
+            udt_type_script: self.funding_udt_type_script.clone(),
             local_amount: self.to_local_amount as u64,
-            local_fee_rate: fee_rate,
+            funding_fee_rate: self.funding_fee_rate,
             remote_amount: self.to_remote_amount as u64,
+            local_reserved_ckb_amount: self.local_reserved_ckb_amount,
+            remote_reserved_ckb_amount: self.remote_reserved_ckb_amount,
         }
     }
 
@@ -2337,6 +2464,35 @@ impl ChannelActorState {
         &self.get_remote_channel_parameters().pubkeys.funding_pubkey
     }
 
+    fn verify_shutdown_fee_rate(&self, fee_rate: FeeRate) -> ProcessingChannelResult {
+        if fee_rate.as_u64() < self.commitment_fee_rate {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Fee rate {} is less than commitment fee rate {}",
+                fee_rate, self.commitment_fee_rate
+            )));
+        }
+
+        let fee = self.calculate_shutdown_fee(fee_rate);
+        debug!("shutdown fee: {:?}", fee);
+
+        let available_max_fee = if self.funding_udt_type_script.is_none() {
+            self.to_local_amount as u64 + self.local_reserved_ckb_amount - MIN_OCCUPIED_CAPACITY
+        } else {
+            self.local_reserved_ckb_amount - MIN_UDT_OCCUPIED_CAPACITY
+        };
+        debug!(
+            "verify_shutdown_fee fee: {} available_max_fee: {}",
+            fee, available_max_fee,
+        );
+        if fee > available_max_fee {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Local balance is not enough to pay the fee, expect fee {} <= available_max_fee {}",
+                fee, available_max_fee
+            )));
+        }
+        Ok(())
+    }
+
     pub fn check_state_for_tlc_update(&self) -> ProcessingChannelResult {
         match self.state {
             ChannelState::ChannelReady() => Ok(()),
@@ -2348,7 +2504,7 @@ impl ChannelActorState {
         }
     }
 
-    pub fn create_outbounding_tlc(&mut self, command: AddTlcCommand) -> TLC {
+    pub fn create_outbounding_tlc(&self, command: AddTlcCommand) -> TLC {
         // TODO: we are filling the user command with a new id here.
         // The advantage of this is that we don't need to burden the users to
         // provide a next id for each tlc. The disadvantage is that users may
@@ -2581,10 +2737,18 @@ impl ChannelActorState {
             )));
         }
 
+        self.check_reserve_amount(
+            accept_channel.reserved_ckb_amount,
+            self.local_reserved_ckb_amount,
+        )?;
+
         self.update_state(ChannelState::NegotiatingFunding(
             NegotiatingFundingFlags::INIT_SENT,
         ));
+
         self.to_remote_amount = accept_channel.funding_amount;
+        self.remote_reserved_ckb_amount = accept_channel.reserved_ckb_amount;
+
         #[cfg(debug_assertions)]
         {
             self.total_amount = self.to_local_amount + self.to_remote_amount;
@@ -2679,8 +2843,7 @@ impl ChannelActorState {
                             NetworkActorCommand::UpdateChannelFunding(
                                 self.get_id(),
                                 msg.tx.clone(),
-                                // TODO: use fee rate set by the user.
-                                self.get_funding_request(20000),
+                                self.get_funding_request(),
                             ),
                         ))
                         .expect(ASSUME_NETWORK_ACTOR_ALIVE);
@@ -3100,7 +3263,8 @@ impl ChannelActorState {
             ))?;
 
         if first_output.lock() != self.get_funding_lock_script() {
-            error!("Checking if transaction final failed as tx's first output's script is not funding lock: tx: {:?}, first output lock script: {:?}, funding lock script: {:?}", &tx, first_output.lock(), self.get_funding_lock_script());
+            error!("Checking if transaction final failed as tx's first output's script is not funding lock: tx: {:?}, first output lock script: {:?}, funding lock script: {:?}",
+                 &tx, first_output.lock(), self.get_funding_lock_script());
             // TODO: return an error here. We panic because we want to move fast.
             panic!("Invalid funding transation")
         }
@@ -3111,25 +3275,24 @@ impl ChannelActorState {
                     .ok_or(ProcessingChannelError::InvalidParameter(
                         "Funding transaction should have at least one output".to_string(),
                     ))?;
-            if data.as_ref().len() >= 16 {
-                let mut amount_bytes = [0u8; 16];
-                amount_bytes.copy_from_slice(&data.as_ref()[0..16]);
-                let udt_amount = u128::from_le_bytes(amount_bytes);
-                debug!(
-                    "udt_amount: {}, to_remote_amount: {}, to_local_amount: {}",
-                    udt_amount, self.to_remote_amount, self.to_local_amount
-                );
-                return Ok(udt_amount == self.to_remote_amount + self.to_local_amount);
-            }
+            assert!(data.as_ref().len() >= 16);
+            let mut amount_bytes = [0u8; 16];
+            amount_bytes.copy_from_slice(&data.as_ref()[0..16]);
+            let udt_amount = u128::from_le_bytes(amount_bytes);
             debug!(
-                "is_tx_final: output data length {} is less than 16",
-                data.as_ref().len()
+                "udt_amount: {}, to_remote_amount: {}, to_local_amount: {}",
+                udt_amount, self.to_remote_amount, self.to_local_amount
             );
-            return Ok(false);
+            return Ok(udt_amount == self.to_remote_amount + self.to_local_amount);
+        } else {
+            let current_capacity: u64 = first_output.capacity().unpack();
+            let is_complete = current_capacity
+                == (self.to_local_amount
+                    + self.to_remote_amount
+                    + self.local_reserved_ckb_amount as u128
+                    + self.remote_reserved_ckb_amount as u128) as u64;
+            Ok(is_complete)
         }
-        let current_capacity: u64 = first_output.capacity().unpack();
-        let is_complete = current_capacity == (self.to_local_amount + self.to_remote_amount) as u64;
-        Ok(is_complete)
     }
 
     pub fn maybe_complete_tx_collaboration(
@@ -3251,6 +3414,45 @@ impl ChannelActorState {
                 && self.should_local_go_first_in_musig2()
     }
 
+    fn calculate_shutdown_fee(&self, fee_rate: FeeRate) -> u64 {
+        let dummy_script = get_script_by_contract(Contract::Secp256k1Lock, &[0u8; 20]);
+        let cell_deps = get_cell_deps(vec![Contract::FundingLock], &self.funding_udt_type_script);
+
+        let (outputs, outputs_data) = if let Some(type_script) = &self.funding_udt_type_script {
+            let dummy_output = CellOutput::new_builder()
+                .lock(dummy_script.clone())
+                .type_(Some(type_script.clone()).pack())
+                .capacity(0.pack())
+                .build();
+            let dummy_output_data = self.to_local_amount.to_le_bytes().pack();
+
+            let outputs = [dummy_output.clone(), dummy_output];
+            let outputs_data = [dummy_output_data.clone(), dummy_output_data];
+            (outputs, outputs_data.to_vec())
+        } else {
+            let dummy_output = CellOutput::new_builder()
+                .capacity(0.pack())
+                .lock(dummy_script.clone())
+                .build();
+            let outputs = [dummy_output.clone(), dummy_output];
+            (outputs, vec![Default::default(), Default::default()])
+        };
+
+        let mock_shutdown_tx = TransactionBuilder::default()
+            .cell_deps(cell_deps)
+            .input(
+                CellInput::new_builder()
+                    .previous_output(self.get_funding_transaction_outpoint())
+                    .build(),
+            )
+            .set_outputs(outputs.to_vec())
+            .set_outputs_data(outputs_data.to_vec())
+            .set_witnesses(vec![[0; FUNDING_CELL_WITNESS_LEN].pack()])
+            .build();
+        let tx_size = mock_shutdown_tx.data().serialized_size_in_block() as u64;
+        fee_rate.fee(tx_size).as_u64()
+    }
+
     pub fn build_shutdown_tx(&self) -> Result<(TransactionView, [u8; 32]), ProcessingChannelError> {
         // Don't use get_local_shutdown_script and get_remote_shutdown_script here
         // as they will panic if the scripts are not present.
@@ -3263,29 +3465,34 @@ impl ChannelActorState {
         ) = match (
             self.local_shutdown_script.clone(),
             self.remote_shutdown_script.clone(),
-            self.local_shutdown_fee,
-            self.remote_shutdown_fee,
+            self.local_shutdown_fee_rate,
+            self.remote_shutdown_fee_rate,
         ) {
             (
                 Some(local_shutdown_script),
                 Some(remote_shutdown_script),
-                Some(local_shutdown_fee),
-                Some(remote_shutdown_fee),
+                Some(local_shutdown_fee_rate),
+                Some(remote_shutdown_fee_rate),
             ) => (
                 local_shutdown_script,
                 remote_shutdown_script,
-                local_shutdown_fee,
-                remote_shutdown_fee,
+                self.calculate_shutdown_fee(FeeRate::from_u64(local_shutdown_fee_rate)),
+                self.calculate_shutdown_fee(FeeRate::from_u64(remote_shutdown_fee_rate)),
             ),
             _ => {
                 return Err(ProcessingChannelError::InvalidState(format!(
-                    "Shutdown scripts are not present: local_shutdown_script {:?}, remote_shutdown_script {:?}, local_shutdown_fee {:?}, remote_shutdown_fee {:?}",
+                    "Shutdown scripts are not present: local_shutdown_script {:?}, remote_shutdown_script {:?}, local_shutdown_fee_rate {:?}, remote_shutdown_fee_rate {:?}",
                     &self.local_shutdown_script, &self.remote_shutdown_script,
-                    &self.local_shutdown_fee, &self.remote_shutdown_fee
+                    &self.local_shutdown_fee_rate, &self.remote_shutdown_fee_rate
                 )));
             }
         };
 
+        debug!(
+            "build_shutdown_tx local_shutdown_fee: local {}, remote {}",
+            local_shutdown_fee, remote_shutdown_fee
+        );
+
         let cell_deps = get_cell_deps(vec![Contract::FundingLock], &self.funding_udt_type_script);
         let tx_builder = TransactionBuilder::default().cell_deps(cell_deps).input(
             CellInput::new_builder()
@@ -3299,10 +3506,10 @@ impl ChannelActorState {
                 self.to_local_amount, self.to_remote_amount
             );
 
-            let local_capacity: u64 = self.local_ckb_amount - local_shutdown_fee as u64;
+            let local_capacity: u64 = self.local_reserved_ckb_amount - local_shutdown_fee as u64;
             debug!(
                 "shutdown_tx local_capacity: {} - {} = {}",
-                self.local_ckb_amount, local_shutdown_fee, local_capacity
+                self.local_reserved_ckb_amount, local_shutdown_fee, local_capacity
             );
             let local_output = CellOutput::new_builder()
                 .lock(local_shutdown_script.clone())
@@ -3311,10 +3518,10 @@ impl ChannelActorState {
                 .build();
             let local_output_data = self.to_local_amount.to_le_bytes().pack();
 
-            let remote_capacity: u64 = self.remote_ckb_amount - remote_shutdown_fee as u64;
+            let remote_capacity: u64 = self.remote_reserved_ckb_amount - remote_shutdown_fee as u64;
             debug!(
                 "shutdown_tx remote_capacity: {} - {} = {}",
-                self.remote_ckb_amount, remote_shutdown_fee, remote_capacity
+                self.remote_reserved_ckb_amount, remote_shutdown_fee, remote_capacity
             );
             let remote_output = CellOutput::new_builder()
                 .lock(remote_shutdown_script.clone())
@@ -3325,10 +3532,11 @@ impl ChannelActorState {
 
             let outputs = self.order_things_for_musig2(local_output, remote_output);
             let outputs_data = self.order_things_for_musig2(local_output_data, remote_output_data);
-            let tx_builder = tx_builder
+            let tx = tx_builder
                 .set_outputs(outputs.to_vec())
-                .set_outputs_data(outputs_data.to_vec());
-            let tx = tx_builder.build();
+                .set_outputs_data(outputs_data.to_vec())
+                .set_witnesses(vec![[0; FUNDING_CELL_WITNESS_LEN].pack()]) // we need to add a dummy witness for calculating shutdown tx size
+                .build();
             let message = get_funding_cell_message_to_sign(
                 u64::MAX,
                 self.get_funding_transaction_outpoint(),
@@ -3345,8 +3553,10 @@ impl ChannelActorState {
                 self.to_local_amount, local_shutdown_fee,
                 self.to_remote_amount, remote_shutdown_fee
             );
-            let local_value = (self.to_local_amount - local_shutdown_fee) as u64;
-            let remote_value = (self.to_remote_amount - remote_shutdown_fee) as u64;
+            let local_value =
+                self.to_local_amount as u64 + self.local_reserved_ckb_amount - local_shutdown_fee;
+            let remote_value = self.to_remote_amount as u64 + self.remote_reserved_ckb_amount
+                - remote_shutdown_fee;
             debug!(
                 "Building shutdown transaction with values: local {}, remote {}",
                 local_value, remote_value
@@ -3360,10 +3570,12 @@ impl ChannelActorState {
                 .lock(remote_shutdown_script)
                 .build();
             let outputs = self.order_things_for_musig2(local_output, remote_output);
-            let tx_builder = tx_builder.set_outputs(outputs.to_vec());
-            let tx_builder =
-                tx_builder.set_outputs_data(vec![Default::default(), Default::default()]);
-            let tx = tx_builder.build();
+            let tx = tx_builder
+                .set_outputs(outputs.to_vec())
+                .set_outputs_data(vec![Default::default(), Default::default()])
+                .set_witnesses(vec![[0; FUNDING_CELL_WITNESS_LEN].pack()]) // we need to add a dummy witness for calculating shutdown tx size
+                .build();
+
             let message = get_funding_cell_message_to_sign(
                 u64::MAX,
                 self.get_funding_transaction_outpoint(),
@@ -3521,13 +3733,27 @@ impl ChannelActorState {
         &self,
         local: bool,
     ) -> (Vec<CellOutput>, Vec<Bytes>, Vec<u8>) {
+        #[cfg(debug_assertions)]
+        {
+            debug_assert_eq!(
+                self.total_amount,
+                self.to_local_amount + self.to_remote_amount
+            );
+        }
+
         // The time_locked_value is amount of assets locked by commitment-lock.
         // Our value is always time-locked. Additionally, we need to add the value of
         // all the TLCs that we have received from the counterparty.
         let (time_locked_value, immediately_spendable_value) = if local {
-            (self.to_local_amount, self.to_remote_amount)
+            (
+                self.to_local_amount + self.local_reserved_ckb_amount as u128,
+                self.to_remote_amount + self.remote_reserved_ckb_amount as u128,
+            )
         } else {
-            (self.to_remote_amount, self.to_local_amount)
+            (
+                self.to_remote_amount + self.remote_reserved_ckb_amount as u128,
+                self.to_local_amount + self.local_reserved_ckb_amount as u128,
+            )
         };
 
         // Only the received tlc value is added here because
@@ -3540,13 +3766,6 @@ impl ChannelActorState {
             time_locked_value, received_tlc_value, immediately_spendable_value);
         let time_locked_value = time_locked_value + received_tlc_value;
         let immediately_spendable_value = immediately_spendable_value - received_tlc_value;
-        #[cfg(debug_assertions)]
-        {
-            debug_assert_eq!(
-                self.total_amount,
-                time_locked_value + immediately_spendable_value
-            );
-        }
 
         debug!("Building commitment transaction with time_locked_value: {}, immediately_spendable_value: {}", time_locked_value, immediately_spendable_value);
         let immediate_payment_key = {
@@ -3590,9 +3809,15 @@ impl ChannelActorState {
         if let Some(udt_type_script) = &self.funding_udt_type_script {
             //FIXME(yukang): we need to add logic for transaction fee here
             let (time_locked_ckb_amount, immediately_spendable_ckb_amount) = if local {
-                (self.local_ckb_amount, self.remote_ckb_amount)
+                (
+                    self.local_reserved_ckb_amount,
+                    self.remote_reserved_ckb_amount,
+                )
             } else {
-                (self.remote_ckb_amount, self.local_ckb_amount)
+                (
+                    self.remote_reserved_ckb_amount,
+                    self.local_reserved_ckb_amount,
+                )
             };
 
             let immediate_output_data = immediately_spendable_value.to_le_bytes().pack();
@@ -4218,6 +4443,8 @@ mod tests {
                     peer_id: node_b.peer_id.clone(),
                     funding_amount: 100000000000,
                     funding_udt_type_script: None,
+                    commitment_fee_rate: None,
+                    funding_fee_rate: None,
                 },
                 rpc_reply,
             ))
@@ -4240,6 +4467,8 @@ mod tests {
 
     #[tokio::test]
     async fn test_open_and_accept_channel() {
+        use crate::ckb::channel::DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT;
+
         let [node_a, mut node_b] = NetworkNode::new_n_interconnected_nodes(2)
             .await
             .try_into()
@@ -4251,6 +4480,8 @@ mod tests {
                     peer_id: node_b.peer_id.clone(),
                     funding_amount: 100000000000,
                     funding_udt_type_script: None,
+                    commitment_fee_rate: None,
+                    funding_fee_rate: None,
                 },
                 rpc_reply,
             ))
@@ -4274,7 +4505,7 @@ mod tests {
             NetworkActorMessage::Command(NetworkActorCommand::AcceptChannel(
                 AcceptChannelCommand {
                     temp_channel_id: open_channel_result.channel_id,
-                    funding_amount: 6100000000,
+                    funding_amount: DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT as u128,
                 },
                 rpc_reply,
             ))
@@ -4300,6 +4531,8 @@ mod tests {
                     peer_id: node_b.peer_id.clone(),
                     funding_amount: 100000000000,
                     funding_udt_type_script: None,
+                    commitment_fee_rate: None,
+                    funding_fee_rate: None,
                 },
                 rpc_reply,
             ))
@@ -4322,7 +4555,7 @@ mod tests {
             NetworkActorMessage::Command(NetworkActorCommand::AcceptChannel(
                 AcceptChannelCommand {
                     temp_channel_id: open_channel_result.channel_id,
-                    funding_amount: 1000,
+                    funding_amount: 6200000000,
                 },
                 rpc_reply,
             ))
@@ -4416,6 +4649,8 @@ mod tests {
                     peer_id: node_b.peer_id.clone(),
                     funding_amount: 100000000000,
                     funding_udt_type_script: None,
+                    commitment_fee_rate: None,
+                    funding_fee_rate: None,
                 },
                 rpc_reply,
             ))
@@ -4439,7 +4674,7 @@ mod tests {
             NetworkActorMessage::Command(NetworkActorCommand::AcceptChannel(
                 AcceptChannelCommand {
                     temp_channel_id: open_channel_result.channel_id,
-                    funding_amount: 6100000000,
+                    funding_amount: 6200000000,
                 },
                 rpc_reply,
             ))
diff --git a/src/ckb/config.rs b/src/ckb/config.rs
index 2a2737e0..5be31bf9 100644
--- a/src/ckb/config.rs
+++ b/src/ckb/config.rs
@@ -8,6 +8,28 @@ use clap_serde_derive::{
 use serde::Deserialize;
 use std::{fs, path::PathBuf};
 
+pub const CKB_SHANNONS: u64 = 100_000_000; // 1 CKB = 10 ^ 8 shannons
+pub const DEFAULT_MIN_INBOUND_LIQUIDITY: u64 = 100 * CKB_SHANNONS; // 100 CKB for minimal inbound liquidity
+pub const DEFAULT_MIN_SHUTDOWN_FEE: u64 = 1 * CKB_SHANNONS; // 1 CKB prepared for shutdown transaction fee
+pub const MIN_OCCUPIED_CAPACITY: u64 = 61 * CKB_SHANNONS; // 61 CKB for occupied capacity
+pub const MIN_UDT_OCCUPIED_CAPACITY: u64 = 142 * CKB_SHANNONS; // 142 CKB for UDT occupied capacity
+
+/// 62 CKB minimal channel amount, at any time a partner should keep at least
+/// `DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT` CKB in the channel,
+/// to make sure he can build a valid shutdown transaction and pay proper fee.
+pub const DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT: u64 =
+    MIN_OCCUPIED_CAPACITY + DEFAULT_MIN_SHUTDOWN_FEE;
+
+/// 143 CKB for minimal UDT amount
+pub const DEFAULT_UDT_MINIMAL_CKB_AMOUNT: u64 =
+    MIN_UDT_OCCUPIED_CAPACITY + DEFAULT_MIN_SHUTDOWN_FEE;
+
+/// 162 CKB to open a channel which maybe automatically acceptted.
+/// 100 CKB for minimal inbound liquidity, 61 CKB for occupied capacity, 1 CKB for shutdown fee
+/// The other party may auto accept the channel if the amount is greater than this.
+pub const DEFAULT_CHANNEL_MIN_AUTO_CKB_AMOUNT: u64 =
+    DEFAULT_MIN_INBOUND_LIQUIDITY + MIN_OCCUPIED_CAPACITY + DEFAULT_MIN_SHUTDOWN_FEE;
+
 // See comment in `LdkConfig` for why do we need to specify both name and long,
 // and prefix them with `ckb-`/`CKB_`.
 #[derive(ClapSerde, Debug, Clone)]
@@ -45,22 +67,22 @@ pub struct CkbConfig {
     #[arg(name = "CKB_NETWORK", long = "ckb-network", env)]
     pub network: Option<CkbNetwork>,
 
-    /// minimum ckb funding amount for open channel requests, unit: shannons [default: 16100000000 shannons]
+    /// minimum ckb funding amount for auto accepting an open channel requests, aunit: shannons [default: 16200000000 shannons]
     #[arg(
-        name = "CKB_OPEN_CHANNEL_MIN_CKB_FUNDING_AMOUNT",
-        long = "ckb-open-channel-min-ckb-funding-amount",
+        name = "CKB_OPEN_CHANNEL_AUTO_ACCEPT_MIN_CKB_FUNDING_AMOUNT",
+        long = "ckb-open-channel-auto-accept-min-ckb-funding-amount",
         env,
-        help = "minimum ckb funding amount for open channel requests, unit: shannons [default: 16100000000 shannons]"
+        help = "minimum ckb funding amount for auto accepting an open channel requests, unit: shannons [default: 16200000000 shannons]"
     )]
-    pub open_channel_min_ckb_funding_amount: Option<u128>,
-    /// whether to accept open channel requests with ckb funding amount automatically, unit: shannons [default: 6100000000 shannons], if this is set to zero, it means to disable auto accept
+    pub open_channel_auto_accept_min_ckb_funding_amount: Option<u64>,
+    /// whether to accept open channel requests with ckb funding amount automatically, unit: shannons [default: 6200000000 shannons], if this is set to zero, it means to disable auto accept
     #[arg(
         name = "CKB_AUTO_ACCEPT_CHANNEL_CKB_FUNDING_AMOUNT",
         long = "ckb-auto-accept-channel-ckb-funding-amount",
         env,
-        help = "whether to accept open channel requests with ckb funding amount automatically, unit: shannons [default: 6100000000 shannons], if this is set to zero, it means to disable auto accept"
+        help = "whether to accept open channel requests with ckb funding amount automatically, unit: shannons [default: 6200000000 shannons], if this is set to zero, it means to disable auto accept"
     )]
-    pub auto_accept_channel_ckb_funding_amount: Option<u128>,
+    pub auto_accept_channel_ckb_funding_amount: Option<u64>,
 }
 
 impl CkbConfig {
@@ -89,14 +111,14 @@ impl CkbConfig {
         path
     }
 
-    pub fn open_channel_min_ckb_funding_amount(&self) -> u128 {
-        self.open_channel_min_ckb_funding_amount
-            .unwrap_or(16100000000)
+    pub fn open_channel_auto_accept_min_ckb_funding_amount(&self) -> u64 {
+        self.open_channel_auto_accept_min_ckb_funding_amount
+            .unwrap_or(DEFAULT_CHANNEL_MIN_AUTO_CKB_AMOUNT)
     }
 
-    pub fn auto_accept_channel_ckb_funding_amount(&self) -> u128 {
+    pub fn auto_accept_channel_ckb_funding_amount(&self) -> u64 {
         self.auto_accept_channel_ckb_funding_amount
-            .unwrap_or(6100000000)
+            .unwrap_or(DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT)
     }
 }
 
diff --git a/src/ckb/gen/cfn.rs b/src/ckb/gen/cfn.rs
index 02ec7545..1579b5e5 100644
--- a/src/ckb/gen/cfn.rs
+++ b/src/ckb/gen/cfn.rs
@@ -2941,6 +2941,12 @@ impl ::core::fmt::Display for OpenChannel {
             self.funding_udt_type_script()
         )?;
         write!(f, ", {}: {}", "funding_amount", self.funding_amount())?;
+        write!(
+            f,
+            ", {}: {}",
+            "reserved_ckb_amount",
+            self.reserved_ckb_amount()
+        )?;
         write!(f, ", {}: {}", "funding_fee_rate", self.funding_fee_rate())?;
         write!(
             f,
@@ -3000,10 +3006,11 @@ impl ::core::default::Default for OpenChannel {
     }
 }
 impl OpenChannel {
-    const DEFAULT_VALUE: [u8; 522] = [
-        10, 2, 0, 0, 80, 0, 0, 0, 112, 0, 0, 0, 144, 0, 0, 0, 144, 0, 0, 0, 160, 0, 0, 0, 168, 0,
-        0, 0, 176, 0, 0, 0, 192, 0, 0, 0, 200, 0, 0, 0, 216, 0, 0, 0, 224, 0, 0, 0, 1, 1, 0, 0, 34,
-        1, 0, 0, 67, 1, 0, 0, 100, 1, 0, 0, 133, 1, 0, 0, 166, 1, 0, 0, 199, 1, 0, 0, 9, 2, 0, 0,
+    const DEFAULT_VALUE: [u8; 534] = [
+        22, 2, 0, 0, 84, 0, 0, 0, 116, 0, 0, 0, 148, 0, 0, 0, 148, 0, 0, 0, 164, 0, 0, 0, 172, 0,
+        0, 0, 180, 0, 0, 0, 188, 0, 0, 0, 204, 0, 0, 0, 212, 0, 0, 0, 228, 0, 0, 0, 236, 0, 0, 0,
+        13, 1, 0, 0, 46, 1, 0, 0, 79, 1, 0, 0, 112, 1, 0, 0, 145, 1, 0, 0, 178, 1, 0, 0, 211, 1, 0,
+        0, 21, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -3018,9 +3025,9 @@ impl OpenChannel {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0,
     ];
-    pub const FIELD_COUNT: usize = 19;
+    pub const FIELD_COUNT: usize = 20;
     pub fn total_size(&self) -> usize {
         molecule::unpack_number(self.as_slice()) as usize
     }
@@ -3061,95 +3068,101 @@ impl OpenChannel {
         let end = molecule::unpack_number(&slice[20..]) as usize;
         Uint128::new_unchecked(self.0.slice(start..end))
     }
-    pub fn funding_fee_rate(&self) -> Uint64 {
+    pub fn reserved_ckb_amount(&self) -> Uint64 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[20..]) as usize;
         let end = molecule::unpack_number(&slice[24..]) as usize;
         Uint64::new_unchecked(self.0.slice(start..end))
     }
-    pub fn commitment_fee_rate(&self) -> Uint64 {
+    pub fn funding_fee_rate(&self) -> Uint64 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[24..]) as usize;
         let end = molecule::unpack_number(&slice[28..]) as usize;
         Uint64::new_unchecked(self.0.slice(start..end))
     }
-    pub fn max_tlc_value_in_flight(&self) -> Uint128 {
+    pub fn commitment_fee_rate(&self) -> Uint64 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[28..]) as usize;
         let end = molecule::unpack_number(&slice[32..]) as usize;
-        Uint128::new_unchecked(self.0.slice(start..end))
+        Uint64::new_unchecked(self.0.slice(start..end))
     }
-    pub fn max_accept_tlcs(&self) -> Uint64 {
+    pub fn max_tlc_value_in_flight(&self) -> Uint128 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[32..]) as usize;
         let end = molecule::unpack_number(&slice[36..]) as usize;
-        Uint64::new_unchecked(self.0.slice(start..end))
+        Uint128::new_unchecked(self.0.slice(start..end))
     }
-    pub fn min_tlc_value(&self) -> Uint128 {
+    pub fn max_accept_tlcs(&self) -> Uint64 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[36..]) as usize;
         let end = molecule::unpack_number(&slice[40..]) as usize;
-        Uint128::new_unchecked(self.0.slice(start..end))
+        Uint64::new_unchecked(self.0.slice(start..end))
     }
-    pub fn to_self_delay(&self) -> Uint64 {
+    pub fn min_tlc_value(&self) -> Uint128 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[40..]) as usize;
         let end = molecule::unpack_number(&slice[44..]) as usize;
-        Uint64::new_unchecked(self.0.slice(start..end))
+        Uint128::new_unchecked(self.0.slice(start..end))
     }
-    pub fn funding_pubkey(&self) -> Pubkey {
+    pub fn to_self_delay(&self) -> Uint64 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[44..]) as usize;
         let end = molecule::unpack_number(&slice[48..]) as usize;
-        Pubkey::new_unchecked(self.0.slice(start..end))
+        Uint64::new_unchecked(self.0.slice(start..end))
     }
-    pub fn revocation_basepoint(&self) -> Pubkey {
+    pub fn funding_pubkey(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[48..]) as usize;
         let end = molecule::unpack_number(&slice[52..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn payment_basepoint(&self) -> Pubkey {
+    pub fn revocation_basepoint(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[52..]) as usize;
         let end = molecule::unpack_number(&slice[56..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn delayed_payment_basepoint(&self) -> Pubkey {
+    pub fn payment_basepoint(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[56..]) as usize;
         let end = molecule::unpack_number(&slice[60..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn tlc_basepoint(&self) -> Pubkey {
+    pub fn delayed_payment_basepoint(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[60..]) as usize;
         let end = molecule::unpack_number(&slice[64..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn first_per_commitment_point(&self) -> Pubkey {
+    pub fn tlc_basepoint(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[64..]) as usize;
         let end = molecule::unpack_number(&slice[68..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn second_per_commitment_point(&self) -> Pubkey {
+    pub fn first_per_commitment_point(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[68..]) as usize;
         let end = molecule::unpack_number(&slice[72..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn next_local_nonce(&self) -> PubNonce {
+    pub fn second_per_commitment_point(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[72..]) as usize;
         let end = molecule::unpack_number(&slice[76..]) as usize;
+        Pubkey::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn next_local_nonce(&self) -> PubNonce {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[76..]) as usize;
+        let end = molecule::unpack_number(&slice[80..]) as usize;
         PubNonce::new_unchecked(self.0.slice(start..end))
     }
     pub fn channel_flags(&self) -> Byte {
         let slice = self.as_slice();
-        let start = molecule::unpack_number(&slice[76..]) as usize;
+        let start = molecule::unpack_number(&slice[80..]) as usize;
         if self.has_extra_fields() {
-            let end = molecule::unpack_number(&slice[80..]) as usize;
+            let end = molecule::unpack_number(&slice[84..]) as usize;
             Byte::new_unchecked(self.0.slice(start..end))
         } else {
             Byte::new_unchecked(self.0.slice(start..))
@@ -3186,6 +3199,7 @@ impl molecule::prelude::Entity for OpenChannel {
             .channel_id(self.channel_id())
             .funding_udt_type_script(self.funding_udt_type_script())
             .funding_amount(self.funding_amount())
+            .reserved_ckb_amount(self.reserved_ckb_amount())
             .funding_fee_rate(self.funding_fee_rate())
             .commitment_fee_rate(self.commitment_fee_rate())
             .max_tlc_value_in_flight(self.max_tlc_value_in_flight())
@@ -3231,6 +3245,12 @@ impl<'r> ::core::fmt::Display for OpenChannelReader<'r> {
             self.funding_udt_type_script()
         )?;
         write!(f, ", {}: {}", "funding_amount", self.funding_amount())?;
+        write!(
+            f,
+            ", {}: {}",
+            "reserved_ckb_amount",
+            self.reserved_ckb_amount()
+        )?;
         write!(f, ", {}: {}", "funding_fee_rate", self.funding_fee_rate())?;
         write!(
             f,
@@ -3284,7 +3304,7 @@ impl<'r> ::core::fmt::Display for OpenChannelReader<'r> {
     }
 }
 impl<'r> OpenChannelReader<'r> {
-    pub const FIELD_COUNT: usize = 19;
+    pub const FIELD_COUNT: usize = 20;
     pub fn total_size(&self) -> usize {
         molecule::unpack_number(self.as_slice()) as usize
     }
@@ -3325,95 +3345,101 @@ impl<'r> OpenChannelReader<'r> {
         let end = molecule::unpack_number(&slice[20..]) as usize;
         Uint128Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn funding_fee_rate(&self) -> Uint64Reader<'r> {
+    pub fn reserved_ckb_amount(&self) -> Uint64Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[20..]) as usize;
         let end = molecule::unpack_number(&slice[24..]) as usize;
         Uint64Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn commitment_fee_rate(&self) -> Uint64Reader<'r> {
+    pub fn funding_fee_rate(&self) -> Uint64Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[24..]) as usize;
         let end = molecule::unpack_number(&slice[28..]) as usize;
         Uint64Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn max_tlc_value_in_flight(&self) -> Uint128Reader<'r> {
+    pub fn commitment_fee_rate(&self) -> Uint64Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[28..]) as usize;
         let end = molecule::unpack_number(&slice[32..]) as usize;
-        Uint128Reader::new_unchecked(&self.as_slice()[start..end])
+        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn max_accept_tlcs(&self) -> Uint64Reader<'r> {
+    pub fn max_tlc_value_in_flight(&self) -> Uint128Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[32..]) as usize;
         let end = molecule::unpack_number(&slice[36..]) as usize;
-        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
+        Uint128Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn min_tlc_value(&self) -> Uint128Reader<'r> {
+    pub fn max_accept_tlcs(&self) -> Uint64Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[36..]) as usize;
         let end = molecule::unpack_number(&slice[40..]) as usize;
-        Uint128Reader::new_unchecked(&self.as_slice()[start..end])
+        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn to_self_delay(&self) -> Uint64Reader<'r> {
+    pub fn min_tlc_value(&self) -> Uint128Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[40..]) as usize;
         let end = molecule::unpack_number(&slice[44..]) as usize;
-        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
+        Uint128Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn funding_pubkey(&self) -> PubkeyReader<'r> {
+    pub fn to_self_delay(&self) -> Uint64Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[44..]) as usize;
         let end = molecule::unpack_number(&slice[48..]) as usize;
-        PubkeyReader::new_unchecked(&self.as_slice()[start..end])
+        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn revocation_basepoint(&self) -> PubkeyReader<'r> {
+    pub fn funding_pubkey(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[48..]) as usize;
         let end = molecule::unpack_number(&slice[52..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn payment_basepoint(&self) -> PubkeyReader<'r> {
+    pub fn revocation_basepoint(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[52..]) as usize;
         let end = molecule::unpack_number(&slice[56..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn delayed_payment_basepoint(&self) -> PubkeyReader<'r> {
+    pub fn payment_basepoint(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[56..]) as usize;
         let end = molecule::unpack_number(&slice[60..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn tlc_basepoint(&self) -> PubkeyReader<'r> {
+    pub fn delayed_payment_basepoint(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[60..]) as usize;
         let end = molecule::unpack_number(&slice[64..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn first_per_commitment_point(&self) -> PubkeyReader<'r> {
+    pub fn tlc_basepoint(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[64..]) as usize;
         let end = molecule::unpack_number(&slice[68..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn second_per_commitment_point(&self) -> PubkeyReader<'r> {
+    pub fn first_per_commitment_point(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[68..]) as usize;
         let end = molecule::unpack_number(&slice[72..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn next_local_nonce(&self) -> PubNonceReader<'r> {
+    pub fn second_per_commitment_point(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[72..]) as usize;
         let end = molecule::unpack_number(&slice[76..]) as usize;
+        PubkeyReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn next_local_nonce(&self) -> PubNonceReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[76..]) as usize;
+        let end = molecule::unpack_number(&slice[80..]) as usize;
         PubNonceReader::new_unchecked(&self.as_slice()[start..end])
     }
     pub fn channel_flags(&self) -> ByteReader<'r> {
         let slice = self.as_slice();
-        let start = molecule::unpack_number(&slice[76..]) as usize;
+        let start = molecule::unpack_number(&slice[80..]) as usize;
         if self.has_extra_fields() {
-            let end = molecule::unpack_number(&slice[80..]) as usize;
+            let end = molecule::unpack_number(&slice[84..]) as usize;
             ByteReader::new_unchecked(&self.as_slice()[start..end])
         } else {
             ByteReader::new_unchecked(&self.as_slice()[start..])
@@ -3472,19 +3498,20 @@ impl<'r> molecule::prelude::Reader<'r> for OpenChannelReader<'r> {
         Uint128Reader::verify(&slice[offsets[3]..offsets[4]], compatible)?;
         Uint64Reader::verify(&slice[offsets[4]..offsets[5]], compatible)?;
         Uint64Reader::verify(&slice[offsets[5]..offsets[6]], compatible)?;
-        Uint128Reader::verify(&slice[offsets[6]..offsets[7]], compatible)?;
-        Uint64Reader::verify(&slice[offsets[7]..offsets[8]], compatible)?;
-        Uint128Reader::verify(&slice[offsets[8]..offsets[9]], compatible)?;
-        Uint64Reader::verify(&slice[offsets[9]..offsets[10]], compatible)?;
-        PubkeyReader::verify(&slice[offsets[10]..offsets[11]], compatible)?;
+        Uint64Reader::verify(&slice[offsets[6]..offsets[7]], compatible)?;
+        Uint128Reader::verify(&slice[offsets[7]..offsets[8]], compatible)?;
+        Uint64Reader::verify(&slice[offsets[8]..offsets[9]], compatible)?;
+        Uint128Reader::verify(&slice[offsets[9]..offsets[10]], compatible)?;
+        Uint64Reader::verify(&slice[offsets[10]..offsets[11]], compatible)?;
         PubkeyReader::verify(&slice[offsets[11]..offsets[12]], compatible)?;
         PubkeyReader::verify(&slice[offsets[12]..offsets[13]], compatible)?;
         PubkeyReader::verify(&slice[offsets[13]..offsets[14]], compatible)?;
         PubkeyReader::verify(&slice[offsets[14]..offsets[15]], compatible)?;
         PubkeyReader::verify(&slice[offsets[15]..offsets[16]], compatible)?;
         PubkeyReader::verify(&slice[offsets[16]..offsets[17]], compatible)?;
-        PubNonceReader::verify(&slice[offsets[17]..offsets[18]], compatible)?;
-        ByteReader::verify(&slice[offsets[18]..offsets[19]], compatible)?;
+        PubkeyReader::verify(&slice[offsets[17]..offsets[18]], compatible)?;
+        PubNonceReader::verify(&slice[offsets[18]..offsets[19]], compatible)?;
+        ByteReader::verify(&slice[offsets[19]..offsets[20]], compatible)?;
         Ok(())
     }
 }
@@ -3494,6 +3521,7 @@ pub struct OpenChannelBuilder {
     pub(crate) channel_id: Byte32,
     pub(crate) funding_udt_type_script: ScriptOpt,
     pub(crate) funding_amount: Uint128,
+    pub(crate) reserved_ckb_amount: Uint64,
     pub(crate) funding_fee_rate: Uint64,
     pub(crate) commitment_fee_rate: Uint64,
     pub(crate) max_tlc_value_in_flight: Uint128,
@@ -3511,7 +3539,7 @@ pub struct OpenChannelBuilder {
     pub(crate) channel_flags: Byte,
 }
 impl OpenChannelBuilder {
-    pub const FIELD_COUNT: usize = 19;
+    pub const FIELD_COUNT: usize = 20;
     pub fn chain_hash(mut self, v: Byte32) -> Self {
         self.chain_hash = v;
         self
@@ -3528,6 +3556,10 @@ impl OpenChannelBuilder {
         self.funding_amount = v;
         self
     }
+    pub fn reserved_ckb_amount(mut self, v: Uint64) -> Self {
+        self.reserved_ckb_amount = v;
+        self
+    }
     pub fn funding_fee_rate(mut self, v: Uint64) -> Self {
         self.funding_fee_rate = v;
         self
@@ -3598,6 +3630,7 @@ impl molecule::prelude::Builder for OpenChannelBuilder {
             + self.channel_id.as_slice().len()
             + self.funding_udt_type_script.as_slice().len()
             + self.funding_amount.as_slice().len()
+            + self.reserved_ckb_amount.as_slice().len()
             + self.funding_fee_rate.as_slice().len()
             + self.commitment_fee_rate.as_slice().len()
             + self.max_tlc_value_in_flight.as_slice().len()
@@ -3626,6 +3659,8 @@ impl molecule::prelude::Builder for OpenChannelBuilder {
         offsets.push(total_size);
         total_size += self.funding_amount.as_slice().len();
         offsets.push(total_size);
+        total_size += self.reserved_ckb_amount.as_slice().len();
+        offsets.push(total_size);
         total_size += self.funding_fee_rate.as_slice().len();
         offsets.push(total_size);
         total_size += self.commitment_fee_rate.as_slice().len();
@@ -3663,6 +3698,7 @@ impl molecule::prelude::Builder for OpenChannelBuilder {
         writer.write_all(self.channel_id.as_slice())?;
         writer.write_all(self.funding_udt_type_script.as_slice())?;
         writer.write_all(self.funding_amount.as_slice())?;
+        writer.write_all(self.reserved_ckb_amount.as_slice())?;
         writer.write_all(self.funding_fee_rate.as_slice())?;
         writer.write_all(self.commitment_fee_rate.as_slice())?;
         writer.write_all(self.max_tlc_value_in_flight.as_slice())?;
@@ -3708,6 +3744,12 @@ impl ::core::fmt::Display for AcceptChannel {
         write!(f, "{} {{ ", Self::NAME)?;
         write!(f, "{}: {}", "channel_id", self.channel_id())?;
         write!(f, ", {}: {}", "funding_amount", self.funding_amount())?;
+        write!(
+            f,
+            ", {}: {}",
+            "reserved_ckb_amount",
+            self.reserved_ckb_amount()
+        )?;
         write!(
             f,
             ", {}: {}",
@@ -3759,10 +3801,10 @@ impl ::core::default::Default for AcceptChannel {
     }
 }
 impl AcceptChannel {
-    const DEFAULT_VALUE: [u8; 453] = [
-        197, 1, 0, 0, 60, 0, 0, 0, 92, 0, 0, 0, 108, 0, 0, 0, 124, 0, 0, 0, 132, 0, 0, 0, 148, 0,
-        0, 0, 156, 0, 0, 0, 189, 0, 0, 0, 222, 0, 0, 0, 255, 0, 0, 0, 32, 1, 0, 0, 65, 1, 0, 0, 98,
-        1, 0, 0, 131, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    const DEFAULT_VALUE: [u8; 465] = [
+        209, 1, 0, 0, 64, 0, 0, 0, 96, 0, 0, 0, 112, 0, 0, 0, 120, 0, 0, 0, 136, 0, 0, 0, 144, 0,
+        0, 0, 160, 0, 0, 0, 168, 0, 0, 0, 201, 0, 0, 0, 234, 0, 0, 0, 11, 1, 0, 0, 44, 1, 0, 0, 77,
+        1, 0, 0, 110, 1, 0, 0, 143, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -3775,9 +3817,9 @@ impl AcceptChannel {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ];
-    pub const FIELD_COUNT: usize = 14;
+    pub const FIELD_COUNT: usize = 15;
     pub fn total_size(&self) -> usize {
         molecule::unpack_number(self.as_slice()) as usize
     }
@@ -3806,77 +3848,83 @@ impl AcceptChannel {
         let end = molecule::unpack_number(&slice[12..]) as usize;
         Uint128::new_unchecked(self.0.slice(start..end))
     }
-    pub fn max_tlc_value_in_flight(&self) -> Uint128 {
+    pub fn reserved_ckb_amount(&self) -> Uint64 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[12..]) as usize;
         let end = molecule::unpack_number(&slice[16..]) as usize;
-        Uint128::new_unchecked(self.0.slice(start..end))
+        Uint64::new_unchecked(self.0.slice(start..end))
     }
-    pub fn max_accept_tlcs(&self) -> Uint64 {
+    pub fn max_tlc_value_in_flight(&self) -> Uint128 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[16..]) as usize;
         let end = molecule::unpack_number(&slice[20..]) as usize;
-        Uint64::new_unchecked(self.0.slice(start..end))
+        Uint128::new_unchecked(self.0.slice(start..end))
     }
-    pub fn min_tlc_value(&self) -> Uint128 {
+    pub fn max_accept_tlcs(&self) -> Uint64 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[20..]) as usize;
         let end = molecule::unpack_number(&slice[24..]) as usize;
-        Uint128::new_unchecked(self.0.slice(start..end))
+        Uint64::new_unchecked(self.0.slice(start..end))
     }
-    pub fn to_self_delay(&self) -> Uint64 {
+    pub fn min_tlc_value(&self) -> Uint128 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[24..]) as usize;
         let end = molecule::unpack_number(&slice[28..]) as usize;
-        Uint64::new_unchecked(self.0.slice(start..end))
+        Uint128::new_unchecked(self.0.slice(start..end))
     }
-    pub fn funding_pubkey(&self) -> Pubkey {
+    pub fn to_self_delay(&self) -> Uint64 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[28..]) as usize;
         let end = molecule::unpack_number(&slice[32..]) as usize;
-        Pubkey::new_unchecked(self.0.slice(start..end))
+        Uint64::new_unchecked(self.0.slice(start..end))
     }
-    pub fn revocation_basepoint(&self) -> Pubkey {
+    pub fn funding_pubkey(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[32..]) as usize;
         let end = molecule::unpack_number(&slice[36..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn payment_basepoint(&self) -> Pubkey {
+    pub fn revocation_basepoint(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[36..]) as usize;
         let end = molecule::unpack_number(&slice[40..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn delayed_payment_basepoint(&self) -> Pubkey {
+    pub fn payment_basepoint(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[40..]) as usize;
         let end = molecule::unpack_number(&slice[44..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn tlc_basepoint(&self) -> Pubkey {
+    pub fn delayed_payment_basepoint(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[44..]) as usize;
         let end = molecule::unpack_number(&slice[48..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn first_per_commitment_point(&self) -> Pubkey {
+    pub fn tlc_basepoint(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[48..]) as usize;
         let end = molecule::unpack_number(&slice[52..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn second_per_commitment_point(&self) -> Pubkey {
+    pub fn first_per_commitment_point(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[52..]) as usize;
         let end = molecule::unpack_number(&slice[56..]) as usize;
         Pubkey::new_unchecked(self.0.slice(start..end))
     }
-    pub fn next_local_nonce(&self) -> PubNonce {
+    pub fn second_per_commitment_point(&self) -> Pubkey {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[56..]) as usize;
+        let end = molecule::unpack_number(&slice[60..]) as usize;
+        Pubkey::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn next_local_nonce(&self) -> PubNonce {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[60..]) as usize;
         if self.has_extra_fields() {
-            let end = molecule::unpack_number(&slice[60..]) as usize;
+            let end = molecule::unpack_number(&slice[64..]) as usize;
             PubNonce::new_unchecked(self.0.slice(start..end))
         } else {
             PubNonce::new_unchecked(self.0.slice(start..))
@@ -3911,6 +3959,7 @@ impl molecule::prelude::Entity for AcceptChannel {
         Self::new_builder()
             .channel_id(self.channel_id())
             .funding_amount(self.funding_amount())
+            .reserved_ckb_amount(self.reserved_ckb_amount())
             .max_tlc_value_in_flight(self.max_tlc_value_in_flight())
             .max_accept_tlcs(self.max_accept_tlcs())
             .min_tlc_value(self.min_tlc_value())
@@ -3946,6 +3995,12 @@ impl<'r> ::core::fmt::Display for AcceptChannelReader<'r> {
         write!(f, "{} {{ ", Self::NAME)?;
         write!(f, "{}: {}", "channel_id", self.channel_id())?;
         write!(f, ", {}: {}", "funding_amount", self.funding_amount())?;
+        write!(
+            f,
+            ", {}: {}",
+            "reserved_ckb_amount",
+            self.reserved_ckb_amount()
+        )?;
         write!(
             f,
             ", {}: {}",
@@ -3991,7 +4046,7 @@ impl<'r> ::core::fmt::Display for AcceptChannelReader<'r> {
     }
 }
 impl<'r> AcceptChannelReader<'r> {
-    pub const FIELD_COUNT: usize = 14;
+    pub const FIELD_COUNT: usize = 15;
     pub fn total_size(&self) -> usize {
         molecule::unpack_number(self.as_slice()) as usize
     }
@@ -4020,77 +4075,83 @@ impl<'r> AcceptChannelReader<'r> {
         let end = molecule::unpack_number(&slice[12..]) as usize;
         Uint128Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn max_tlc_value_in_flight(&self) -> Uint128Reader<'r> {
+    pub fn reserved_ckb_amount(&self) -> Uint64Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[12..]) as usize;
         let end = molecule::unpack_number(&slice[16..]) as usize;
-        Uint128Reader::new_unchecked(&self.as_slice()[start..end])
+        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn max_accept_tlcs(&self) -> Uint64Reader<'r> {
+    pub fn max_tlc_value_in_flight(&self) -> Uint128Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[16..]) as usize;
         let end = molecule::unpack_number(&slice[20..]) as usize;
-        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
+        Uint128Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn min_tlc_value(&self) -> Uint128Reader<'r> {
+    pub fn max_accept_tlcs(&self) -> Uint64Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[20..]) as usize;
         let end = molecule::unpack_number(&slice[24..]) as usize;
-        Uint128Reader::new_unchecked(&self.as_slice()[start..end])
+        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn to_self_delay(&self) -> Uint64Reader<'r> {
+    pub fn min_tlc_value(&self) -> Uint128Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[24..]) as usize;
         let end = molecule::unpack_number(&slice[28..]) as usize;
-        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
+        Uint128Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn funding_pubkey(&self) -> PubkeyReader<'r> {
+    pub fn to_self_delay(&self) -> Uint64Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[28..]) as usize;
         let end = molecule::unpack_number(&slice[32..]) as usize;
-        PubkeyReader::new_unchecked(&self.as_slice()[start..end])
+        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn revocation_basepoint(&self) -> PubkeyReader<'r> {
+    pub fn funding_pubkey(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[32..]) as usize;
         let end = molecule::unpack_number(&slice[36..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn payment_basepoint(&self) -> PubkeyReader<'r> {
+    pub fn revocation_basepoint(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[36..]) as usize;
         let end = molecule::unpack_number(&slice[40..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn delayed_payment_basepoint(&self) -> PubkeyReader<'r> {
+    pub fn payment_basepoint(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[40..]) as usize;
         let end = molecule::unpack_number(&slice[44..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn tlc_basepoint(&self) -> PubkeyReader<'r> {
+    pub fn delayed_payment_basepoint(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[44..]) as usize;
         let end = molecule::unpack_number(&slice[48..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn first_per_commitment_point(&self) -> PubkeyReader<'r> {
+    pub fn tlc_basepoint(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[48..]) as usize;
         let end = molecule::unpack_number(&slice[52..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn second_per_commitment_point(&self) -> PubkeyReader<'r> {
+    pub fn first_per_commitment_point(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[52..]) as usize;
         let end = molecule::unpack_number(&slice[56..]) as usize;
         PubkeyReader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn next_local_nonce(&self) -> PubNonceReader<'r> {
+    pub fn second_per_commitment_point(&self) -> PubkeyReader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[56..]) as usize;
+        let end = molecule::unpack_number(&slice[60..]) as usize;
+        PubkeyReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn next_local_nonce(&self) -> PubNonceReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[60..]) as usize;
         if self.has_extra_fields() {
-            let end = molecule::unpack_number(&slice[60..]) as usize;
+            let end = molecule::unpack_number(&slice[64..]) as usize;
             PubNonceReader::new_unchecked(&self.as_slice()[start..end])
         } else {
             PubNonceReader::new_unchecked(&self.as_slice()[start..])
@@ -4145,18 +4206,19 @@ impl<'r> molecule::prelude::Reader<'r> for AcceptChannelReader<'r> {
         }
         Byte32Reader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
         Uint128Reader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
-        Uint128Reader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
-        Uint64Reader::verify(&slice[offsets[3]..offsets[4]], compatible)?;
-        Uint128Reader::verify(&slice[offsets[4]..offsets[5]], compatible)?;
-        Uint64Reader::verify(&slice[offsets[5]..offsets[6]], compatible)?;
-        PubkeyReader::verify(&slice[offsets[6]..offsets[7]], compatible)?;
+        Uint64Reader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
+        Uint128Reader::verify(&slice[offsets[3]..offsets[4]], compatible)?;
+        Uint64Reader::verify(&slice[offsets[4]..offsets[5]], compatible)?;
+        Uint128Reader::verify(&slice[offsets[5]..offsets[6]], compatible)?;
+        Uint64Reader::verify(&slice[offsets[6]..offsets[7]], compatible)?;
         PubkeyReader::verify(&slice[offsets[7]..offsets[8]], compatible)?;
         PubkeyReader::verify(&slice[offsets[8]..offsets[9]], compatible)?;
         PubkeyReader::verify(&slice[offsets[9]..offsets[10]], compatible)?;
         PubkeyReader::verify(&slice[offsets[10]..offsets[11]], compatible)?;
         PubkeyReader::verify(&slice[offsets[11]..offsets[12]], compatible)?;
         PubkeyReader::verify(&slice[offsets[12]..offsets[13]], compatible)?;
-        PubNonceReader::verify(&slice[offsets[13]..offsets[14]], compatible)?;
+        PubkeyReader::verify(&slice[offsets[13]..offsets[14]], compatible)?;
+        PubNonceReader::verify(&slice[offsets[14]..offsets[15]], compatible)?;
         Ok(())
     }
 }
@@ -4164,6 +4226,7 @@ impl<'r> molecule::prelude::Reader<'r> for AcceptChannelReader<'r> {
 pub struct AcceptChannelBuilder {
     pub(crate) channel_id: Byte32,
     pub(crate) funding_amount: Uint128,
+    pub(crate) reserved_ckb_amount: Uint64,
     pub(crate) max_tlc_value_in_flight: Uint128,
     pub(crate) max_accept_tlcs: Uint64,
     pub(crate) min_tlc_value: Uint128,
@@ -4178,7 +4241,7 @@ pub struct AcceptChannelBuilder {
     pub(crate) next_local_nonce: PubNonce,
 }
 impl AcceptChannelBuilder {
-    pub const FIELD_COUNT: usize = 14;
+    pub const FIELD_COUNT: usize = 15;
     pub fn channel_id(mut self, v: Byte32) -> Self {
         self.channel_id = v;
         self
@@ -4187,6 +4250,10 @@ impl AcceptChannelBuilder {
         self.funding_amount = v;
         self
     }
+    pub fn reserved_ckb_amount(mut self, v: Uint64) -> Self {
+        self.reserved_ckb_amount = v;
+        self
+    }
     pub fn max_tlc_value_in_flight(mut self, v: Uint128) -> Self {
         self.max_tlc_value_in_flight = v;
         self
@@ -4243,6 +4310,7 @@ impl molecule::prelude::Builder for AcceptChannelBuilder {
         molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
             + self.channel_id.as_slice().len()
             + self.funding_amount.as_slice().len()
+            + self.reserved_ckb_amount.as_slice().len()
             + self.max_tlc_value_in_flight.as_slice().len()
             + self.max_accept_tlcs.as_slice().len()
             + self.min_tlc_value.as_slice().len()
@@ -4264,6 +4332,8 @@ impl molecule::prelude::Builder for AcceptChannelBuilder {
         offsets.push(total_size);
         total_size += self.funding_amount.as_slice().len();
         offsets.push(total_size);
+        total_size += self.reserved_ckb_amount.as_slice().len();
+        offsets.push(total_size);
         total_size += self.max_tlc_value_in_flight.as_slice().len();
         offsets.push(total_size);
         total_size += self.max_accept_tlcs.as_slice().len();
@@ -4293,6 +4363,7 @@ impl molecule::prelude::Builder for AcceptChannelBuilder {
         }
         writer.write_all(self.channel_id.as_slice())?;
         writer.write_all(self.funding_amount.as_slice())?;
+        writer.write_all(self.reserved_ckb_amount.as_slice())?;
         writer.write_all(self.max_tlc_value_in_flight.as_slice())?;
         writer.write_all(self.max_accept_tlcs.as_slice())?;
         writer.write_all(self.min_tlc_value.as_slice())?;
@@ -6413,7 +6484,7 @@ impl ::core::fmt::Display for Shutdown {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         write!(f, "{} {{ ", Self::NAME)?;
         write!(f, "{}: {}", "channel_id", self.channel_id())?;
-        write!(f, ", {}: {}", "fee", self.fee())?;
+        write!(f, ", {}: {}", "fee_rate", self.fee_rate())?;
         write!(f, ", {}: {}", "close_script", self.close_script())?;
         let extra_count = self.count_extra_fields();
         if extra_count != 0 {
@@ -6429,11 +6500,11 @@ impl ::core::default::Default for Shutdown {
     }
 }
 impl Shutdown {
-    const DEFAULT_VALUE: [u8; 117] = [
-        117, 0, 0, 0, 16, 0, 0, 0, 48, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 53, 0, 0, 0, 16, 0, 0, 0, 48, 0, 0, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    const DEFAULT_VALUE: [u8; 109] = [
+        109, 0, 0, 0, 16, 0, 0, 0, 48, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0,
+        0, 16, 0, 0, 0, 48, 0, 0, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ];
     pub const FIELD_COUNT: usize = 3;
     pub fn total_size(&self) -> usize {
@@ -6458,11 +6529,11 @@ impl Shutdown {
         let end = molecule::unpack_number(&slice[8..]) as usize;
         Byte32::new_unchecked(self.0.slice(start..end))
     }
-    pub fn fee(&self) -> Uint128 {
+    pub fn fee_rate(&self) -> Uint64 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[8..]) as usize;
         let end = molecule::unpack_number(&slice[12..]) as usize;
-        Uint128::new_unchecked(self.0.slice(start..end))
+        Uint64::new_unchecked(self.0.slice(start..end))
     }
     pub fn close_script(&self) -> Script {
         let slice = self.as_slice();
@@ -6502,7 +6573,7 @@ impl molecule::prelude::Entity for Shutdown {
     fn as_builder(self) -> Self::Builder {
         Self::new_builder()
             .channel_id(self.channel_id())
-            .fee(self.fee())
+            .fee_rate(self.fee_rate())
             .close_script(self.close_script())
     }
 }
@@ -6526,7 +6597,7 @@ impl<'r> ::core::fmt::Display for ShutdownReader<'r> {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         write!(f, "{} {{ ", Self::NAME)?;
         write!(f, "{}: {}", "channel_id", self.channel_id())?;
-        write!(f, ", {}: {}", "fee", self.fee())?;
+        write!(f, ", {}: {}", "fee_rate", self.fee_rate())?;
         write!(f, ", {}: {}", "close_script", self.close_script())?;
         let extra_count = self.count_extra_fields();
         if extra_count != 0 {
@@ -6559,11 +6630,11 @@ impl<'r> ShutdownReader<'r> {
         let end = molecule::unpack_number(&slice[8..]) as usize;
         Byte32Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn fee(&self) -> Uint128Reader<'r> {
+    pub fn fee_rate(&self) -> Uint64Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[8..]) as usize;
         let end = molecule::unpack_number(&slice[12..]) as usize;
-        Uint128Reader::new_unchecked(&self.as_slice()[start..end])
+        Uint64Reader::new_unchecked(&self.as_slice()[start..end])
     }
     pub fn close_script(&self) -> ScriptReader<'r> {
         let slice = self.as_slice();
@@ -6623,7 +6694,7 @@ impl<'r> molecule::prelude::Reader<'r> for ShutdownReader<'r> {
             return ve!(Self, OffsetsNotMatch);
         }
         Byte32Reader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
-        Uint128Reader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
+        Uint64Reader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
         ScriptReader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
         Ok(())
     }
@@ -6631,7 +6702,7 @@ impl<'r> molecule::prelude::Reader<'r> for ShutdownReader<'r> {
 #[derive(Clone, Debug, Default)]
 pub struct ShutdownBuilder {
     pub(crate) channel_id: Byte32,
-    pub(crate) fee: Uint128,
+    pub(crate) fee_rate: Uint64,
     pub(crate) close_script: Script,
 }
 impl ShutdownBuilder {
@@ -6640,8 +6711,8 @@ impl ShutdownBuilder {
         self.channel_id = v;
         self
     }
-    pub fn fee(mut self, v: Uint128) -> Self {
-        self.fee = v;
+    pub fn fee_rate(mut self, v: Uint64) -> Self {
+        self.fee_rate = v;
         self
     }
     pub fn close_script(mut self, v: Script) -> Self {
@@ -6655,7 +6726,7 @@ impl molecule::prelude::Builder for ShutdownBuilder {
     fn expected_length(&self) -> usize {
         molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
             + self.channel_id.as_slice().len()
-            + self.fee.as_slice().len()
+            + self.fee_rate.as_slice().len()
             + self.close_script.as_slice().len()
     }
     fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
@@ -6664,7 +6735,7 @@ impl molecule::prelude::Builder for ShutdownBuilder {
         offsets.push(total_size);
         total_size += self.channel_id.as_slice().len();
         offsets.push(total_size);
-        total_size += self.fee.as_slice().len();
+        total_size += self.fee_rate.as_slice().len();
         offsets.push(total_size);
         total_size += self.close_script.as_slice().len();
         writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
@@ -6672,7 +6743,7 @@ impl molecule::prelude::Builder for ShutdownBuilder {
             writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
         }
         writer.write_all(self.channel_id.as_slice())?;
-        writer.write_all(self.fee.as_slice())?;
+        writer.write_all(self.fee_rate.as_slice())?;
         writer.write_all(self.close_script.as_slice())?;
         Ok(())
     }
@@ -8834,11 +8905,12 @@ impl ::core::default::Default for CFNMessage {
     }
 }
 impl CFNMessage {
-    const DEFAULT_VALUE: [u8; 526] = [
-        0, 0, 0, 0, 10, 2, 0, 0, 80, 0, 0, 0, 112, 0, 0, 0, 144, 0, 0, 0, 144, 0, 0, 0, 160, 0, 0,
-        0, 168, 0, 0, 0, 176, 0, 0, 0, 192, 0, 0, 0, 200, 0, 0, 0, 216, 0, 0, 0, 224, 0, 0, 0, 1,
-        1, 0, 0, 34, 1, 0, 0, 67, 1, 0, 0, 100, 1, 0, 0, 133, 1, 0, 0, 166, 1, 0, 0, 199, 1, 0, 0,
-        9, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    const DEFAULT_VALUE: [u8; 538] = [
+        0, 0, 0, 0, 22, 2, 0, 0, 84, 0, 0, 0, 116, 0, 0, 0, 148, 0, 0, 0, 148, 0, 0, 0, 164, 0, 0,
+        0, 172, 0, 0, 0, 180, 0, 0, 0, 188, 0, 0, 0, 204, 0, 0, 0, 212, 0, 0, 0, 228, 0, 0, 0, 236,
+        0, 0, 0, 13, 1, 0, 0, 46, 1, 0, 0, 79, 1, 0, 0, 112, 1, 0, 0, 145, 1, 0, 0, 178, 1, 0, 0,
+        211, 1, 0, 0, 21, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -8852,7 +8924,7 @@ impl CFNMessage {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,
     ];
     pub const ITEMS_COUNT: usize = 16;
     pub fn item_id(&self) -> molecule::Number {
diff --git a/src/ckb/network.rs b/src/ckb/network.rs
index cd218f97..c9081aa5 100644
--- a/src/ckb/network.rs
+++ b/src/ckb/network.rs
@@ -32,8 +32,9 @@ use tokio::sync::{mpsc, oneshot};
 use tokio_util::task::TaskTracker;
 
 use super::channel::{
-    ChannelActorMessage, ChannelActorStateStore, ChannelCommandWithId, ChannelEvent,
-    ProcessingChannelError, ProcessingChannelResult,
+    AcceptChannelParameter, ChannelActorMessage, ChannelActorStateStore, ChannelCommandWithId,
+    ChannelEvent, OpenChannelParameter, ProcessingChannelError, ProcessingChannelResult,
+    DEFAULT_COMMITMENT_FEE_RATE, DEFAULT_FEE_RATE,
 };
 use super::key::blake2b_hash_with_salt;
 use super::types::{Hash256, OpenChannel};
@@ -44,11 +45,10 @@ use super::{
 };
 
 use crate::ckb::channel::{TxCollaborationCommand, TxUpdateCommand};
+use crate::ckb::config::{DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT, DEFAULT_UDT_MINIMAL_CKB_AMOUNT};
 use crate::ckb::types::TxSignatures;
-use crate::ckb_chain::contracts::check_udt_script;
-use crate::ckb_chain::{
-    CkbChainMessage, FundingRequest, FundingTx, FundingUdtInfo, TraceTxRequest,
-};
+use crate::ckb_chain::contracts::{check_udt_script, is_udt_type_auto_accept};
+use crate::ckb_chain::{CkbChainMessage, FundingRequest, FundingTx, TraceTxRequest};
 use crate::{unwrap_or_return, Error};
 
 pub const CFN_PROTOCOL_ID: ProtocolId = ProtocolId::new(42);
@@ -110,6 +110,8 @@ pub struct OpenChannelCommand {
     pub peer_id: PeerId,
     pub funding_amount: u128,
     pub funding_udt_type_script: Option<Script>,
+    pub commitment_fee_rate: Option<u64>,
+    pub funding_fee_rate: Option<u64>,
 }
 
 #[derive(Debug)]
@@ -180,6 +182,7 @@ pub enum NetworkActorEvent {
         Option<Script>,
         u64,
         u64,
+        u64,
     ),
     /// A channel is ready to use.
     ChannelReady(Hash256, PeerId),
@@ -283,15 +286,28 @@ where
             // to the channel id in the message yet.
             CFNMessage::OpenChannel(open_channel) => {
                 let temp_channel_id = open_channel.channel_id.clone();
-                match state.on_open_channel_msg(peer_id, open_channel).await {
+                match state
+                    .on_open_channel_msg(peer_id, open_channel.clone())
+                    .await
+                {
                     Ok(()) => {
-                        if state.auto_accept_channel_ckb_funding_amount > 0 {
-                            let open_channel = AcceptChannelCommand {
+                        let auto_accept = if let Some(udt_type_script) =
+                            open_channel.funding_udt_type_script
+                        {
+                            is_udt_type_auto_accept(&udt_type_script, open_channel.funding_amount)
+                        } else {
+                            state.auto_accept_channel_ckb_funding_amount > 0
+                                && open_channel.all_ckb_amount()
+                                    >= state.open_channel_auto_accept_min_ckb_funding_amount
+                        };
+                        if auto_accept {
+                            let accept_channel = AcceptChannelCommand {
                                 temp_channel_id,
-                                funding_amount: state.auto_accept_channel_ckb_funding_amount,
+                                funding_amount: state.auto_accept_channel_ckb_funding_amount
+                                    as u128,
                             };
                             state
-                                .create_inbound_channel(open_channel, self.store.clone())
+                                .create_inbound_channel(accept_channel, self.store.clone())
                                 .await?;
                         }
                     }
@@ -362,12 +378,19 @@ where
                 local,
                 remote,
                 script,
-                funding_script,
-                local_ckb_amount,
-                remote_ckb_amount,
+                udt_funding_script,
+                local_reserved_ckb_amount,
+                remote_reserved_ckb_amount,
+                funding_fee_rate,
             ) => {
                 assert_ne!(new, old, "new and old channel id must be different");
                 if let Some(session) = state.get_peer_session(&peer_id) {
+                    self.check_accept_channel_ckb_parameters(
+                        local_reserved_ckb_amount,
+                        remote_reserved_ckb_amount,
+                        funding_fee_rate,
+                        &udt_funding_script,
+                    )?;
                     if let Some(channel) = state.channels.remove(&old) {
                         debug!("Channel accepted: {:?} -> {:?}", old, new);
                         state.channels.insert(new, channel);
@@ -385,17 +408,14 @@ where
                                     new,
                                     Default::default(),
                                     FundingRequest {
-                                        udt_info: funding_script.as_ref().map(|type_script| {
-                                            FundingUdtInfo::new(
-                                                type_script,
-                                                local_ckb_amount,
-                                                remote_ckb_amount,
-                                            )
-                                        }),
                                         script,
+                                        udt_type_script: udt_funding_script.clone(),
                                         local_amount: local as u64,
-                                        local_fee_rate: 0,
+                                        funding_fee_rate: funding_fee_rate,
                                         remote_amount: remote as u64,
+                                        local_reserved_ckb_amount: local_reserved_ckb_amount as u64,
+                                        remote_reserved_ckb_amount: remote_reserved_ckb_amount
+                                            as u64,
                                     },
                                 ),
                             ))
@@ -728,6 +748,36 @@ where
         };
         Ok(())
     }
+
+    fn check_accept_channel_ckb_parameters(
+        &self,
+        remote_reserved_ckb_amount: u64,
+        local_reserved_ckb_amount: u64,
+        funding_fee_rate: u64,
+        udt_type_script: &Option<Script>,
+    ) -> crate::Result<()> {
+        let reserved_ckb_amount = if udt_type_script.is_some() {
+            DEFAULT_UDT_MINIMAL_CKB_AMOUNT
+        } else {
+            DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT
+        };
+
+        if remote_reserved_ckb_amount < reserved_ckb_amount
+            || local_reserved_ckb_amount < reserved_ckb_amount
+        {
+            return Err(Error::InvalidParameter(format!(
+                "Reserved CKB amount is less than the minimal amount: {}",
+                reserved_ckb_amount
+            )));
+        }
+
+        if funding_fee_rate < DEFAULT_FEE_RATE {
+            return Err(Error::InvalidParameter(
+                "Funding fee rate is less than 1".to_string(),
+            ));
+        }
+        Ok(())
+    }
 }
 
 pub struct NetworkActorState {
@@ -750,8 +800,10 @@ pub struct NetworkActorState {
     pending_channels: HashMap<OutPoint, Hash256>,
     // Used to broadcast and query network info.
     chain_actor: ActorRef<CkbChainMessage>,
-    open_channel_min_ckb_funding_amount: u128,
-    auto_accept_channel_ckb_funding_amount: u128,
+    // If the other party funding more than this amount, we will automatically accept the channel.
+    open_channel_auto_accept_min_ckb_funding_amount: u64,
+    // Tha default amount of CKB to be funded when auto accepting a channel.
+    auto_accept_channel_ckb_funding_amount: u64,
 }
 
 impl NetworkActorState {
@@ -777,6 +829,8 @@ impl NetworkActorState {
             peer_id,
             funding_amount,
             funding_udt_type_script,
+            commitment_fee_rate,
+            funding_fee_rate,
         } = open_channel;
         if let Some(udt_type_script) = funding_udt_type_script.as_ref() {
             if !check_udt_script(udt_type_script) {
@@ -785,17 +839,22 @@ impl NetworkActorState {
                 ));
             }
         }
+        // NOTE: here we only check the amount is valid, we will also check more in the `pre_start` from channel creation
+        let (_funding_amount, _reserved_ckb_amount) =
+            self.get_funding_and_reserved_amount(funding_amount, &funding_udt_type_script)?;
         let seed = self.generate_channel_seed();
         let (tx, rx) = oneshot::channel::<Hash256>();
         let channel = Actor::spawn_linked(
             None,
             ChannelActor::new(peer_id.clone(), network.clone(), store),
-            ChannelInitializationParameter::OpenChannel(
+            ChannelInitializationParameter::OpenChannel(OpenChannelParameter {
                 funding_amount,
                 seed,
                 funding_udt_type_script,
-                tx,
-            ),
+                channel_id_sender: tx,
+                commitment_fee_rate,
+                funding_fee_rate,
+            }),
             network.clone().get_cell(),
         )
         .await?
@@ -813,6 +872,7 @@ impl NetworkActorState {
             temp_channel_id,
             funding_amount,
         } = accept_channel;
+
         let (peer_id, open_channel) = self
             .to_be_accepted_channels
             .remove(&temp_channel_id)
@@ -820,6 +880,12 @@ impl NetworkActorState {
                 "No channel with temp id {:?} found",
                 &temp_channel_id
             )))?;
+
+        let (funding_amount, reserved_ckb_amount) = self.get_funding_and_reserved_amount(
+            funding_amount,
+            &open_channel.funding_udt_type_script,
+        )?;
+
         let network = self.network.clone();
         let id = open_channel.channel_id;
         if let Some(channel) = self.channels.get(&id) {
@@ -832,12 +898,13 @@ impl NetworkActorState {
         let channel = Actor::spawn_linked(
             None,
             ChannelActor::new(peer_id.clone(), network.clone(), store),
-            ChannelInitializationParameter::AcceptChannel(
+            ChannelInitializationParameter::AcceptChannel(AcceptChannelParameter {
                 funding_amount,
+                reserved_ckb_amount,
                 seed,
                 open_channel,
-                Some(tx),
-            ),
+                channel_id_sender: Some(tx),
+            }),
             network.clone().get_cell(),
         )
         .await?
@@ -850,6 +917,66 @@ impl NetworkActorState {
         self.peer_session_map.get(peer_id).cloned()
     }
 
+    fn get_funding_and_reserved_amount(
+        &self,
+        funding_amount: u128,
+        udt_type_script: &Option<Script>,
+    ) -> Result<(u128, u64), ProcessingChannelError> {
+        let reserved_ckb_amount = if udt_type_script.is_some() {
+            DEFAULT_UDT_MINIMAL_CKB_AMOUNT
+        } else {
+            DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT
+        };
+        if udt_type_script.is_none() && funding_amount < reserved_ckb_amount.into() {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "The value of the channel should be greater than the reserve amount: {}",
+                reserved_ckb_amount
+            )));
+        }
+        let funding_amount = if udt_type_script.is_some() {
+            funding_amount
+        } else {
+            funding_amount - reserved_ckb_amount as u128
+        };
+        Ok((funding_amount, reserved_ckb_amount))
+    }
+
+    fn check_open_ckb_parameters(
+        &self,
+        open_channel: &OpenChannel,
+    ) -> Result<(), ProcessingChannelError> {
+        let reserved_ckb_amount = open_channel.reserved_ckb_amount;
+        let udt_type_script = &open_channel.funding_udt_type_script;
+
+        let minimal_reserved_ckb_amount = if udt_type_script.is_some() {
+            DEFAULT_UDT_MINIMAL_CKB_AMOUNT
+        } else {
+            DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT
+        };
+
+        if reserved_ckb_amount < minimal_reserved_ckb_amount {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Remote reserved CKB amount {} is less than the minimal amount: {}",
+                reserved_ckb_amount, minimal_reserved_ckb_amount,
+            )));
+        }
+
+        if open_channel.funding_fee_rate < DEFAULT_FEE_RATE {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Funding fee rate is less than {}",
+                DEFAULT_FEE_RATE,
+            )));
+        }
+
+        if open_channel.commitment_fee_rate < DEFAULT_COMMITMENT_FEE_RATE {
+            return Err(ProcessingChannelError::InvalidParameter(format!(
+                "Commitment fee rate is less than {}",
+                DEFAULT_COMMITMENT_FEE_RATE,
+            )));
+        }
+        Ok(())
+    }
+
     async fn send_message_to_session(
         &self,
         session_id: SessionId,
@@ -955,6 +1082,8 @@ impl NetworkActorState {
         peer_id: PeerId,
         open_channel: OpenChannel,
     ) -> ProcessingChannelResult {
+        self.check_open_ckb_parameters(&open_channel)?;
+
         if let Some(udt_type_script) = &open_channel.funding_udt_type_script {
             if !check_udt_script(&udt_type_script) {
                 return Err(ProcessingChannelError::InvalidParameter(format!(
@@ -962,11 +1091,6 @@ impl NetworkActorState {
                     udt_type_script
                 )));
             }
-        } else if open_channel.funding_amount < self.open_channel_min_ckb_funding_amount {
-            return Err(ProcessingChannelError::InvalidParameter(format!(
-                "Funding amount too low: {}",
-                open_channel.funding_amount
-            )));
         }
 
         let id = open_channel.channel_id;
@@ -1186,7 +1310,8 @@ where
             to_be_accepted_channels: Default::default(),
             pending_channels: Default::default(),
             chain_actor: self.chain_actor.clone(),
-            open_channel_min_ckb_funding_amount: config.open_channel_min_ckb_funding_amount(),
+            open_channel_auto_accept_min_ckb_funding_amount: config
+                .open_channel_auto_accept_min_ckb_funding_amount(),
             auto_accept_channel_ckb_funding_amount: config.auto_accept_channel_ckb_funding_amount(),
         })
     }
diff --git a/src/ckb/schema/cfn.mol b/src/ckb/schema/cfn.mol
index 7ccefb92..ce7f9e1f 100644
--- a/src/ckb/schema/cfn.mol
+++ b/src/ckb/schema/cfn.mol
@@ -9,6 +9,7 @@ table OpenChannel {
     channel_id:                  Byte32,
     funding_udt_type_script:     ScriptOpt,
     funding_amount:              Uint128,
+    reserved_ckb_amount:          Uint64,
     funding_fee_rate:            Uint64,
     commitment_fee_rate:         Uint64,
     max_tlc_value_in_flight:     Uint128,
@@ -29,6 +30,7 @@ table OpenChannel {
 table AcceptChannel {
     channel_id:                  Byte32,
     funding_amount:              Uint128,
+    reserved_ckb_amount:          Uint64,
     max_tlc_value_in_flight:     Uint128,
     max_accept_tlcs:             Uint64,
     min_tlc_value:               Uint128,
@@ -84,7 +86,7 @@ table TxAckRBF {
 
 table Shutdown {
     channel_id: Byte32,
-    fee:        Uint128,
+    fee_rate:        Uint64,
     close_script: Script,
 }
 
diff --git a/src/ckb/test_utils.rs b/src/ckb/test_utils.rs
index 2b6e9702..26b6b5f0 100644
--- a/src/ckb/test_utils.rs
+++ b/src/ckb/test_utils.rs
@@ -194,7 +194,7 @@ impl NetworkNode {
                         None => panic!("Event emitter unexpectedly stopped"),
                         Some(event) => {
                             println!("Recevied event when waiting for specific event: {:?}", &event);
-                            if let Some(r) =  event_processor(&event) {
+                            if let Some(r) = event_processor(&event) {
                                 println!("Event ({:?}) matching filter received, exiting waiting for event loop", &event);
                                 return r;
                             }
diff --git a/src/ckb/types.rs b/src/ckb/types.rs
index 3532b214..9804ea59 100644
--- a/src/ckb/types.rs
+++ b/src/ckb/types.rs
@@ -4,6 +4,7 @@ use super::gen::cfn::{self as molecule_cfn, PubNonce as Byte66};
 use super::serde_utils::SliceHex;
 use anyhow::anyhow;
 use ckb_sdk::{Since, SinceType};
+use ckb_types::core::FeeRate;
 use ckb_types::packed::Uint64;
 use ckb_types::{
     packed::{Byte32 as MByte32, BytesVec, Script, Transaction},
@@ -457,6 +458,7 @@ pub struct OpenChannel {
     pub channel_id: Hash256,
     pub funding_udt_type_script: Option<Script>,
     pub funding_amount: u128,
+    pub reserved_ckb_amount: u64,
     pub funding_fee_rate: u64,
     pub commitment_fee_rate: u64,
     pub max_tlc_value_in_flight: u128,
@@ -474,6 +476,16 @@ pub struct OpenChannel {
     pub channel_flags: u8,
 }
 
+impl OpenChannel {
+    pub fn all_ckb_amount(&self) -> u64 {
+        if self.funding_udt_type_script.is_none() {
+            self.funding_amount as u64 + self.reserved_ckb_amount
+        } else {
+            self.reserved_ckb_amount
+        }
+    }
+}
+
 impl From<OpenChannel> for molecule_cfn::OpenChannel {
     fn from(open_channel: OpenChannel) -> Self {
         molecule_cfn::OpenChannel::new_builder()
@@ -481,6 +493,7 @@ impl From<OpenChannel> for molecule_cfn::OpenChannel {
             .channel_id(open_channel.channel_id.into())
             .funding_udt_type_script(open_channel.funding_udt_type_script.pack())
             .funding_amount(open_channel.funding_amount.pack())
+            .reserved_ckb_amount(open_channel.reserved_ckb_amount.pack())
             .funding_fee_rate(open_channel.funding_fee_rate.pack())
             .commitment_fee_rate(open_channel.commitment_fee_rate.pack())
             .max_tlc_value_in_flight(open_channel.max_tlc_value_in_flight.pack())
@@ -509,6 +522,7 @@ impl TryFrom<molecule_cfn::OpenChannel> for OpenChannel {
             channel_id: open_channel.channel_id().into(),
             funding_udt_type_script: open_channel.funding_udt_type_script().to_opt(),
             funding_amount: open_channel.funding_amount().unpack(),
+            reserved_ckb_amount: open_channel.reserved_ckb_amount().unpack(),
             funding_fee_rate: open_channel.funding_fee_rate().unpack(),
             commitment_fee_rate: open_channel.commitment_fee_rate().unpack(),
             max_tlc_value_in_flight: open_channel.max_tlc_value_in_flight().unpack(),
@@ -535,6 +549,7 @@ impl TryFrom<molecule_cfn::OpenChannel> for OpenChannel {
 pub struct AcceptChannel {
     pub channel_id: Hash256,
     pub funding_amount: u128,
+    pub reserved_ckb_amount: u64,
     pub max_tlc_value_in_flight: u128,
     pub max_accept_tlcs: u64,
     pub min_tlc_value: u128,
@@ -554,6 +569,7 @@ impl From<AcceptChannel> for molecule_cfn::AcceptChannel {
         molecule_cfn::AcceptChannel::new_builder()
             .channel_id(accept_channel.channel_id.into())
             .funding_amount(accept_channel.funding_amount.pack())
+            .reserved_ckb_amount(accept_channel.reserved_ckb_amount.pack())
             .max_tlc_value_in_flight(accept_channel.max_tlc_value_in_flight.pack())
             .max_accept_tlcs(accept_channel.max_accept_tlcs.pack())
             .min_tlc_value(accept_channel.min_tlc_value.pack())
@@ -577,6 +593,7 @@ impl TryFrom<molecule_cfn::AcceptChannel> for AcceptChannel {
         Ok(AcceptChannel {
             channel_id: accept_channel.channel_id().into(),
             funding_amount: accept_channel.funding_amount().unpack(),
+            reserved_ckb_amount: accept_channel.reserved_ckb_amount().unpack(),
             max_tlc_value_in_flight: accept_channel.max_tlc_value_in_flight().unpack(),
             max_accept_tlcs: accept_channel.max_accept_tlcs().unpack(),
             min_tlc_value: accept_channel.min_tlc_value().unpack(),
@@ -847,7 +864,7 @@ impl TryFrom<molecule_cfn::TxAckRBF> for TxAckRBF {
 pub struct Shutdown {
     pub channel_id: Hash256,
     pub close_script: Script,
-    pub fee: u128,
+    pub fee_rate: FeeRate,
 }
 
 impl From<Shutdown> for molecule_cfn::Shutdown {
@@ -855,7 +872,7 @@ impl From<Shutdown> for molecule_cfn::Shutdown {
         molecule_cfn::Shutdown::new_builder()
             .channel_id(shutdown.channel_id.into())
             .close_script(shutdown.close_script)
-            .fee(shutdown.fee.pack())
+            .fee_rate(shutdown.fee_rate.as_u64().pack())
             .build()
     }
 }
@@ -867,7 +884,7 @@ impl TryFrom<molecule_cfn::Shutdown> for Shutdown {
         Ok(Shutdown {
             channel_id: shutdown.channel_id().into(),
             close_script: shutdown.close_script(),
-            fee: shutdown.fee().unpack(),
+            fee_rate: FeeRate::from_u64(shutdown.fee_rate().unpack()),
         })
     }
 }
diff --git a/src/ckb_chain/actor.rs b/src/ckb_chain/actor.rs
index 92372bb8..de14a406 100644
--- a/src/ckb_chain/actor.rs
+++ b/src/ckb_chain/actor.rs
@@ -316,7 +316,9 @@ mod test_utils {
                                 return Ok(());
                             }
                             let current_capacity: u64 = output.capacity().unpack();
-                            let capacity = request.local_amount + current_capacity;
+                            let capacity = request.local_amount
+                                + request.local_reserved_ckb_amount
+                                + current_capacity;
                             let mut outputs_builder = outputs.as_builder();
 
                             outputs_builder
@@ -324,7 +326,9 @@ mod test_utils {
                             outputs_builder.build()
                         }
                         None => [CellOutput::new_builder()
-                            .capacity(request.local_amount.pack())
+                            .capacity(
+                                (request.local_amount + request.local_reserved_ckb_amount).pack(),
+                            )
                             .lock(request.script.clone())
                             .build()]
                         .pack(),
diff --git a/src/ckb_chain/config.rs b/src/ckb_chain/config.rs
index 6476ccf5..fb99a3fa 100644
--- a/src/ckb_chain/config.rs
+++ b/src/ckb_chain/config.rs
@@ -1,6 +1,7 @@
+use ckb_types::prelude::PackVec;
 use clap_serde_derive::ClapSerde;
-
 use secp256k1::SecretKey;
+use serde_with::serde_as;
 use std::{
     io::{ErrorKind, Read},
     path::PathBuf,
@@ -9,14 +10,13 @@ use std::{
 use std::str::FromStr;
 
 use ckb_types::prelude::Builder;
+use ckb_types::prelude::Pack;
 use ckb_types::H256;
 use ckb_types::{
     core::DepType,
     packed::{CellDep, OutPoint},
 };
 use ckb_types::{core::ScriptHashType, packed::CellDepVec};
-use ckb_types::{packed::Script, prelude::Pack};
-use clap::ValueEnum;
 use clap_serde_derive::clap::{self};
 use molecule::prelude::Entity;
 use serde::Deserialize;
@@ -48,10 +48,9 @@ pub struct CkbChainConfig {
         name = "CKB_UDT_WHITELIST",
         long = "ckb-udt-whitelist",
         env,
-        value_parser,
         help = "a list of supported UDT scripts"
     )]
-    udt_whitelist: Option<UdtInfos>,
+    pub udt_whitelist: Option<UdtCfgInfos>,
 }
 
 impl CkbChainConfig {
@@ -104,40 +103,32 @@ impl CkbChainConfig {
             std::io::Error::new(ErrorKind::InvalidData, "invalid secret key data").into()
         })
     }
-
-    pub fn udt_whitelist(&self) -> Vec<UdtScriptInfo> {
-        let mut udt_whitelist: Vec<UdtScriptInfo> = vec![];
-        if let Some(udt_infos) = &self.udt_whitelist {
-            for udt_info in udt_infos.0.iter() {
-                let cell_deps: Vec<CellDep> = udt_info
-                    .cell_deps
-                    .iter()
-                    .map(|dep| CellDep::from(dep))
-                    .collect();
-                let cell_deps = CellDepVec::new_builder().set(cell_deps).build();
-                let script: Script = (&udt_info.script).into();
-                let arg_pattern = udt_info.script.args.clone();
-                udt_whitelist.push((udt_info.name.clone(), script, arg_pattern, cell_deps));
-            }
-        }
-        return udt_whitelist;
-    }
 }
 
-#[derive(Debug, Clone, Copy, ValueEnum, Deserialize, PartialEq, Eq)]
-enum UdtScriptHashType {
-    Type,
-    Data,
-    Data1,
-    Data2,
-}
+serde_with::serde_conv!(
+    ScriptHashTypeWrapper,
+    ScriptHashType,
+    |_: &ScriptHashType| { panic!("no support to serialize") },
+    |s: String| {
+        let v = match s.to_lowercase().as_str() {
+            "type" => ScriptHashType::Type,
+            "data" => ScriptHashType::Data,
+            "data1" => ScriptHashType::Data1,
+            "data2" => ScriptHashType::Data2,
+            _ => return Err("invalid hash type"),
+        };
+        Ok(v)
+    }
+);
 
+#[serde_as]
 #[derive(Deserialize, Debug, Clone)]
-struct UdtScript {
-    code_hash: H256,
-    hash_type: UdtScriptHashType,
+pub struct UdtScript {
+    pub code_hash: H256,
+    #[serde_as(as = "ScriptHashTypeWrapper")]
+    pub hash_type: ScriptHashType,
     /// args may be used in pattern matching
-    args: String,
+    pub args: String,
 }
 
 #[derive(Deserialize, Clone, Debug)]
@@ -147,19 +138,36 @@ struct UdtCellDep {
     index: u32,
 }
 
+serde_with::serde_conv!(
+    CellDepVecWrapper,
+    CellDepVec,
+    |_: &CellDepVec| { panic!("no support to serialize") },
+    |s: Vec<UdtCellDep>| -> Result<CellDepVec, &'static str> {
+        let cell_deps: Vec<CellDep> = s.iter().map(|dep| CellDep::from(dep)).collect();
+        Ok(cell_deps.pack())
+    }
+);
+
+#[serde_as]
 #[derive(Deserialize, Clone, Debug)]
-struct UdtInfo {
-    name: String,
-    script: UdtScript,
-    cell_deps: Vec<UdtCellDep>,
+pub struct UdtArgInfo {
+    pub name: String,
+    pub script: UdtScript,
+    pub auto_accept_amount: Option<u128>,
+    #[serde_as(as = "CellDepVecWrapper")]
+    pub cell_deps: CellDepVec,
 }
 
 #[derive(Deserialize, Clone, Debug)]
-struct UdtInfos(Vec<UdtInfo>);
+pub struct UdtCfgInfos(pub Vec<UdtArgInfo>);
 
-pub type UdtScriptInfo = (String, Script, String, CellDepVec);
+impl Default for UdtCfgInfos {
+    fn default() -> Self {
+        UdtCfgInfos(Vec::new())
+    }
+}
 
-impl FromStr for UdtInfos {
+impl FromStr for UdtCfgInfos {
     type Err = serde_json::Error;
 
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
@@ -167,26 +175,6 @@ impl FromStr for UdtInfos {
     }
 }
 
-impl From<&UdtScript> for Script {
-    fn from(script: &UdtScript) -> Self {
-        let _type = match script.hash_type {
-            UdtScriptHashType::Data => ScriptHashType::Data,
-            UdtScriptHashType::Data1 => ScriptHashType::Data1,
-            UdtScriptHashType::Data2 => ScriptHashType::Data2,
-            UdtScriptHashType::Type => ScriptHashType::Type,
-        };
-        let mut builder = Script::new_builder()
-            .code_hash(script.code_hash.pack())
-            .hash_type(_type.into());
-
-        let arg = script.args.strip_prefix("0x").unwrap_or(&script.args);
-        if let Ok(packed_args) = H256::from_str(arg) {
-            builder = builder.args(packed_args.as_bytes().pack());
-        }
-        builder.build()
-    }
-}
-
 impl From<&UdtCellDep> for CellDep {
     fn from(cell_dep: &UdtCellDep) -> Self {
         let dep_type = match cell_dep.dep_type.as_str() {
diff --git a/src/ckb_chain/contracts.rs b/src/ckb_chain/contracts.rs
index 2616991b..516cb35d 100644
--- a/src/ckb_chain/contracts.rs
+++ b/src/ckb_chain/contracts.rs
@@ -17,7 +17,10 @@ use ckb_testtool::{ckb_types::bytes::Bytes, context::Context};
 #[cfg(test)]
 use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 
-use super::config::UdtScriptInfo;
+use super::{
+    config::{UdtArgInfo, UdtCfgInfos},
+    CkbChainConfig,
+};
 
 #[cfg(test)]
 #[derive(Clone, Debug)]
@@ -99,7 +102,7 @@ impl MockContext {
             contracts_context: Arc::new(ContractsInfo {
                 contract_default_scripts: map,
                 script_cell_deps,
-                udt_whitelist: vec![],
+                udt_whitelist: UdtCfgInfos::default(),
             }),
         };
         debug!("Created mock context to test transactions.");
@@ -129,7 +132,7 @@ pub enum Contract {
 struct ContractsInfo {
     contract_default_scripts: HashMap<Contract, Script>,
     script_cell_deps: HashMap<Contract, CellDepVec>,
-    udt_whitelist: Vec<UdtScriptInfo>,
+    udt_whitelist: UdtCfgInfos,
 }
 
 #[derive(Clone)]
@@ -218,7 +221,7 @@ impl From<MockContext> for ContractsContext {
 }
 
 impl ContractsContext {
-    pub fn new(network: CkbNetwork, udt_whitelist: Vec<UdtScriptInfo>) -> Self {
+    pub fn new(network: CkbNetwork, udt_whitelist: UdtCfgInfos) -> Self {
         match network {
             #[cfg(test)]
             CkbNetwork::Mocknet => {
@@ -429,7 +432,7 @@ impl ContractsContext {
         res.build()
     }
 
-    fn get_udt_whitelist(&self) -> &Vec<UdtScriptInfo> {
+    fn get_udt_whitelist(&self) -> &UdtCfgInfos {
         match self {
             #[cfg(test)]
             Self::Mock(mock) => &mock.contracts_context.udt_whitelist,
@@ -447,15 +450,16 @@ impl ContractsContext {
             .build()
     }
 
-    pub(crate) fn get_udt_cell_deps(&self, udt_script: &Script) -> Option<CellDepVec> {
-        for (_name, script, arg_pattern, cell_deps) in self.get_udt_whitelist().iter() {
-            if script.code_hash() == udt_script.code_hash()
-                && script.hash_type() == udt_script.hash_type()
+    pub(crate) fn get_udt_info(&self, udt_script: &Script) -> Option<&UdtArgInfo> {
+        for udt in &self.get_udt_whitelist().0 {
+            let _type: ScriptHashType = udt_script.hash_type().try_into().expect("valid hash type");
+            if udt.script.code_hash.pack() == udt_script.code_hash()
+                && udt.script.hash_type == _type
             {
                 let args = format!("0x{:x}", udt_script.args().raw_data());
-                let pattern = Regex::new(arg_pattern).expect("invalid expressio");
+                let pattern = Regex::new(&udt.script.args).expect("invalid expressio");
                 if pattern.is_match(&args) {
-                    return Some(cell_deps.clone());
+                    return Some(&udt);
                 }
             }
         }
@@ -465,13 +469,16 @@ impl ContractsContext {
 
 pub fn init_contracts_context(
     network: Option<CkbNetwork>,
-    udt_whitelist: Option<Vec<UdtScriptInfo>>,
+    ckb_chain_config: Option<&CkbChainConfig>,
 ) -> &'static ContractsContext {
     static INSTANCE: once_cell::sync::OnceCell<ContractsContext> = once_cell::sync::OnceCell::new();
+    let udt_whitelist = ckb_chain_config
+        .map(|config| config.udt_whitelist.clone())
+        .unwrap_or_default();
     INSTANCE.get_or_init(|| {
         ContractsContext::new(
             network.unwrap_or(DEFAULT_CONTRACT_NETWORK),
-            udt_whitelist.unwrap_or(vec![]),
+            udt_whitelist.unwrap_or_default(),
         )
     });
     INSTANCE.get().unwrap()
@@ -490,14 +497,25 @@ pub fn get_cell_deps_by_contracts(contracts: Vec<Contract>) -> CellDepVec {
     init_contracts_context(None, None).get_cell_deps(contracts)
 }
 
+fn get_udt_info(script: &Script) -> Option<&UdtArgInfo> {
+    init_contracts_context(None, None).get_udt_info(script)
+}
+
 pub fn check_udt_script(script: &Script) -> bool {
-    init_contracts_context(None, None)
-        .get_udt_cell_deps(script)
-        .is_some()
+    get_udt_info(script).is_some()
 }
 
 pub fn get_udt_cell_deps(script: &Script) -> Option<CellDepVec> {
-    init_contracts_context(None, None).get_udt_cell_deps(script)
+    get_udt_info(script).map(|udt| udt.cell_deps.clone())
+}
+
+pub fn is_udt_type_auto_accept(script: &Script, amount: u128) -> bool {
+    if let Some(udt_info) = get_udt_info(script) {
+        if let Some(auto_accept_amount) = udt_info.auto_accept_amount {
+            return amount >= auto_accept_amount;
+        }
+    }
+    false
 }
 
 pub fn get_cell_deps(contracts: Vec<Contract>, udt_script: &Option<Script>) -> CellDepVec {
diff --git a/src/ckb_chain/funding/funding_tx.rs b/src/ckb_chain/funding/funding_tx.rs
index 05fded76..efe97c8d 100644
--- a/src/ckb_chain/funding/funding_tx.rs
+++ b/src/ckb_chain/funding/funding_tx.rs
@@ -51,47 +51,24 @@ impl From<Transaction> for FundingTx {
     }
 }
 
-#[allow(dead_code)]
-#[serde_as]
-#[derive(Clone, Debug, Default, Deserialize)]
-pub struct FundingUdtInfo {
-    /// The UDT type script
-    #[serde_as(as = "EntityHex")]
-    pub type_script: packed::Script,
-    /// CKB amount to be provided by the local party.
-    pub local_ckb_amount: u64,
-    /// CKB amount to be provided by the remote party.
-    pub remote_ckb_amount: u64,
-}
-
-impl FundingUdtInfo {
-    pub fn new(
-        type_script: &packed::Script,
-        local_ckb_amount: u64,
-        remote_ckb_amount: u64,
-    ) -> Self {
-        Self {
-            type_script: type_script.clone(),
-            local_ckb_amount,
-            remote_ckb_amount,
-        }
-    }
-}
-
 #[serde_as]
 #[derive(Clone, Debug, Default, Deserialize)]
 pub struct FundingRequest {
-    /// UDT channel info
-    pub udt_info: Option<FundingUdtInfo>,
     /// The funding cell lock script args
     #[serde_as(as = "EntityHex")]
     pub script: Script,
+    #[serde_as(as = "Option<EntityHex>")]
+    pub udt_type_script: Option<packed::Script>,
     /// Assets amount to be provided by the local party
     pub local_amount: u64,
     /// Fee to be provided by the local party
-    pub local_fee_rate: u64,
+    pub funding_fee_rate: u64,
     /// Assets amount to be provided by the remote party
     pub remote_amount: u64,
+    /// CKB amount to be provided by the local party.
+    pub local_reserved_ckb_amount: u64,
+    /// CKB amount to be provided by the remote party.
+    pub remote_reserved_ckb_amount: u64,
 }
 
 // TODO: trace locked cells
@@ -152,11 +129,17 @@ impl TxBuilder for FundingTxBuilder {
             None => packed::Transaction::default().as_advanced_builder(),
         };
 
+        // set a placeholder_witness for calculating transaction fee according to transaction size
+        let placeholder_witness = packed::WitnessArgs::new_builder()
+            .lock(Some(molecule::bytes::Bytes::from(vec![0u8; 170])).pack())
+            .build();
+
         let tx_builder = builder
             .set_inputs(inputs)
             .set_outputs(outputs)
             .set_outputs_data(outputs_data)
-            .set_cell_deps(cell_deps.into_iter().collect());
+            .set_cell_deps(cell_deps.into_iter().collect())
+            .set_witnesses(vec![placeholder_witness.as_bytes().pack()]);
         warn!("tx_builder: {:?}", tx_builder);
         let tx = tx_builder.build();
         Ok(tx)
@@ -173,23 +156,23 @@ impl FundingTxBuilder {
             .map(|tx| !tx.outputs().is_empty())
             .unwrap_or(false);
 
-        match self.request.udt_info {
-            Some(ref udt_info) => {
+        match self.request.udt_type_script {
+            Some(ref udt_type_script) => {
                 let mut udt_amount = self.request.local_amount as u128;
-                let mut ckb_amount = udt_info.local_ckb_amount;
+                let mut ckb_amount = self.request.local_reserved_ckb_amount;
 
                 // To make tx building easier, do not include the amount not funded yet in the
                 // funding cell.
                 if remote_funded {
                     udt_amount += self.request.remote_amount as u128;
                     ckb_amount = ckb_amount
-                        .checked_add(udt_info.remote_ckb_amount)
+                        .checked_add(self.request.remote_reserved_ckb_amount)
                         .ok_or(FundingError::InvalidChannel)?;
                 }
 
                 let udt_output = packed::CellOutput::new_builder()
                     .capacity(Capacity::shannons(ckb_amount).pack())
-                    .type_(Some(udt_info.type_script.clone()).pack())
+                    .type_(Some(udt_type_script.clone()).pack())
                     .lock(self.context.funding_cell_lock_script.clone())
                     .build();
                 let mut data = BytesMut::with_capacity(16);
@@ -199,10 +182,13 @@ impl FundingTxBuilder {
                 Ok((udt_output, data.freeze().pack()))
             }
             None => {
-                let mut ckb_amount = self.request.local_amount;
+                let mut ckb_amount =
+                    self.request.local_amount + self.request.local_reserved_ckb_amount;
                 if remote_funded {
                     ckb_amount = ckb_amount
-                        .checked_add(self.request.remote_amount)
+                        .checked_add(
+                            self.request.remote_amount + self.request.remote_reserved_ckb_amount,
+                        )
                         .ok_or(FundingError::InvalidChannel)?;
                 }
                 let ckb_output = packed::CellOutput::new_builder()
@@ -224,12 +210,12 @@ impl FundingTxBuilder {
         cell_deps: &mut HashSet<packed::CellDep>,
     ) -> Result<(), TxBuilderError> {
         let udt_amount = self.request.local_amount as u128;
-        let udt_info = match &self.request.udt_info {
-            Some(ref udt_info) if self.request.local_amount > 0 => udt_info,
-            _ => return Ok(()),
-        };
+        // return early if we don't need to build UDT cell
+        if self.request.udt_type_script.is_none() || udt_amount == 0 {
+            return Ok(());
+        }
 
-        let udt_type_script = udt_info.type_script.clone();
+        let udt_type_script = self.request.udt_type_script.clone().unwrap();
         let owner = self.context.funding_source_lock_script.clone();
         let mut found_udt_amount = 0;
 
@@ -306,10 +292,18 @@ impl FundingTxBuilder {
         let sender = self.context.funding_source_lock_script.clone();
         // Build CapacityBalancer
         let placeholder_witness = packed::WitnessArgs::new_builder()
-            .lock(Some(molecule::bytes::Bytes::from(vec![0u8; 65])).pack())
+            .lock(Some(molecule::bytes::Bytes::from(vec![0u8; 170])).pack())
             .build();
-        let balancer =
-            CapacityBalancer::new_simple(sender, placeholder_witness, self.request.local_fee_rate);
+
+        warn!(
+            "request.funding_fee_rate: {}",
+            self.request.funding_fee_rate
+        );
+        let balancer = CapacityBalancer::new_simple(
+            sender,
+            placeholder_witness,
+            self.request.funding_fee_rate,
+        );
 
         let ckb_client = CkbRpcClient::new(&self.context.rpc_url);
         let cell_dep_resolver = {
diff --git a/src/ckb_chain/funding/mod.rs b/src/ckb_chain/funding/mod.rs
index 7d51c777..6f1f6d64 100644
--- a/src/ckb_chain/funding/mod.rs
+++ b/src/ckb_chain/funding/mod.rs
@@ -1,4 +1,4 @@
 mod funding_tx;
 
 pub(crate) use funding_tx::FundingContext;
-pub use funding_tx::{FundingRequest, FundingTx, FundingUdtInfo};
+pub use funding_tx::{FundingRequest, FundingTx};
diff --git a/src/ckb_chain/mod.rs b/src/ckb_chain/mod.rs
index 13c9b1cf..07092830 100644
--- a/src/ckb_chain/mod.rs
+++ b/src/ckb_chain/mod.rs
@@ -6,7 +6,7 @@ mod funding;
 pub use actor::{CkbChainActor, CkbChainMessage, TraceTxRequest};
 pub use config::{CkbChainConfig, DEFAULT_CKB_CHAIN_BASE_DIR_NAME};
 pub use error::{CkbChainError, FundingError};
-pub use funding::{FundingRequest, FundingTx, FundingUdtInfo};
+pub use funding::{FundingRequest, FundingTx};
 
 #[cfg(test)]
 pub use actor::{submit_tx, MockChainActor};
diff --git a/src/errors.rs b/src/errors.rs
index 563f16a0..e485fea3 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -35,6 +35,8 @@ pub enum Error {
     CkbInvoiceError(#[from] InvoiceError),
     #[error("Funding error: {0}")]
     FundingError(#[from] FundingError),
+    #[error("InvalidParameter: {0}")]
+    InvalidParameter(String),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
diff --git a/src/main.rs b/src/main.rs
index e95fbe9d..9d0bb673 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -50,8 +50,7 @@ pub async fn main() {
             let ckb_chain_config = config.ckb_chain.expect("ckb-chain service is required for ckb service. \
             Add ckb-chain service to the services list in the config file and relevant configuration to the ckb_chain section of the config file.");
 
-            let _ =
-                init_contracts_context(ckb_config.network, Some(ckb_chain_config.udt_whitelist()));
+            let _ = init_contracts_context(ckb_config.network, Some(&ckb_chain_config));
 
             let ckb_chain_actor = Actor::spawn_linked(
                 Some("ckb-chain".to_string()),
diff --git a/src/rpc/channel.rs b/src/rpc/channel.rs
index b69cdd30..b6d80932 100644
--- a/src/rpc/channel.rs
+++ b/src/rpc/channel.rs
@@ -10,6 +10,7 @@ use crate::ckb::{
 };
 use crate::{handle_actor_call, handle_actor_cast, log_and_error};
 use ckb_jsonrpc_types::Script;
+use ckb_types::core::FeeRate;
 use jsonrpsee::{
     core::async_trait,
     proc_macros::rpc,
@@ -29,6 +30,10 @@ pub struct OpenChannelParams {
     #[serde_as(as = "U128Hex")]
     pub funding_amount: u128,
     pub funding_udt_type_script: Option<Script>,
+    #[serde_as(as = "Option<U64Hex>")]
+    pub commitment_fee_rate: Option<u64>,
+    #[serde_as(as = "Option<U64Hex>")]
+    pub funding_fee_rate: Option<u64>,
 }
 
 #[derive(Clone, Serialize)]
@@ -124,8 +129,8 @@ pub enum RemoveTlcReason {
 pub struct ShutdownChannelParams {
     pub channel_id: Hash256,
     pub close_script: Script,
-    #[serde_as(as = "U128Hex")]
-    pub fee: u128,
+    #[serde_as(as = "U64Hex")]
+    pub fee_rate: u64,
 }
 
 #[rpc(server)]
@@ -194,6 +199,8 @@ where
                         .funding_udt_type_script
                         .clone()
                         .map(|s| s.into()),
+                    commitment_fee_rate: params.commitment_fee_rate,
+                    funding_fee_rate: params.funding_fee_rate,
                 },
                 rpc_reply,
             ))
@@ -322,8 +329,8 @@ where
                     channel_id: params.channel_id,
                     command: ChannelCommand::Shutdown(
                         ShutdownCommand {
-                            close_script: params.clone().close_script.into(),
-                            fee: params.fee,
+                            close_script: params.close_script.clone().into(),
+                            fee_rate: FeeRate::from_u64(params.fee_rate),
                         },
                         rpc_reply,
                     ),
diff --git a/tests/bruno/e2e/3-nodes-transfer/21-node1-send-shutdown-channel-1.bru b/tests/bruno/e2e/3-nodes-transfer/21-node1-send-shutdown-channel-1.bru
index 4a8ff1bd..d284d2a7 100644
--- a/tests/bruno/e2e/3-nodes-transfer/21-node1-send-shutdown-channel-1.bru
+++ b/tests/bruno/e2e/3-nodes-transfer/21-node1-send-shutdown-channel-1.bru
@@ -28,7 +28,7 @@ body:json {
           "hash_type": "data",
           "args": "0x0101010101010101010101010101010101010101"
         },
-        "fee": "0xbebc200"
+        "fee_rate": "0x3FC"
       }
     ]
   }
diff --git a/tests/bruno/e2e/3-nodes-transfer/22-node2-send-shutdown-channel-1.bru b/tests/bruno/e2e/3-nodes-transfer/22-node2-send-shutdown-channel-1.bru
index ac678407..976927e7 100644
--- a/tests/bruno/e2e/3-nodes-transfer/22-node2-send-shutdown-channel-1.bru
+++ b/tests/bruno/e2e/3-nodes-transfer/22-node2-send-shutdown-channel-1.bru
@@ -28,7 +28,7 @@ body:json {
           "hash_type": "data",
           "args": "0x0101010101010101010101010101010101010101"
         },
-        "fee": "0xbebc200"
+        "fee_rate": "0x3FC"
       }
     ]
   }
diff --git a/tests/bruno/e2e/3-nodes-transfer/23-node2-send-shutdown-channel-2.bru b/tests/bruno/e2e/3-nodes-transfer/23-node2-send-shutdown-channel-2.bru
index 5bee814b..fe8d969a 100644
--- a/tests/bruno/e2e/3-nodes-transfer/23-node2-send-shutdown-channel-2.bru
+++ b/tests/bruno/e2e/3-nodes-transfer/23-node2-send-shutdown-channel-2.bru
@@ -28,7 +28,7 @@ body:json {
           "hash_type": "data",
           "args": "0x0101010101010101010101010101010101010101"
         },
-        "fee": "0xbebc200"
+        "fee_rate": "0x3FC"
       }
     ]
   }
diff --git a/tests/bruno/e2e/3-nodes-transfer/24-node3-send-shutdown-channel-2.bru b/tests/bruno/e2e/3-nodes-transfer/24-node3-send-shutdown-channel-2.bru
index d4eb4c0a..335ce880 100644
--- a/tests/bruno/e2e/3-nodes-transfer/24-node3-send-shutdown-channel-2.bru
+++ b/tests/bruno/e2e/3-nodes-transfer/24-node3-send-shutdown-channel-2.bru
@@ -28,7 +28,7 @@ body:json {
           "hash_type": "data",
           "args": "0x0101010101010101010101010101010101010101"
         },
-        "fee": "0xbebc200"
+        "fee_rate": "0x3FC"
       }
     ]
   }
diff --git a/tests/bruno/e2e/open-use-close-a-channel/08-add-tlc-from-NODE1.bru b/tests/bruno/e2e/open-use-close-a-channel/08-add-tlc-from-NODE1.bru
index d73164b6..9bdff254 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/08-add-tlc-from-NODE1.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/08-add-tlc-from-NODE1.bru
@@ -32,12 +32,14 @@ body:json {
 }
 
 assert {
-  res.body.error: isUndefined
-  res.body.result.tlc_id: isDefined
+  res.body.error: isDefined
+  res.body.result: isUndefined
 }
 
 script:post-response {
   // Sleep for sometime to make sure current operation finishes before next request starts.
   await new Promise(r => setTimeout(r, 100));
-  bru.setVar("TLC_ID2", res.body.result.tlc_id);
+  // Node 1 only holds 62 CKB as reserved amount, there is no extra amount for TLC, so the request will fail.
+  // Set the TLC ID into a wrong one, than step 14 will fail as expected.
+  bru.setVar("TLC_ID2", "0x3200");
 }
diff --git a/tests/bruno/e2e/open-use-close-a-channel/09-add-tlc-from-NODE3.bru b/tests/bruno/e2e/open-use-close-a-channel/09-add-tlc-from-NODE3.bru
index 55a524a7..094a3eb9 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/09-add-tlc-from-NODE3.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/09-add-tlc-from-NODE3.bru
@@ -37,6 +37,7 @@ assert {
 }
 
 script:post-response {
+  console.log("step 9 response: ", res.body);
   // Sleep for sometime to make sure current operation finishes before next request starts.
   await new Promise(r => setTimeout(r, 100));
   bru.setVar("TLC_ID3", res.body.result.tlc_id);
diff --git a/tests/bruno/e2e/open-use-close-a-channel/19-remove-tlc-error-from-NODE1.bru b/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-amount-err.bru
similarity index 67%
rename from tests/bruno/e2e/open-use-close-a-channel/19-remove-tlc-error-from-NODE1.bru
rename to tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-amount-err.bru
index b7f087ff..1dc88d01 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/19-remove-tlc-error-from-NODE1.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-amount-err.bru
@@ -1,7 +1,7 @@
 meta {
-  name: remove tlc from NODE1
+  name: add tlc from NODE1
   type: http
-  seq: 19
+  seq: 10
 }
 
 post {
@@ -19,14 +19,13 @@ body:json {
   {
     "id": "42",
     "jsonrpc": "2.0",
-    "method": "remove_tlc",
+    "method": "add_tlc",
     "params": [
       {
         "channel_id": "{{CHANNEL_ID}}",
-        "tlc_id": "{{TLC_ID5}}",
-        "reason": {
-          "payment_preimage": "0x0000000000000000000000000000000000000000000000000000000000000042"
-        }
+        "amount": "0x0",
+        "payment_hash": "0xcb7bce98a778f130d34da522623d7e56705bddfe0dc4781bd2331211134a19a5",
+        "expiry": 40
       }
     ]
   }
@@ -38,7 +37,7 @@ assert {
 }
 
 script:post-response {
+  console.log("step 10 response: ", res.body);
   // Sleep for sometime to make sure current operation finishes before next request starts.
   await new Promise(r => setTimeout(r, 100));
-  console.log(res.body);
 }
diff --git a/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1.bru b/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-balance-err.bru
similarity index 85%
rename from tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1.bru
rename to tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-balance-err.bru
index d587ba7f..9f557b11 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/10-add-tlc-from-NODE1-balance-err.bru
@@ -32,12 +32,12 @@ body:json {
 }
 
 assert {
-  res.body.error: isUndefined
-  res.body.result.tlc_id: isDefined
+  res.body.error: isDefined
+  res.body.result: isUndefined
 }
 
 script:post-response {
+  console.log("step 10 response: ", res.body);
   // Sleep for sometime to make sure current operation finishes before next request starts.
   await new Promise(r => setTimeout(r, 100));
-  bru.setVar("TLC_ID4", res.body.result.tlc_id);
 }
diff --git a/tests/bruno/e2e/open-use-close-a-channel/14-remove-tlc-from-NODE3.bru b/tests/bruno/e2e/open-use-close-a-channel/14-remove-tlc-from-NODE3.bru
index 7b169f58..dd358ac0 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/14-remove-tlc-from-NODE3.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/14-remove-tlc-from-NODE3.bru
@@ -33,11 +33,12 @@ body:json {
 }
 
 assert {
-  res.body.error: isUndefined
-  res.body.result: isNull
+  res.body.error: isDefined
+  res.body.result: isUndefined
 }
 
 script:post-response {
+  console.log("step 14: ", res.body);
   // Sleep for sometime to make sure current operation finishes before next request starts.
   await new Promise(r => setTimeout(r, 100));
 }
diff --git a/tests/bruno/e2e/open-use-close-a-channel/15-shutdown-from-NODE1.bru b/tests/bruno/e2e/open-use-close-a-channel/15-shutdown-from-NODE1.bru
index 123bac3f..bef583df 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/15-shutdown-from-NODE1.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/15-shutdown-from-NODE1.bru
@@ -28,7 +28,7 @@ body:json {
           "hash_type": "data",
           "args": "0x0101010101010101010101010101010101010101"
         },
-        "fee": "0xbebc200"
+        "fee_rate": "0x3FC"
       }
     ]
   }
diff --git a/tests/bruno/e2e/open-use-close-a-channel/16-shutdown-from-NODE3.bru b/tests/bruno/e2e/open-use-close-a-channel/16-shutdown-from-NODE3.bru
index ba2116ad..da14826a 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/16-shutdown-from-NODE3.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/16-shutdown-from-NODE3.bru
@@ -28,7 +28,7 @@ body:json {
           "hash_type": "data",
           "args": "0x0202020202020202020202020202020202020202"
         },
-        "fee": "0x0"
+        "fee_rate": "0x3FC"
       }
     ]
   }
diff --git a/tests/bruno/e2e/open-use-close-a-channel/18-remove-tlc-from-NODE3.bru b/tests/bruno/e2e/open-use-close-a-channel/18-remove-tlc-from-NODE3.bru
index 4306509b..d51641c1 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/18-remove-tlc-from-NODE3.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/18-remove-tlc-from-NODE3.bru
@@ -23,7 +23,7 @@ body:json {
     "params": [
       {
         "channel_id": "{{CHANNEL_ID}}",
-        "tlc_id": "{{TLC_ID4}}",
+        "tlc_id": "{{TLC_ID3}}",
         "reason": {
           "error_code": "0x2a"
         }
@@ -33,11 +33,13 @@ body:json {
 }
 
 assert {
-  res.body.error: isUndefined
-  res.body.result: isNull
+  res.body.error: isDefined
+  res.body.result: isUndefined
 }
 
 script:post-response {
+    console.log("step 18: ", res.body);
+  // This request is remove a TLC which already removed in previous step.
   // Sleep for sometime to make sure current operation finishes before next request starts.
   await new Promise(r => setTimeout(r, 100));
 }
diff --git a/tests/bruno/e2e/reestablish/15-shutdown-from-NODE1.bru b/tests/bruno/e2e/reestablish/15-shutdown-from-NODE1.bru
index 7148cc43..bef583df 100644
--- a/tests/bruno/e2e/reestablish/15-shutdown-from-NODE1.bru
+++ b/tests/bruno/e2e/reestablish/15-shutdown-from-NODE1.bru
@@ -28,7 +28,7 @@ body:json {
           "hash_type": "data",
           "args": "0x0101010101010101010101010101010101010101"
         },
-        "fee": "0x0"
+        "fee_rate": "0x3FC"
       }
     ]
   }
diff --git a/tests/bruno/e2e/reestablish/16-shutdown-from-NODE3.bru b/tests/bruno/e2e/reestablish/16-shutdown-from-NODE3.bru
index 6a43beb1..da14826a 100644
--- a/tests/bruno/e2e/reestablish/16-shutdown-from-NODE3.bru
+++ b/tests/bruno/e2e/reestablish/16-shutdown-from-NODE3.bru
@@ -28,7 +28,7 @@ body:json {
           "hash_type": "data",
           "args": "0x0202020202020202020202020202020202020202"
         },
-        "fee": "0xbebc200"
+        "fee_rate": "0x3FC"
       }
     ]
   }
diff --git a/tests/bruno/e2e/udt/02-node1-node2-open-channel-amount-err.bru b/tests/bruno/e2e/udt/02-node1-node2-open-channel-amount-err.bru
new file mode 100644
index 00000000..1f63aeef
--- /dev/null
+++ b/tests/bruno/e2e/udt/02-node1-node2-open-channel-amount-err.bru
@@ -0,0 +1,48 @@
+meta {
+  name: Node1 open a channel to Node2, run a specific UDT type we don't have enough cells, (args is not right)
+  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": "open_channel",
+    "params": [
+      {
+        "peer_id": "{{NODE2_PEERID}}",
+          "funding_amount": "0x4b0",
+          "funding_udt_type_script": {
+            "code_hash": "{{UDT_CODE_HASH}}",
+            "hash_type": "data1",
+            "args": "0x32e555f3ff8e135cece1351a6a2971518392c1e30375c1e006ad0ce8eac0794a"
+          }
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result.temporary_channel_id: isDefined
+}
+
+script:post-response {
+  await new Promise(r => setTimeout(r, 1000));
+  console.log("N1N2 response: ", res.body);
+  console.log("N1N2 response: ", res.body.result.temporary_channel_id);
+  bru.setVar("N1N2_TEMP_CHANNEL_ID", res.body.result.temporary_channel_id);
+}
diff --git a/tests/bruno/e2e/udt/03-node2-list-channel-empty.bru b/tests/bruno/e2e/udt/03-node2-list-channel-empty.bru
new file mode 100644
index 00000000..8cebf50d
--- /dev/null
+++ b/tests/bruno/e2e/udt/03-node2-list-channel-empty.bru
@@ -0,0 +1,43 @@
+meta {
+  name: get channel list from node2
+  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": "list_channels",
+    "params": [
+      {
+        "peer_id": "{{NODE1_PEERID}}"
+      }
+    ]
+  }
+}
+
+assert {
+  res.body.error: isUndefined
+  res.body.result.channels: isDefined
+}
+
+script:post-response {
+  // Sleep for sometime to make sure current operation finishes before next request starts.
+  await new Promise(r => setTimeout(r, 2000));
+  console.log("accept channel result: ", res.body);
+  if (res.body.result.channels.length != 0) {
+    throw new Error("Assertion failed: expect there is no channel");
+  }
+}
diff --git a/tests/bruno/e2e/udt/02-node1-node2-open-channel.bru b/tests/bruno/e2e/udt/04-node1-node2-open-channel.bru
similarity index 99%
rename from tests/bruno/e2e/udt/02-node1-node2-open-channel.bru
rename to tests/bruno/e2e/udt/04-node1-node2-open-channel.bru
index 2c8a0b04..a26e5a25 100644
--- a/tests/bruno/e2e/udt/02-node1-node2-open-channel.bru
+++ b/tests/bruno/e2e/udt/04-node1-node2-open-channel.bru
@@ -1,7 +1,7 @@
 meta {
   name: Node1 open a channel to Node2
   type: http
-  seq: 2
+  seq: 4
 }
 
 post {
diff --git a/tests/bruno/e2e/udt/03-node2-accept-channel.bru b/tests/bruno/e2e/udt/05-node2-list-channel.bru
similarity index 98%
rename from tests/bruno/e2e/udt/03-node2-accept-channel.bru
rename to tests/bruno/e2e/udt/05-node2-list-channel.bru
index 99bb57c2..91fe1e09 100644
--- a/tests/bruno/e2e/udt/03-node2-accept-channel.bru
+++ b/tests/bruno/e2e/udt/05-node2-list-channel.bru
@@ -1,7 +1,7 @@
 meta {
   name: get channel list from node2
   type: http
-  seq: 3
+  seq: 5
 }
 
 post {
diff --git a/tests/bruno/e2e/udt/04-ckb-generate-blocks.bru b/tests/bruno/e2e/udt/06-ckb-generate-blocks.bru
similarity index 99%
rename from tests/bruno/e2e/udt/04-ckb-generate-blocks.bru
rename to tests/bruno/e2e/udt/06-ckb-generate-blocks.bru
index 159a5fff..cd65f8e5 100644
--- a/tests/bruno/e2e/udt/04-ckb-generate-blocks.bru
+++ b/tests/bruno/e2e/udt/06-ckb-generate-blocks.bru
@@ -1,7 +1,7 @@
 meta {
   name: generate a few blocks for channel 2
   type: http
-  seq: 4
+  seq: 6
 }
 
 post {
diff --git a/tests/bruno/e2e/udt/05-node2-gen-invoice.bru b/tests/bruno/e2e/udt/07-node2-gen-invoice.bru
similarity index 99%
rename from tests/bruno/e2e/udt/05-node2-gen-invoice.bru
rename to tests/bruno/e2e/udt/07-node2-gen-invoice.bru
index 192efe7f..fdc21afb 100644
--- a/tests/bruno/e2e/udt/05-node2-gen-invoice.bru
+++ b/tests/bruno/e2e/udt/07-node2-gen-invoice.bru
@@ -1,7 +1,7 @@
 meta {
   name: generate a invoice
   type: http
-  seq: 5
+  seq: 7
 }
 
 post {
diff --git a/tests/bruno/e2e/udt/06-node1-add-tlc.bru b/tests/bruno/e2e/udt/08-node1-add-tlc.bru
similarity index 99%
rename from tests/bruno/e2e/udt/06-node1-add-tlc.bru
rename to tests/bruno/e2e/udt/08-node1-add-tlc.bru
index 4a960eec..79e391c4 100644
--- a/tests/bruno/e2e/udt/06-node1-add-tlc.bru
+++ b/tests/bruno/e2e/udt/08-node1-add-tlc.bru
@@ -1,7 +1,7 @@
 meta {
   name: Node1 add tlc
   type: http
-  seq: 6
+  seq: 8
 }
 
 post {
diff --git a/tests/bruno/e2e/udt/07-node2-remove-tlc.bru b/tests/bruno/e2e/udt/09-node2-remove-tlc.bru
similarity index 98%
rename from tests/bruno/e2e/udt/07-node2-remove-tlc.bru
rename to tests/bruno/e2e/udt/09-node2-remove-tlc.bru
index 04a3d617..f9761878 100644
--- a/tests/bruno/e2e/udt/07-node2-remove-tlc.bru
+++ b/tests/bruno/e2e/udt/09-node2-remove-tlc.bru
@@ -1,7 +1,7 @@
 meta {
   name: remove tlc from NODE2
   type: http
-  seq: 7
+  seq: 9
 }
 
 post {
diff --git a/tests/bruno/e2e/udt/08-node1-node2-open-channel-invalid.bru b/tests/bruno/e2e/udt/10-node1-node2-open-channel-invalid.bru
similarity index 98%
rename from tests/bruno/e2e/udt/08-node1-node2-open-channel-invalid.bru
rename to tests/bruno/e2e/udt/10-node1-node2-open-channel-invalid.bru
index c8823e32..66fafefb 100644
--- a/tests/bruno/e2e/udt/08-node1-node2-open-channel-invalid.bru
+++ b/tests/bruno/e2e/udt/10-node1-node2-open-channel-invalid.bru
@@ -1,7 +1,7 @@
 meta {
   name: Node1 open a invalid channel to Node3
   type: http
-  seq: 8
+  seq: 10
 }
 
 post {
diff --git a/tests/bruno/e2e/udt/09-node1-send-shutdown-channel.bru b/tests/bruno/e2e/udt/11-node1-send-shutdown-channel.bru
similarity index 95%
rename from tests/bruno/e2e/udt/09-node1-send-shutdown-channel.bru
rename to tests/bruno/e2e/udt/11-node1-send-shutdown-channel.bru
index d262c9c4..c43e197d 100644
--- a/tests/bruno/e2e/udt/09-node1-send-shutdown-channel.bru
+++ b/tests/bruno/e2e/udt/11-node1-send-shutdown-channel.bru
@@ -1,7 +1,7 @@
 meta {
   name: Node1 send shutdown channel1
   type: http
-  seq: 9
+  seq: 11
 }
 
 post {
@@ -28,7 +28,7 @@ body:json {
           "hash_type": "data",
           "args": "0x0101010101010101010101010101010101010101"
         },
-        "fee": "0xbebc200"
+        "fee_rate": "0x3FC"
       }
     ]
   }
diff --git a/tests/bruno/e2e/udt/10-node2-send-shutdown-channel.bru b/tests/bruno/e2e/udt/12-node2-send-shutdown-channel.bru
similarity index 95%
rename from tests/bruno/e2e/udt/10-node2-send-shutdown-channel.bru
rename to tests/bruno/e2e/udt/12-node2-send-shutdown-channel.bru
index 8f59c7e9..2b1f032b 100644
--- a/tests/bruno/e2e/udt/10-node2-send-shutdown-channel.bru
+++ b/tests/bruno/e2e/udt/12-node2-send-shutdown-channel.bru
@@ -1,7 +1,7 @@
 meta {
   name: Node2 send shutdown channel1
   type: http
-  seq: 10
+  seq: 12
 }
 
 post {
@@ -28,7 +28,7 @@ body:json {
           "hash_type": "data",
           "args": "0x0101010101010101010101010101010101010101"
         },
-        "fee": "0xbebc200"
+        "fee_rate": "0x3FC"
       }
     ]
   }
diff --git a/tests/bruno/e2e/udt/11-node2-send-shutdown-channel-error.bru b/tests/bruno/e2e/udt/13-node2-send-shutdown-channel-error.bru
similarity index 96%
rename from tests/bruno/e2e/udt/11-node2-send-shutdown-channel-error.bru
rename to tests/bruno/e2e/udt/13-node2-send-shutdown-channel-error.bru
index ae441775..81cadd62 100644
--- a/tests/bruno/e2e/udt/11-node2-send-shutdown-channel-error.bru
+++ b/tests/bruno/e2e/udt/13-node2-send-shutdown-channel-error.bru
@@ -1,7 +1,7 @@
 meta {
   name: Node2 send shutdown channel1, will report error for closed channel
   type: http
-  seq: 11
+  seq: 13
 }
 
 post {
@@ -28,7 +28,7 @@ body:json {
           "hash_type": "data",
           "args": "0x0101010101010101010101010101010101010101"
         },
-        "fee": "0xbebc200"
+        "fee_rate": "0xbebc200"
       }
     ]
   }
diff --git a/tests/deploy/udt-init/src/main.rs b/tests/deploy/udt-init/src/main.rs
index cfaedb11..82694c63 100644
--- a/tests/deploy/udt-init/src/main.rs
+++ b/tests/deploy/udt-init/src/main.rs
@@ -192,6 +192,7 @@ struct UdtCellDep {
 struct UdtInfo {
     name: String,
     script: UdtScript,
+    auto_accept_amount: Option<u128>,
     cell_deps: Vec<UdtCellDep>,
 }
 
@@ -209,6 +210,7 @@ fn genrate_nodes_config() {
     for udt in UDT_KINDS {
         let udt_info = UdtInfo {
             name: udt.to_string(),
+            auto_accept_amount: Some(0),
             script: UdtScript {
                 code_hash: get_code_hash(udt),
                 hash_type: "Data1".to_string(),