Implement the calls from the EVM to {EVM,Wasm}. (#3717)

## Motivation

We have the EVM application, but not the function calls from the EVM to
EVM/Wasm.

## Proposal

We have two cases to cover and the implementation is distinct for both
cases.

Call to EVM:
* The EVM itself has cross-application calls and it has a well
established system for doing application calls.
* We want to reproduce that system and the canonical technique in REVM
is to use a Call interceptor that implements the inspector trait. We
need a Contract version and a Service version.
* That call is thus bypassed and send to a
`try_call_application/try_query_application`.
* However, for the inspector trait, we need more than just the output,
we need the full `InterpreterResult`. This forces adding a specific
selector named `INTERPRETER_RESULT_SELECTOR`. This hack has the same
cryptographic assumption as the use of selectors by the EVM.
* Depending on the case, we return differently.
* The EVM addresses are converted to ApplicationId by adding 12 values
0.

Call to Wasm:
* Calling the Wasm is done by using the precompile. This address returns
the `bytes` output, which is then processed.
* Of course we need precompile for contract and for service. They call
`try_call_application/try_query_application`.
* The calls are done directly with the serialization/deserialization
being done in the solidity code.
* The address is composed as a `bytes32`.

Next steps:
* Implement the fuel consumption.
* Implement the transfer.
* Implement further LINERA APIs in the EVM. Implement the code by using
solidity code.

Coauthored by Andreas Fackler

## Test Plan

The testing framework is done in parallel to the test in
`test_wasm_call_evm_end_to_end_counter` with the same values and the
same APIs.

For the `test_evm_call_evm_end_to_end_counter` this is rather
straightforward in term of contract code and it would be the same if one
write something in ethereum.

For the `test_evm_call_wasm_end_to_end_counter` this is far more
problematic:
* The serialization for `execute_operation` is done with BCS. We wrote
the code as generated by `serde-reflection`.
* The serialization for `query_operation` is done with `serde_json`. So
far, there is no code for generating this code in `serde-reflection`.

In the EVM, we have a `eth_sendRawTransaction/eth_getTransactionReceipt`
and the `eth_call`. If an EVM smart contract in linera is calling Wasm
application, then we cannot have the same behavior.

## Release Plan

This should be significant for next TestNet.

## Links

None.

Author: MathieuDutSik

Cargo.lock

@@ -142,10 +142,10 @@ rcgen = "0.12.1"
 reqwest = { version = "0.11.24", default-features = false, features = [
     "rustls-tls",
 ] }
-revm = "19.4.0"
-revm-interpreter = { version = "15.1.0", features = ["serde"] }
-revm-precompile = "16.0.0"
-revm-primitives = "15.1.0"
+revm = "19.7.0"
+revm-interpreter = { version = "15.2.0", features = ["serde"] }
+revm-precompile = "16.2.0"
+revm-primitives = "15.2.0"
 rocksdb = "0.21.0"
 ruzstd = "0.7.1"
 scylla = "0.15.1"

Cargo.toml

@@ -14,6 +14,7 @@ version.workspace = true
 [features]
 metrics = ["prometheus"]
 reqwest = ["dep:reqwest"]
+revm = []
 test = ["test-strategy", "proptest"]
 web = [
     "getrandom/js",

linera-base/Cargo.toml

@@ -8,6 +8,7 @@ fn main() {
         with_metrics: { all(not(target_arch = "wasm32"), feature = "metrics") },
         with_reqwest: { feature = "reqwest" },
         with_testing: { any(test, feature = "test") },
+        with_revm: { any(test, feature = "revm") },
 
         // the old version of `getrandom` we pin here is available on all targets, but
         // using it will panic if no suitable source of entropy is found

linera-base/build.rs

@@ -10,6 +10,8 @@ use std::{
     str::FromStr,
 };
 
+#[cfg(with_revm)]
+use alloy_primitives::{Address, B256};
 use anyhow::{anyhow, Context};
 use async_graphql::SimpleObject;
 use custom_debug_derive::Debug;
@@ -952,6 +954,21 @@ impl<A> ApplicationId<A> {
     }
 }
 
+#[cfg(with_revm)]
+impl<A> ApplicationId<A> {
+    /// Converts the `ApplicationId` into an Ethereum Address.
+    pub fn evm_address(&self) -> Address {
+        let bytes = self.application_description_hash.as_bytes();
+        let bytes = bytes.0.as_ref();
+        Address::from_slice(&bytes[0..20])
+    }
+
+    /// Converts the `ApplicationId` into an Ethereum-compatible 32-byte array.
+    pub fn bytes32(&self) -> B256 {
+        *self.application_description_hash.as_bytes()
+    }
+}
+
 #[derive(Serialize, Deserialize)]
 #[serde(rename = "AccountOwner")]
 enum SerializableAccountOwner {

linera-base/src/identifiers.rs

@@ -16,6 +16,8 @@ test = ["tokio/macros", "linera-base/test", "linera-views/test", "proptest"]
 revm = [
     "dep:revm",
     "dep:revm-primitives",
+    "dep:revm-precompile",
+    "dep:revm-interpreter",
     "dep:alloy",
     "dep:alloy-sol-types",
     "dep:hex",
@@ -55,6 +57,8 @@ prometheus = { workspace = true, optional = true }
 proptest = { workspace = true, optional = true }
 reqwest = { workspace = true, features = ["blocking", "json", "stream"] }
 revm = { workspace = true, optional = true, features = ["serde"] }
+revm-interpreter = { workspace = true, optional = true, features = ["serde"] }
+revm-precompile = { workspace = true, optional = true }
 revm-primitives = { workspace = true, optional = true }
 serde.workspace = true
 serde_bytes.workspace = true