Set reserve bit in monotonically increasing counters (#18418)

vusirikala · web-flow · commit ac16a37f8648 · 2026-01-09T17:41:56.000-08:00
diff --git a/api/types/src/transaction.rs b/api/types/src/transaction.rs
@@ -2415,6 +2415,11 @@ impl From<aptos_types::transaction::PersistedAuxiliaryInfo> for PersistedAuxilia
             aptos_types::transaction::PersistedAuxiliaryInfo::V1 { transaction_index } => Self {
                 transaction_index: Some(transaction_index),
             },
+            aptos_types::transaction::PersistedAuxiliaryInfo::TimestampNotYetAssignedV1 {
+                transaction_index,
+            } => Self {
+                transaction_index: Some(transaction_index),
+            },
         }
     }
 }
diff --git a/aptos-move/aptos-release-builder/src/simulate.rs b/aptos-move/aptos-release-builder/src/simulate.rs
@@ -37,10 +37,7 @@ use aptos_types::{
     account_config::ChainIdResource,
     on_chain_config::{ApprovedExecutionHashes, GasScheduleV2, OnChainConfig},
     state_store::TStateView,
-    transaction::{
-        AuxiliaryInfo, ExecutionStatus, PersistedAuxiliaryInfo, Script, TransactionArgument,
-        TransactionStatus,
-    },
+    transaction::{AuxiliaryInfo, ExecutionStatus, Script, TransactionArgument, TransactionStatus},
 };
 use aptos_vm::{data_cache::AsMoveResolver, move_vm_ext::SessionId, AptosVM};
 use aptos_vm_environment::environment::AptosEnvironment;
@@ -496,12 +493,7 @@ pub async fn simulate_multistep_proposal(
                 &code_storage,
                 &txn,
                 &log_context,
-                &AuxiliaryInfo::new(
-                    PersistedAuxiliaryInfo::V1 {
-                        transaction_index: 0,
-                    },
-                    None,
-                ),
+                &AuxiliaryInfo::new_timestamp_not_yet_assigned(0),
             );
             vm_output
         } else {
@@ -512,12 +504,7 @@ pub async fn simulate_multistep_proposal(
                     &txn,
                     &log_context,
                     GasProfiler::new_script,
-                    &AuxiliaryInfo::new(
-                        PersistedAuxiliaryInfo::V1 {
-                            transaction_index: 0,
-                        },
-                        None,
-                    ),
+                    &AuxiliaryInfo::new_timestamp_not_yet_assigned(0),
                 )?;
 
             let gas_log = gas_profiler.finish();
diff --git a/aptos-move/aptos-transaction-simulation-session/src/session.rs b/aptos-move/aptos-transaction-simulation-session/src/session.rs
@@ -17,8 +17,8 @@ use aptos_types::{
     fee_statement::FeeStatement,
     state_store::{state_key::StateKey, TStateView},
     transaction::{
-        AuxiliaryInfo, PersistedAuxiliaryInfo, SignedTransaction, TransactionExecutable,
-        TransactionOutput, TransactionPayload, TransactionPayloadInner, TransactionStatus,
+        AuxiliaryInfo, SignedTransaction, TransactionExecutable, TransactionOutput,
+        TransactionPayload, TransactionPayloadInner, TransactionStatus,
     },
     vm_status::VMStatus,
 };
@@ -284,12 +284,7 @@ impl Session {
             &code_storage,
             &txn,
             &log_context,
-            &AuxiliaryInfo::new(
-                PersistedAuxiliaryInfo::V1 {
-                    transaction_index: 0,
-                },
-                None,
-            ),
+            &AuxiliaryInfo::new_timestamp_not_yet_assigned(0),
         );
         let txn_output = vm_output.try_materialize_into_transaction_output(&resolver)?;
 
diff --git a/aptos-move/aptos-vm/src/aptos_vm.rs b/aptos-move/aptos-vm/src/aptos_vm.rs
@@ -78,11 +78,11 @@ use aptos_types::{
         authenticator::{AbstractAuthenticationData, AnySignature, AuthenticationProof},
         block_epilogue::{BlockEpiloguePayload, FeeDistribution},
         signature_verified_transaction::SignatureVerifiedTransaction,
-        AuxiliaryInfo, AuxiliaryInfoTrait, BlockOutput, EntryFunction, ExecutionError,
-        ExecutionStatus, ModuleBundle, MultisigTransactionPayload, ReplayProtector, Script,
-        SignedTransaction, Transaction, TransactionArgument, TransactionExecutableRef,
-        TransactionExtraConfig, TransactionOutput, TransactionPayload, TransactionStatus,
-        VMValidatorResult, ViewFunctionOutput, WriteSetPayload,
+        AuxiliaryInfo, BlockOutput, EntryFunction, ExecutionError, ExecutionStatus, ModuleBundle,
+        MultisigTransactionPayload, ReplayProtector, Script, SignedTransaction, Transaction,
+        TransactionArgument, TransactionExecutableRef, TransactionExtraConfig, TransactionOutput,
+        TransactionPayload, TransactionStatus, VMValidatorResult, ViewFunctionOutput,
+        WriteSetPayload,
     },
     vm::module_metadata::{
         get_compilation_metadata, get_metadata, get_randomness_annotation_for_entry_function,
@@ -2967,7 +2967,7 @@ impl AptosVM {
                             vm_status.sub_status(),
                             Some(
                                 unknown_invariant_violation::EREFERENCE_SAFETY_FAILURE
-                                    | unknown_invariant_violation::EINDEXED_REF_TAG_MISMATCH
+                                | unknown_invariant_violation::EINDEXED_REF_TAG_MISMATCH
                             )
                         ) =>
                         {
@@ -2976,8 +2976,8 @@ impl AptosVM {
                             "[aptos_vm] Transaction breaking paranoid reference safety check (including enum tag guard). txn: {:?}, status: {:?}",
                             bcs::to_bytes::<SignedTransaction>(txn),
                             vm_status,
-                        );
-                        },
+                            );
+                        }
                         // Ignore DelayedFields speculative errors as it can be intentionally triggered by parallel execution.
                         StatusCode::SPECULATIVE_EXECUTION_ABORT_ERROR => (),
                         // We will log the rest of invariant violation directly with regular logger as they shouldn't happen.
@@ -3205,14 +3205,13 @@ impl VMValidator for AptosVM {
         if transaction.payload().is_encrypted_variant() {
             return VMValidatorResult::error(StatusCode::FEATURE_UNDER_GATING);
         }
-
         let txn = match transaction.check_signature() {
             Ok(t) => t,
             _ => {
                 return VMValidatorResult::error(StatusCode::INVALID_SIGNATURE);
             },
         };
-        let auxiliary_info = AuxiliaryInfo::new_empty();
+        let auxiliary_info = AuxiliaryInfo::new_timestamp_not_yet_assigned(0);
         let txn_data = TransactionMetadata::new(&txn, &auxiliary_info);
 
         let resolver = self.as_move_resolver(&state_view);
@@ -3346,7 +3345,7 @@ impl AptosSimulationVM {
             &code_storage,
             transaction,
             &log_context,
-            &AuxiliaryInfo::new_empty(),
+            &AuxiliaryInfo::new_timestamp_not_yet_assigned(0),
         );
         let txn_output = vm_output
             .try_materialize_into_transaction_output(&resolver)
diff --git a/aptos-move/aptos-vm/src/move_vm_ext/session/session_id.rs b/aptos-move/aptos-vm/src/move_vm_ext/session/session_id.rs
@@ -207,7 +207,7 @@ impl SessionId {
 
     // This is used in `monotonically_increasing_number` native function. Every call to the native function
     // will output a monotonically increasing number.
-    // monotonically_increasing_number (128 bits) = 0 (8 bits -- Reserved for future use) || timestamp (64 bits) || transaction_index_inside_block (24 bits) || session_counter_inside_transaction (8 bits) || local_counter_inside_session (16 bits)
+    // monotonically_increasing_number (128 bits) = 0 (8 bits -- Reserved for future use) || timestamp (64 bits) || transaction_index_inside_block (32 bits) || session_counter_inside_transaction (8 bits) || local_counter_inside_session (16 bits)
     // This function is used to obtain `session_counter_inside_transaction`.
     // The sessions here are organized in the increasing order in which they are created. Eg: Prologue < Txn < RunOnAbort < Epilogue.
     // When introducing new session types, please check the order in which the sessions are created during a transaction execution and assign a number here accordingly.
diff --git a/aptos-move/aptos-vm/src/transaction_metadata.rs b/aptos-move/aptos-vm/src/transaction_metadata.rs
@@ -7,10 +7,11 @@ use aptos_types::{
     account_address::AccountAddress,
     chain_id::ChainId,
     transaction::{
-        authenticator::AuthenticationProof, user_transaction_context::UserTransactionContext,
-        AuxiliaryInfo, AuxiliaryInfoTrait, EntryFunction, Multisig, MultisigTransactionPayload,
-        ReplayProtector, SignedTransaction, TransactionExecutable, TransactionExecutableRef,
-        TransactionExtraConfig, TransactionPayload, TransactionPayloadInner,
+        authenticator::AuthenticationProof,
+        user_transaction_context::{TransactionIndexKind, UserTransactionContext},
+        AuxiliaryInfo, EntryFunction, Multisig, MultisigTransactionPayload, ReplayProtector,
+        SignedTransaction, TransactionExecutable, TransactionExecutableRef, TransactionExtraConfig,
+        TransactionPayload, TransactionPayloadInner,
     },
 };
 
@@ -34,8 +35,8 @@ pub struct TransactionMetadata {
     pub is_keyless: bool,
     pub entry_function_payload: Option<EntryFunction>,
     pub multisig_payload: Option<Multisig>,
-    // Index of the transaction in the block.
-    pub transaction_index: Option<u32>,
+    /// The transaction index context for the monotonically increasing counter.
+    pub transaction_index_kind: TransactionIndexKind,
 }
 
 impl TransactionMetadata {
@@ -108,7 +109,7 @@ impl TransactionMetadata {
                 }),
                 _ => None,
             },
-            transaction_index: auxiliary_info.transaction_index(),
+            transaction_index_kind: auxiliary_info.transaction_index_kind(),
         }
     }
 
@@ -203,11 +204,24 @@ impl TransactionMetadata {
                 .map(|entry_func| entry_func.as_entry_function_payload()),
             self.multisig_payload()
                 .map(|multisig| multisig.as_multisig_payload()),
-            self.transaction_index,
+            self.transaction_index_kind,
         )
     }
 
+    pub fn transaction_index_kind(&self) -> TransactionIndexKind {
+        self.transaction_index_kind
+    }
+
+    /// Returns the transaction index if available, regardless of execution mode.
+    /// Returns `Some(index)` for both `BlockExecution` and `ValidationOrSimulation`,
+    /// Returns `None` for `NotAvailable`.
     pub fn transaction_index(&self) -> Option<u32> {
-        self.transaction_index
+        match self.transaction_index_kind {
+            TransactionIndexKind::BlockExecution { transaction_index }
+            | TransactionIndexKind::ValidationOrSimulation { transaction_index } => {
+                Some(transaction_index)
+            },
+            TransactionIndexKind::NotAvailable => None,
+        }
     }
 }
diff --git a/aptos-move/framework/src/natives/transaction_context.rs b/aptos-move/framework/src/natives/transaction_context.rs
@@ -10,7 +10,9 @@ use aptos_types::{
     error,
     transaction::{
         authenticator::AuthenticationKey,
-        user_transaction_context::{EntryFunctionPayload, UserTransactionContext},
+        user_transaction_context::{
+            EntryFunctionPayload, TransactionIndexKind, UserTransactionContext,
+        },
     },
 };
 use better_any::{Tid, TidAble};
@@ -179,23 +181,34 @@ fn native_monotonically_increasing_counter_internal(
     let local_counter = transaction_context.local_counter as u128;
     let session_counter = transaction_context.session_counter as u128;
 
-    let user_transaction_context_opt = get_user_transaction_context_opt_from_context(context);
+    let user_transaction_context_opt: &Option<UserTransactionContext> =
+        get_user_transaction_context_opt_from_context(context);
     if let Some(user_transaction_context) = user_transaction_context_opt {
-        // monotonically_increasing_counter (128 bits) = `<reserved_byte (8 bits) = 0 for block/chunk execution, 1 for validation/simulation> || timestamp_us (64 bits) || transaction_index (32 bits) || session counter (8 bits) || local_counter (16 bits)`
+        // monotonically_increasing_counter (128 bits) = `<reserved_byte (8 bits)> || timestamp_us (64 bits) || transaction_index (32 bits) || session counter (8 bits) || local_counter (16 bits)`
+        // reserved_byte: 0 for block/chunk execution (V1), 1 for validation/simulation (TimestampNotYetAssignedV1)
         let timestamp_us = safely_pop_arg!(args, u64);
-        let transaction_index = user_transaction_context.transaction_index();
-
-        if let Some(transaction_index) = transaction_index {
-            let mut monotonically_increasing_counter: u128 = (timestamp_us as u128) << 56;
-            monotonically_increasing_counter |= (transaction_index as u128) << 24;
-            monotonically_increasing_counter |= session_counter << 16;
-            monotonically_increasing_counter |= local_counter;
-            Ok(smallvec![Value::u128(monotonically_increasing_counter)])
-        } else {
-            Err(SafeNativeError::Abort {
-                abort_code: error::invalid_state(abort_codes::ETRANSACTION_INDEX_NOT_AVAILABLE),
-            })
-        }
+        let transaction_index_kind = user_transaction_context.transaction_index_kind();
+
+        let (reserved_byte, transaction_index) = match transaction_index_kind {
+            TransactionIndexKind::BlockExecution { transaction_index } => {
+                (0u128, transaction_index)
+            },
+            TransactionIndexKind::ValidationOrSimulation { transaction_index } => {
+                (1u128, transaction_index)
+            },
+            TransactionIndexKind::NotAvailable => {
+                return Err(SafeNativeError::Abort {
+                    abort_code: error::invalid_state(abort_codes::ETRANSACTION_INDEX_NOT_AVAILABLE),
+                });
+            },
+        };
+
+        let mut monotonically_increasing_counter: u128 = reserved_byte << 120;
+        monotonically_increasing_counter |= (timestamp_us as u128) << 56;
+        monotonically_increasing_counter |= (transaction_index as u128) << 24;
+        monotonically_increasing_counter |= session_counter << 16;
+        monotonically_increasing_counter |= local_counter;
+        Ok(smallvec![Value::u128(monotonically_increasing_counter)])
     } else {
         // When transaction context is not available, return an error
         Err(SafeNativeError::Abort {
diff --git a/execution/executor/src/workflow/do_ledger_update.rs b/execution/executor/src/workflow/do_ledger_update.rs
@@ -63,6 +63,7 @@ impl DoLedgerUpdate {
                     PersistedAuxiliaryInfo::V1 { .. } => {
                         Some(CryptoHash::hash(persisted_auxiliary_info))
                     },
+                    PersistedAuxiliaryInfo::TimestampNotYetAssignedV1 { .. } => None,
                 };
                 let state_checkpoint_hash = state_checkpoint_hashes[i];
                 let event_hashes = txn_output
diff --git a/types/src/transaction/mod.rs b/types/src/transaction/mod.rs
@@ -2800,7 +2800,8 @@ fn verify_auxiliary_infos_against_transaction_infos(
         .zip_eq(transaction_infos.par_iter())
         .map(|(aux_info, txn_info)| {
             match aux_info {
-                PersistedAuxiliaryInfo::None => {
+                PersistedAuxiliaryInfo::None
+                | PersistedAuxiliaryInfo::TimestampNotYetAssignedV1 { .. } => {
                     ensure!(
                         txn_info.auxiliary_info_hash().is_none(),
                         "The transaction info has an auxiliary info hash: {:?}, \
@@ -3200,7 +3201,8 @@ impl AuxiliaryInfo {
     pub fn persisted_info_hash(&self) -> Option<HashValue> {
         match self.persisted_info {
             PersistedAuxiliaryInfo::V1 { .. } => Some(self.persisted_info.hash()),
-            PersistedAuxiliaryInfo::None => None,
+            PersistedAuxiliaryInfo::None
+            | PersistedAuxiliaryInfo::TimestampNotYetAssignedV1 { .. } => None,
         }
     }
 }
@@ -3214,6 +3216,30 @@ impl Default for AuxiliaryInfo {
     }
 }
 
+impl AuxiliaryInfo {
+    pub fn new_timestamp_not_yet_assigned(transaction_index: u32) -> Self {
+        Self {
+            persisted_info: PersistedAuxiliaryInfo::TimestampNotYetAssignedV1 { transaction_index },
+            ephemeral_info: None,
+        }
+    }
+
+    pub fn transaction_index_kind(
+        &self,
+    ) -> crate::transaction::user_transaction_context::TransactionIndexKind {
+        use crate::transaction::user_transaction_context::TransactionIndexKind;
+        match self.persisted_info {
+            PersistedAuxiliaryInfo::V1 { transaction_index } => {
+                TransactionIndexKind::BlockExecution { transaction_index }
+            },
+            PersistedAuxiliaryInfo::TimestampNotYetAssignedV1 { transaction_index } => {
+                TransactionIndexKind::ValidationOrSimulation { transaction_index }
+            },
+            PersistedAuxiliaryInfo::None => TransactionIndexKind::NotAvailable,
+        }
+    }
+}
+
 impl AuxiliaryInfoTrait for AuxiliaryInfo {
     fn new_empty() -> Self {
         Self {
@@ -3224,7 +3250,10 @@ impl AuxiliaryInfoTrait for AuxiliaryInfo {
 
     fn transaction_index(&self) -> Option<u32> {
         match self.persisted_info {
-            PersistedAuxiliaryInfo::V1 { transaction_index } => Some(transaction_index),
+            PersistedAuxiliaryInfo::V1 { transaction_index }
+            | PersistedAuxiliaryInfo::TimestampNotYetAssignedV1 { transaction_index } => {
+                Some(transaction_index)
+            },
             PersistedAuxiliaryInfo::None => None,
         }
     }
@@ -3254,6 +3283,11 @@ pub enum PersistedAuxiliaryInfo {
     // Note that this would be slightly different from the index of transactions that get committed
     // onchain, as this considers transactions that may get discarded.
     V1 { transaction_index: u32 },
+    // When we are doing a simulation or validation of transactions, the transaction is not executed
+    // within the context of a block. The timestamp is not yet assigned, but we still track the
+    // transaction index for multi-transaction simulations. For single transaction simulation or
+    // validation, the transaction index is set to 0.
+    TimestampNotYetAssignedV1 { transaction_index: u32 },
 }
 
 pub trait AuxiliaryInfoTrait: Clone {
diff --git a/types/src/transaction/user_transaction_context.rs b/types/src/transaction/user_transaction_context.rs

Original file line number	Diff line number	Diff line change
`@@ -2415,6 +2415,11 @@ impl From<aptos_types::transaction::PersistedAuxiliaryInfo> for PersistedAuxilia`
`2415`	`2415`	`aptos_types::transaction::PersistedAuxiliaryInfo::V1 { transaction_index } => Self {`
`2416`	`2416`	`transaction_index: Some(transaction_index),`
`2417`	`2417`	`},`
	`2418`	`+ aptos_types::transaction::PersistedAuxiliaryInfo::TimestampNotYetAssignedV1 {`
	`2419`	`+ transaction_index,`
	`2420`	`+ } => Self {`
	`2421`	`+ transaction_index: Some(transaction_index),`
	`2422`	`+ },`
`2418`	`2423`	`}`
`2419`	`2424`	`}`
`2420`	`2425`	`}`