blockifier: omit cairo-vm-specific VM frames from SierraGas revert traces

For SierraGas-mode (Cairo 1) contracts the choice of execution backend
(cairo-vm CASM vs cairo-native) is meant to be a free implementation
detail, but blockifier's stack-trace formatter was committing the
backend choice into the rendered revert reason: cairo-vm produces a
`VmException` with a PC and a Cairo traceback, cairo-native does not,
and `stack_trace.rs` faithfully rendered the former and skipped the
latter. Because the revert reason is hashed verbatim into the receipt
commitment (and thus the block hash), the same Cairo 1 contract
reverting on the same input produced two different receipts depending
on which backend was hot in the contract class manager's cache at the
moment of execution. This is what bites echonet replays of mainnet:
any mainnet block where a Cairo 1 contract reverts can mismatch
echonet's receipt commitment iff echonet ran that class via native
while mainnet ran it via CASM (or vice versa).

This patch flips the `strip_vm_frames_in_sierra_gas` flag (introduced
as a no-op in the preceding commit) from false to true at protocol
v0.14.3, and teaches the stack-trace formatter to honor it:

  * The flag is set in `blockifier_versioned_constants_0_14_3.json`.
    Pre-v0.14.3 versions remain at false, so historical receipts
    replay byte-identically.
  * `extract_entry_point_execution_error_into_stack_trace` reads the
    annotation from the `AnnotatedEntryPointExecutionError` carried
    by the outer `TransactionExecutionError` field, and inside the
    `CairoRunError` arm skips the `Error at pc=` / `Cairo traceback`
    block when the frame is `SierraGas`-tracked AND the strip policy
    is on. Cairo 0 (`CairoSteps`) frames are unaffected at every
    version.
  * Cairo 0 traces are unchanged at every protocol version. Native
    traces are unchanged. A SierraGas-mode contract at v0.14.3+ now
    renders identically whether it ran via cairo-vm CASM or
    cairo-native.

Verified by a new parameterized test
(`test_revert_text_is_backend_invariant_for_sierra_gas`) that runs
the same Cairo 1 deploy-faulty-ctor flow on both backends and asserts
byte-identical revert text, plus three unit tests covering the four
`(TrackedResource, strip)` cells of the rendering matrix. Real-data
confirmation: with `strip_vm_frames_in_sierra_gas: true` forced into
the 0.14.1 json locally, `--compare-native` on mainnet block 6481044
reports matched=1 (formerly matched=0 between backends).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ron-starkware

crates/blockifier/resources/blockifier_versioned_constants_0_14_3.json

@@ -121,7 +121,7 @@
     "enable_reverts": true,
     "enable_casm_hash_migration": true,
     "block_casm_hash_v1_declares": true,
-    "strip_vm_frames_in_sierra_gas": false,
+    "strip_vm_frames_in_sierra_gas": true,
     "min_sierra_version_for_sierra_gas": "1.7.0",
     "enable_tip": true,
     "segment_arena_cells": false,

crates/blockifier/resources/versioned_constants_diff_regression/0.14.2_0.14.3.txt

@@ -6,3 +6,4 @@
 ~ /os_resources/execute_syscalls/Sha512ProcessBlock/n_steps: 4737
 ~ /os_resources/execute_syscalls/StorageRead/n_steps: 240
 ~ /os_resources/execute_syscalls/StorageWrite/n_steps: 599
+~ /strip_vm_frames_in_sierra_gas: true

crates/blockifier/src/execution/stack_trace.rs

@@ -10,8 +10,13 @@ use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector};
 use starknet_api::execution_utils::format_panic_data;
 
 use crate::execution::call_info::{CallInfo, Retdata};
+use crate::execution::contract_class::TrackedResource;
 use crate::execution::deprecated_syscalls::hint_processor::DeprecatedSyscallExecutionError;
-use crate::execution::errors::{ConstructorEntryPointExecutionError, EntryPointExecutionError};
+use crate::execution::errors::{
+    AnnotatedEntryPointExecutionError,
+    ConstructorEntryPointExecutionError,
+    EntryPointExecutionError,
+};
 use crate::execution::syscalls::hint_processor::{
     SyscallExecutionError,
     ENTRYPOINT_FAILED_ERROR_FELT,
@@ -409,7 +414,7 @@ pub fn gen_tx_execution_error_trace(error: &TransactionExecutionError) -> ErrorS
             selector,
         } => gen_error_trace_from_entry_point_error(
             ErrorStackHeader::Execution,
-            error.unannotated(),
+            error,
             storage_address,
             class_hash,
             Some(selector),
@@ -422,7 +427,7 @@ pub fn gen_tx_execution_error_trace(error: &TransactionExecutionError) -> ErrorS
             selector,
         } => gen_error_trace_from_entry_point_error(
             ErrorStackHeader::Validation,
-            error.unannotated(),
+            error,
             storage_address,
             class_hash,
             Some(selector),
@@ -437,7 +442,7 @@ pub fn gen_tx_execution_error_trace(error: &TransactionExecutionError) -> ErrorS
             },
         ) => gen_error_trace_from_entry_point_error(
             ErrorStackHeader::Constructor,
-            error.unannotated(),
+            error,
             storage_address,
             class_hash,
             constructor_selector.as_ref(),
@@ -460,7 +465,7 @@ pub fn gen_tx_execution_error_trace(error: &TransactionExecutionError) -> ErrorS
 /// Generate error stack from top-level entry point execution error.
 fn gen_error_trace_from_entry_point_error(
     header: ErrorStackHeader,
-    error: &EntryPointExecutionError,
+    error: &AnnotatedEntryPointExecutionError,
     storage_address: &ContractAddress,
     class_hash: &ClassHash,
     entry_point_selector: Option<&EntryPointSelector>,
@@ -486,16 +491,19 @@ fn extract_cairo_run_error_into_stack_trace(
     error_stack: &mut ErrorStack,
     depth: usize,
     error: &CairoRunError,
+    omit_vm_frame: bool,
 ) {
     if let CairoRunError::VmException(vm_exception) = error {
-        error_stack.push(
-            VmExceptionFrame {
-                pc: vm_exception.pc,
-                error_attr_value: vm_exception.error_attr_value.clone(),
-                traceback: vm_exception.traceback.clone(),
-            }
-            .into(),
-        );
+        if !omit_vm_frame {
+            error_stack.push(
+                VmExceptionFrame {
+                    pc: vm_exception.pc,
+                    error_attr_value: vm_exception.error_attr_value.clone(),
+                    traceback: vm_exception.traceback.clone(),
+                }
+                .into(),
+            );
+        }
         extract_virtual_machine_error_into_stack_trace(error_stack, depth, &vm_exception.inner_exc);
     } else {
         error_stack.push(error.to_string().into());
@@ -604,17 +612,13 @@ fn extract_syscall_execution_error_into_stack_trace(
                 }
                 .into(),
             );
-            extract_entry_point_execution_error_into_stack_trace(
-                error_stack,
-                depth,
-                error.unannotated(),
-            )
+            extract_entry_point_execution_error_into_stack_trace(error_stack, depth, error)
         }
         SyscallExecutionError::EntryPointExecutionError(entry_point_error) => {
             extract_entry_point_execution_error_into_stack_trace(
                 error_stack,
                 depth,
-                entry_point_error.unannotated(),
+                entry_point_error,
             )
         }
         _ => {
@@ -691,17 +695,13 @@ fn extract_deprecated_syscall_execution_error_into_stack_trace(
                 }
                 .into(),
             );
-            extract_entry_point_execution_error_into_stack_trace(
-                error_stack,
-                depth,
-                error.unannotated(),
-            )
+            extract_entry_point_execution_error_into_stack_trace(error_stack, depth, error)
         }
         DeprecatedSyscallExecutionError::EntryPointExecutionError(entry_point_error) => {
             extract_entry_point_execution_error_into_stack_trace(
                 error_stack,
                 depth,
-                entry_point_error.unannotated(),
+                entry_point_error,
             )
         }
         _ => error_stack.push(syscall_error.to_string().into()),
@@ -711,11 +711,22 @@ fn extract_deprecated_syscall_execution_error_into_stack_trace(
 fn extract_entry_point_execution_error_into_stack_trace(
     error_stack: &mut ErrorStack,
     depth: usize,
-    entry_point_error: &EntryPointExecutionError,
+    entry_point_error: &AnnotatedEntryPointExecutionError,
 ) {
-    match entry_point_error {
+    let inner = entry_point_error.unannotated();
+    match inner {
         EntryPointExecutionError::CairoRunError(cairo_run_error) => {
-            extract_cairo_run_error_into_stack_trace(error_stack, depth, cairo_run_error)
+            // Omit the cairo-vm PC/traceback only for SierraGas frames at versions where the
+            // strip policy is on — makes the revert reason invariant across execution
+            // backends. Cairo 0 (CairoSteps) always emits; it has no native counterpart.
+            let omit_vm_frame = entry_point_error.strip_vm_frames_in_sierra_gas()
+                && entry_point_error.tracked_resource() == TrackedResource::SierraGas;
+            extract_cairo_run_error_into_stack_trace(
+                error_stack,
+                depth,
+                cairo_run_error,
+                omit_vm_frame,
+            )
         }
         #[cfg(feature = "cairo_native")]
         EntryPointExecutionError::NativeUnrecoverableError(error) => {
@@ -724,6 +735,6 @@ fn extract_entry_point_execution_error_into_stack_trace(
         EntryPointExecutionError::ExecutionFailed { error_trace } => {
             error_stack.push(error_trace.clone().into())
         }
-        _ => error_stack.push(format!("{entry_point_error}\n").into()),
+        _ => error_stack.push(format!("{inner}\n").into()),
     }
 }

crates/blockifier/src/execution/stack_trace_regression/test_contract_ctor_frame_stack_trace_cairo1_casm.txt

@@ -1,8 +1,6 @@
 Transaction execution has failed:
 0: Error in the called contract (contract address: 0x00000000000000000000000000000000000000000000000000000000c0020000, class hash: 0x0000000000000000000000000000000000000000000000000000000080020000, selector: 0x015d40a3d6ca2ac30f4031e42be28da9b056fef9bb7357ac5e85627ee876e5ad):
-Error at pc=0:443:
 1: Error in the called contract (contract address: 0x00000000000000000000000000000000000000000000000000000000c0020000, class hash: 0x0000000000000000000000000000000000000000000000000000000080020000, selector: 0x02730079d734ee55315f4f141eaed376bddd8c2133523d223a344c5604e0f7f8):
-Error at pc=0:797:
 2: Error in the contract class constructor (contract address: 0x0103ee82605273496eed8d9141c5b3ad967baa08be63aa5bc49ffae5eae454cc, class hash: 0x0000000000000000000000000000000000000000000000000000000080040000, selector: 0x028ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194):
 Execution failed. Failure reason:
 Error in contract (contract address: 0x0103ee82605273496eed8d9141c5b3ad967baa08be63aa5bc49ffae5eae454cc, class hash: 0x0000000000000000000000000000000000000000000000000000000080040000, selector: 0x028ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194):

crates/blockifier/src/execution/stack_trace_test.rs

@@ -2,6 +2,10 @@ use assert_matches::assert_matches;
 use blockifier_test_utils::cairo_versions::{CairoVersion, RunnableCairo1};
 use blockifier_test_utils::calldata::create_calldata;
 use blockifier_test_utils::contracts::FeatureContract;
+use cairo_vm::types::relocatable::Relocatable;
+use cairo_vm::vm::errors::cairo_run_errors::CairoRunError;
+use cairo_vm::vm::errors::vm_errors::VirtualMachineError;
+use cairo_vm::vm::errors::vm_exception::VmException;
 use expect_test::expect_file;
 use pretty_assertions::assert_eq;
 use regex::Regex;
@@ -32,15 +36,17 @@ use starknet_api::transaction::fields::{
     ValidResourceBounds,
 };
 use starknet_api::transaction::TransactionVersion;
-use starknet_api::{calldata, felt, invoke_tx_args};
+use starknet_api::{calldata, class_hash, contract_address, felt, invoke_tx_args};
 use starknet_types_core::felt::Felt;
 
 use crate::context::{BlockContext, ChainInfo};
 use crate::execution::call_info::{CallExecution, CallInfo, Retdata};
+use crate::execution::contract_class::TrackedResource;
 use crate::execution::entry_point::CallEntryPoint;
 use crate::execution::errors::EntryPointExecutionError;
 use crate::execution::stack_trace::{
     extract_trailing_cairo1_revert_trace,
+    gen_tx_execution_error_trace,
     Cairo1RevertHeader,
     Cairo1RevertSummary,
     MIN_CAIRO1_FRAME_LENGTH,
@@ -51,6 +57,7 @@ use crate::test_utils::initial_test_state::{fund_account, test_state};
 use crate::test_utils::test_templates::cairo_version;
 use crate::test_utils::BALANCE;
 use crate::transaction::account_transaction::{AccountTransaction, ExecutionFlags};
+use crate::transaction::errors::TransactionExecutionError;
 use crate::transaction::objects::TransactionInfoCreator;
 use crate::transaction::test_utils::{
     block_context,
@@ -842,6 +849,71 @@ Error in contract (contract address: {expected_address:#066x}, class hash: {:#06
     );
 }
 
+/// Drives the deploy-faulty-ctor flow once on the given Cairo 1 backend and returns the
+/// rendered revert text. Same setup as `test_contract_ctor_frame_stack_trace` (Cairo1 cases),
+/// extracted so the cross-backend equality test below can run both backends in one process.
+#[cfg(feature = "cairo_native")]
+fn render_faulty_ctor_revert(
+    block_context: &BlockContext,
+    default_all_resource_bounds: ValidResourceBounds,
+    runnable: RunnableCairo1,
+) -> String {
+    let cairo_version = CairoVersion::Cairo1(runnable);
+    let chain_info = &block_context.chain_info;
+    let account = FeatureContract::AccountWithoutValidations(cairo_version);
+    let faulty_ctor = FeatureContract::FaultyAccount(cairo_version);
+    let state = &mut test_state(chain_info, BALANCE, &[(account, 1), (faulty_ctor, 0)]);
+    let account_address = account.get_instance_address(0);
+    let faulty_class_hash = faulty_ctor.get_class_hash();
+
+    let invoke_deploy_tx = invoke_tx_with_default_flags(invoke_tx_args! {
+        sender_address: account_address,
+        signature: TransactionSignature(vec![felt!(INVALID)].into()),
+        calldata: create_calldata(
+            account_address,
+            DEPLOY_CONTRACT_FUNCTION_ENTRY_POINT_NAME,
+            &[
+                faulty_class_hash.0,
+                felt!(7_u8),     // salt
+                felt!(1_u8),     // ctor args length
+                felt!(FELT_TRUE), // validate_constructor: true → fail
+            ]
+        ),
+        resource_bounds: default_all_resource_bounds,
+        nonce: Nonce(felt!(0_u8)),
+    });
+    invoke_deploy_tx.execute(state, block_context).unwrap().revert_error.unwrap().to_string()
+}
+
+/// At v0.14.3+ (strip policy on), the same Cairo 1 flow must produce a byte-identical revert
+/// string regardless of execution backend — this is what makes `receipt_commitment` invariant
+/// under cairo-native vs cairo-vm CASM. Pre-patch (origin/main-v0.14.3), this assertion would
+/// fail: CASM emitted `Error at pc=0:443:` / `Error at pc=0:797:` lines under the outer two
+/// frames that native never produced, see the historical diff of
+/// `test_contract_ctor_frame_stack_trace_cairo1_casm.txt`.
+#[cfg(feature = "cairo_native")]
+#[rstest]
+fn test_revert_text_is_backend_invariant_for_sierra_gas(
+    block_context: BlockContext,
+    default_all_resource_bounds: ValidResourceBounds,
+) {
+    let casm_revert = render_faulty_ctor_revert(
+        &block_context,
+        default_all_resource_bounds,
+        RunnableCairo1::Casm,
+    );
+    let native_revert = render_faulty_ctor_revert(
+        &block_context,
+        default_all_resource_bounds,
+        RunnableCairo1::Native,
+    );
+    assert_eq!(
+        casm_revert, native_revert,
+        "Cairo 1 revert text must be backend-invariant at v0.14.3+; CASM and Native \
+         diverged.\nCASM:\n{casm_revert}\n\nNative:\n{native_revert}"
+    );
+}
+
 #[test]
 fn test_min_cairo1_frame_length() {
     let failure_hex = "0xdeadbeef";
@@ -1080,3 +1152,92 @@ fn test_cairo1_stack_extraction_not_failure_fallback() {
         if stack.is_empty() && last_retdata == expected_retdata
     );
 }
+
+/// Build a synthetic `EntryPointExecutionError::CairoRunError(VmException)` to feed into the
+/// formatter. The exact PC/traceback strings are arbitrary; the test asserts on whether the
+/// `Error at pc=` block survives the formatter, not on its contents.
+fn synthetic_vm_exception_error() -> EntryPointExecutionError {
+    let vm_exception = VmException {
+        pc: Relocatable { segment_index: 0, offset: 42 },
+        inst_location: None,
+        inner_exc: VirtualMachineError::Unexpected,
+        error_attr_value: None,
+        traceback: Some(
+            "Cairo traceback (most recent call last):\nUnknown location (pc=0:7)\n".to_string(),
+        ),
+    };
+    EntryPointExecutionError::CairoRunError(Box::new(CairoRunError::VmException(vm_exception)))
+}
+
+/// Wraps a synthetic CairoRunError as the top-level error of a `TransactionExecutionError`
+/// with the given `(tracked_resource, strip_vm_frames_in_sierra_gas)` annotation. Returns
+/// the formatted revert string.
+fn render_revert_for(tracked_resource: TrackedResource, strip: bool) -> String {
+    let top_error = synthetic_vm_exception_error().annotated(tracked_resource, strip);
+    let tx_error = TransactionExecutionError::ExecutionError {
+        error: Box::new(top_error),
+        class_hash: class_hash!("0xabc"),
+        storage_address: contract_address!("0x123"),
+        selector: EntryPointSelector(felt!("0xdef")),
+    };
+    gen_tx_execution_error_trace(&tx_error).to_string()
+}
+
+/// SierraGas frame at a protocol version where the policy is active (v0.14.3+): the formatter
+/// MUST omit the `Error at pc=` / `Cairo traceback` block, so the revert reason is identical
+/// whether the contract ran via cairo-vm CASM or cairo-native.
+#[test]
+fn test_sierra_gas_frame_omits_vm_exception_block_when_strip_enabled() {
+    let rendered = render_revert_for(TrackedResource::SierraGas, true);
+    assert!(
+        !rendered.contains("Error at pc="),
+        "with strip enabled, SierraGas-mode revert must not include `Error at pc=` (got: \
+         {rendered:?})"
+    );
+    assert!(
+        !rendered.contains("Cairo traceback"),
+        "with strip enabled, SierraGas-mode revert must not include `Cairo traceback` (got: \
+         {rendered:?})"
+    );
+    // The frame preamble must still be present.
+    assert!(
+        rendered.contains("Error in the called contract"),
+        "frame preamble missing (got: {rendered:?})"
+    );
+}
+
+/// SierraGas frame at a protocol version where the policy is OFF (pre-v0.14.3): the formatter
+/// MUST keep the legacy `Error at pc=` / `Cairo traceback` block, so we replay historical
+/// blocks with byte-identical receipts. Replaying old blocks would break otherwise.
+#[test]
+fn test_sierra_gas_frame_keeps_vm_exception_block_when_strip_disabled() {
+    let rendered = render_revert_for(TrackedResource::SierraGas, false);
+    assert!(
+        rendered.contains("Error at pc=0:42:"),
+        "with strip disabled, SierraGas-mode revert must include `Error at pc=` (got: \
+         {rendered:?})"
+    );
+    assert!(
+        rendered.contains("Cairo traceback (most recent call last):"),
+        "with strip disabled, SierraGas-mode revert must include `Cairo traceback` (got: \
+         {rendered:?})"
+    );
+}
+
+/// CairoSteps frame (Cairo 0): the formatter MUST emit the `Error at pc=` block regardless of
+/// the strip policy, since Cairo 0 has no alternative execution backend and the PC + traceback
+/// are useful debug information that nothing else carries.
+#[rstest]
+fn test_cairo_steps_frame_keeps_vm_exception_block_under_either_policy(
+    #[values(true, false)] strip: bool,
+) {
+    let rendered = render_revert_for(TrackedResource::CairoSteps, strip);
+    assert!(
+        rendered.contains("Error at pc=0:42:"),
+        "CairoSteps-mode revert (strip={strip}) must include `Error at pc=` (got: {rendered:?})"
+    );
+    assert!(
+        rendered.contains("Cairo traceback (most recent call last):"),
+        "CairoSteps-mode revert (strip={strip}) must include `Cairo traceback` (got: {rendered:?})"
+    );
+}

crates/blockifier_reexecution/block_numbers_for_reexecution.json

@@ -10,6 +10,7 @@
     "0.13.6": 1743490,
     "0.14.0": 2509604,
     "0.14.1": 4448394,
+    "0.14.1_sierra_gas_revert": 6481044,
     "0.14.2_with_proof_facts": 9023035,
     "first_0.13.5_rpc_v0_8": 1400000,
     "second_0.13.5_rpc_v0_8": 1450000,

crates/blockifier_reexecution/src/state_reader/offline_state_reader_test.rs

@@ -39,6 +39,7 @@ fn reexecute_block_for_testing(block_number: u64) {
 #[case::v_0_13_6(1743490)]
 #[case::v_0_14_0(2509604)]
 #[case::v_0_14_1(4448394)]
+#[case::v_0_14_1_sierra_gas_revert(6481044)]
 #[case::v_0_14_2_with_proof_facts(9023035)]
 #[case::first_v_0_13_5_rpc_v8(1400000)]
 #[case::second_v_0_13_5_rpc_v8(1450000)]