Introduce the linera.sol for solidity code. (#3775)

## Motivation

The introduction of the Wasm calls is making the code complicated.
The `linera.sol` isolates the Linera specific code in a separate
library.

Fixes #3761 

## Proposal

The following is done:
* The `PrecompileTag` is introduced with only two options. This can be
extended in the future.
* The few lines in `evm_call_wasm_example_counter.sol` is moved to
`linera.sol`. This again can be extended
* The `linera.sol` is available as a fixture in the `linera-execution`.
The compilation uses it if the solidity is selected.
* The use of the function has a prefix "Linera." which makes it clear
about what it is.

## Test Plan

The CI.

## Release Plan

Normal release mode. The objective is to have the EVM functional for the
next TestNet.

## Links

None

Author: MathieuDutSik

Cargo.lock

@@ -123,6 +123,7 @@ lru = "0.12.3"
 num-bigint = "0.4.3"
 num-format = "0.4.4"
 num-traits = "0.2.18"
+num_enum = "0.7.3"
 octocrab = "0.42.1"
 oneshot = "0.1.6"
 pathdiff = "0.2.1"

Cargo.toml

@@ -52,6 +52,7 @@ linera-views.workspace = true
 linera-views-derive.workspace = true
 linera-witty = { workspace = true, features = ["log", "macros"] }
 lru.workspace = true
+num_enum.workspace = true
 oneshot.workspace = true
 prometheus = { workspace = true, optional = true }
 proptest = { workspace = true, optional = true }

examples/Cargo.lock

@@ -0,0 +1,28 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+// Precompile keys:
+// 0: try_call_application
+// 1: try_query_application
+
+library Linera {
+  function try_call_application(bytes32 universal_address, bytes memory operation) internal returns (bytes memory) {
+    address precompile = address(0x0b);
+    bytes1 input1 = bytes1(uint8(0));
+    bytes memory input2 = abi.encodePacked(input1, universal_address, operation);
+    (bool success, bytes memory output) = precompile.call(input2);
+    require(success);
+    return output;
+  }
+
+  function try_query_application(bytes32 universal_address, bytes memory argument) internal returns (bytes memory) {
+    address precompile = address(0x0b);
+    bytes1 input1 = bytes1(uint8(1));
+    bytes memory input2 = abi.encodePacked(input1, universal_address, argument);
+    (bool success, bytes memory output) = precompile.call(input2);
+    require(success);
+    return output;
+  }
+
+}

linera-execution/Cargo.toml

@@ -4,7 +4,7 @@
 //! Code specific to the usage of the [Revm](https://bluealloy.github.io/revm/) runtime.
 
 use core::ops::Range;
-use std::sync::Arc;
+use std::{convert::TryFrom, sync::Arc};
 
 use alloy::primitives::Address;
 use linera_base::{
@@ -13,6 +13,7 @@ use linera_base::{
     identifiers::{ApplicationId, StreamName},
     vm::EvmQuery,
 };
+use num_enum::TryFromPrimitive;
 use revm::{
     db::WrapDatabaseRef, inspector_handle_register, primitives::Bytes, ContextPrecompile,
     ContextStatefulPrecompile, Evm, EvmContext, InnerEvmContext, Inspector,
@@ -238,6 +239,15 @@ fn address_to_user_application_id(address: Address) -> ApplicationId {
     u8_slice_to_application_id(&vec)
 }
 
+#[repr(u8)]
+#[derive(TryFromPrimitive)]
+enum PrecompileTag {
+    /// Key prefix for the try_call_application
+    TryCallApplication,
+    /// Key prefix for the try_query_application
+    TryQueryApplication,
+}
+
 struct GeneralContractCall;
 
 impl<Runtime: ContractRuntime>
@@ -251,26 +261,38 @@ impl<Runtime: ContractRuntime>
         context: &mut InnerEvmContext<WrapDatabaseRef<&mut DatabaseRuntime<Runtime>>>,
     ) -> PrecompileResult {
         let vec = input.to_vec();
-        let target = u8_slice_to_application_id(&vec[0..32]);
-        let argument: Vec<u8> = vec[32..].to_vec();
-        let result = {
-            let authenticated = true;
-            let mut runtime = context
-                .db
-                .0
-                .runtime
-                .lock()
-                .expect("The lock should be possible");
-            runtime.try_call_application(authenticated, target, argument)
-        }
-        .map_err(|error| PrecompileErrors::Fatal {
-            msg: format!("{}", error),
+        let tag = vec[0];
+        let tag = PrecompileTag::try_from(tag).map_err(|error| PrecompileErrors::Fatal {
+            msg: format!("{error} when trying to convert tag={tag}"),
         })?;
-        // We do not know how much gas was used.
-        let gas_used = 0;
-        let bytes = Bytes::copy_from_slice(&result);
-        let result = PrecompileOutput { gas_used, bytes };
-        Ok(result)
+        match tag {
+            PrecompileTag::TryCallApplication => {
+                let target = u8_slice_to_application_id(&vec[1..33]);
+                let argument = vec[33..].to_vec();
+                let result = {
+                    let authenticated = true;
+                    let mut runtime = context
+                        .db
+                        .0
+                        .runtime
+                        .lock()
+                        .expect("The lock should be possible");
+                    runtime.try_call_application(authenticated, target, argument)
+                }
+                .map_err(|error| PrecompileErrors::Fatal {
+                    msg: format!("{}", error),
+                })?;
+                // We do not know how much gas was used.
+                let gas_used = 0;
+                let bytes = Bytes::copy_from_slice(&result);
+                let result = PrecompileOutput { gas_used, bytes };
+                Ok(result)
+            }
+            PrecompileTag::TryQueryApplication => Err(PrecompileErrors::Fatal {
+                msg: "try_query_application is not available in the GeneralContractCall"
+                    .to_string(),
+            }),
+        }
     }
 }
 
@@ -287,25 +309,36 @@ impl<Runtime: ServiceRuntime>
         context: &mut InnerEvmContext<WrapDatabaseRef<&mut DatabaseRuntime<Runtime>>>,
     ) -> PrecompileResult {
         let vec = input.to_vec();
-        let target = u8_slice_to_application_id(&vec[0..32]);
-        let argument: Vec<u8> = vec[32..].to_vec();
-        let result = {
-            let mut runtime = context
-                .db
-                .0
-                .runtime
-                .lock()
-                .expect("The lock should be possible");
-            runtime.try_query_application(target, argument)
-        }
-        .map_err(|error| PrecompileErrors::Fatal {
-            msg: format!("{}", error),
+        let tag = vec[0];
+        let tag = PrecompileTag::try_from(tag).map_err(|error| PrecompileErrors::Fatal {
+            msg: format!("{error} when trying to convert tag={tag}"),
         })?;
-        // We do not know how much gas was used.
-        let gas_used = 0;
-        let bytes = Bytes::copy_from_slice(&result);
-        let result = PrecompileOutput { gas_used, bytes };
-        Ok(result)
+        match tag {
+            PrecompileTag::TryCallApplication => Err(PrecompileErrors::Fatal {
+                msg: "try_call_application is not available in the GeneralServiceCall".to_string(),
+            }),
+            PrecompileTag::TryQueryApplication => {
+                let target = u8_slice_to_application_id(&vec[1..33]);
+                let argument = vec[33..].to_vec();
+                let result = {
+                    let mut runtime = context
+                        .db
+                        .0
+                        .runtime
+                        .lock()
+                        .expect("The lock should be possible");
+                    runtime.try_query_application(target, argument)
+                }
+                .map_err(|error| PrecompileErrors::Fatal {
+                    msg: format!("{}", error),
+                })?;
+                // We do not know how much gas was used.
+                let gas_used = 0;
+                let bytes = Bytes::copy_from_slice(&result);
+                let result = PrecompileOutput { gas_used, bytes };
+                Ok(result)
+            }
+        }
     }
 }
 

linera-execution/solidity/linera.sol

@@ -76,6 +76,10 @@ pub use crate::{
     transaction_tracker::{TransactionOutcome, TransactionTracker},
 };
 
+/// The `linera.sol` library code to be included in solidity smart
+/// contracts using Linera features.
+pub const LINERA_SOL: &str = include_str!("../solidity/linera.sol");
+
 /// The maximum length of a stream name.
 const MAX_STREAM_NAME_LEN: usize = 64;
 

linera-execution/src/evm/revm.rs

@@ -14,6 +14,8 @@ use anyhow::Context;
 use serde_json::Value;
 use tempfile::{tempdir, TempDir};
 
+use crate::LINERA_SOL;
+
 fn write_compilation_json(path: &Path, file_name: &str) -> anyhow::Result<()> {
     let mut source = File::create(path).unwrap();
     writeln!(
@@ -78,6 +80,13 @@ fn get_bytecode_path(path: &Path, file_name: &str, contract_name: &str) -> anyho
 pub fn get_bytecode(source_code: &str, contract_name: &str) -> anyhow::Result<Vec<u8>> {
     let dir = tempdir().unwrap();
     let path = dir.path();
+    if source_code.contains("linera.sol") {
+        // The source code seems to import linera.sol, so let us write it in the code
+        let file_name = "linera.sol";
+        let test_code_path = path.join(file_name);
+        let mut test_code_file = File::create(&test_code_path)?;
+        writeln!(test_code_file, "{}", LINERA_SOL)?;
+    }
     let file_name = "test_code.sol";
     let test_code_path = path.join(file_name);
     let mut test_code_file = File::create(&test_code_path)?;

linera-execution/src/lib.rs

@@ -13,6 +13,8 @@ pragma solidity ^0.8.0;
 // solidity code. See,
 // TODO(#3761): Implement the Linera functionalities in a linera.sol library.
 
+import "./linera.sol";
+
 contract ExampleCallWasmCounter {
   bytes32 universal_address;
   constructor(bytes32 _universal_address) {
@@ -121,9 +123,7 @@ contract ExampleCallWasmCounter {
     address precompile = address(0x0b);
     CounterOperation memory input2 = CounterOperation({choice: 0, increment: input1});
     bytes memory input3 = bcs_serialize_CounterOperation(input2);
-    bytes memory input4 = abi.encodePacked(universal_address, input3);
-    (bool success, bytes memory return1) = precompile.call(input4);
-    require(success);
+    bytes memory return1 = Linera.try_call_application(universal_address, input3);
     uint64 return2 = bcs_deserialize_uint64(return1);
     return return2;
   }
@@ -132,9 +132,7 @@ contract ExampleCallWasmCounter {
     address precompile = address(0x0b);
     CounterRequest memory input2 = CounterRequest({choice:0, increment: 0});
     bytes memory input3 = serde_json_serialize_CounterRequest(input2);
-    bytes memory input4 = abi.encodePacked(universal_address, input3);
-    (bool success, bytes memory return1) = precompile.call(input4);
-    require(success);
+    bytes memory return1 = Linera.try_query_application(universal_address, input3);
     uint64 return2 = serde_json_deserialize_u64(return1);
     return return2;
   }