diff --git a/docs/specs/p2p-message.md b/docs/specs/p2p-message.md
index f25a83da..33f1e43e 100644
--- a/docs/specs/p2p-message.md
+++ b/docs/specs/p2p-message.md
@@ -54,13 +54,11 @@ table OpenChannel {
     funding_fee_rate:            Uint64,
     commitment_fee_rate:         Uint64,
     max_tlc_value_in_flight:     Uint128,
-    max_tlc_number_in_flight:      Uint64,
+    max_tlc_number_in_flight:    Uint64,
     min_tlc_value:               Uint128,
     to_self_delay:               Uint64,
     funding_pubkey:              Byte33,
-    revocation_basepoint:        Byte33,
-    payment_basepoint:           Byte33,
-    delayed_payment_basepoint:   Byte33,
+    tlc_basepoint:               Byte33,
     first_per_commitment_point:  Byte33,
     second_per_commitment_point: Byte33,
     next_local_nonce:            Byte66,
@@ -69,7 +67,7 @@ table OpenChannel {
 ```
 
 - chain_hash: Chain genesis block hash
-- channel_id: The ID of the channel, which is a temporary ID derived from the revocation_basepoint before the channel is officially established. After the channel is established, it will be replaced with the actual channel ID, derived from a blake2b hash of the sorted revocation_basepoints of both parties.
+- channel_id: The ID of the channel, which is a temporary ID derived from the tlc_basepoint before the channel is officially established. After the channel is established, it will be replaced with the actual channel ID, derived from a blake2b hash of the sorted tlc_basepoints of both parties.
 - funding_type_script: Specifies the asset type of the channel. If empty, it indicates using CKB native token as the asset.
 - funding_amount: The amount of assets the channel initiator wants to contribute.
 - funding_fee_rate: Funding transaction fee rate, in shannons per kilo-bytes.
@@ -79,16 +77,12 @@ table OpenChannel {
 - min_tlc_value: The minimum value of TLCs that the channel initiator can accept.
 - to_self_delay: The delay time for the channel initiator to unlock the outputs from the commitment transaction, in EpochNumberWithFraction.
 - funding_pubkey: The pubkey of the channel initiator, used for generating 2-2 multisig contracts.
-- revocation_basepoint: See further description below.
-- payment_basepoint:
-- delayed_payment_basepoint:
+- tlc_basepoint: The master key used to derive child keys required for tlcs, we will use the same method as lightning network to derive these keys, see [Secret Derivations] for more details.
 - first_per_commitment_point:
 - second_per_commitment_point:
 - next_local_nonce: Used for generating partial signatures for unlocking 2-2 Schnorr multisig.
 - channel_flags: Channel flags, currently only using one bit to indicate whether to broadcast this channel information on the P2P network.
 
-The xxx_basepoints here are master keys used to derive child keys required for different types of transactions. For example, they can be used with per_commitment_point to derive commitment transactions keys. We will use the same method as lightning network to derive these keys, see [Secret Derivations] for more details.
-
 ### AcceptChannel
 
 `AcceptChannel` is sent by the receiver of the channel to the initiator of the channel to accept the establishment of a payment channel.
@@ -98,11 +92,11 @@ table AcceptChannel {
     channel_id:                  Byte32,
     funding_amount:              Uint128,
     max_tlc_value_in_flight:     Uint128,
-    max_tlc_number_in_flight:      Uint64,
+    max_tlc_number_in_flight:    Uint64,
     min_tlc_value:               Uint128,
     to_self_delay:               Uint64,
     funding_pubkey:              Byte33,
-    revocation_basepoint:        Byte33,
+    tlc_basepoint:               Byte33,
     payment_basepoint:           Byte33,
     delayed_payment_basepoint:   Byte33,
     first_per_commitment_point:  Byte33,
@@ -118,10 +112,7 @@ table AcceptChannel {
 - min_tlc_value: The minimum value of TLCs that the channel receiver can accept.
 - to_self_delay: The delay time for the channel receiver to unlock the outputs from the commitment transaction, in EpochNumberWithFraction.
 - funding_pubkey: The pubkey of the channel receiver, used for generating 2-2 multisig contracts.
-- revocation_basepoint: See the description in `OpenChannel` message.
-- payment_basepoint:
-- delayed_payment_basepoint:
-- tlc_basepoint:
+- tlc_basepoint: See the description in `OpenChannel` message.
 - first_per_commitment_point:
 - second_per_commitment_point:
 - next_local_nonce: Used for generating partial signatures for unlocking 2-2 Schnorr multisig.
diff --git a/src/fiber/channel.rs b/src/fiber/channel.rs
index da434551..8660cf33 100644
--- a/src/fiber/channel.rs
+++ b/src/fiber/channel.rs
@@ -12,9 +12,9 @@ use crate::{
     invoice::InvoiceStore,
 };
 use ckb_hash::{blake2b_256, new_blake2b};
-use ckb_sdk::Since;
+use ckb_sdk::{Since, SinceType};
 use ckb_types::{
-    core::{FeeRate, TransactionBuilder, TransactionView},
+    core::{EpochNumberWithFraction, FeeRate, TransactionBuilder, TransactionView},
     packed::{Bytes, CellInput, CellOutput, OutPoint, Script, Transaction},
     prelude::{AsTransactionBuilder, IntoTransactionView, Pack, Unpack},
 };
@@ -180,11 +180,16 @@ pub struct ChannelCommandWithId {
 
 pub const DEFAULT_FEE_RATE: u64 = 1_000;
 pub const DEFAULT_COMMITMENT_FEE_RATE: u64 = 1_000;
+// The default commitment delay is 6 epochs = 24 hours.
+pub const DEFAULT_COMMITMENT_DELAY_EPOCHS: u64 = 6;
+// The min commitment delay is 1 epoch = 4 hours.
+pub const MIN_COMMITMENT_DELAY_EPOCHS: u64 = 1;
+// The max commitment delay is 84 epochs = 14 days.
+pub const MAX_COMMITMENT_DELAY_EPOCHS: u64 = 84;
 pub const DEFAULT_MAX_TLC_VALUE_IN_FLIGHT: u128 = u128::MAX;
 pub const DEFAULT_MAX_TLC_NUMBER_IN_FLIGHT: u64 = 30;
 pub const SYS_MAX_TLC_NUMBER_IN_FLIGHT: u64 = 253;
 pub const DEFAULT_MIN_TLC_VALUE: u128 = 0;
-pub const DEFAULT_TO_LOCAL_DELAY_BLOCKS: u64 = 10;
 
 #[derive(Debug)]
 pub struct TxUpdateCommand {
@@ -199,6 +204,7 @@ pub struct OpenChannelParameter {
     pub shutdown_script: Script,
     pub channel_id_sender: oneshot::Sender<Hash256>,
     pub commitment_fee_rate: Option<u64>,
+    pub commitment_delay_epoch: Option<EpochNumberWithFraction>,
     pub funding_fee_rate: Option<u64>,
     pub max_tlc_value_in_flight: Option<u128>,
     pub max_tlc_number_in_flight: Option<u64>,
@@ -1508,12 +1514,12 @@ where
                     channel_id,
                     chain_hash,
                     commitment_fee_rate,
+                    commitment_delay_epoch,
                     funding_fee_rate,
                     funding_udt_type_script,
                     funding_amount,
                     shutdown_script,
                     reserved_ckb_amount,
-                    to_local_delay,
                     first_per_commitment_point,
                     second_per_commitment_point,
                     next_local_nonce,
@@ -1546,6 +1552,7 @@ where
                     local_funding_amount,
                     local_reserved_ckb_amount,
                     *commitment_fee_rate,
+                    *commitment_delay_epoch,
                     *funding_fee_rate,
                     funding_udt_type_script.clone(),
                     &seed,
@@ -1555,7 +1562,6 @@ where
                     shutdown_script.clone(),
                     *funding_amount,
                     *reserved_ckb_amount,
-                    *to_local_delay,
                     counterpart_pubkeys,
                     next_local_nonce.clone(),
                     channel_announcement_nonce.clone(),
@@ -1569,6 +1575,7 @@ where
                     "local_reserved_ckb_amount",
                     "remote_reserved_ckb_amount",
                     "commitment_fee_rate",
+                    "commitment_delay_epoch",
                     "funding_fee_rate",
                     "max_tlc_number_in_flight",
                 ])?;
@@ -1587,12 +1594,8 @@ where
                     reserved_ckb_amount: local_reserved_ckb_amount,
                     max_tlc_value_in_flight: DEFAULT_MAX_TLC_VALUE_IN_FLIGHT,
                     max_tlc_number_in_flight: DEFAULT_MAX_TLC_NUMBER_IN_FLIGHT,
-                    to_local_delay: *to_local_delay,
                     funding_pubkey: state.signer.funding_key.pubkey(),
-                    revocation_basepoint: state.signer.revocation_base_key.pubkey(),
-                    payment_basepoint: state.signer.payment_key.pubkey(),
                     min_tlc_value: DEFAULT_MIN_TLC_VALUE,
-                    delayed_payment_basepoint: state.signer.delayed_payment_base_key.pubkey(),
                     tlc_basepoint: state.signer.tlc_base_key.pubkey(),
                     first_per_commitment_point: state
                         .signer
@@ -1631,6 +1634,7 @@ where
                 shutdown_script,
                 channel_id_sender,
                 commitment_fee_rate,
+                commitment_delay_epoch,
                 funding_fee_rate,
                 max_tlc_number_in_flight,
                 max_tlc_value_in_flight,
@@ -1654,16 +1658,23 @@ where
                     funding_amount,
                     reserved_ckb_amount,
                     commitment_fee_rate,
+                    commitment_delay_epoch
+                        .unwrap_or(EpochNumberWithFraction::new(
+                            DEFAULT_COMMITMENT_DELAY_EPOCHS,
+                            0,
+                            1,
+                        ))
+                        .full_value(),
                     funding_fee_rate,
                     funding_udt_type_script.clone(),
                     shutdown_script.clone(),
                     max_tlc_value_in_flight.unwrap_or(DEFAULT_MAX_TLC_VALUE_IN_FLIGHT),
                     max_tlc_number_in_flight.unwrap_or(DEFAULT_MAX_TLC_NUMBER_IN_FLIGHT),
-                    LockTime::new(DEFAULT_TO_LOCAL_DELAY_BLOCKS),
                 );
 
                 channel.check_ckb_params(vec![
                     "commitment_fee_rate",
+                    "commitment_delay_epoch",
                     "funding_fee_rate",
                     "local_reserved_ckb_amount",
                     "max_tlc_number_in_flight",
@@ -1689,10 +1700,10 @@ where
                     reserved_ckb_amount: channel.local_reserved_ckb_amount,
                     funding_fee_rate,
                     commitment_fee_rate,
+                    commitment_delay_epoch: channel.commitment_delay_epoch,
                     max_tlc_value_in_flight: channel.max_tlc_value_in_flight,
                     max_tlc_number_in_flight: channel.max_tlc_number_in_flight,
                     min_tlc_value: DEFAULT_MIN_TLC_VALUE,
-                    to_local_delay: LockTime::new(DEFAULT_TO_LOCAL_DELAY_BLOCKS),
                     channel_flags,
                     first_per_commitment_point: channel
                         .signer
@@ -1700,23 +1711,8 @@ where
                     second_per_commitment_point: channel
                         .signer
                         .get_commitment_point(commitment_number + 1),
-                    funding_pubkey: channel
-                        .get_local_channel_parameters()
-                        .pubkeys
-                        .funding_pubkey,
-                    revocation_basepoint: channel
-                        .get_local_channel_parameters()
-                        .pubkeys
-                        .revocation_base_key,
-                    payment_basepoint: channel
-                        .get_local_channel_parameters()
-                        .pubkeys
-                        .payment_base_key,
-                    delayed_payment_basepoint: channel
-                        .get_local_channel_parameters()
-                        .pubkeys
-                        .delayed_payment_base_key,
-                    tlc_basepoint: channel.get_local_channel_parameters().pubkeys.tlc_base_key,
+                    funding_pubkey: channel.get_local_channel_public_keys().funding_pubkey,
+                    tlc_basepoint: channel.get_local_channel_public_keys().tlc_base_key,
                     next_local_nonce: channel.get_local_musig2_pubnonce(),
                     channel_announcement_nonce,
                 });
@@ -1997,6 +1993,10 @@ pub struct ChannelActorState {
     // The side who want to submit the commitment transaction will pay fee
     pub commitment_fee_rate: u64,
 
+    // The delay time for the commitment transaction, this value is set by the initiator of the channel.
+    // It must be a relative EpochNumberWithFraction in u64 format.
+    pub commitment_delay_epoch: 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,
@@ -2004,8 +2004,8 @@ pub struct ChannelActorState {
     // Signer is used to sign the commitment transactions.
     pub signer: InMemorySigner,
 
-    // Cached channel parameter for easier of access.
-    pub local_channel_parameters: ChannelParametersOneParty,
+    // Cached channel public keys for easier of access.
+    pub local_channel_public_keys: ChannelBasePublicKeys,
 
     // Commitment numbers that are used to derive keys.
     // This value is guaranteed to be 0 when channel is just created.
@@ -2045,7 +2045,7 @@ pub struct ChannelActorState {
     // All the commitment point that are sent from the counterparty.
     // We need to save all these points to derive the keys for the commitment transactions.
     pub remote_commitment_points: Vec<Pubkey>,
-    pub remote_channel_parameters: Option<ChannelParametersOneParty>,
+    pub remote_channel_public_keys: Option<ChannelBasePublicKeys>,
 
     // The shutdown info for both local and remote, they are setup by the shutdown command or message.
     pub local_shutdown_info: Option<ShutdownInfo>,
@@ -2280,25 +2280,18 @@ impl ChannelState {
     }
 }
 
-pub fn new_channel_id_from_seed(seed: &[u8]) -> Hash256 {
+fn new_channel_id_from_seed(seed: &[u8]) -> Hash256 {
     blake2b_256(seed).into()
 }
 
-fn derive_channel_id_from_revocation_keys(
-    revocation_basepoint1: &Pubkey,
-    revocation_basepoint2: &Pubkey,
-) -> Hash256 {
-    let local_revocation = revocation_basepoint1.0.serialize();
-    let remote_revocation = revocation_basepoint2.0.serialize();
-    let mut preimage = [local_revocation, remote_revocation];
+fn derive_channel_id_from_tlc_keys(tlc_basepoint1: &Pubkey, tlc_basepoint2: &Pubkey) -> Hash256 {
+    let mut preimage = [tlc_basepoint1.0.serialize(), tlc_basepoint2.0.serialize()];
     preimage.sort();
     new_channel_id_from_seed(&preimage.concat())
 }
 
-fn derive_temp_channel_id_from_revocation_key(revocation_basepoint: &Pubkey) -> Hash256 {
-    let revocation = revocation_basepoint.0.serialize();
-    let zero_point = [0; 33];
-    let preimage = [zero_point, revocation].concat();
+fn derive_temp_channel_id_from_tlc_key(tlc_basepoint: &Pubkey) -> Hash256 {
+    let preimage = [tlc_basepoint.0.serialize(), [0; 33]].concat();
     new_channel_id_from_seed(&preimage)
 }
 
@@ -2345,14 +2338,8 @@ impl From<&ChannelActorState> for Musig2VerifyContext {
 impl From<(&ChannelActorState, bool)> for Musig2SignContext {
     fn from(value: (&ChannelActorState, bool)) -> Self {
         let (channel, local) = value;
-        let local_pubkey = channel
-            .get_local_channel_parameters()
-            .pubkeys
-            .funding_pubkey;
-        let remote_pubkey = channel
-            .get_remote_channel_parameters()
-            .pubkeys
-            .funding_pubkey;
+        let local_pubkey = channel.get_local_channel_public_keys().funding_pubkey;
+        let remote_pubkey = channel.get_remote_channel_public_keys().funding_pubkey;
         let pubkeys = if local {
             [local_pubkey, remote_pubkey]
         } else {
@@ -2381,14 +2368,8 @@ impl From<(&ChannelActorState, bool)> for Musig2SignContext {
 impl From<(&ChannelActorState, bool)> for Musig2VerifyContext {
     fn from(value: (&ChannelActorState, bool)) -> Self {
         let (channel, local) = value;
-        let local_pubkey = channel
-            .get_local_channel_parameters()
-            .pubkeys
-            .funding_pubkey;
-        let remote_pubkey = channel
-            .get_remote_channel_parameters()
-            .pubkeys
-            .funding_pubkey;
+        let local_pubkey = channel.get_local_channel_public_keys().funding_pubkey;
+        let remote_pubkey = channel.get_remote_channel_public_keys().funding_pubkey;
         let pubkeys = if local {
             [local_pubkey, remote_pubkey]
         } else {
@@ -2661,6 +2642,7 @@ impl ChannelActorState {
         local_value: u128,
         local_reserved_ckb_amount: u64,
         commitment_fee_rate: u64,
+        commitment_delay_epoch: u64,
         funding_fee_rate: u64,
         funding_udt_type_script: Option<Script>,
         seed: &[u8],
@@ -2670,7 +2652,6 @@ impl ChannelActorState {
         remote_shutdown_script: Script,
         remote_value: u128,
         remote_reserved_ckb_amount: u64,
-        remote_delay: LockTime,
         remote_pubkeys: ChannelBasePublicKeys,
         remote_nonce: PubNonce,
         remote_channel_announcement_nonce: Option<PubNonce>,
@@ -2682,9 +2663,9 @@ impl ChannelActorState {
         let signer = InMemorySigner::generate_from_seed(seed);
         let local_base_pubkeys = signer.get_base_public_keys();
 
-        let channel_id = derive_channel_id_from_revocation_keys(
-            &local_base_pubkeys.revocation_base_key,
-            &remote_pubkeys.revocation_base_key,
+        let channel_id = derive_channel_id_from_tlc_keys(
+            &local_base_pubkeys.tlc_base_key,
+            &remote_pubkeys.tlc_base_key,
         );
 
         debug!(
@@ -2704,20 +2685,15 @@ impl ChannelActorState {
             to_local_amount: local_value,
             to_remote_amount: remote_value,
             commitment_fee_rate,
+            commitment_delay_epoch,
             funding_fee_rate,
             id: channel_id,
             tlc_ids: Default::default(),
             tlcs: Default::default(),
             local_shutdown_script: Some(local_shutdown_script),
-            local_channel_parameters: ChannelParametersOneParty {
-                pubkeys: local_base_pubkeys,
-                selected_contest_delay: remote_delay,
-            },
+            local_channel_public_keys: local_base_pubkeys,
             signer,
-            remote_channel_parameters: Some(ChannelParametersOneParty {
-                pubkeys: remote_pubkeys,
-                selected_contest_delay: remote_delay,
-            }),
+            remote_channel_public_keys: Some(remote_pubkeys),
             commitment_numbers: Default::default(),
             remote_shutdown_script: Some(remote_shutdown_script),
             previous_remote_nonce: None,
@@ -2749,17 +2725,16 @@ impl ChannelActorState {
         value: u128,
         local_reserved_ckb_amount: u64,
         commitment_fee_rate: u64,
+        commitment_delay_epoch: u64,
         funding_fee_rate: u64,
         funding_udt_type_script: Option<Script>,
         shutdown_script: Script,
         max_tlc_value_in_flight: u128,
         max_tlc_number_in_flight: u64,
-        to_local_delay: LockTime,
     ) -> Self {
         let signer = InMemorySigner::generate_from_seed(seed);
         let local_pubkeys = signer.get_base_public_keys();
-        let temp_channel_id =
-            derive_temp_channel_id_from_revocation_key(&local_pubkeys.revocation_base_key);
+        let temp_channel_id = derive_temp_channel_id_from_tlc_key(&local_pubkeys.tlc_base_key);
         Self {
             state: ChannelState::NegotiatingFunding(NegotiatingFundingFlags::empty()),
             public_channel_info,
@@ -2772,18 +2747,16 @@ impl ChannelActorState {
             to_local_amount: value,
             to_remote_amount: 0,
             commitment_fee_rate,
+            commitment_delay_epoch,
             funding_fee_rate,
             id: temp_channel_id,
             tlc_ids: Default::default(),
             tlcs: Default::default(),
             signer,
-            local_channel_parameters: ChannelParametersOneParty {
-                pubkeys: local_pubkeys,
-                selected_contest_delay: to_local_delay,
-            },
+            local_channel_public_keys: local_pubkeys,
             max_tlc_number_in_flight,
             max_tlc_value_in_flight,
-            remote_channel_parameters: None,
+            remote_channel_public_keys: None,
             previous_remote_nonce: None,
             remote_nonce: None,
             commitment_numbers: Default::default(),
@@ -2860,6 +2833,33 @@ impl ChannelActorState {
                     )));
                     }
                 }
+                "commitment_delay_epoch" => {
+                    let epoch = EpochNumberWithFraction::from_full_value_unchecked(
+                        self.commitment_delay_epoch,
+                    );
+                    if !epoch.is_well_formed() {
+                        return Err(ProcessingChannelError::InvalidParameter(format!(
+                            "Commitment delay epoch {} is not a valid value",
+                            self.commitment_delay_epoch,
+                        )));
+                    }
+
+                    let min = EpochNumberWithFraction::new(MIN_COMMITMENT_DELAY_EPOCHS, 0, 1);
+                    if epoch < min {
+                        return Err(ProcessingChannelError::InvalidParameter(format!(
+                            "Commitment delay epoch {} is less than the minimal value {}",
+                            epoch, min
+                        )));
+                    }
+
+                    let max = EpochNumberWithFraction::new(MAX_COMMITMENT_DELAY_EPOCHS, 0, 1);
+                    if epoch > max {
+                        return Err(ProcessingChannelError::InvalidParameter(format!(
+                            "Commitment delay epoch {} is greater than the maximal value {}",
+                            epoch, max
+                        )));
+                    }
+                }
                 "max_tlc_number_in_flight" => {
                     if self.max_tlc_number_in_flight > SYS_MAX_TLC_NUMBER_IN_FLIGHT {
                         return Err(ProcessingChannelError::InvalidParameter(format!(
@@ -3168,16 +3168,18 @@ impl ChannelActorState {
             (output, output_data)
         };
 
-        let local_pubkey = self.get_local_channel_parameters().pubkeys.funding_pubkey;
-        let remote_pubkey = self.get_remote_channel_parameters().pubkeys.funding_pubkey;
+        let local_pubkey = self.get_local_channel_public_keys().funding_pubkey;
+        let remote_pubkey = self.get_remote_channel_public_keys().funding_pubkey;
         let key_agg_ctx = KeyAggContext::new([remote_pubkey, local_pubkey]).expect("Valid pubkeys");
 
         let x_only_aggregated_pubkey = key_agg_ctx.aggregated_pubkey::<Point>().serialize_xonly();
-        let delay_epoch = self.get_remote_channel_parameters().selected_contest_delay;
+        let delay_epoch = self.commitment_delay_epoch;
         let commitment_number = self.get_remote_commitment_number();
         let commitment_lock_script_args = [
             &blake2b_256(x_only_aggregated_pubkey)[0..20],
-            (Since::from(delay_epoch).value()).to_le_bytes().as_slice(),
+            (Since::new(SinceType::EpochNumberWithFraction, delay_epoch, true).value())
+                .to_le_bytes()
+                .as_slice(),
             commitment_number.to_be_bytes().as_slice(),
         ]
         .concat();
@@ -3561,12 +3563,12 @@ impl ChannelActorState {
         Ok(tlc.clone())
     }
 
-    pub fn get_local_channel_parameters(&self) -> &ChannelParametersOneParty {
-        &self.local_channel_parameters
+    pub fn get_local_channel_public_keys(&self) -> &ChannelBasePublicKeys {
+        &self.local_channel_public_keys
     }
 
-    pub fn get_remote_channel_parameters(&self) -> &ChannelParametersOneParty {
-        self.remote_channel_parameters.as_ref().unwrap()
+    pub fn get_remote_channel_public_keys(&self) -> &ChannelBasePublicKeys {
+        self.remote_channel_public_keys.as_ref().unwrap()
     }
 
     pub fn get_funding_transaction(&self) -> &Transaction {
@@ -3668,8 +3670,8 @@ impl ChannelActorState {
     }
 
     pub fn get_musig2_agg_context(&self) -> KeyAggContext {
-        let local_pubkey = self.get_local_channel_parameters().pubkeys.funding_pubkey;
-        let remote_pubkey = self.get_remote_channel_parameters().pubkeys.funding_pubkey;
+        let local_pubkey = self.get_local_channel_public_keys().funding_pubkey;
+        let remote_pubkey = self.get_remote_channel_public_keys().funding_pubkey;
         let keys = self.order_things_for_musig2(local_pubkey, remote_pubkey);
         KeyAggContext::new(keys).expect("Valid pubkeys")
     }
@@ -3802,11 +3804,11 @@ impl ChannelActorState {
             local_commitment_number, remote_commitment_number
         );
         let local_pubkey = derive_tlc_pubkey(
-            &self.get_local_channel_parameters().pubkeys.tlc_base_key,
+            &self.get_local_channel_public_keys().tlc_base_key,
             &self.get_local_commitment_point(remote_commitment_number),
         );
         let remote_pubkey = derive_tlc_pubkey(
-            &self.get_remote_channel_parameters().pubkeys.tlc_base_key,
+            &self.get_remote_channel_public_keys().tlc_base_key,
             &self.get_remote_commitment_point(local_commitment_number),
         );
 
@@ -3890,11 +3892,11 @@ impl ChannelActorState {
     }
 
     pub fn get_local_funding_pubkey(&self) -> &Pubkey {
-        &self.get_local_channel_parameters().pubkeys.funding_pubkey
+        &self.get_local_channel_public_keys().funding_pubkey
     }
 
     pub fn get_remote_funding_pubkey(&self) -> &Pubkey {
-        &self.get_remote_channel_parameters().pubkeys.funding_pubkey
+        &self.get_remote_channel_public_keys().funding_pubkey
     }
 
     fn check_valid_to_auto_accept_shutdown(&self) -> bool {
@@ -4185,10 +4187,7 @@ impl ChannelActorState {
 
         self.remote_nonce = Some(accept_channel.next_local_nonce.clone());
         let remote_pubkeys = (&accept_channel).into();
-        self.remote_channel_parameters = Some(ChannelParametersOneParty {
-            pubkeys: remote_pubkeys,
-            selected_contest_delay: accept_channel.to_local_delay,
-        });
+        self.remote_channel_public_keys = Some(remote_pubkeys);
         self.remote_commitment_points = vec![
             accept_channel.first_per_commitment_point,
             accept_channel.second_per_commitment_point,
@@ -4651,17 +4650,19 @@ impl ChannelActorState {
             (output, output_data)
         };
 
-        let local_pubkey = self.get_local_channel_parameters().pubkeys.funding_pubkey;
-        let remote_pubkey = self.get_remote_channel_parameters().pubkeys.funding_pubkey;
+        let local_pubkey = self.get_local_channel_public_keys().funding_pubkey;
+        let remote_pubkey = self.get_remote_channel_public_keys().funding_pubkey;
         let key_agg_ctx = KeyAggContext::new([local_pubkey, remote_pubkey]).expect("Valid pubkeys");
 
         let x_only_aggregated_pubkey = key_agg_ctx.aggregated_pubkey::<Point>().serialize_xonly();
-        let delay_epoch = self.get_local_channel_parameters().selected_contest_delay;
+        let delay_epoch = self.commitment_delay_epoch;
         let commitment_number = self.get_local_commitment_number();
 
         let commitment_lock_script_args = [
             &blake2b_256(x_only_aggregated_pubkey)[0..20],
-            (Since::from(delay_epoch).value()).to_le_bytes().as_slice(),
+            (Since::new(SinceType::EpochNumberWithFraction, delay_epoch, true).value())
+                .to_le_bytes()
+                .as_slice(),
             commitment_number.to_be_bytes().as_slice(),
         ]
         .concat();
@@ -4967,24 +4968,11 @@ impl ChannelActorState {
         Ok(())
     }
 
-    fn fill_in_channel_id(&mut self) {
-        assert!(
-            self.remote_channel_parameters.is_some(),
-            "Counterparty pubkeys is required to derive actual channel id"
-        );
-        let remote_revocation = &self
-            .get_remote_channel_parameters()
-            .pubkeys
-            .revocation_base_key;
-        let local_revocation = &self
-            .get_local_channel_parameters()
-            .pubkeys
-            .revocation_base_key;
-        let channel_id =
-            derive_channel_id_from_revocation_keys(local_revocation, remote_revocation);
-
+    pub fn fill_in_channel_id(&mut self) {
+        let local = &self.get_local_channel_public_keys().tlc_base_key;
+        let remote = &self.get_remote_channel_public_keys().tlc_base_key;
+        let channel_id = derive_channel_id_from_tlc_keys(local, remote);
         debug!("Channel Id changed from {:?} to {:?}", self.id, channel_id,);
-
         self.id = channel_id;
     }
 
@@ -4992,8 +4980,8 @@ impl ChannelActorState {
     // We define a definitive order for the pubkeys in musig2 to makes it easier
     // to aggregate musig2 signatures.
     fn should_local_go_first_in_musig2(&self) -> bool {
-        let local_pubkey = self.get_local_channel_parameters().pubkeys.funding_pubkey;
-        let remote_pubkey = self.get_remote_channel_parameters().pubkeys.funding_pubkey;
+        let local_pubkey = self.get_local_channel_public_keys().funding_pubkey;
+        let remote_pubkey = self.get_remote_channel_public_keys().funding_pubkey;
         local_pubkey <= remote_pubkey
     }
 
@@ -5178,8 +5166,8 @@ impl ChannelActorState {
     }
 
     fn build_commitment_transaction_output(&self, local: bool) -> (CellOutput, Bytes) {
-        let local_pubkey = self.get_local_channel_parameters().pubkeys.funding_pubkey;
-        let remote_pubkey = self.get_remote_channel_parameters().pubkeys.funding_pubkey;
+        let local_pubkey = self.get_local_channel_public_keys().funding_pubkey;
+        let remote_pubkey = self.get_remote_channel_public_keys().funding_pubkey;
         let pubkeys = if local {
             [local_pubkey, remote_pubkey]
         } else {
@@ -5190,19 +5178,15 @@ impl ChannelActorState {
             .aggregated_pubkey::<Point>()
             .serialize_xonly();
 
-        let delay_epoch = if local {
-            self.get_remote_channel_parameters().selected_contest_delay
-        } else {
-            self.get_local_channel_parameters().selected_contest_delay
-        };
-
+        let delay_epoch = self.commitment_delay_epoch;
         let version = self.get_current_commitment_number(local);
-
         let htlcs = self.get_active_htlcs(local);
 
         let mut commitment_lock_script_args = [
             &blake2b_256(x_only_aggregated_pubkey)[0..20],
-            (Since::from(delay_epoch).value()).to_le_bytes().as_slice(),
+            (Since::new(SinceType::EpochNumberWithFraction, delay_epoch, true).value())
+                .to_le_bytes()
+                .as_slice(),
             version.to_be_bytes().as_slice(),
         ]
         .concat();
@@ -5565,18 +5549,6 @@ impl ChannelParametersOneParty {
         &self.pubkeys.funding_pubkey
     }
 
-    pub fn payment_base_key(&self) -> &Pubkey {
-        &self.pubkeys.payment_base_key
-    }
-
-    pub fn delayed_payment_base_key(&self) -> &Pubkey {
-        &self.pubkeys.delayed_payment_base_key
-    }
-
-    pub fn revocation_base_key(&self) -> &Pubkey {
-        &self.pubkeys.revocation_base_key
-    }
-
     pub fn tlc_base_key(&self) -> &Pubkey {
         &self.pubkeys.tlc_base_key
     }
@@ -5588,19 +5560,6 @@ pub struct ChannelBasePublicKeys {
     /// The public key which is used to sign all commitment transactions, as it appears in the
     /// on-chain channel lock-in 2-of-2 multisig output.
     pub funding_pubkey: Pubkey,
-    /// The base point which is used (with derive_public_revocation_key) to derive per-commitment
-    /// revocation keys. This is combined with the per-commitment-secret generated by the
-    /// counterparty to create a secret which the counterparty can reveal to revoke previous
-    /// states.
-    pub revocation_base_key: Pubkey,
-    /// The public key on which the non-broadcaster (ie the countersignatory) receives an immediately
-    /// spendable primary channel balance on the broadcaster's commitment transaction. This key is
-    /// static across every commitment transaction.
-    pub payment_base_key: Pubkey,
-    /// The base point which is used (with derive_public_key) to derive a per-commitment payment
-    /// public key which receives non-HTLC-encumbered funds which are only available for spending
-    /// after some delay (or can be claimed via the revocation path).
-    pub delayed_payment_base_key: Pubkey,
     /// The base point which is used (with derive_public_key) to derive a per-commitment public key
     /// which is used to encumber HTLC-in-flight outputs.
     pub tlc_base_key: Pubkey,
@@ -5610,9 +5569,6 @@ impl From<&OpenChannel> for ChannelBasePublicKeys {
     fn from(value: &OpenChannel) -> Self {
         ChannelBasePublicKeys {
             funding_pubkey: value.funding_pubkey,
-            revocation_base_key: value.revocation_basepoint,
-            payment_base_key: value.payment_basepoint,
-            delayed_payment_base_key: value.delayed_payment_basepoint,
             tlc_base_key: value.tlc_basepoint,
         }
     }
@@ -5622,9 +5578,6 @@ impl From<&AcceptChannel> for ChannelBasePublicKeys {
     fn from(value: &AcceptChannel) -> Self {
         ChannelBasePublicKeys {
             funding_pubkey: value.funding_pubkey,
-            revocation_base_key: value.revocation_basepoint,
-            payment_base_key: value.payment_basepoint,
-            delayed_payment_base_key: value.delayed_payment_basepoint,
             tlc_base_key: value.tlc_basepoint,
         }
     }
@@ -5762,15 +5715,6 @@ fn derive_public_key(base_key: &Pubkey, commitment_point: &Pubkey) -> Pubkey {
     base_key.tweak(get_tweak_by_commitment_point(commitment_point))
 }
 
-pub fn derive_revocation_pubkey(base_key: &Pubkey, commitment_point: &Pubkey) -> Pubkey {
-    let result = derive_public_key(commitment_point, base_key);
-    debug!(
-        "Derived revocation pub key from commitment point {:?}, base_key {:?}, result {:?}",
-        &commitment_point, &base_key, &result
-    );
-    result
-}
-
 pub fn derive_payment_pubkey(base_key: &Pubkey, commitment_point: &Pubkey) -> Pubkey {
     derive_public_key(base_key, commitment_point)
 }
@@ -5792,12 +5736,6 @@ pub struct InMemorySigner {
     /// Holder secret key in the 2-of-2 multisig script of a channel. This key also backs the
     /// holder's anchor output in a commitment transaction, if one is present.
     pub funding_key: Privkey,
-    /// Holder secret key for blinded revocation pubkey.
-    pub revocation_base_key: Privkey,
-    /// Holder secret key used for our balance in counterparty-broadcasted commitment transactions.
-    pub payment_key: Privkey,
-    /// Holder secret key used in an HTLC transaction.
-    pub delayed_payment_base_key: Privkey,
     /// Holder HTLC secret key used in commitment transaction HTLC outputs.
     pub tlc_base_key: Privkey,
     /// SecNonce used to generate valid signature in musig.
@@ -5826,18 +5764,11 @@ impl InMemorySigner {
         };
 
         let funding_key = key_derive(&seed, b"funding key");
-        let revocation_base_key = key_derive(funding_key.as_ref(), b"revocation base key");
-        let payment_key = key_derive(revocation_base_key.as_ref(), b"payment key");
-        let delayed_payment_base_key =
-            key_derive(payment_key.as_ref(), b"delayed payment base key");
-        let tlc_base_key = key_derive(delayed_payment_base_key.as_ref(), b"HTLC base key");
+        let tlc_base_key = key_derive(funding_key.as_ref(), b"HTLC base key");
         let musig2_base_nonce = key_derive(tlc_base_key.as_ref(), b"musig nocne");
 
         Self {
             funding_key,
-            revocation_base_key,
-            payment_key,
-            delayed_payment_base_key,
             tlc_base_key,
             musig2_base_nonce,
             commitment_seed,
@@ -5847,9 +5778,6 @@ impl InMemorySigner {
     fn get_base_public_keys(&self) -> ChannelBasePublicKeys {
         ChannelBasePublicKeys {
             funding_pubkey: self.funding_key.pubkey(),
-            revocation_base_key: self.revocation_base_key.pubkey(),
-            payment_base_key: self.payment_key.pubkey(),
-            delayed_payment_base_key: self.delayed_payment_base_key.pubkey(),
             tlc_base_key: self.tlc_base_key.pubkey(),
         }
     }
@@ -5862,28 +5790,6 @@ impl InMemorySigner {
         get_commitment_secret(&self.commitment_seed, commitment_number)
     }
 
-    pub fn derive_revocation_key(&self, commitment_number: u64) -> Privkey {
-        let per_commitment_secret = self.get_commitment_secret(commitment_number);
-        // Note that here we don't derive private key in the same way as we ususally do.
-        // Instead we use per commitment secret as "master key" and public revocation key
-        // as derivation material. In this way when we reveal the per round "master key",
-        // the counterparty can obtain the secret key for that round.
-        derive_private_key(
-            &per_commitment_secret.into(),
-            &self.revocation_base_key.pubkey(),
-        )
-    }
-
-    pub fn derive_payment_key(&self, new_commitment_number: u64) -> Privkey {
-        let per_commitment_point = self.get_commitment_point(new_commitment_number);
-        derive_private_key(&self.payment_key, &per_commitment_point)
-    }
-
-    pub fn derive_delayed_payment_key(&self, new_commitment_number: u64) -> Privkey {
-        let per_commitment_point = self.get_commitment_point(new_commitment_number);
-        derive_private_key(&self.delayed_payment_base_key, &per_commitment_point)
-    }
-
     pub fn derive_tlc_key(&self, new_commitment_number: u64) -> Privkey {
         let per_commitment_point = self.get_commitment_point(new_commitment_number);
         derive_private_key(&self.tlc_base_key, &per_commitment_point)
diff --git a/src/fiber/gen/fiber.rs b/src/fiber/gen/fiber.rs
index 7772c083..86daaeb1 100644
--- a/src/fiber/gen/fiber.rs
+++ b/src/fiber/gen/fiber.rs
@@ -4387,7 +4387,12 @@ impl ::core::fmt::Display for OpenChannel {
             self.max_tlc_number_in_flight()
         )?;
         write!(f, ", {}: {}", "min_tlc_value", self.min_tlc_value())?;
-        write!(f, ", {}: {}", "to_self_delay", self.to_self_delay())?;
+        write!(
+            f,
+            ", {}: {}",
+            "commitment_delay_epoch",
+            self.commitment_delay_epoch()
+        )?;
         write!(f, ", {}: {}", "funding_pubkey", self.funding_pubkey())?;
         write!(
             f,
@@ -4543,7 +4548,7 @@ impl OpenChannel {
         let end = molecule::unpack_number(&slice[48..]) as usize;
         Uint128::new_unchecked(self.0.slice(start..end))
     }
-    pub fn to_self_delay(&self) -> Uint64 {
+    pub fn commitment_delay_epoch(&self) -> Uint64 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[48..]) as usize;
         let end = molecule::unpack_number(&slice[52..]) as usize;
@@ -4651,7 +4656,7 @@ impl molecule::prelude::Entity for OpenChannel {
             .max_tlc_value_in_flight(self.max_tlc_value_in_flight())
             .max_tlc_number_in_flight(self.max_tlc_number_in_flight())
             .min_tlc_value(self.min_tlc_value())
-            .to_self_delay(self.to_self_delay())
+            .commitment_delay_epoch(self.commitment_delay_epoch())
             .funding_pubkey(self.funding_pubkey())
             .revocation_basepoint(self.revocation_basepoint())
             .payment_basepoint(self.payment_basepoint())
@@ -4719,7 +4724,12 @@ impl<'r> ::core::fmt::Display for OpenChannelReader<'r> {
             self.max_tlc_number_in_flight()
         )?;
         write!(f, ", {}: {}", "min_tlc_value", self.min_tlc_value())?;
-        write!(f, ", {}: {}", "to_self_delay", self.to_self_delay())?;
+        write!(
+            f,
+            ", {}: {}",
+            "commitment_delay_epoch",
+            self.commitment_delay_epoch()
+        )?;
         write!(f, ", {}: {}", "funding_pubkey", self.funding_pubkey())?;
         write!(
             f,
@@ -4846,7 +4856,7 @@ impl<'r> OpenChannelReader<'r> {
         let end = molecule::unpack_number(&slice[48..]) as usize;
         Uint128Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn to_self_delay(&self) -> Uint64Reader<'r> {
+    pub fn commitment_delay_epoch(&self) -> Uint64Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[48..]) as usize;
         let end = molecule::unpack_number(&slice[52..]) as usize;
@@ -5001,7 +5011,7 @@ pub struct OpenChannelBuilder {
     pub(crate) max_tlc_value_in_flight: Uint128,
     pub(crate) max_tlc_number_in_flight: Uint64,
     pub(crate) min_tlc_value: Uint128,
-    pub(crate) to_self_delay: Uint64,
+    pub(crate) commitment_delay_epoch: Uint64,
     pub(crate) funding_pubkey: Pubkey,
     pub(crate) revocation_basepoint: Pubkey,
     pub(crate) payment_basepoint: Pubkey,
@@ -5059,8 +5069,8 @@ impl OpenChannelBuilder {
         self.min_tlc_value = v;
         self
     }
-    pub fn to_self_delay(mut self, v: Uint64) -> Self {
-        self.to_self_delay = v;
+    pub fn commitment_delay_epoch(mut self, v: Uint64) -> Self {
+        self.commitment_delay_epoch = v;
         self
     }
     pub fn funding_pubkey(mut self, v: Pubkey) -> Self {
@@ -5120,7 +5130,7 @@ impl molecule::prelude::Builder for OpenChannelBuilder {
             + self.max_tlc_value_in_flight.as_slice().len()
             + self.max_tlc_number_in_flight.as_slice().len()
             + self.min_tlc_value.as_slice().len()
-            + self.to_self_delay.as_slice().len()
+            + self.commitment_delay_epoch.as_slice().len()
             + self.funding_pubkey.as_slice().len()
             + self.revocation_basepoint.as_slice().len()
             + self.payment_basepoint.as_slice().len()
@@ -5158,7 +5168,7 @@ impl molecule::prelude::Builder for OpenChannelBuilder {
         offsets.push(total_size);
         total_size += self.min_tlc_value.as_slice().len();
         offsets.push(total_size);
-        total_size += self.to_self_delay.as_slice().len();
+        total_size += self.commitment_delay_epoch.as_slice().len();
         offsets.push(total_size);
         total_size += self.funding_pubkey.as_slice().len();
         offsets.push(total_size);
@@ -5194,7 +5204,7 @@ impl molecule::prelude::Builder for OpenChannelBuilder {
         writer.write_all(self.max_tlc_value_in_flight.as_slice())?;
         writer.write_all(self.max_tlc_number_in_flight.as_slice())?;
         writer.write_all(self.min_tlc_value.as_slice())?;
-        writer.write_all(self.to_self_delay.as_slice())?;
+        writer.write_all(self.commitment_delay_epoch.as_slice())?;
         writer.write_all(self.funding_pubkey.as_slice())?;
         writer.write_all(self.revocation_basepoint.as_slice())?;
         writer.write_all(self.payment_basepoint.as_slice())?;
@@ -5255,7 +5265,12 @@ impl ::core::fmt::Display for AcceptChannel {
             self.max_tlc_number_in_flight()
         )?;
         write!(f, ", {}: {}", "min_tlc_value", self.min_tlc_value())?;
-        write!(f, ", {}: {}", "to_self_delay", self.to_self_delay())?;
+        write!(
+            f,
+            ", {}: {}",
+            "commitment_delay_epoch",
+            self.commitment_delay_epoch()
+        )?;
         write!(f, ", {}: {}", "funding_pubkey", self.funding_pubkey())?;
         write!(
             f,
@@ -5383,7 +5398,7 @@ impl AcceptChannel {
         let end = molecule::unpack_number(&slice[32..]) as usize;
         Uint128::new_unchecked(self.0.slice(start..end))
     }
-    pub fn to_self_delay(&self) -> Uint64 {
+    pub fn commitment_delay_epoch(&self) -> Uint64 {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[32..]) as usize;
         let end = molecule::unpack_number(&slice[36..]) as usize;
@@ -5481,7 +5496,7 @@ impl molecule::prelude::Entity for AcceptChannel {
             .max_tlc_value_in_flight(self.max_tlc_value_in_flight())
             .max_tlc_number_in_flight(self.max_tlc_number_in_flight())
             .min_tlc_value(self.min_tlc_value())
-            .to_self_delay(self.to_self_delay())
+            .commitment_delay_epoch(self.commitment_delay_epoch())
             .funding_pubkey(self.funding_pubkey())
             .revocation_basepoint(self.revocation_basepoint())
             .payment_basepoint(self.payment_basepoint())
@@ -5534,7 +5549,12 @@ impl<'r> ::core::fmt::Display for AcceptChannelReader<'r> {
             self.max_tlc_number_in_flight()
         )?;
         write!(f, ", {}: {}", "min_tlc_value", self.min_tlc_value())?;
-        write!(f, ", {}: {}", "to_self_delay", self.to_self_delay())?;
+        write!(
+            f,
+            ", {}: {}",
+            "commitment_delay_epoch",
+            self.commitment_delay_epoch()
+        )?;
         write!(f, ", {}: {}", "funding_pubkey", self.funding_pubkey())?;
         write!(
             f,
@@ -5636,7 +5656,7 @@ impl<'r> AcceptChannelReader<'r> {
         let end = molecule::unpack_number(&slice[32..]) as usize;
         Uint128Reader::new_unchecked(&self.as_slice()[start..end])
     }
-    pub fn to_self_delay(&self) -> Uint64Reader<'r> {
+    pub fn commitment_delay_epoch(&self) -> Uint64Reader<'r> {
         let slice = self.as_slice();
         let start = molecule::unpack_number(&slice[32..]) as usize;
         let end = molecule::unpack_number(&slice[36..]) as usize;
@@ -5776,7 +5796,7 @@ pub struct AcceptChannelBuilder {
     pub(crate) max_tlc_value_in_flight: Uint128,
     pub(crate) max_tlc_number_in_flight: Uint64,
     pub(crate) min_tlc_value: Uint128,
-    pub(crate) to_self_delay: Uint64,
+    pub(crate) commitment_delay_epoch: Uint64,
     pub(crate) funding_pubkey: Pubkey,
     pub(crate) revocation_basepoint: Pubkey,
     pub(crate) payment_basepoint: Pubkey,
@@ -5817,8 +5837,8 @@ impl AcceptChannelBuilder {
         self.min_tlc_value = v;
         self
     }
-    pub fn to_self_delay(mut self, v: Uint64) -> Self {
-        self.to_self_delay = v;
+    pub fn commitment_delay_epoch(mut self, v: Uint64) -> Self {
+        self.commitment_delay_epoch = v;
         self
     }
     pub fn funding_pubkey(mut self, v: Pubkey) -> Self {
@@ -5870,7 +5890,7 @@ impl molecule::prelude::Builder for AcceptChannelBuilder {
             + self.max_tlc_value_in_flight.as_slice().len()
             + self.max_tlc_number_in_flight.as_slice().len()
             + self.min_tlc_value.as_slice().len()
-            + self.to_self_delay.as_slice().len()
+            + self.commitment_delay_epoch.as_slice().len()
             + self.funding_pubkey.as_slice().len()
             + self.revocation_basepoint.as_slice().len()
             + self.payment_basepoint.as_slice().len()
@@ -5899,7 +5919,7 @@ impl molecule::prelude::Builder for AcceptChannelBuilder {
         offsets.push(total_size);
         total_size += self.min_tlc_value.as_slice().len();
         offsets.push(total_size);
-        total_size += self.to_self_delay.as_slice().len();
+        total_size += self.commitment_delay_epoch.as_slice().len();
         offsets.push(total_size);
         total_size += self.funding_pubkey.as_slice().len();
         offsets.push(total_size);
@@ -5929,7 +5949,7 @@ impl molecule::prelude::Builder for AcceptChannelBuilder {
         writer.write_all(self.max_tlc_value_in_flight.as_slice())?;
         writer.write_all(self.max_tlc_number_in_flight.as_slice())?;
         writer.write_all(self.min_tlc_value.as_slice())?;
-        writer.write_all(self.to_self_delay.as_slice())?;
+        writer.write_all(self.commitment_delay_epoch.as_slice())?;
         writer.write_all(self.funding_pubkey.as_slice())?;
         writer.write_all(self.revocation_basepoint.as_slice())?;
         writer.write_all(self.payment_basepoint.as_slice())?;
diff --git a/src/fiber/network.rs b/src/fiber/network.rs
index cd946b9f..0b260a38 100644
--- a/src/fiber/network.rs
+++ b/src/fiber/network.rs
@@ -1,6 +1,6 @@
 use ckb_hash::blake2b_256;
 use ckb_jsonrpc_types::{BlockNumber, Status, TxStatus};
-use ckb_types::core::TransactionView;
+use ckb_types::core::{EpochNumberWithFraction, TransactionView};
 use ckb_types::packed::{self, Byte32, CellOutput, OutPoint, Script, Transaction};
 use ckb_types::prelude::{IntoTransactionView, Pack, Unpack};
 use musig2::CompactSignature;
@@ -257,6 +257,7 @@ pub struct OpenChannelCommand {
     pub shutdown_script: Option<Script>,
     pub funding_udt_type_script: Option<Script>,
     pub commitment_fee_rate: Option<u64>,
+    pub commitment_delay_epoch: Option<EpochNumberWithFraction>,
     pub funding_fee_rate: Option<u64>,
     pub tlc_locktime_expiry_delta: Option<u64>,
     pub tlc_min_value: Option<u128>,
@@ -2854,6 +2855,7 @@ where
             shutdown_script,
             funding_udt_type_script,
             commitment_fee_rate,
+            commitment_delay_epoch,
             funding_fee_rate,
             tlc_locktime_expiry_delta,
             tlc_min_value,
@@ -2904,6 +2906,7 @@ where
                     .unwrap_or_else(|| self.default_shutdown_script.clone()),
                 channel_id_sender: tx,
                 commitment_fee_rate,
+                commitment_delay_epoch,
                 funding_fee_rate,
                 max_tlc_value_in_flight,
                 max_tlc_number_in_flight,
diff --git a/src/fiber/schema/fiber.mol b/src/fiber/schema/fiber.mol
index cc719452..d1a6f329 100644
--- a/src/fiber/schema/fiber.mol
+++ b/src/fiber/schema/fiber.mol
@@ -19,12 +19,15 @@ table OpenChannel {
     funding_fee_rate:            Uint64,
     commitment_fee_rate:         Uint64,
     max_tlc_value_in_flight:     Uint128,
-    max_tlc_number_in_flight:      Uint64,
+    max_tlc_number_in_flight:    Uint64,
     min_tlc_value:               Uint128,
-    to_self_delay:               Uint64,
+    commitment_delay_epoch:      Uint64,
     funding_pubkey:              Pubkey,
+    // deprecated
     revocation_basepoint:        Pubkey,
+    // deprecated
     payment_basepoint:           Pubkey,
+    // deprecated
     delayed_payment_basepoint:   Pubkey,
     tlc_basepoint:               Pubkey,
     first_per_commitment_point:  Pubkey,
@@ -40,12 +43,16 @@ table AcceptChannel {
     shutdown_script:             Script,
     reserved_ckb_amount:         Uint64,
     max_tlc_value_in_flight:     Uint128,
-    max_tlc_number_in_flight:      Uint64,
+    max_tlc_number_in_flight:    Uint64,
     min_tlc_value:               Uint128,
-    to_self_delay:               Uint64,
+    // deprecated
+    commitment_delay_epoch:      Uint64,
     funding_pubkey:              Pubkey,
+    // deprecated
     revocation_basepoint:        Pubkey,
+    // deprecated
     payment_basepoint:           Pubkey,
+    // deprecated
     delayed_payment_basepoint:   Pubkey,
     tlc_basepoint:               Pubkey,
     first_per_commitment_point:  Pubkey,
diff --git a/src/fiber/tests/channel.rs b/src/fiber/tests/channel.rs
index 01c17363..e8f2ada8 100644
--- a/src/fiber/tests/channel.rs
+++ b/src/fiber/tests/channel.rs
@@ -2,9 +2,9 @@ use crate::{
     ckb::contracts::{get_cell_deps, Contract},
     fiber::{
         channel::{
-            derive_private_key, derive_revocation_pubkey, derive_tlc_pubkey, AddTlcCommand,
-            ChannelActorStateStore, ChannelCommand, ChannelCommandWithId, InMemorySigner,
-            RemoveTlcCommand, ShutdownCommand, DEFAULT_COMMITMENT_FEE_RATE,
+            derive_private_key, derive_tlc_pubkey, AddTlcCommand, ChannelActorStateStore,
+            ChannelCommand, ChannelCommandWithId, InMemorySigner, RemoveTlcCommand,
+            ShutdownCommand, DEFAULT_COMMITMENT_FEE_RATE,
         },
         config::DEFAULT_CHANNEL_MINIMAL_CKB_AMOUNT,
         hash_algorithm::HashAlgorithm,
@@ -44,18 +44,6 @@ fn test_derive_private_and_public_tlc_keys() {
     assert_eq!(derived_privkey.pubkey(), derived_pubkey);
 }
 
-#[test]
-fn test_derive_private_and_public_revocation_keys() {
-    let base_revocation_key = Privkey::from(&[1; 32]);
-    let per_commitment_secret = Privkey::from(&[2; 32]);
-    let derived_privkey = derive_private_key(&per_commitment_secret, &base_revocation_key.pubkey());
-    let derived_pubkey = derive_revocation_pubkey(
-        &base_revocation_key.pubkey(),
-        &per_commitment_secret.pubkey(),
-    );
-    assert_eq!(derived_privkey.pubkey(), derived_pubkey);
-}
-
 #[tokio::test]
 async fn test_open_channel_to_peer() {
     let [node_a, mut node_b] = NetworkNode::new_n_interconnected_nodes().await;
@@ -69,6 +57,7 @@ async fn test_open_channel_to_peer() {
                 funding_amount: 100000000000,
                 funding_udt_type_script: None,
                 commitment_fee_rate: None,
+                commitment_delay_epoch: None,
                 funding_fee_rate: None,
                 tlc_locktime_expiry_delta: None,
                 tlc_min_value: None,
@@ -109,6 +98,7 @@ async fn test_open_and_accept_channel() {
                 funding_amount: 100000000000,
                 funding_udt_type_script: None,
                 commitment_fee_rate: None,
+                commitment_delay_epoch: None,
                 funding_fee_rate: None,
                 tlc_locktime_expiry_delta: None,
                 tlc_min_value: None,
@@ -207,6 +197,7 @@ async fn do_test_channel_commitment_tx_after_add_tlc(algorithm: HashAlgorithm) {
                 funding_amount: node_a_funding_amount,
                 funding_udt_type_script: None,
                 commitment_fee_rate: None,
+                commitment_delay_epoch: None,
                 funding_fee_rate: None,
                 tlc_locktime_expiry_delta: None,
                 tlc_min_value: None,
@@ -397,6 +388,7 @@ async fn create_nodes_with_established_channel(
                 funding_amount: node_a_funding_amount,
                 funding_udt_type_script: None,
                 commitment_fee_rate: None,
+                commitment_delay_epoch: None,
                 funding_fee_rate: None,
                 tlc_locktime_expiry_delta: None,
                 tlc_min_value: None,
@@ -734,6 +726,7 @@ async fn test_open_channel_with_invalid_ckb_amount_range() {
                 funding_amount: 0xfffffffffffffffffffffffffffffff,
                 funding_udt_type_script: None,
                 commitment_fee_rate: None,
+                commitment_delay_epoch: None,
                 funding_fee_rate: None,
                 tlc_locktime_expiry_delta: None,
                 tlc_min_value: None,
@@ -768,6 +761,7 @@ async fn test_revoke_old_commitment_transaction() {
                 funding_amount: 100000000000,
                 funding_udt_type_script: None,
                 commitment_fee_rate: None,
+                commitment_delay_epoch: None,
                 funding_fee_rate: None,
                 tlc_locktime_expiry_delta: None,
                 tlc_min_value: None,
@@ -945,6 +939,7 @@ async fn test_create_channel() {
                 funding_amount: 100000000000,
                 funding_udt_type_script: None,
                 commitment_fee_rate: None,
+                commitment_delay_epoch: None,
                 funding_fee_rate: None,
                 tlc_locktime_expiry_delta: None,
                 tlc_min_value: None,
@@ -1069,6 +1064,7 @@ async fn test_reestablish_channel() {
                 funding_amount: 100000000000,
                 funding_udt_type_script: None,
                 commitment_fee_rate: None,
+                commitment_delay_epoch: None,
                 funding_fee_rate: None,
                 tlc_locktime_expiry_delta: None,
                 tlc_min_value: None,
diff --git a/src/fiber/types.rs b/src/fiber/types.rs
index 4ecca2c3..ba906bbb 100644
--- a/src/fiber/types.rs
+++ b/src/fiber/types.rs
@@ -642,14 +642,11 @@ pub struct OpenChannel {
     pub reserved_ckb_amount: u64,
     pub funding_fee_rate: u64,
     pub commitment_fee_rate: u64,
+    pub commitment_delay_epoch: u64,
     pub max_tlc_value_in_flight: u128,
     pub max_tlc_number_in_flight: u64,
     pub min_tlc_value: u128,
-    pub to_local_delay: LockTime,
     pub funding_pubkey: Pubkey,
-    pub revocation_basepoint: Pubkey,
-    pub payment_basepoint: Pubkey,
-    pub delayed_payment_basepoint: Pubkey,
     pub tlc_basepoint: Pubkey,
     pub first_per_commitment_point: Pubkey,
     pub second_per_commitment_point: Pubkey,
@@ -682,15 +679,12 @@ impl From<OpenChannel> for molecule_fiber::OpenChannel {
             .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())
+            .commitment_delay_epoch(open_channel.commitment_delay_epoch.pack())
             .max_tlc_value_in_flight(open_channel.max_tlc_value_in_flight.pack())
             .max_tlc_number_in_flight(open_channel.max_tlc_number_in_flight.pack())
             .min_tlc_value(open_channel.min_tlc_value.pack())
             .shutdown_script(open_channel.shutdown_script)
-            .to_self_delay(open_channel.to_local_delay.into())
             .funding_pubkey(open_channel.funding_pubkey.into())
-            .revocation_basepoint(open_channel.revocation_basepoint.into())
-            .payment_basepoint(open_channel.payment_basepoint.into())
-            .delayed_payment_basepoint(open_channel.delayed_payment_basepoint.into())
             .tlc_basepoint(open_channel.tlc_basepoint.into())
             .first_per_commitment_point(open_channel.first_per_commitment_point.into())
             .second_per_commitment_point(open_channel.second_per_commitment_point.into())
@@ -718,14 +712,11 @@ impl TryFrom<molecule_fiber::OpenChannel> for OpenChannel {
             shutdown_script: open_channel.shutdown_script(),
             funding_fee_rate: open_channel.funding_fee_rate().unpack(),
             commitment_fee_rate: open_channel.commitment_fee_rate().unpack(),
+            commitment_delay_epoch: open_channel.commitment_delay_epoch().unpack(),
             max_tlc_value_in_flight: open_channel.max_tlc_value_in_flight().unpack(),
             max_tlc_number_in_flight: open_channel.max_tlc_number_in_flight().unpack(),
             min_tlc_value: open_channel.min_tlc_value().unpack(),
-            to_local_delay: open_channel.to_self_delay().try_into()?,
             funding_pubkey: open_channel.funding_pubkey().try_into()?,
-            revocation_basepoint: open_channel.revocation_basepoint().try_into()?,
-            payment_basepoint: open_channel.payment_basepoint().try_into()?,
-            delayed_payment_basepoint: open_channel.delayed_payment_basepoint().try_into()?,
             tlc_basepoint: open_channel.tlc_basepoint().try_into()?,
             first_per_commitment_point: open_channel.first_per_commitment_point().try_into()?,
             second_per_commitment_point: open_channel.second_per_commitment_point().try_into()?,
@@ -754,12 +745,8 @@ pub struct AcceptChannel {
     pub max_tlc_value_in_flight: u128,
     pub max_tlc_number_in_flight: u64,
     pub min_tlc_value: u128,
-    pub to_local_delay: LockTime,
     pub funding_pubkey: Pubkey,
     pub shutdown_script: Script,
-    pub revocation_basepoint: Pubkey,
-    pub payment_basepoint: Pubkey,
-    pub delayed_payment_basepoint: Pubkey,
     pub tlc_basepoint: Pubkey,
     pub first_per_commitment_point: Pubkey,
     pub second_per_commitment_point: Pubkey,
@@ -777,11 +764,7 @@ impl From<AcceptChannel> for molecule_fiber::AcceptChannel {
             .max_tlc_number_in_flight(accept_channel.max_tlc_number_in_flight.pack())
             .shutdown_script(accept_channel.shutdown_script)
             .min_tlc_value(accept_channel.min_tlc_value.pack())
-            .to_self_delay(accept_channel.to_local_delay.into())
             .funding_pubkey(accept_channel.funding_pubkey.into())
-            .revocation_basepoint(accept_channel.revocation_basepoint.into())
-            .payment_basepoint(accept_channel.payment_basepoint.into())
-            .delayed_payment_basepoint(accept_channel.delayed_payment_basepoint.into())
             .tlc_basepoint(accept_channel.tlc_basepoint.into())
             .first_per_commitment_point(accept_channel.first_per_commitment_point.into())
             .second_per_commitment_point(accept_channel.second_per_commitment_point.into())
@@ -811,11 +794,7 @@ impl TryFrom<molecule_fiber::AcceptChannel> for AcceptChannel {
             max_tlc_value_in_flight: accept_channel.max_tlc_value_in_flight().unpack(),
             max_tlc_number_in_flight: accept_channel.max_tlc_number_in_flight().unpack(),
             min_tlc_value: accept_channel.min_tlc_value().unpack(),
-            to_local_delay: accept_channel.to_self_delay().try_into()?,
             funding_pubkey: accept_channel.funding_pubkey().try_into()?,
-            revocation_basepoint: accept_channel.revocation_basepoint().try_into()?,
-            payment_basepoint: accept_channel.payment_basepoint().try_into()?,
-            delayed_payment_basepoint: accept_channel.delayed_payment_basepoint().try_into()?,
             tlc_basepoint: accept_channel.tlc_basepoint().try_into()?,
             first_per_commitment_point: accept_channel.first_per_commitment_point().try_into()?,
             second_per_commitment_point: accept_channel.second_per_commitment_point().try_into()?,
diff --git a/src/rpc/README.md b/src/rpc/README.md
index de9d791c..4fec6278 100644
--- a/src/rpc/README.md
+++ b/src/rpc/README.md
@@ -72,6 +72,7 @@ Attempts to open a channel with a peer.
 * `funding_udt_type_script` - The type script of the UDT to fund the channel with, an optional parameter
 * `shutdown_script` - The script used to receive the channel balance, an optional parameter, default value is the secp256k1_blake160_sighash_all script corresponding to the configured private key
 * `commitment_fee_rate` - The fee rate for the commitment transaction, an optional parameter
+* `commitment_delay_epoch` - The delay time for the commitment transaction, must be an [EpochNumberWithFraction](https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0017-tx-valid-since/e-i-l-encoding.png) in u64 format, an optional parameter, default value is 24 hours
 * `funding_fee_rate` - The fee rate for the funding transaction, an optional parameter
 * `tlc_locktime_expiry_delta` - The expiry delta for the TLC locktime, an optional parameter
 * `tlc_min_value` - The minimum value for a TLC, an optional parameter
@@ -383,4 +384,4 @@ Returns a struct with these fields:
     * `cell_deps`: The cell deps of the UDT, with fields of
         * `tx_hash`: The tx hash of the cell dep
         * `index`: The index of the cell dep
-        * `dep_type`: The dep type of the cell dep
\ No newline at end of file
+        * `dep_type`: The dep type of the cell dep
diff --git a/src/rpc/channel.rs b/src/rpc/channel.rs
index 300b06e8..9c105848 100644
--- a/src/rpc/channel.rs
+++ b/src/rpc/channel.rs
@@ -11,8 +11,8 @@ use crate::fiber::{
     NetworkActorCommand, NetworkActorMessage,
 };
 use crate::{handle_actor_call, handle_actor_cast, log_and_error};
-use ckb_jsonrpc_types::Script;
-use ckb_types::core::FeeRate;
+use ckb_jsonrpc_types::{EpochNumberWithFraction, Script};
+use ckb_types::core::{EpochNumberWithFraction as EpochNumberWithFractionCore, FeeRate};
 use jsonrpsee::{
     core::async_trait,
     proc_macros::rpc,
@@ -35,6 +35,7 @@ pub(crate) struct OpenChannelParams {
     public: Option<bool>,
     funding_udt_type_script: Option<Script>,
     shutdown_script: Option<Script>,
+    commitment_delay_epoch: Option<EpochNumberWithFraction>,
     #[serde_as(as = "Option<U64Hex>")]
     commitment_fee_rate: Option<u64>,
     #[serde_as(as = "Option<U64Hex>")]
@@ -307,6 +308,10 @@ where
                     funding_amount: params.funding_amount,
                     public: params.public.unwrap_or(false),
                     shutdown_script: params.shutdown_script.clone().map(|s| s.into()),
+                    commitment_delay_epoch: params
+                        .commitment_delay_epoch
+                        .clone()
+                        .map(|e| EpochNumberWithFractionCore::from_full_value(e.value())),
                     funding_udt_type_script: params
                         .funding_udt_type_script
                         .clone()
diff --git a/tests/bruno/e2e/open-use-close-a-channel/02-open-channel.bru b/tests/bruno/e2e/open-use-close-a-channel/02-open-channel.bru
index 9ddbbe7d..be94e30f 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/02-open-channel.bru
+++ b/tests/bruno/e2e/open-use-close-a-channel/02-open-channel.bru
@@ -23,7 +23,8 @@ body:json {
     "params": [
       {
         "peer_id": "{{NODE1_PEERID}}",
-        "funding_amount": "0xba43b7400"
+        "funding_amount": "0xba43b7400",
+        "commitment_delay_epoch": "0x20001000003"
       }
     ]
   }
diff --git a/tests/bruno/e2e/open-use-close-a-channel/README.md b/tests/bruno/e2e/open-use-close-a-channel/README.md
index ed4caef1..f7ec2da9 100644
--- a/tests/bruno/e2e/open-use-close-a-channel/README.md
+++ b/tests/bruno/e2e/open-use-close-a-channel/README.md
@@ -27,6 +27,8 @@ The whole process is something like:
 21. There are still payment1, payment4 and payment5 waiting for resolution. We remove them payment1 and payment5 by failing them from NODE1, and complete payment4 from NODE3. NODE1 has 101000000000 ckb ready to use, and NODE3 has 49000000000 ckb ready to use.
 22. NODE3 and NODE1 automatically send a `closing_signed` to their counterparty on all tlc finished.
 
+Note that the channel is opened with a delay of 3.5 epochs (14 hours), 3.5 epochs is [presented](https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0017-tx-valid-since/e-i-l-encoding.png) as 3(E) and 1(I)/2(L): (L << 40) | (I << 24) | E = 0x20001000003,
+
 ## Starting nodes
 
 ```