Use a more robust way to run fn instantiate for EVM contracts. (#3939)

## Motivation

The `fn instantiate` function of EVM contract is called if the
`instantiate_argument` is non-empty. But it is conceivable to have an
empty instantiation argument.

## Proposal

We can identify if a selector is present in the bytecode by looking for
`[PUSH4; selector]` pattern.

## Test Plan

The CI.

## Release Plan

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

## Links

None.

Author: MathieuDutSik

linera-execution/src/evm/revm.rs

@@ -91,6 +91,13 @@ mod tests {
     }
 }
 
+fn has_instantiation_function(module: &[u8]) -> bool {
+    let push4 = 0x63; // An EVM instruction
+    let mut vec = vec![push4];
+    vec.extend(INSTANTIATE_SELECTOR);
+    module.windows(5).any(|window| window == vec)
+}
+
 #[cfg(with_metrics)]
 mod metrics {
     use std::sync::LazyLock;
@@ -833,8 +840,8 @@ where
 {
     fn instantiate(&mut self, argument: Vec<u8>) -> Result<(), ExecutionError> {
         self.initialize_contract()?;
-        let instantiation_argument = serde_json::from_slice::<Vec<u8>>(&argument)?;
-        if !instantiation_argument.is_empty() {
+        if has_instantiation_function(&self.module) {
+            let instantiation_argument = serde_json::from_slice::<Vec<u8>>(&argument)?;
             let argument = get_revm_instantiation_bytes(instantiation_argument);
             let result = self.transact_commit(Choice::Call, &argument)?;
             self.write_logs(result.logs, "instantiate")?;

linera-service/tests/fixtures/evm_example_empty_instantiate.sol

@@ -0,0 +1,20 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+contract ExampleExecuteMessage {
+    uint64 value;
+
+    constructor() {
+        value = 37;
+    }
+
+    function instantiate(bytes memory input) external {
+        require(input.length == 0);
+        value = 42;
+    }
+
+    function get_value() external view returns (uint64) {
+        return value;
+    }
+}

linera-service/tests/linera_net_tests.rs

@@ -950,6 +950,88 @@ async fn test_evm_execute_message_end_to_end_counter(config: impl LineraNetConfi
     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_evm_empty_instantiate(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, client1) = config.instantiate().await?;
+
+    let client2 = net.make_client().await;
+    client2.wallet_init(None).await?;
+
+    let chain1 = client1.load_wallet()?.default_chain().unwrap();
+    let chain2 = client1.open_and_assign(&client2, Amount::ONE).await?;
+
+    // Creating the API of the contracts
+
+    sol! {
+        function get_value();
+    }
+    let query = get_valueCall {};
+    let query = query.abi_encode();
+    let query = EvmQuery::Query(query);
+
+    let constructor_argument = Vec::new();
+    let instantiation_argument = Vec::new();
+
+    let (evm_contract, _dir) =
+        get_evm_contract_path("tests/fixtures/evm_example_empty_instantiate.sol")?;
+
+    let application_id = client1
+        .publish_and_create::<EvmAbi, Vec<u8>, Vec<u8>>(
+            evm_contract.clone(),
+            evm_contract,
+            VmRuntime::Evm,
+            &constructor_argument,
+            &instantiation_argument,
+            &[],
+            None,
+        )
+        .await?;
+
+    let port1 = get_node_port().await;
+    let port2 = get_node_port().await;
+    let mut node_service1 = client1.run_node_service(port1, ProcessInbox::Skip).await?;
+    let mut node_service2 = client2.run_node_service(port2, ProcessInbox::Skip).await?;
+
+    // Creating the applications.
+
+    let application1 = node_service1
+        .make_application(&chain1, &application_id)
+        .await?;
+
+    let application2 = node_service2
+        .make_application(&chain2, &application_id)
+        .await?;
+
+    // Checking the initial value of the contracts.
+    let result = application1.run_json_query(query.clone()).await?;
+    let counter_value = read_evm_u64_entry(result);
+    assert_eq!(counter_value, 42);
+    let result = application2.run_json_query(query).await?;
+    let counter_value = read_evm_u64_entry(result);
+    assert_eq!(counter_value, 37);
+
+    node_service1.ensure_is_running()?;
+    node_service2.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"))]