Implement the end-to-end test that calls an EVM smart contract. (#3685)

## Motivation

The EVM smart contract have the `EvmAbi`. A test is needed to
demonstrate on how to call them from Wasm.

## Proposal

The following changes are made:
* The `EvmQuery` is added to the `linera_base_types`.
* The `call-evm-counter` is added, which is a non GraphQL app.
* A demonstration of query and mutation is introduced in the end-to-end
test.

There are some changes to the `linera-sdk`:
* The `EvmAbi` should not be protected by a `revm` feature as the fact
that we use REVM is incidental.
* The `call-evm-counter` calling for the `revm` feature forces the
`revm` feature by default which is unfortunate.

This is the first example of a query to a smart contract that leads to
another `query_application` being created in the end-to-end test.

## Test Plan

The introduced test demonstrates the functionality.

## Release Plan

Normal release plan.

## Links

None.

Author: MathieuDutSik

Cargo.lock

@@ -250,6 +250,7 @@ linera-witty = { version = "0.14.0", path = "./linera-witty" }
 linera-witty-macros = { version = "0.14.0", path = "./linera-witty-macros" }
 
 amm = { path = "./examples/amm" }
+call-evm-counter = { path = "./examples/call-evm-counter" }
 counter = { path = "./examples/counter" }
 counter-no-graphql = { path = "./examples/counter-no-graphql" }
 crowd-funding = { path = "./examples/crowd-funding" }

Cargo.toml

@@ -3,6 +3,7 @@ resolver = "2"
 members = [
     "amm",
     "counter",
+    "call-evm-counter",
     "counter-no-graphql",
     "crowd-funding",
     "ethereum-tracker",
@@ -21,6 +22,7 @@ members = [
 
 [workspace.dependencies]
 alloy = { version = "0.9.2", default-features = false }
+alloy-sol-types = "0.8.18"
 anyhow = "1.0.80"
 assert_matches = "1.5.0"
 async-graphql = { version = "=7.0.2", default-features = false }

examples/Cargo.lock

@@ -0,0 +1,30 @@
+[package]
+name = "call-evm-counter"
+version = "0.1.0"
+authors = ["Linera <[email protected]>"]
+edition = "2021"
+
+[dependencies]
+alloy = { workspace = true, default-features = false, features = [
+    "rpc-types-eth",
+] }
+alloy-sol-types.workspace = true
+linera-sdk.workspace = true
+serde.workspace = true
+
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+linera-sdk = { workspace = true, features = ["test", "wasmer"] }
+tokio = { workspace = true, features = ["rt", "sync"] }
+
+[dev-dependencies]
+assert_matches.workspace = true
+linera-sdk = { workspace = true, features = ["test"] }
+
+[[bin]]
+name = "call_evm_counter_contract"
+path = "src/contract.rs"
+
+[[bin]]
+name = "call_evm_counter_service"
+path = "src/service.rs"

examples/Cargo.toml

@@ -0,0 +1,59 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(target_arch = "wasm32", no_main)]
+
+use alloy::primitives::U256;
+use alloy_sol_types::{sol, SolCall};
+use call_evm_counter::{CallCounterAbi, CallCounterOperation};
+use linera_sdk::{
+    abis::evm::EvmAbi,
+    linera_base_types::{ApplicationId, WithContractAbi},
+    Contract, ContractRuntime,
+};
+
+pub struct CallCounterContract {
+    runtime: ContractRuntime<Self>,
+}
+
+linera_sdk::contract!(CallCounterContract);
+
+impl WithContractAbi for CallCounterContract {
+    type Abi = CallCounterAbi;
+}
+
+impl Contract for CallCounterContract {
+    type Message = ();
+    type InstantiationArgument = ();
+    type Parameters = ApplicationId<EvmAbi>;
+
+    async fn load(runtime: ContractRuntime<Self>) -> Self {
+        CallCounterContract { runtime }
+    }
+
+    async fn instantiate(&mut self, _value: ()) {
+        // Validate that the application parameters were configured correctly.
+        self.runtime.application_parameters();
+    }
+
+    async fn execute_operation(&mut self, operation: CallCounterOperation) -> u64 {
+        let CallCounterOperation::Increment(increment) = operation;
+        sol! {
+            function increment(uint64 input);
+        }
+        let operation = incrementCall { input: increment };
+        let operation = operation.abi_encode();
+        let evm_counter_id = self.runtime.application_parameters();
+        let result = self
+            .runtime
+            .call_application(true, evm_counter_id, &operation);
+        let arr: [u8; 32] = result.try_into().expect("result should have length 32");
+        U256::from_be_bytes(arr).to::<u64>()
+    }
+
+    async fn execute_message(&mut self, _message: ()) {
+        panic!("Counter application doesn't support any cross-chain messages");
+    }
+
+    async fn store(self) {}
+}

examples/call-evm-counter/Cargo.toml

@@ -0,0 +1,30 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/*! ABI of the Counter Example Application that does not use GraphQL */
+
+use linera_sdk::linera_base_types::{ContractAbi, ServiceAbi};
+use serde::{Deserialize, Serialize};
+
+pub struct CallCounterAbi;
+
+impl ContractAbi for CallCounterAbi {
+    type Operation = CallCounterOperation;
+    type Response = u64;
+}
+
+impl ServiceAbi for CallCounterAbi {
+    type Query = CallCounterRequest;
+    type QueryResponse = u64;
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum CallCounterRequest {
+    Query,
+    Increment(u64),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum CallCounterOperation {
+    Increment(u64),
+}

examples/call-evm-counter/src/contract.rs

@@ -0,0 +1,57 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(target_arch = "wasm32", no_main)]
+
+use std::sync::Arc;
+
+use alloy::primitives::U256;
+use alloy_sol_types::{sol, SolCall};
+use call_evm_counter::{CallCounterOperation, CallCounterRequest};
+use linera_sdk::{
+    abis::evm::EvmAbi,
+    linera_base_types::{ApplicationId, EvmQuery, WithServiceAbi},
+    Service, ServiceRuntime,
+};
+
+pub struct CallCounterService {
+    runtime: Arc<ServiceRuntime<Self>>,
+}
+
+linera_sdk::service!(CallCounterService);
+
+impl WithServiceAbi for CallCounterService {
+    type Abi = call_evm_counter::CallCounterAbi;
+}
+
+impl Service for CallCounterService {
+    type Parameters = ApplicationId<EvmAbi>;
+
+    async fn new(runtime: ServiceRuntime<Self>) -> Self {
+        CallCounterService {
+            runtime: Arc::new(runtime),
+        }
+    }
+
+    async fn handle_query(&self, request: CallCounterRequest) -> u64 {
+        match request {
+            CallCounterRequest::Query => {
+                sol! {
+                    function get_value();
+                }
+                let query = get_valueCall {};
+                let query = query.abi_encode();
+                let query = EvmQuery::Query(query);
+                let evm_counter_id = self.runtime.application_parameters();
+                let result = self.runtime.query_application(evm_counter_id, &query);
+                let arr: [u8; 32] = result.try_into().expect("result should have length 32");
+                U256::from_be_bytes(arr).to::<u64>()
+            }
+            CallCounterRequest::Increment(value) => {
+                let operation = CallCounterOperation::Increment(value);
+                self.runtime.schedule_operation(&operation);
+                0
+            }
+        }
+    }
+}

examples/call-evm-counter/src/lib.rs

@@ -24,7 +24,6 @@ ignored = ["base64ct"]
 
 [features]
 ethereum = ["async-trait", "linera-ethereum"]
-revm = ["linera-execution/revm"]
 wasmer = [
     "linera-core/wasmer",
     "linera-execution/wasmer",

examples/call-evm-counter/src/service.rs

@@ -3,7 +3,6 @@
 
 fn main() {
     cfg_aliases::cfg_aliases! {
-        with_revm: { feature = "revm" },
         with_testing: { any(test, feature = "test") },
         with_wasm_runtime: { any(feature = "wasmer", feature = "wasmtime") },
         with_integration_testing: {

linera-sdk/Cargo.toml

@@ -3,6 +3,5 @@
 
 //! Common ABIs that may have multiple implementations.
 
-#[cfg(with_revm)]
 pub mod evm;
 pub mod fungible;

linera-sdk/build.rs

@@ -4,5 +4,5 @@
 //! Types reexported from [`linera_base`].
 
 pub use linera_base::{
-    abi::*, crypto::*, data_types::*, identifiers::*, ownership::*, BcsHexParseError,
+    abi::*, crypto::*, data_types::*, identifiers::*, ownership::*, vm::EvmQuery, BcsHexParseError,
 };

linera-sdk/src/abis/mod.rs

@@ -14,12 +14,7 @@ version.workspace = true
 [features]
 ethereum = []
 default = ["wasmer", "rocksdb", "storage-service"]
-revm = [
-    "linera-execution/revm",
-    "linera-storage/revm",
-    "linera-sdk/revm",
-    "dep:alloy-sol-types",
-]
+revm = ["linera-execution/revm", "linera-storage/revm", "dep:alloy-sol-types"]
 test = [
     "linera-base/test",
     "linera-execution/test",
@@ -147,6 +142,7 @@ alloy = { workspace = true, default-features = false, features = [
 ] }
 amm.workspace = true
 base64.workspace = true
+call-evm-counter.workspace = true
 counter.workspace = true
 counter-no-graphql.workspace = true
 criterion = { workspace = true, features = ["async_tokio"] }

linera-sdk/src/linera_base_types.rs

@@ -415,6 +415,99 @@ async fn test_evm_end_to_end_counter(config: impl LineraNetConfig) -> Result<()>
     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"))]
+#[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_wasm_call_evm_end_to_end_counter(config: impl LineraNetConfig) -> Result<()> {
+    use alloy_sol_types::{sol, SolValue};
+    use call_evm_counter::{CallCounterAbi, CallCounterRequest};
+    use linera_execution::test_utils::solidity::{
+        get_contract_service_paths, get_evm_example_counter,
+    };
+    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?;
+    let chain = client.load_wallet()?.default_chain().unwrap();
+
+    // Creating the EVM contract
+
+    let module = get_evm_example_counter()?;
+
+    sol! {
+        struct ConstructorArgs {
+            uint64 initial_value;
+        }
+    }
+
+    let original_counter_value = 35;
+    let evm_instantiation_argument = ConstructorArgs {
+        initial_value: original_counter_value,
+    };
+    let evm_instantiation_argument = evm_instantiation_argument.abi_encode();
+
+    let (evm_contract, evm_service, _dir) = get_contract_service_paths(module)?;
+    type InstantiationArgument = Vec<u8>;
+
+    let evm_application_id = client
+        .publish_and_create::<EvmAbi, (), InstantiationArgument>(
+            evm_contract,
+            evm_service,
+            VmRuntime::Evm,
+            &(),
+            &evm_instantiation_argument,
+            &[],
+            None,
+        )
+        .await?;
+
+    // Creating the WASM contract
+
+    let (wasm_contract, wasm_service) = client.build_example("call-evm-counter").await?;
+    type WasmParameter = ApplicationId<EvmAbi>;
+    let wasm_application_id = client
+        .publish_and_create::<CallCounterAbi, WasmParameter, ()>(
+            wasm_contract,
+            wasm_service,
+            VmRuntime::Wasm,
+            &evm_application_id,
+            &(),
+            &[],
+            None,
+        )
+        .await?;
+
+    let port = get_node_port().await;
+    let mut node_service = client.run_node_service(port, ProcessInbox::Skip).await?;
+
+    let wasm_application = node_service
+        .make_application(&chain, &wasm_application_id)
+        .await?;
+
+    let query = CallCounterRequest::Query;
+    let counter_value = wasm_application.run_json_query(&query).await?;
+    assert_eq!(counter_value, original_counter_value);
+
+    let increment = 5;
+    let query_increment = CallCounterRequest::Increment(increment);
+    wasm_application.run_json_query(&query_increment).await?;
+
+    let counter_value = wasm_application.run_json_query(&query).await?;
+    assert_eq!(counter_value, original_counter_value + increment);
+
+    node_service.ensure_is_running()?;
+
+    net.ensure_is_running().await?;
+    net.terminate().await?;
+
+    Ok(())
+}
+
 #[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(all(feature = "rocksdb", feature = "scylladb"), test_case(LocalNetConfig::new_test(Database::DualRocksDbScyllaDb, Network::Grpc) ; "dualrocksdbscylladb_grpc"))]