test actually passes

Author: edg-l

src/execution/execution_entry_point.rs

@@ -430,7 +430,6 @@ impl ExecutionEntryPoint {
         class_hash: [u8; 32],
         support_reverted: bool,
     ) -> Result<CallInfo, TransactionError> {
-        dbg!("called");
         let previous_cairo_usage = resources_manager.cairo_usage.clone();
 
         // fetch selected entry point
@@ -560,8 +559,6 @@ impl ExecutionEntryPoint {
         resources_manager.cairo_usage += &runner.get_execution_resources()?;
 
         let call_result = runner.get_call_result(self.initial_gas)?;
-        dbg!(&call_result.is_success);
-        dbg!(&call_result.retdata);
         self.build_call_info::<S>(
             previous_cairo_usage,
             resources_manager,

tests/account_panic.rs

@@ -5,17 +5,11 @@ use num_traits::Zero;
 use starknet_in_rust::{
     core::contract_address::compute_casm_class_hash,
     definitions::{block_context::BlockContext, constants::TRANSACTION_VERSION},
-    execution::{
-        execution_entry_point::ExecutionEntryPoint, CallType, TransactionExecutionContext,
-    },
     services::api::contract_classes::compiled_class::CompiledClass,
-    state::{
-        cached_state::CachedState, in_memory_state_reader::InMemoryStateReader, state_api::State,
-        ExecutionResourcesManager,
-    },
-    transaction::{DeclareV2, Deploy, DeployAccount, InvokeFunction, Transaction},
-    utils::{Address, ClassHash},
-    CasmContractClass, EntryPointType,
+    state::{cached_state::CachedState, in_memory_state_reader::InMemoryStateReader},
+    transaction::{InvokeFunction, Transaction},
+    utils::{calculate_sn_keccak, Address},
+    CasmContractClass,
 };
 
 #[test]
@@ -61,36 +55,60 @@ fn account_panic() {
         .insert(contract_address.clone(), contract_class_hash);
     state_reader
         .address_to_nonce_mut()
-        .insert(contract_address.clone(), 1.into());
+        .insert(contract_address, 1.into());
     let mut state = CachedState::new(Arc::new(state_reader), contract_class_cache);
 
-    let entrypoints = contract_class.entry_points_by_type;
-
-    let entrypoint_selector = &entrypoints.external.get(0).unwrap().selector;
+    let selector = Felt252::from_bytes_be(&calculate_sn_keccak(b"__execute__"));
 
     // arguments of contract_a contract
-    let calldata: Vec<_> = [2.into()].to_vec();
+    // calldata is a Vec of Call, which is
+    /*
+       #[derive(Drop, Serde)]
+       struct Call {
+           to: ContractAddress,
+           selector: felt252,
+           calldata: Array<felt252>
+       }
+    */
+    let selector_contract = &contract_class
+        .entry_points_by_type
+        .external
+        .get(0)
+        .unwrap()
+        .selector;
+    // calldata of contract_a is 1 value.
+    let calldata: Vec<_> = [
+        1.into(),
+        contract_class_hash_felt,
+        selector_contract.into(),
+        1.into(),
+        2.into(),
+    ]
+    .to_vec();
 
     // set up remaining structures
 
     let invoke = InvokeFunction::new(
-        contract_address,
-        Felt252::new(entrypoint_selector.clone()),
+        account_address,
+        Felt252::new(selector),
         0,
         TRANSACTION_VERSION.clone(),
         calldata,
         vec![],
         block_context.starknet_os_config().chain_id().clone(),
-        Some(1.into()),
+        Some(0.into()),
     )
     .unwrap();
 
     let tx = Transaction::InvokeFunction(invoke);
-    let call_info = tx
+    let exec_info = tx
         .execute(&mut state, &block_context, u128::MAX)
         .expect("failed to invoke");
+    let call_info = exec_info.call_info.as_ref().unwrap();
+
+    assert_eq!(exec_info.revert_error, None);
 
-    dbg!(call_info.revert_error);
-    //dbg!(call_info);
-    panic!()
+    // 482670963043u128 == 'panic'
+    assert_eq!(call_info.retdata[0], 482670963043u128.into());
+    assert!(call_info.failure_flag);
 }