Move basic EVM test from end-to-end test to linera-execution. (#4112)

## Motivation

Some of the EVM tests are in `linera-service` as end-to-end test when
they can be usefully moved to `linera-execution`.

## Proposal

This corresponds to the `test_evm_end_to_end_basic_check`.

All the other remaining tests in `linera-service` for REVM require the
use of end-to-end tests and cannot be moved to `linera-execution`.

## Test Plan

The CI.

## Release Plan

- Nothing to do / These changes follow the usual release cycle.

## Links

None.

Author: MathieuDutSik

linera-execution/Cargo.toml

@@ -26,6 +26,7 @@ revm = [
     "dep:alloy-sol-types",
     "dep:hex",
     "dep:tempfile",
+    "linera-base/revm",
 ]
 fs = ["tokio/fs"]
 metrics = ["prometheus", "linera-views/metrics"]

linera-service/tests/fixtures/evm_basic_check.sol renamed to linera-execution/tests/fixtures/evm_basic_check.sol

@@ -328,3 +328,142 @@ async fn test_terminate_query_by_lack_of_fuel() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_basic_evm_features() -> anyhow::Result<()> {
+    let module = load_solidity_example("tests/fixtures/evm_basic_check.sol")?;
+
+    sol! {
+        function failing_function();
+        function test_precompile_sha256();
+    function check_contract_address(address evm_address);
+    }
+
+    let constructor_argument = Vec::<u8>::new();
+    let constructor_argument = serde_json::to_string(&constructor_argument)?.into_bytes();
+    let instantiation_argument = Vec::<u8>::new();
+    let instantiation_argument = serde_json::to_string(&instantiation_argument)?.into_bytes();
+    let state = SystemExecutionState {
+        description: Some(dummy_chain_description(0)),
+        ..Default::default()
+    };
+    let (mut app_desc, contract_blob, service_blob) = create_dummy_user_application_description(1);
+    app_desc.parameters = constructor_argument;
+    let chain_id = app_desc.creator_chain_id;
+    let mut view = state
+        .into_view_with(chain_id, ExecutionRuntimeConfig::default())
+        .await;
+    let app_id = From::from(&app_desc);
+    let app_desc_blob_id = Blob::new_application_description(&app_desc).id();
+    let contract_blob_id = contract_blob.id();
+    let service_blob_id = service_blob.id();
+
+    let contract = EvmContractModule::Revm {
+        module: module.clone(),
+    };
+    view.context()
+        .extra()
+        .user_contracts()
+        .insert(app_id, contract.clone().into());
+
+    let service = EvmServiceModule::Revm { module };
+    view.context()
+        .extra()
+        .user_services()
+        .insert(app_id, service.into());
+
+    view.simulate_instantiation(
+        contract.into(),
+        Timestamp::from(2),
+        app_desc,
+        instantiation_argument,
+        contract_blob,
+        service_blob,
+    )
+    .await?;
+
+    let operation_context = OperationContext {
+        chain_id,
+        height: BlockHeight(0),
+        round: Some(0),
+        authenticated_signer: None,
+        authenticated_caller_id: None,
+        timestamp: Default::default(),
+    };
+
+    let policy = ResourceControlPolicy {
+        evm_fuel_unit: Amount::from_attos(1),
+        maximum_evm_fuel_per_block: 20000,
+        ..ResourceControlPolicy::default()
+    };
+    let mut controller =
+        ResourceController::new(Arc::new(policy), ResourceTracker::default(), None);
+    let mut txn_tracker = TransactionTracker::new_replaying_blobs([
+        app_desc_blob_id,
+        contract_blob_id,
+        service_blob_id,
+    ]);
+    let query_context = QueryContext {
+        chain_id,
+        next_block_height: BlockHeight(0),
+        local_time: Timestamp::from(0),
+    };
+
+    // Trying a failing function, should be an error
+    let operation = failing_functionCall {};
+    let bytes = operation.abi_encode();
+    let operation = Operation::User {
+        application_id: app_id,
+        bytes,
+    };
+    let result = view
+        .execute_operation(
+            operation_context,
+            operation,
+            &mut txn_tracker,
+            &mut controller,
+        )
+        .await;
+    assert!(result.is_err());
+
+    // Trying a call to an ethereum precompile function
+    let query = test_precompile_sha256Call {};
+    let query = query.abi_encode();
+    let query = EvmQuery::Query(query);
+    let bytes = serde_json::to_vec(&query)?;
+
+    let query = Query::User {
+        application_id: app_id,
+        bytes,
+    };
+
+    let result = view.query_application(query_context, query, None).await?;
+
+    let QueryResponse::User(result) = result.response else {
+        anyhow::bail!("Wrong QueryResponse result");
+    };
+    let result: serde_json::Value = serde_json::from_slice(&result).unwrap();
+    assert_eq!(read_evm_u64_entry(result), 0);
+
+    // Testing that the created contract has the right address
+    let evm_address = app_id.evm_address();
+    let query = check_contract_addressCall { evm_address };
+    let query = query.abi_encode();
+    let query = EvmQuery::Query(query);
+    let bytes = serde_json::to_vec(&query)?;
+
+    let query = Query::User {
+        application_id: app_id,
+        bytes,
+    };
+
+    let result = view.query_application(query_context, query, None).await?;
+
+    let QueryResponse::User(result) = result.response else {
+        anyhow::bail!("Wrong QueryResponse result");
+    };
+    let result: serde_json::Value = serde_json::from_slice(&result).unwrap();
+    assert_eq!(read_evm_u64_entry(result), 49);
+
+    Ok(())
+}

linera-execution/tests/revm.rs

@@ -330,84 +330,6 @@ impl AmmApp {
     }
 }
 
-#[cfg(with_revm)]
-#[cfg_attr(feature = "storage-service", test_case(LocalNetConfig::new_test(Database::Service, Network::Grpc) ; "storage_test_service_grpc"))]
-#[cfg_attr(feature = "scylladb", test_case(LocalNetConfig::new_test(Database::ScyllaDb, Network::Grpc) ; "scylladb_grpc"))]
-#[cfg_attr(feature = "dynamodb", test_case(LocalNetConfig::new_test(Database::DynamoDb, Network::Grpc) ; "aws_grpc"))]
-#[cfg_attr(feature = "kubernetes", test_case(SharedLocalKubernetesNetTestingConfig::new(Network::Grpc, BuildArg::Build) ; "kubernetes_grpc"))]
-#[cfg_attr(feature = "remote-net", test_case(RemoteNetTestingConfig::new(None) ; "remote_net_grpc"))]
-#[test_log::test(tokio::test)]
-async fn test_evm_end_to_end_basic_check(config: impl LineraNetConfig) -> Result<()> {
-    use alloy_sol_types::{sol, SolCall};
-    use linera_base::vm::EvmQuery;
-    use linera_execution::test_utils::solidity::{get_evm_contract_path, read_evm_u64_entry};
-    use linera_sdk::abis::evm::EvmAbi;
-    let _guard = INTEGRATION_TEST_GUARD.lock().await;
-    tracing::info!("Starting test {}", test_name!());
-
-    let (mut net, client) = config.instantiate().await?;
-
-    sol! {
-        function failing_function();
-        function test_precompile_sha256();
-        function check_contract_address(address evm_address);
-    }
-    let chain = client.load_wallet()?.default_chain().unwrap();
-
-    let (evm_contract, _dir) = get_evm_contract_path("tests/fixtures/evm_basic_check.sol")?;
-
-    let constructor_argument = Vec::new();
-    let instantiation_argument = Vec::new();
-    let application_id = client
-        .publish_and_create::<EvmAbi, Vec<u8>, Vec<u8>>(
-            evm_contract.clone(),
-            evm_contract,
-            VmRuntime::Evm,
-            &constructor_argument,
-            &instantiation_argument,
-            &[],
-            None,
-        )
-        .await?;
-
-    let evm_address = application_id.evm_address();
-
-    let port = get_node_port().await;
-    let mut node_service = client.run_node_service(port, ProcessInbox::Skip).await?;
-
-    let application = node_service
-        .make_application(&chain, &application_id)
-        .await?;
-
-    // Checking that failing function lead to an error
-    let failing_function = failing_functionCall {};
-    let failing_function = failing_function.abi_encode();
-    let failing_function = EvmQuery::Query(failing_function);
-    let result = application.run_json_query(failing_function).await;
-    assert!(result.is_err());
-
-    // Checking that failing function lead to an error
-    let test_sha256 = test_precompile_sha256Call {};
-    let test_sha256 = test_sha256.abi_encode();
-    let test_sha256 = EvmQuery::Query(test_sha256);
-    let result = application.run_json_query(test_sha256).await?;
-    assert_eq!(read_evm_u64_entry(result), 0);
-
-    // Checking that the EVM contract address matches the one of Linera
-    let check_contract_address = check_contract_addressCall { evm_address };
-    let check_contract_address = check_contract_address.abi_encode();
-    let check_contract_address = EvmQuery::Query(check_contract_address);
-    let result = application.run_json_query(check_contract_address).await?;
-    assert_eq!(read_evm_u64_entry(result), 49);
-
-    node_service.ensure_is_running()?;
-
-    net.ensure_is_running().await?;
-    net.terminate().await?;
-
-    Ok(())
-}
-
 #[cfg(with_revm)]
 #[cfg_attr(feature = "storage-service", test_case(LocalNetConfig::new_test(Database::Service, Network::Grpc) ; "storage_test_service_grpc"))]
 #[cfg_attr(feature = "scylladb", test_case(LocalNetConfig::new_test(Database::ScyllaDb, Network::Grpc) ; "scylladb_grpc"))]