diff --git a/crates/benches/benches/benchmarks/smt.rs b/crates/benches/benches/benchmarks/smt.rs
index d55e54c48..9dd066c98 100644
--- a/crates/benches/benches/benchmarks/smt.rs
+++ b/crates/benches/benches/benchmarks/smt.rs
@@ -146,6 +146,7 @@ impl BenchExecutionEnvironment {
         let rollup_context = RollupContext {
             rollup_config: genesis_config.rollup_config.clone().into(),
             rollup_script_hash: ROLLUP_TYPE_HASH.into(),
+            ..Default::default()
         };
 
         let backend_manage = {
diff --git a/crates/benches/benches/benchmarks/sudt.rs b/crates/benches/benches/benchmarks/sudt.rs
index 2ca6a0a66..4cbe8fae2 100644
--- a/crates/benches/benches/benchmarks/sudt.rs
+++ b/crates/benches/benches/benchmarks/sudt.rs
@@ -104,6 +104,7 @@ fn run_contract_get_result<S: State + CodeStore + JournalDB>(
     let rollup_ctx = RollupContext {
         rollup_config: rollup_config.clone(),
         rollup_script_hash: [42u8; 32].into(),
+        ..Default::default()
     };
     let generator = Generator::new(
         backend_manage,
diff --git a/crates/generator/src/utils.rs b/crates/generator/src/utils.rs
index fe6bf690a..e943eb0e2 100644
--- a/crates/generator/src/utils.rs
+++ b/crates/generator/src/utils.rs
@@ -3,6 +3,7 @@ use std::convert::TryInto;
 use gw_common::{builtins::CKB_SUDT_ACCOUNT_ID, state::State, H256};
 use gw_config::BackendType;
 use gw_traits::CodeStore;
+use gw_types::core::Timepoint;
 use gw_types::{
     bytes::Bytes,
     core::{AllowedContractType, ScriptHashType},
@@ -43,7 +44,7 @@ pub fn build_withdrawal_cell_output(
     rollup_context: &RollupContext,
     req: &WithdrawalRequestExtra,
     block_hash: &H256,
-    block_number: u64,
+    block_timepoint: &Timepoint,
     opt_asset_script: Option<Script>,
 ) -> Result<(CellOutput, Bytes), WithdrawalCellError> {
     let withdrawal_capacity: u64 = req.raw().capacity().unpack();
@@ -51,7 +52,7 @@ pub fn build_withdrawal_cell_output(
         let withdrawal_lock_args = WithdrawalLockArgs::new_builder()
             .account_script_hash(req.raw().account_script_hash())
             .withdrawal_block_hash(Into::<[u8; 32]>::into(*block_hash).pack())
-            .withdrawal_block_number(block_number.pack())
+            .withdrawal_block_number(block_timepoint.full_value().pack())
             .owner_lock_hash(req.raw().owner_lock_hash())
             .build();
 
@@ -138,7 +139,7 @@ mod test {
     use gw_common::h256_ext::H256Ext;
     use gw_common::H256;
     use gw_types::bytes::Bytes;
-    use gw_types::core::ScriptHashType;
+    use gw_types::core::{ScriptHashType, Timepoint};
     use gw_types::offchain::RollupContext;
     use gw_types::packed::{
         RawWithdrawalRequest, RollupConfig, Script, WithdrawalRequest, WithdrawalRequestExtra,
@@ -155,6 +156,7 @@ mod test {
             rollup_config: RollupConfig::new_builder()
                 .withdrawal_script_type_hash(H256::from_u32(100).pack())
                 .build(),
+            ..Default::default()
         };
         let sudt_script = Script::new_builder()
             .code_hash(H256::from_u32(1).pack())
@@ -188,12 +190,12 @@ mod test {
             .build();
 
         let block_hash = H256::from_u32(11);
-        let block_number = 11u64;
+        let block_timepoint = Timepoint::from_block_number(11);
         let (output, data) = build_withdrawal_cell_output(
             &rollup_context,
             &withdrawal,
             &block_hash,
-            block_number,
+            &block_timepoint,
             Some(sudt_script.clone()),
         )
         .unwrap();
@@ -226,7 +228,10 @@ mod test {
             req.raw().account_script_hash()
         );
         assert_eq!(lock_args.withdrawal_block_hash(), block_hash.pack());
-        assert_eq!(lock_args.withdrawal_block_number().unpack(), block_number);
+        assert_eq!(
+            lock_args.withdrawal_block_number().unpack(),
+            block_timepoint.full_value()
+        );
         assert_eq!(lock_args.owner_lock_hash(), owner_lock.hash().pack());
 
         // ## None asset script
@@ -234,7 +239,7 @@ mod test {
             &rollup_context,
             &withdrawal,
             &block_hash,
-            block_number,
+            &block_timepoint,
             None,
         )
         .unwrap();
@@ -261,7 +266,7 @@ mod test {
                 .owner_lock(owner_lock)
                 .build(),
             &block_hash,
-            block_number,
+            &block_timepoint,
             Some(sudt_script.clone()),
         )
         .unwrap_err();
@@ -286,7 +291,7 @@ mod test {
                 .owner_lock(err_owner_lock)
                 .build(),
             &block_hash,
-            block_number,
+            &block_timepoint,
             Some(sudt_script),
         )
         .unwrap_err();
diff --git a/crates/tests/src/testing_tool/chain.rs b/crates/tests/src/testing_tool/chain.rs
index 1a50278cd..508aca1a3 100644
--- a/crates/tests/src/testing_tool/chain.rs
+++ b/crates/tests/src/testing_tool/chain.rs
@@ -463,6 +463,7 @@ pub fn chain_generator(chain: &Chain, rollup_type_script: Script) -> Arc<Generat
     let rollup_context = RollupContext {
         rollup_script_hash: rollup_type_script.hash().into(),
         rollup_config,
+        ..Default::default()
     };
     Arc::new(Generator::new(
         backend_manage,
@@ -499,6 +500,7 @@ pub async fn setup_chain_with_account_lock_manage(
     let rollup_context = RollupContext {
         rollup_script_hash: rollup_script_hash.into(),
         rollup_config: rollup_config.clone(),
+        ..Default::default()
     };
     let generator = Arc::new(Generator::new(
         backend_manage,
@@ -519,7 +521,7 @@ pub async fn setup_chain_with_account_lock_manage(
     };
     let mem_pool = MemPool::create(args).await.unwrap();
     Chain::create(
-        &rollup_config,
+        rollup_config.clone(),
         &rollup_type_script,
         &ChainConfig::default(),
         store,
@@ -615,7 +617,7 @@ pub async fn construct_block_with_timestamp(
     let stake_cell_owner_lock_hash = H256::zero();
     let db = &chain.store().begin_transaction();
     let generator = chain.generator();
-    let rollup_config_hash = (*chain.rollup_config_hash()).into();
+    let rollup_config_hash = chain.rollup_config_hash().into();
 
     let provider = DummyMemPoolProvider {
         deposit_cells: deposit_info_vec.unpack(),
@@ -636,10 +638,12 @@ pub async fn construct_block_with_timestamp(
     let remaining_capacity = mem_block.take_finalized_custodians_capacity();
     let block_param = generate_produce_block_param(chain.store(), mem_block, post_merkle_state)?;
     let reverted_block_root = db.get_reverted_block_smt_root().unwrap();
+    let l1_confirmed_header_timestamp = 0;
     let param = ProduceBlockParam {
         stake_cell_owner_lock_hash,
         rollup_config_hash,
         reverted_block_root,
+        l1_confirmed_header_timestamp,
         block_param,
     };
     produce_block(db, generator, param).map(|mut r| {
diff --git a/crates/tests/src/tests/export_import_block.rs b/crates/tests/src/tests/export_import_block.rs
index 6b7f0ee1b..8b4526774 100644
--- a/crates/tests/src/tests/export_import_block.rs
+++ b/crates/tests/src/tests/export_import_block.rs
@@ -22,7 +22,7 @@ use gw_generator::account_lock_manage::always_success::AlwaysSuccess;
 use gw_generator::account_lock_manage::secp256k1::Secp256k1Eth;
 use gw_generator::account_lock_manage::AccountLockManage;
 use gw_store::{readonly::StoreReadonly, traits::chain_store::ChainStore, Store};
-use gw_types::core::Status;
+use gw_types::core::{Status, Timepoint};
 use gw_types::packed::DepositInfoVec;
 use gw_types::{
     bytes::Bytes,
@@ -67,9 +67,9 @@ async fn test_export_import_block() {
         .finality_blocks(0u64.pack())
         .build();
 
-    let last_finalized_block_number = 100u64;
+    let last_finalized_timepoint = Timepoint::from_block_number(100);
     let global_state = GlobalState::new_builder()
-        .last_finalized_block_number(last_finalized_block_number.pack())
+        .last_finalized_block_number(last_finalized_timepoint.full_value().pack())
         .rollup_config_hash(rollup_config.hash().pack())
         .build();
 
diff --git a/crates/tests/src/tests/mem_block_repackage.rs b/crates/tests/src/tests/mem_block_repackage.rs
index e81f0b799..b3a174cdd 100644
--- a/crates/tests/src/tests/mem_block_repackage.rs
+++ b/crates/tests/src/tests/mem_block_repackage.rs
@@ -78,12 +78,14 @@ async fn test_repackage_mem_block() {
         let smt = db.reverted_block_smt().unwrap();
         smt.root().to_owned()
     };
+    let l1_confirmed_header_timestamp = 0;
     let param = ProduceBlockParam {
         stake_cell_owner_lock_hash: random_always_success_script(&rollup_script_hash)
             .hash()
             .into(),
         reverted_block_root,
         rollup_config_hash: rollup_context.rollup_config.hash().into(),
+        l1_confirmed_header_timestamp,
         block_param,
     };
     let store = chain.store();
diff --git a/crates/tests/src/tests/restore_mem_pool_pending_withdrawal.rs b/crates/tests/src/tests/restore_mem_pool_pending_withdrawal.rs
index 8d4aeb72d..d93a1f73e 100644
--- a/crates/tests/src/tests/restore_mem_pool_pending_withdrawal.rs
+++ b/crates/tests/src/tests/restore_mem_pool_pending_withdrawal.rs
@@ -3,7 +3,7 @@ use std::time::Duration;
 
 use crate::testing_tool::chain::{
     build_sync_tx, construct_block, construct_block_with_timestamp, into_deposit_info_cell,
-    produce_empty_block, restart_chain, setup_chain, DEFAULT_FINALITY_BLOCKS, TEST_CHAIN_ID,
+    restart_chain, setup_chain, DEFAULT_FINALITY_BLOCKS, TEST_CHAIN_ID,
 };
 use crate::testing_tool::common::random_always_success_script;
 use crate::testing_tool::mem_pool_provider::DummyMemPoolProvider;
@@ -77,7 +77,29 @@ async fn test_restore_mem_pool_pending_withdrawal() {
     assert!(chain.last_sync_event().is_success());
 
     for _ in 0..DEFAULT_FINALITY_BLOCKS {
-        produce_empty_block(&mut chain).await.unwrap();
+        let block_result = {
+            let mem_pool = chain.mem_pool().as_ref().unwrap();
+            let mut mem_pool = mem_pool.lock().await;
+            construct_block(&chain, &mut mem_pool, Default::default())
+                .await
+                .unwrap()
+        };
+        let empty_l1action = L1Action {
+            context: L1ActionContext::SubmitBlock {
+                l2block: block_result.block.clone(),
+                deposit_info_vec: Default::default(),
+                deposit_asset_scripts: Default::default(),
+                withdrawals: Default::default(),
+            },
+            transaction: build_sync_tx(rollup_cell.clone(), block_result),
+        };
+        let param = SyncParam {
+            updates: vec![empty_l1action],
+            reverts: Default::default(),
+        };
+        chain.sync(param).await.unwrap();
+        chain.notify_new_tip().await.unwrap();
+        assert!(chain.last_sync_event().is_success());
     }
 
     // Generate withdrawals
diff --git a/crates/tests/src/tests/unlock_withdrawal_to_owner.rs b/crates/tests/src/tests/unlock_withdrawal_to_owner.rs
index 8059ecd77..262564873 100644
--- a/crates/tests/src/tests/unlock_withdrawal_to_owner.rs
+++ b/crates/tests/src/tests/unlock_withdrawal_to_owner.rs
@@ -25,15 +25,16 @@ use gw_common::sparse_merkle_tree::default_store::DefaultStore;
 use gw_common::H256;
 use gw_config::ContractsCellDep;
 use gw_types::bytes::Bytes;
-use gw_types::core::{AllowedEoaType, DepType, ScriptHashType};
+use gw_types::core::{AllowedEoaType, DepType, ScriptHashType, Timepoint};
 use gw_types::offchain::{
-    CellInfo, CollectedCustodianCells, FinalizedCustodianCapacity, InputCellInfo, RollupContext,
+    CellInfo, CollectedCustodianCells, CompatibleFinalizedTimepoint, FinalizedCustodianCapacity,
+    InputCellInfo, RollupContext,
 };
 use gw_types::packed::{
-    self, AllowedTypeHash, CellDep, CellInput, CellOutput, CustodianLockArgs, DepositRequest,
-    GlobalState, OutPoint, RawWithdrawalRequest, RollupAction, RollupActionUnion, RollupConfig,
-    RollupSubmitBlock, Script, StakeLockArgs, WithdrawalRequest, WithdrawalRequestExtra,
-    WitnessArgs,
+    self, AllowedTypeHash, BlockMerkleState, CellDep, CellInput, CellOutput, CustodianLockArgs,
+    DepositRequest, GlobalState, OutPoint, RawWithdrawalRequest, RollupAction, RollupActionUnion,
+    RollupConfig, RollupSubmitBlock, Script, StakeLockArgs, WithdrawalRequest,
+    WithdrawalRequestExtra, WitnessArgs,
 };
 use gw_types::prelude::{Pack, PackVec, Unpack};
 use gw_utils::local_cells::LocalCellsManager;
@@ -130,9 +131,18 @@ async fn test_build_unlock_to_owner_tx() {
         data: rollup_config.as_bytes(),
     };
 
-    let last_finalized_block_number = 100u64;
+    let last_finalized_block_number = 100;
+    let last_finalized_timepoint = Timepoint::from_block_number(last_finalized_block_number);
     let global_state = GlobalState::new_builder()
-        .last_finalized_block_number(last_finalized_block_number.pack())
+        .last_finalized_block_number(last_finalized_timepoint.full_value().pack())
+        .block(
+            BlockMerkleState::new_builder()
+                .count(
+                    (1 + last_finalized_block_number + rollup_config.finality_blocks().unpack())
+                        .pack(),
+                )
+                .build(),
+        )
         .rollup_config_hash(rollup_config.hash().pack())
         .build();
 
@@ -167,7 +177,8 @@ async fn test_build_unlock_to_owner_tx() {
         setup_chain_with_config(rollup_type_script.clone(), rollup_config.clone()).await;
     let rollup_context = RollupContext {
         rollup_script_hash,
-        rollup_config,
+        rollup_config: rollup_config.clone(),
+        ..Default::default()
     };
 
     let contracts_dep = ContractsCellDep {
@@ -183,6 +194,10 @@ async fn test_build_unlock_to_owner_tx() {
             .out_point(custodian_lock_cell.out_point.clone())
             .build()
             .into(),
+        rollup_config: CellDep::new_builder()
+            .out_point(rollup_config_cell.out_point.clone())
+            .build()
+            .into(),
         ..Default::default()
     };
 
@@ -356,7 +371,6 @@ async fn test_build_unlock_to_owner_tx() {
             .hash_type(ScriptHashType::Type.into())
             .args(lock_args.pack())
             .build();
-
         CellInfo {
             out_point: OutPoint::new_builder()
                 .tx_hash(rand::random::<[u8; 32]>().pack())
@@ -369,9 +383,10 @@ async fn test_build_unlock_to_owner_tx() {
         }
     };
     let output_stake = {
-        let block_number = withdrawal_block_result.block.raw().number();
+        let stake_timepoint =
+            Timepoint::from_block_number(withdrawal_block_result.block.raw().number().unpack());
         let stake_lock_args = StakeLockArgs::new_builder()
-            .stake_block_number(block_number)
+            .stake_block_number(stake_timepoint.full_value().pack())
             .build();
 
         let mut lock_args = rollup_script_hash.as_slice().to_vec();
@@ -474,7 +489,7 @@ async fn test_build_unlock_to_owner_tx() {
         cell_deps: input_cell_deps,
         inputs,
     };
-    verify_tx(tx_with_context, 7000_0000u64).expect("pass");
+    verify_tx(tx_with_context, 700_000_000_u64).expect("pass");
 
     // Check unlock to owner tx
     let random_withdrawal_cells = {
@@ -497,6 +512,7 @@ async fn test_build_unlock_to_owner_tx() {
         withdrawals: random_withdrawal_cells.clone(),
     };
     let cell_deps = vec![
+        into_input_cell(rollup_config_cell.clone()),
         into_input_cell(rollup_cell.clone()),
         into_input_cell(always_cell.clone()),
         into_input_cell(withdrawal_lock_cell.clone()),
@@ -520,16 +536,20 @@ async fn test_build_unlock_to_owner_tx() {
         inputs,
     };
 
-    verify_tx(tx_with_context, 7000_0000u64).expect("pass");
+    verify_tx(tx_with_context, 700_000_000_u64).expect("pass");
 
     // Simulate rpc client filter no owner lock withdrawal cells
-    let last_finalized_block_number = withdrawal_block_result.block.raw().number().unpack();
+    let finality_as_blocks = rollup_config.finality_blocks().unpack();
+    let compatible_finalized_timepoint = CompatibleFinalizedTimepoint::from_block_number(
+        withdrawal_block_result.block.raw().number().unpack() + finality_as_blocks,
+        finality_as_blocks,
+    );
     let unlockable_random_withdrawals: Vec<_> = random_withdrawal_cells
         .into_iter()
         .filter(|cell| {
             gw_rpc_client::withdrawal::verify_unlockable_to_owner(
                 cell,
-                last_finalized_block_number,
+                &compatible_finalized_timepoint,
                 &rollup_context.rollup_config.l1_sudt_script_type_hash(),
             )
             .is_ok()
@@ -556,7 +576,7 @@ async fn test_build_unlock_to_owner_tx() {
         inputs,
     };
 
-    verify_tx(tx_with_context, 7000_0000u64).expect("pass");
+    verify_tx(tx_with_context, 700_000_000_u64).expect("pass");
 
     // Make sure revert withdrawal also work
     const BLOCK_TIMESTAMP2: u64 = BLOCK_TIMESTAMP * 2;
@@ -631,9 +651,10 @@ async fn test_build_unlock_to_owner_tx() {
     let output_rollup_cell = (rollup_cell.output, block_result.global_state.as_bytes());
 
     let output_stake = {
-        let block_number = block_result.block.raw().number();
+        let stake_timepoint =
+            Timepoint::from_block_number(block_result.block.raw().number().unpack());
         let stake_lock_args = StakeLockArgs::new_builder()
-            .stake_block_number(block_number)
+            .stake_block_number(stake_timepoint.full_value().pack())
             .build();
 
         let mut lock_args = rollup_script_hash.as_slice().to_vec();
@@ -644,7 +665,6 @@ async fn test_build_unlock_to_owner_tx() {
             .hash_type(ScriptHashType::Type.into())
             .args(lock_args.pack())
             .build();
-
         let output = CellOutput::new_builder()
             .capacity(STAKE_CAPACITY.pack())
             .lock(stake_lock)
@@ -735,7 +755,7 @@ async fn test_build_unlock_to_owner_tx() {
         cell_deps: input_cell_deps,
         inputs,
     };
-    verify_tx(tx_with_context, 7000_0000u64).expect("pass");
+    verify_tx(tx_with_context, 700_000_000_u64).expect("pass");
 }
 
 struct DummyUnlocker {
@@ -761,7 +781,7 @@ impl BuildUnlockWithdrawalToOwner for DummyUnlocker {
 
     async fn query_unlockable_withdrawals(
         &self,
-        _last_finalized_block_number: u64,
+        _last_finalized_timepoint: &CompatibleFinalizedTimepoint,
         _unlocked: &HashSet<OutPoint>,
     ) -> anyhow::Result<Vec<CellInfo>> {
         Ok(self.withdrawals.clone())
diff --git a/crates/tools/src/deposit_ckb.rs b/crates/tools/src/deposit_ckb.rs
index 3172341c0..173c3b912 100644
--- a/crates/tools/src/deposit_ckb.rs
+++ b/crates/tools/src/deposit_ckb.rs
@@ -12,6 +12,7 @@ use ckb_types::{
     prelude::Unpack as CKBUnpack,
 };
 use gw_common::builtins::{CKB_SUDT_ACCOUNT_ID, ETH_REGISTRY_ACCOUNT_ID};
+use gw_types::core::Timepoint;
 use gw_types::packed::{CellOutput, CustodianLockArgs};
 use gw_types::U256;
 use gw_types::{
@@ -239,12 +240,12 @@ async fn get_balance_by_script_hash(
 fn minimal_deposit_capacity(deposit_lock_args: &DepositLockArgs) -> Result<u64> {
     // fixed size, the specific value is not important.
     let dummy_hash = gw_types::core::H256::zero();
-    let dummy_block_number = 0u64;
+    let dummy_timepoint = Timepoint::from_block_number(0);
     let dummy_rollup_type_hash = dummy_hash;
 
     let custodian_lock_args = CustodianLockArgs::new_builder()
         .deposit_block_hash(dummy_hash.pack())
-        .deposit_block_number(gw_types::prelude::Pack::pack(&dummy_block_number))
+        .deposit_block_number(gw_types::prelude::Pack::pack(&dummy_timepoint.full_value()))
         .deposit_lock_args(deposit_lock_args.clone())
         .build();
 
diff --git a/crates/tools/src/main.rs b/crates/tools/src/main.rs
index 0097bb630..6d5852e8b 100644
--- a/crates/tools/src/main.rs
+++ b/crates/tools/src/main.rs
@@ -34,6 +34,7 @@ use godwoken_rpc::GodwokenRpcClient;
 use gw_common::builtins::ETH_REGISTRY_ACCOUNT_ID;
 use gw_jsonrpc_types::godwoken::ChallengeTargetType;
 use gw_rpc_client::indexer_client::CKBIndexerClient;
+use gw_types::offchain::CompatibleFinalizedTimepoint;
 use std::{
     collections::HashMap,
     path::{Path, PathBuf},
@@ -1447,9 +1448,10 @@ async fn main() -> Result<()> {
             let custodian_script_type_hash =
                 cli_args::to_h256(m.value_of("custodian-script-type-hash").unwrap())?;
             let min_capacity: u64 = m.value_of("min-capacity").unwrap_or_default().parse()?;
-            let tip_block_number: u64 =
+            let _tip_block_number: u64 =
                 m.value_of("tip-block-number").unwrap_or_default().parse()?;
-            let finalize_blocks: u64 = m.value_of("finality-blocks").unwrap_or_default().parse()?;
+            let _finalize_blocks: u64 =
+                m.value_of("finality-blocks").unwrap_or_default().parse()?;
             let rpc_client = CKBIndexerClient::with_url(indexer_rpc_url)?;
 
             let alias: HashMap<ckb_types::bytes::Bytes, String> = [
@@ -1483,14 +1485,16 @@ async fn main() -> Result<()> {
             })
             .collect();
 
-            let last_finalized_block_number = tip_block_number.saturating_sub(finalize_blocks);
+            // FIXME @keroro520 get global state, construct CompatibleFinalizedTimepoint
+            let compatible_finalized_timepoint = CompatibleFinalizedTimepoint::default();
+            // tip_block_number.saturating_sub(finalize_blocks);
 
             let stat = stat::stat_custodian_cells(
                 &rpc_client,
                 &rollup_type_hash.into(),
                 &custodian_script_type_hash.into(),
                 Some(min_capacity),
-                last_finalized_block_number,
+                &compatible_finalized_timepoint,
             )
             .await?;
 
diff --git a/crates/tools/src/stat/mod.rs b/crates/tools/src/stat/mod.rs
index d437e4434..28e978056 100644
--- a/crates/tools/src/stat/mod.rs
+++ b/crates/tools/src/stat/mod.rs
@@ -2,6 +2,7 @@ use anyhow::Result;
 use ckb_types::prelude::{Builder, Entity};
 use gw_common::H256;
 use gw_rpc_client::indexer_client::CKBIndexerClient;
+use gw_types::offchain::CompatibleFinalizedTimepoint;
 use gw_types::{core::ScriptHashType, offchain::CustodianStat, packed::Script, prelude::Pack};
 
 /// Query custodian ckb from ckb-indexer
@@ -10,7 +11,7 @@ pub async fn stat_custodian_cells(
     rollup_type_hash: &H256,
     custodian_script_type_hash: &H256,
     min_capacity: Option<u64>,
-    last_finalized_block_number: u64,
+    compatible_finalized_timepoint: &CompatibleFinalizedTimepoint,
 ) -> Result<CustodianStat> {
     let script = Script::new_builder()
         .code_hash(custodian_script_type_hash.pack())
@@ -18,6 +19,6 @@ pub async fn stat_custodian_cells(
         .args(rollup_type_hash.as_slice().to_vec().pack())
         .build();
     rpc_client
-        .stat_custodian_cells(script, min_capacity, last_finalized_block_number)
+        .stat_custodian_cells(script, min_capacity, compatible_finalized_timepoint)
         .await
 }
diff --git a/crates/tools/src/withdraw.rs b/crates/tools/src/withdraw.rs
index e67424450..b6af26b0e 100644
--- a/crates/tools/src/withdraw.rs
+++ b/crates/tools/src/withdraw.rs
@@ -13,7 +13,7 @@ use gw_generator::account_lock_manage::{
     eip712::{traits::EIP712Encode, types::Withdrawal},
     secp256k1::Secp256k1Eth,
 };
-use gw_types::core::ScriptHashType;
+use gw_types::core::{ScriptHashType, Timepoint};
 use gw_types::packed::{CellOutput, Script, WithdrawalLockArgs, WithdrawalRequestExtra};
 use gw_types::U256;
 use gw_types::{
@@ -216,13 +216,13 @@ fn parse_capacity(capacity: &str) -> Result<u64> {
 fn minimal_withdrawal_capacity(is_sudt: bool) -> Result<u64> {
     // fixed size, the specific value is not important.
     let dummy_hash = gw_types::core::H256::zero();
-    let dummy_block_number = 0u64;
+    let dummy_timepoint = Timepoint::from_block_number(0);
     let dummy_rollup_type_hash = dummy_hash;
 
     let dummy_withdrawal_lock_args = WithdrawalLockArgs::new_builder()
         .account_script_hash(dummy_hash.pack())
         .withdrawal_block_hash(dummy_hash.pack())
-        .withdrawal_block_number(dummy_block_number.pack())
+        .withdrawal_block_number(dummy_timepoint.full_value().pack())
         .owner_lock_hash(dummy_hash.pack())
         .build();