fix: use prev_global_state as standard

contracts/custodian-lock/src/entry.rs

@@ -65,7 +65,7 @@ pub fn main() -> Result<(), Error> {
         &config,
         &global_state,
         &Timepoint::from_full_value(lock_args.deposit_block_number().unpack()),
-    )?;
+    );
     if is_finalized {
         // this custodian lock is already finalized, rollup will handle the logic
         return Ok(());

contracts/gw-utils/src/finality.rs

@@ -6,27 +6,27 @@
 //!
 //! **IMPORTANT NOTE: Offchain and onchain checking logic must be consistent.**
 //!
-//! - Entity is number-based, post_global_state.last_finalized_block_number is number-based
+//! - Entity is number-based, prev_global_state.last_finalized_block_number is number-based
 //!
-//!   Assert entity's timepoint <= post_global_state.last_finalized_block_number
+//!   Assert entity's timepoint <= prev_global_state.last_finalized_block_number
 //!
-//! - Entity is number-based, post_global_state.last_finalized_block_number is timestamp-based
+//! - Entity is number-based, prev_global_state.last_finalized_block_number is timestamp-based
 //!
-//!   Instead of using post_global_state.last_finalized_block_number, we choose post_global_state.block.count as finality standard.
+//!   Instead of using prev_global_state.last_finalized_block_number, we choose prev_global_state.block.count as finality standard.
 //!
-//!   Assert entity's timepoint <= post_global_state.block.count - 1 + FINALITY_REQUIREMENT
+//!   Assert entity's timepoint <= prev_global_state.block.count - 1 + FINALITY_REQUIREMENT
 //!
-//! - Entity is timestamp-based, post_global_state.last_finalized_block_number is number-based
+//! - Entity is timestamp-based, prev_global_state.last_finalized_block_number is number-based
 //!
-//!   Invalid
+//!   Currently swtiching version from v1 to v2, the entity is sure unfinalized.
 //!
-//! - Entity is timestamp-based, post_global_state.last_finalized_block_number is timestamp-based
+//! - Entity is timestamp-based, prev_global_state.last_finalized_block_number is timestamp-based
 //!
-//!   Assert entity's timepoint <= post_global_state.last_finalized_block_number
+//!   Assert entity's timepoint <= prev_global_state.last_finalized_block_number
 
-use crate::error::Error;
 use ckb_std::{
     ckb_constants::Source,
+    debug,
     high_level::{load_header, QueryIter},
 };
 use gw_types::core::Timepoint;
@@ -38,36 +38,37 @@ const BLOCK_INTERVAL_IN_MILLISECONDS: u64 = 36000;
 
 pub fn is_finalized(
     rollup_config: &RollupConfig,
-    global_state: &GlobalState,
+    prev_global_state: &GlobalState,
     timepoint: &Timepoint,
-) -> Result<bool, Error> {
+) -> bool {
     match timepoint {
-        Timepoint::BlockNumber(block_number) => Ok(is_block_number_finalized(
-            rollup_config,
-            global_state,
-            *block_number,
-        )),
-        Timepoint::Timestamp(timestamp) => is_timestamp_finalized(global_state, *timestamp),
+        Timepoint::BlockNumber(block_number) => {
+            is_block_number_finalized(rollup_config, prev_global_state, *block_number)
+        }
+        Timepoint::Timestamp(timestamp) => is_timestamp_finalized(prev_global_state, *timestamp),
     }
 }
 
-pub fn is_timestamp_finalized(global_state: &GlobalState, timestamp: u64) -> Result<bool, Error> {
-    match Timepoint::from_full_value(global_state.last_finalized_block_number().unpack()) {
-        Timepoint::BlockNumber(_) => Err(Error::InvalidPostGlobalState),
-        Timepoint::Timestamp(finalized) => Ok(timestamp <= finalized),
+pub fn is_timestamp_finalized(prev_global_state: &GlobalState, timestamp: u64) -> bool {
+    match Timepoint::from_full_value(prev_global_state.last_finalized_block_number().unpack()) {
+        Timepoint::BlockNumber(_) => {
+            debug!("[is_timestamp_finalized] switching version, prev_global_state.last_finalized_block_number is number-based");
+            false
+        }
+        Timepoint::Timestamp(finalized) => timestamp <= finalized,
     }
 }
 
 pub fn is_block_number_finalized(
     rollup_config: &RollupConfig,
-    global_state: &GlobalState,
+    prev_global_state: &GlobalState,
     block_number: u64,
 ) -> bool {
-    match Timepoint::from_full_value(global_state.last_finalized_block_number().unpack()) {
+    match Timepoint::from_full_value(prev_global_state.last_finalized_block_number().unpack()) {
         Timepoint::BlockNumber(finalized) => block_number <= finalized,
         Timepoint::Timestamp(_) => {
             let finality = finality_as_blocks(rollup_config);
-            let tip_number: u64 = global_state.block().count().unpack().saturating_sub(1);
+            let tip_number: u64 = prev_global_state.block().count().unpack().saturating_sub(1);
             block_number.saturating_add(finality) <= tip_number
         }
     }

contracts/stake-lock/src/entry.rs

@@ -61,7 +61,7 @@ pub fn main() -> Result<(), Error> {
             &config,
             &global_state,
             &Timepoint::from_full_value(lock_args.stake_block_number().unpack()),
-        )?;
+        );
         if is_finalized
             && search_lock_hash(&lock_args.owner_lock_hash().unpack(), Source::Input).is_some()
         {

contracts/state-validator/src/verifications/challenge.rs

@@ -49,7 +49,7 @@ pub fn verify_enter_challenge(
             challenged_block.number().unpack(),
         )
     } else {
-        is_timestamp_finalized(post_global_state, challenged_block.timestamp().unpack())?
+        is_timestamp_finalized(post_global_state, challenged_block.timestamp().unpack())
     };
     if is_block_finalized {
         debug!("cannot challenge a finalized block");

contracts/state-validator/src/verifications/submit_block.rs

@@ -141,7 +141,6 @@ fn check_input_custodian_cells(
                     global_state,
                     &Timepoint::from_full_value(cell.args.deposit_block_number().unpack()),
                 )
-                .unwrap_or(false)
             });
     // check unfinalized custodian cells == reverted deposit requests
     let mut reverted_deposit_cells =
@@ -191,7 +190,6 @@ fn check_output_custodian_cells(
                     global_state,
                     &Timepoint::from_full_value(cell.args.deposit_block_number().unpack()),
                 )
-                .unwrap_or(false)
             });
     // check deposits request cells == unfinalized custodian cells
     // check l2block's timepoint == unfinalized custodian cells' deposit_block_number

contracts/withdrawal-lock/src/entry.rs

@@ -173,7 +173,7 @@ pub fn main() -> Result<(), Error> {
                 &config,
                 &global_state,
                 &Timepoint::from_full_value(lock_args.withdrawal_block_number().unpack()),
-            )?;
+            );
             if !is_finalized {
                 return Err(Error::NotFinalized);
             }