feat: support catching EntryPointNotFound

crates/blockifier/feature_contracts/cairo1/test_contract.cairo

@@ -106,7 +106,7 @@ mod TestContract {
         syscalls::replace_class_syscall(class_hash).unwrap_syscall();
         syscalls::send_message_to_l1_syscall(17.try_into().unwrap(), dummy_span).unwrap_syscall();
         self.my_storage_var.write(17);
-        panic!("test_revert_helper");
+        panic(array!['test_revert_helper']);
     }
 
     #[external(v0)]
@@ -626,6 +626,12 @@ mod TestContract {
                     *error_span.pop_back().unwrap() == 'ENTRYPOINT_FAILED',
                     'Unexpected error',
                 );
+                let inner_error = *error_span.pop_back().unwrap();
+                if entry_point_selector == selector!("bad_selector") {
+                    assert(inner_error == 'ENTRYPOINT_NOT_FOUND', 'Unexpected error');
+                } else {
+                    assert(inner_error == 'test_revert_helper', 'Unexpected error');
+                }
             },
         };
         // TODO(Yoni, 1/12/2024): test replace class once get_class_hash_at syscall is supported.

crates/blockifier/src/execution/entry_point_test.rs

@@ -4,6 +4,7 @@ use cairo_vm::types::builtin_name::BuiltinName;
 use num_bigint::BigInt;
 use pretty_assertions::assert_eq;
 use starknet_api::core::{EntryPointSelector, PatriciaKey};
+use starknet_api::execution_utils::format_panic_data;
 use starknet_api::transaction::{Calldata, Fee};
 use starknet_api::{calldata, felt, storage_key};
 
@@ -164,10 +165,11 @@ fn test_entry_point_not_found_in_contract() {
     let entry_point_selector = EntryPointSelector(felt!(2_u8));
     let entry_point_call =
         CallEntryPoint { entry_point_selector, ..trivial_external_entry_point_new(test_contract) };
-    let error = entry_point_call.execute_directly(&mut state).unwrap_err();
+    let call_info = entry_point_call.execute_directly(&mut state).unwrap();
+    assert!(call_info.execution.failed);
     assert_eq!(
-        format!("Entry point {entry_point_selector:?} not found in contract."),
-        format!("{error}")
+        format_panic_data(&call_info.execution.retdata.0),
+        "0x454e545259504f494e545f4e4f545f464f554e44 ('ENTRYPOINT_NOT_FOUND')"
     );
 }
 
@@ -396,13 +398,6 @@ fn test_syscall_execution_security_failures() {
         "test_bad_syscall_request_arg_type",
         calldata![],
     );
-    run_security_test(
-        state,
-        security_contract,
-        "Entry point EntryPointSelector(0x19) not found in contract",
-        "test_bad_call_selector",
-        calldata![],
-    );
     run_security_test(
         state,
         security_contract,

crates/blockifier/src/execution/execution_utils.rs

@@ -21,6 +21,14 @@ use starknet_api::deprecated_contract_class::Program as DeprecatedProgram;
 use starknet_api::transaction::Calldata;
 use starknet_types_core::felt::Felt;
 
+use super::call_info::CallExecution;
+use super::entry_point::ConstructorEntryPointExecutionResult;
+use super::errors::{
+    ConstructorEntryPointExecutionError,
+    EntryPointExecutionError,
+    PreExecutionError,
+};
+use super::syscalls::hint_processor::ENTRYPOINT_NOT_FOUND_ERROR;
 use crate::execution::call_info::{CallInfo, Retdata};
 use crate::execution::contract_class::{ContractClass, TrackedResource};
 use crate::execution::entry_point::{
@@ -77,21 +85,38 @@ pub fn execute_entry_point_call_wrapper(
         None => context.tracked_resource_stack.push(contract_tracked_resource),
     };
 
+    let orig_call = call.clone();
     let res = execute_entry_point_call(call, contract_class, state, resources, context);
-    context.tracked_resource_stack.pop();
-
-    if let Ok(call_info) = &res {
-        if call_info.execution.failed && !context.versioned_constants().enable_reverts {
-            // Reverts are disabled.
-            return Err(EntryPointExecutionError::ExecutionFailed {
-                error_trace: extract_trailing_cairo1_revert_trace(call_info),
-            });
+    let current_tracked_resource =
+        context.tracked_resource_stack.pop().expect("Unexpected empty tracked resource.");
+
+    match res {
+        Ok(call_info) => {
+            if call_info.execution.failed && !context.versioned_constants().enable_reverts {
+                // Reverts are disabled.
+                return Err(EntryPointExecutionError::ExecutionFailed {
+                    error_trace: extract_trailing_cairo1_revert_trace(call_info),
+                });
+            }
+            update_remaining_gas(remaining_gas, &call_info);
+            Ok(call_info)
         }
-
-        update_remaining_gas(remaining_gas, call_info);
+        Err(EntryPointExecutionError::PreExecutionError(
+            PreExecutionError::EntryPointNotFound(_)
+            | PreExecutionError::NoEntryPointOfTypeFound(_),
+        )) if context.versioned_constants().enable_reverts => Ok(CallInfo {
+            call: orig_call,
+            execution: CallExecution {
+                retdata: Retdata(vec![Felt::from_hex(ENTRYPOINT_NOT_FOUND_ERROR).unwrap()]),
+                failed: true,
+                gas_consumed: 0,
+                ..CallExecution::default()
+            },
+            tracked_resource: current_tracked_resource,
+            ..CallInfo::default()
+        }),
+        Err(err) => Err(err),
     }
-
-    res
 }
 
 /// Executes a specific call to a contract entry point and returns its output.

crates/blockifier/src/execution/syscalls/hint_processor.rs

@@ -192,6 +192,9 @@ pub const OUT_OF_GAS_ERROR: &str =
 // "Block number out of range";
 pub const BLOCK_NUMBER_OUT_OF_RANGE_ERROR: &str =
     "0x00000000000000426c6f636b206e756d626572206f7574206f662072616e6765";
+// "ENTRYPOINT_NOT_FOUND";
+pub const ENTRYPOINT_NOT_FOUND_ERROR: &str =
+    "0x000000000000000000000000454e545259504f494e545f4e4f545f464f554e44";
 // "ENTRYPOINT_FAILED";
 pub const ENTRYPOINT_FAILED_ERROR: &str =
     "0x000000000000000000000000000000454e545259504f494e545f4641494c4544";

crates/blockifier/src/execution/syscalls/syscall_tests/call_contract.rs

@@ -48,7 +48,10 @@ fn test_call_contract_that_panics() {
     };
     // The inner call should have failed.
     assert!(inner_call.execution.failed);
-    assert_eq!(format_panic_data(&inner_call.execution.retdata.0), "\"test_revert_helper\"");
+    assert_eq!(
+        format_panic_data(&inner_call.execution.retdata.0),
+        "0x746573745f7265766572745f68656c706572 ('test_revert_helper')"
+    );
     assert!(inner_call.execution.events.is_empty());
     assert!(inner_call.execution.l2_to_l1_messages.is_empty());
     assert_eq!(

crates/blockifier/src/transaction/account_transactions_test.rs

@@ -1548,12 +1548,11 @@ fn test_revert_in_execute(
 }
 
 #[rstest]
-#[case(true)]
-#[case(false)]
 fn test_call_contract_that_panics(
     mut block_context: BlockContext,
     default_l1_resource_bounds: ValidResourceBounds,
-    #[case] enable_reverts: bool,
+    #[values(true, false)] enable_reverts: bool,
+    #[values("test_revert_helper", "bad_selector")] inner_selector: &str,
 ) {
     // Override enable reverts.
     block_context.versioned_constants.enable_reverts = enable_reverts;
@@ -1569,7 +1568,7 @@ fn test_call_contract_that_panics(
 
     let calldata = [
         *FeatureContract::TestContract(CairoVersion::Cairo1).get_instance_address(0).0.key(),
-        selector_from_name("test_revert_helper").0,
+        selector_from_name(inner_selector).0,
         felt!(1_u8),
         new_class_hash.0,
     ];

crates/papyrus_rpc/src/v0_8/execution_test.rs

@@ -287,7 +287,17 @@ async fn execution_call() {
         .unwrap_err();
 
     const CONTRACT_ERROR_CODE: i32 = 40;
-    assert_matches!(err, Error::Call(err) if err.code() == CONTRACT_ERROR_CODE);
+
+    match err {
+        Error::Call(err) => {
+            assert_eq!(err.code(), CONTRACT_ERROR_CODE);
+            assert_eq!(
+                err.data().unwrap().get(),
+                r##"{"revert_error":"0x454e545259504f494e545f4e4f545f464f554e44 ('ENTRYPOINT_NOT_FOUND')"}"##
+            );
+        }
+        _ => panic!("Expected Error::Call"),
+    }
 
     // Test that the block context is passed correctly to blockifier.
     let mut calldata = get_calldata_for_test_execution_info(