Merge branch 'main' into custom-l1-price

MexicanAce · web-flow · commit f1f000d262ad · 2024-06-26T15:44:35.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,6 +11,7 @@ categories = ["cryptography"]
 publish = false # We don't want to publish our binaries.
 
 [dependencies]
+zkevm_opcode_defs = { git = "https://github.com/matter-labs/era-zkevm_opcode_defs.git", branch = "v1.5.0" }
 zksync_basic_types = { git = "https://github.com/matter-labs/zksync-era.git", rev = "e10bbdd1e863962552f37e768ae6af649353e4ea" }
 zksync_node_fee_model = { git = "https://github.com/matter-labs/zksync-era.git", rev = "e10bbdd1e863962552f37e768ae6af649353e4ea" }
 multivm = { git = "https://github.com/matter-labs/zksync-era.git", rev = "e10bbdd1e863962552f37e768ae6af649353e4ea" }
diff --git a/README.md b/README.md
@@ -46,6 +46,26 @@ Please note that `era-test-node` is still in its **alpha** stage. Some features
 
 ## 📥 Installation & Setup
 
+### Using the installation script
+
+1. Download the installation script and mark as executable:
+   ```bash
+   curl --proto '=https' -sSf https://raw.githubusercontent.com/matter-labs/era-test-node/main/scripts/install.sh > install.sh
+   chmod +x install.sh
+   ```
+
+2. Run the script with `sudo` (version can optionally be specified via the `--version` argument):
+   ```bash
+   sudo ./install.sh
+   ```
+
+3. Start the node:
+   ```bash
+   era_test_node run
+   ```
+
+### Manually
+
 1. Download `era-test-node` from latest [Release](https://github.com/matter-labs/era-test-node/releases/latest)
 
 2. Extract the binary and mark as executable:
@@ -68,7 +88,7 @@ Please note that `era-test-node` is still in its **alpha** stage. Some features
 
 ## 📄 System Contracts
 
-The system contract within the node can be specified via the `--dev-system-contracts` option. 
+The system contract within the node can be specified via the `--dev-system-contracts` option.
 It can take one of the following options:
    * `built-in`: Use the compiled built-in contracts
    * `built-in-no-verify`: Use the compiled built-in contracts, but without signature verification
@@ -91,7 +111,7 @@ The logging can be configured during runtime via the [`config_setLogLevel`](./SU
 ## 📃 Caching
 
 The node will cache certain network request by default to disk in the `.cache` directory. Alternatively the caching can be disabled or set to in-memory only
-via the `--cache=none|memory|disk` parameter. 
+via the `--cache=none|memory|disk` parameter.
 
 ```bash
 era_test_node --cache=none run
@@ -159,7 +179,7 @@ Payer: 0x4eaf936c172b5e5511959167e8ab4f7031113ca3
 Gas - Limit: 2_487_330 | Used: 969_330 | Refunded: 1_518_000
 Use --show-gas-details flag or call config_setShowGasDetails to display more info
 
-==== Console logs: 
+==== Console logs:
 
 ==== 22 call traces.  Use --show-calls flag or call config_setShowCalls to display more info.
   Call(Normal) 0x4eaf936c172b5e5511959167e8ab4f7031113ca3           validateTransaction(bytes32, bytes32, tuple)   1830339
@@ -171,16 +191,16 @@ Use --show-gas-details flag or call config_setShowGasDetails to display more inf
 
 You can use the following options to get more granular information during transaction processing:
 
-- `--show-storage-logs <SHOW_STORAGE_LOGS>`: Show storage log information.  
-  [default: none]  
+- `--show-storage-logs <SHOW_STORAGE_LOGS>`: Show storage log information.
+  [default: none]
   [possible values: none, read, paid, write, all]
 
-- `--show-vm-details <SHOW_VM_DETAILS>`: Show VM details information.  
-  [default: none]  
+- `--show-vm-details <SHOW_VM_DETAILS>`: Show VM details information.
+  [default: none]
   [possible values: none, all]
 
-- `--show-gas-details <SHOW_GAS_DETAILS>`: Show Gas details information.  
-  [default: none]  
+- `--show-gas-details <SHOW_GAS_DETAILS>`: Show Gas details information.
+  [default: none]
   [possible values: none, all]
 
 Example:
diff --git a/e2e-tests/test/hardhat-apis.test.ts b/e2e-tests/test/hardhat-apis.test.ts
@@ -1,6 +1,6 @@
 import { expect } from "chai";
 import { Wallet } from "zksync-web3";
-import { deployContract, getTestProvider } from "../helpers/utils";
+import { deployContract, expectThrowsAsync, getTestProvider } from "../helpers/utils";
 import { RichAccounts } from "../helpers/constants";
 import { ethers } from "hardhat";
 import { Deployer } from "@matterlabs/hardhat-zksync-deploy";
@@ -118,6 +118,24 @@ describe("hardhat_setCode", function () {
     expect(BigNumber.from(result).toNumber()).to.eq(5);
   });
 
+  it("Should reject invalid code", async function () {
+    const action = async () => {
+      // Arrange
+      const wallet = new Wallet(RichAccounts[0].PrivateKey);
+      const deployer = new Deployer(hre, wallet);
+
+      const address = "0x1000000000000000000000000000000000001111";
+      const artifact = await deployer.loadArtifact("Return5");
+      const contractCode = [...ethers.utils.arrayify(artifact.deployedBytecode)];
+      const shortCode = contractCode.slice(0, contractCode.length - 1);
+
+      // Act
+      await provider.send("hardhat_setCode", [address, shortCode]);
+    };
+
+    await expectThrowsAsync(action, "bytes must be divisible by 32");
+  });
+
   it("Should update code with a different smart contract", async function () {
     // Arrange
     const wallet = new Wallet(RichAccounts[0].PrivateKey);
diff --git a/scripts/install.sh b/scripts/install.sh
@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+
+set -e
+
+ERA_TEST_NODE_REPO="https://github.com/matter-labs/era-test-node"
+
+function script_usage() {
+    cat << EOF
+Era Test Node Installer v0.1.0
+
+USAGE:
+    -h | --help              Display help information
+    -v | --version           Downloads a specific version of Era Test Node              (default: latest release)
+    -d | --destination       The path to the folder where the binary will be installed  (default: /usr/local/bin)
+EOF
+}
+
+function parse_args() {
+    version=$(get_latest_version)
+    destination="/usr/local/bin"
+
+    while [[ $# -gt 0 ]]; do
+        arg="$1"
+        shift
+        case $arg in
+            -h | --help)
+                script_usage
+                exit 0
+                ;;
+            -v | --version)
+                version="$1"
+                shift
+                ;;
+            -d | --destination)
+                destination="$1"
+                shift
+                ;;
+            *)
+                echo "Invalid argument was provided: $arg"
+                exit 1
+                ;;
+        esac
+    done
+}
+
+function main() {
+    parse_args "$@"
+
+    echo "Running install script for Era Test Node..."
+
+    get_os_info
+    download_binary
+    prepare_binary
+
+    echo "Era Test Node has been successfully installed!"
+}
+
+function prepare_binary() {
+    echo "Preparing binary..."
+
+    tar xz -f "$file_name"
+    rm "$file_name"
+    mv era_test_node "$destination/era_test_node"
+    chmod +x "$destination/era_test_node"
+
+    echo "Succesfully prepared binary!"
+}
+
+function download_binary() {
+    file_name="era_test_node-$version-$architecture-$os.tar.gz"
+    url="$ERA_TEST_NODE_REPO/releases/download/$version/$file_name"
+
+    echo "Downloading Era Test Node binary from: $url..."
+    wget $url
+
+    echo "Successfully downloaded Era Test Node Binary!"
+}
+
+function get_os_info() {
+    unamestr="$(uname)"
+    case "$unamestr" in
+        "Linux")
+            os="unknown-linux-gnu"
+            arch=$(lscpu | awk '/Architecture:/{print $2}')
+            ;;
+        "Darwin")
+            os="apple-darwin"
+            arch=$(arch)
+            ;;
+        *)
+            echo "ERROR: Era Test Node only supports Linux and MacOS! Detected OS: $unamestr"
+            exit 1
+            ;;
+    esac
+
+    case "$arch" in
+        "x86_64")
+            architecture="x86_64"
+            ;;
+        "arm64")
+            architecture="aarch64"
+            ;;
+        *)
+            echo "ERROR: Unsupported architecture detected!"
+            exit 1
+            ;;
+    esac
+
+    echo "Operating system: $os"
+    echo "Architecture: $architecture"
+}
+
+function get_latest_version() {
+    echo v$(curl --proto '=https' -sSf https://raw.githubusercontent.com/matter-labs/era-test-node/main/Cargo.toml | \
+        grep "version" -m 1 | \
+        awk '{print $3}' | \
+        sed 's/"//g')
+}
+
+main "$@"
diff --git a/src/node/hardhat.rs b/src/node/hardhat.rs
@@ -5,7 +5,7 @@ use crate::{
     fork::ForkSource,
     namespaces::{HardhatNamespaceT, RpcResult},
     node::InMemoryNode,
-    utils::{into_jsrpc_error, IntoBoxedFuture},
+    utils::{into_jsrpc_error, into_jsrpc_error_message, IntoBoxedFuture},
 };
 
 impl<S: ForkSource + std::fmt::Debug + Clone + Send + Sync + 'static> HardhatNamespaceT
@@ -60,7 +60,7 @@ impl<S: ForkSource + std::fmt::Debug + Clone + Send + Sync + 'static> HardhatNam
         self.set_code(address, code)
             .map_err(|err| {
                 tracing::error!("failed setting code: {:?}", err);
-                into_jsrpc_error(Web3Error::InternalError(err))
+                into_jsrpc_error_message(err.to_string())
             })
             .into_boxed_future()
     }
diff --git a/src/node/in_memory.rs b/src/node/in_memory.rs
@@ -1544,11 +1544,17 @@ impl<S: ForkSource + std::fmt::Debug + Clone> InMemoryNode<S> {
             ..Default::default()
         };
 
-        let bytecodes: HashMap<U256, Vec<U256>> = vm
-            .get_last_tx_compressed_bytecodes()
-            .iter()
-            .map(|b| bytecode_to_factory_dep(b.original.clone()))
-            .collect();
+        let mut bytecodes = HashMap::new();
+        for b in vm.get_last_tx_compressed_bytecodes().iter() {
+            let hashcode = match bytecode_to_factory_dep(b.original.clone()) {
+                Ok(hc) => hc,
+                Err(error) => {
+                    tracing::error!("{}", format!("cannot convert bytecode: {}", error).on_red());
+                    return Err(error.to_string());
+                }
+            };
+            bytecodes.insert(hashcode.0, hashcode.1);
+        }
         if execute_bootloader {
             vm.execute(VmExecutionMode::Bootloader);
         }
diff --git a/src/node/in_memory_ext.rs b/src/node/in_memory_ext.rs
@@ -96,10 +96,10 @@ impl<S: ForkSource + std::fmt::Debug + Clone + Send + Sync + 'static> InMemoryNo
         self.get_inner()
             .write()
             .map_err(|err| anyhow!("failed acquiring lock: {:?}", err))
-            .map(|mut writer| {
-                utils::mine_empty_blocks(&mut writer, 1, 1000);
+            .and_then(|mut writer| {
+                utils::mine_empty_blocks(&mut writer, 1, 1000)?;
                 tracing::info!("👷 Mined block #{}", writer.current_miniblock);
-                "0x0".to_string()
+                Ok("0x0".to_string())
             })
     }
 
@@ -260,7 +260,7 @@ impl<S: ForkSource + std::fmt::Debug + Clone + Send + Sync + 'static> InMemoryNo
                         "Number of blocks must be greater than 0".to_string(),
                     ));
                 }
-                utils::mine_empty_blocks(&mut writer, num_blocks.as_u64(), interval_ms.as_u64());
+                utils::mine_empty_blocks(&mut writer, num_blocks.as_u64(), interval_ms.as_u64())?;
                 tracing::info!("👷 Mined {} blocks", num_blocks);
 
                 Ok(true)
@@ -304,22 +304,23 @@ impl<S: ForkSource + std::fmt::Debug + Clone + Send + Sync + 'static> InMemoryNo
         self.get_inner()
             .write()
             .map_err(|err| anyhow!("failed acquiring lock: {:?}", err))
-            .map(|mut writer| {
+            .and_then(|mut writer| {
                 let code_key = get_code_key(&address);
                 tracing::info!("set code for address {address:#x}");
-                let (hash, code) = bytecode_to_factory_dep(code);
-                let hash = u256_to_h256(hash);
-                writer.fork_storage.store_factory_dep(
-                    hash,
-                    code.iter()
-                        .flat_map(|entry| {
-                            let mut bytes = vec![0u8; 32];
-                            entry.to_big_endian(&mut bytes);
-                            bytes.to_vec()
-                        })
-                        .collect(),
-                );
+                let hashcode = bytecode_to_factory_dep(code)?;
+                let hash = u256_to_h256(hashcode.0);
+                let code = hashcode
+                    .1
+                    .iter()
+                    .flat_map(|entry| {
+                        let mut bytes = vec![0u8; 32];
+                        entry.to_big_endian(&mut bytes);
+                        bytes.to_vec()
+                    })
+                    .collect();
+                writer.fork_storage.store_factory_dep(hash, code);
                 writer.fork_storage.set_value(code_key, hash);
+                Ok(())
             })
     }
 }
diff --git a/src/utils.rs b/src/utils.rs
