diff --git a/crates/blockifier/src/execution/stack_trace_test.rs b/crates/blockifier/src/execution/stack_trace_test.rs
index d3a20f94d02..ae12a95b8a0 100644
--- a/crates/blockifier/src/execution/stack_trace_test.rs
+++ b/crates/blockifier/src/execution/stack_trace_test.rs
@@ -1,7 +1,8 @@
+use assert_matches::assert_matches;
 use pretty_assertions::assert_eq;
 use regex::Regex;
 use rstest::rstest;
-use starknet_api::core::{calculate_contract_address, Nonce};
+use starknet_api::core::{calculate_contract_address, ContractAddress, EntryPointSelector, Nonce};
 use starknet_api::transaction::{
     ContractAddressSalt,
     Fee,
@@ -10,10 +11,15 @@ use starknet_api::transaction::{
     ValidResourceBounds,
 };
 use starknet_api::{calldata, felt, invoke_tx_args};
+use starknet_types_core::felt::Felt;
 
 use crate::abi::abi_utils::selector_from_name;
 use crate::abi::constants::CONSTRUCTOR_ENTRY_POINT_NAME;
 use crate::context::{BlockContext, ChainInfo};
+use crate::execution::call_info::{CallExecution, CallInfo, Retdata};
+use crate::execution::errors::EntryPointExecutionError;
+use crate::execution::stack_trace::{extract_trailing_cairo1_revert_trace, Cairo1RevertStack};
+use crate::execution::syscalls::hint_processor::ENTRYPOINT_FAILED_ERROR;
 use crate::test_utils::contracts::FeatureContract;
 use crate::test_utils::initial_test_state::{fund_account, test_state};
 use crate::test_utils::{create_calldata, CairoVersion, BALANCE};
@@ -818,3 +824,113 @@ Error in contract (contract address: {expected_address:#064x}, class hash: {:#06
         invoke_deploy_tx.execute(state, &block_context, true, true).unwrap().revert_error.unwrap();
     assert_eq!(error.to_string(), expected_error);
 }
+
+#[test]
+fn test_cairo1_stack_extraction_inner_call_successful() {
+    let error_data = Retdata(vec![felt!("0xdeadbeef")]);
+    let callinfo = CallInfo {
+        execution: CallExecution { retdata: error_data, failed: true, ..Default::default() },
+        inner_calls: vec![CallInfo {
+            execution: CallExecution { failed: false, ..Default::default() },
+            ..Default::default()
+        }],
+        ..Default::default()
+    };
+    let error = EntryPointExecutionError::ExecutionFailed {
+        error_trace: extract_trailing_cairo1_revert_trace(&callinfo),
+    };
+    assert_eq!(
+        error.to_string(),
+        format!(
+            "Execution failed. Failure reason:
+Error in contract (contract address: {:#064x}, class hash: _, selector: {:#064x}):
+0xdeadbeef.",
+            ContractAddress::default().0.key(),
+            EntryPointSelector::default().0
+        )
+    );
+}
+
+#[test]
+fn test_ambiguous_inner_cairo1_failure() {
+    let outer_retdata =
+        Retdata(vec![felt!("0xdeadbeef"), felt!("0xdeadbeef2"), felt!(ENTRYPOINT_FAILED_ERROR)]);
+    let inner_call_info = CallInfo {
+        execution: CallExecution {
+            retdata: Retdata(outer_retdata.0[..outer_retdata.0.len() - 1].into()),
+            failed: true,
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    let call_info = CallInfo {
+        execution: CallExecution {
+            retdata: outer_retdata.clone(),
+            failed: true,
+            ..Default::default()
+        },
+        inner_calls: vec![inner_call_info.clone(), inner_call_info],
+        ..Default::default()
+    };
+    assert_matches!(
+        extract_trailing_cairo1_revert_trace(&call_info),
+        Cairo1RevertStack { stack, last_retdata }
+        if stack.is_empty() && last_retdata == outer_retdata
+    );
+}
+
+#[rstest]
+fn test_inner_cairo1_failure_not_last(#[values(true, false)] last_is_failed: bool) {
+    let outer_retdata =
+        Retdata(vec![felt!("0xdeadbeef"), felt!("0xdeadbeef2"), felt!(ENTRYPOINT_FAILED_ERROR)]);
+    let first_inner_retdata = Retdata(outer_retdata.0[..outer_retdata.0.len() - 1].into());
+    let first_inner_call_info = CallInfo {
+        execution: CallExecution {
+            retdata: first_inner_retdata.clone(),
+            failed: true,
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    let last_inner_call_info = CallInfo {
+        execution: CallExecution {
+            retdata: Retdata(
+                // Not a prefix of the outer retdata. Should not be selected as inner failure.
+                vec![felt!("0xdeadbeef2"), felt!(ENTRYPOINT_FAILED_ERROR)],
+            ),
+            failed: last_is_failed,
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    let call_info = CallInfo {
+        execution: CallExecution {
+            retdata: outer_retdata.clone(),
+            failed: true,
+            ..Default::default()
+        },
+        inner_calls: vec![first_inner_call_info, last_inner_call_info],
+        ..Default::default()
+    };
+    assert_matches!(
+        extract_trailing_cairo1_revert_trace(&call_info),
+        Cairo1RevertStack { stack, last_retdata }
+        if stack.len() == 2 && last_retdata == first_inner_retdata
+    );
+}
+
+/// If extraction function is called with a successful callinfo, it should return an empty stack and
+/// the original retdata.
+#[test]
+fn test_cairo1_stack_extraction_not_failure_fallback() {
+    let expected_retdata = Retdata(vec![Felt::ONE, Felt::THREE]);
+    let successful_call = CallInfo {
+        execution: CallExecution { retdata: expected_retdata.clone(), ..Default::default() },
+        ..Default::default()
+    };
+    assert_matches!(
+        extract_trailing_cairo1_revert_trace(&successful_call),
+        Cairo1RevertStack { stack, last_retdata }
+        if stack.is_empty() && last_retdata == expected_retdata
+    );
+}