Add new tests: cairo0 non-existent method, fork call (#693)

Author: FabijanC

crates/starknet-devnet-server/src/api/json_rpc/error.rs

@@ -223,7 +223,7 @@ impl ApiError {
             | Self::NoTraceAvailable
             | Self::TypesError(_)
             | Self::RpcError(_)
-            | Self::ContractNotFound
+            | Self::ContractNotFound // Doesn't require forwarding, handled at state reader level
             | Self::InvalidTransactionIndexInBlock
             | Self::ContractError { .. }
             | Self::NoBlocks

tests/integration/test_call.rs

@@ -33,7 +33,34 @@ async fn calling_method_of_undeployed_contract() {
 }
 
 #[tokio::test]
-async fn calling_nonexistent_contract_method() {
+async fn calling_nonexistent_cairo0_contract_method() {
+    let devnet_args = ["--account-class", "cairo0"];
+    let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
+    let contract_address = Felt::from_hex_unchecked(PREDEPLOYED_ACCOUNT_ADDRESS);
+    let entry_point_selector =
+        starknet_rs_core::utils::get_selector_from_name("nonExistentMethod").unwrap();
+
+    let err = devnet
+        .json_rpc_client
+        .call(
+            FunctionCall {
+                contract_address,
+                entry_point_selector,
+                calldata: vec![contract_address],
+            },
+            BlockId::Tag(BlockTag::Latest),
+        )
+        .await
+        .expect_err("Should have failed");
+
+    match err {
+        ProviderError::StarknetError(StarknetError::ContractError(_)) => (),
+        _ => panic!("Invalid error: {err:?}"),
+    }
+}
+
+#[tokio::test]
+async fn calling_nonexistent_cairo1_contract_method() {
     let devnet = BackgroundDevnet::spawn().await.expect("Could not start Devnet");
     let contract_address = Felt::from_hex_unchecked(PREDEPLOYED_ACCOUNT_ADDRESS);
     let entry_point_selector =

tests/integration/test_fork.rs

@@ -448,6 +448,44 @@ async fn test_get_storage_if_contract_deployed_on_origin() {
     assert_eq!(real_value, signer.get_public_key().await.unwrap().scalar());
 }
 
+#[tokio::test]
+async fn test_deploying_on_origin_calling_on_fork() {
+    let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();
+
+    // obtain account for deployment
+    let (signer, account_address) = origin_devnet.get_first_predeployed_account().await;
+    let predeployed_account = SingleOwnerAccount::new(
+        &origin_devnet.json_rpc_client,
+        signer.clone(),
+        account_address,
+        constants::CHAIN_ID,
+        ExecutionEncoding::New,
+    );
+
+    let (contract_class, casm_hash) = get_simple_contract_in_sierra_and_compiled_class_hash();
+
+    let initial_value = Felt::from(10_u32);
+    let ctor_args = vec![initial_value];
+    let (_, contract_address) =
+        declare_v3_deploy_v3(&predeployed_account, contract_class.clone(), casm_hash, &ctor_args)
+            .await
+            .unwrap();
+
+    let fork_devnet = origin_devnet.fork().await.unwrap();
+
+    let entry_point_selector = get_selector_from_name("get_balance").unwrap();
+    let call_result = fork_devnet
+        .json_rpc_client
+        .call(
+            FunctionCall { contract_address, entry_point_selector, calldata: vec![] },
+            BlockId::Tag(BlockTag::Latest),
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(call_result, vec![initial_value]);
+}
+
 #[tokio::test]
 async fn test_fork_using_origin_token_contract() {
     let origin_devnet = BackgroundDevnet::spawn_forkable_devnet().await.unwrap();