Merge branch 'main' into fix/begintx-missingconstraint

Author: curryrasul

.github/workflows/geth-utils.yml

@@ -30,7 +30,7 @@ jobs:
     - name: Set up Go
       uses: actions/setup-go@v4
       with:
-        go-version: '1.20'
+        go-version: '1.21'
 
     - name: Format
       uses: Jerome1337/[email protected]

.github/workflows/integration.yml

@@ -70,19 +70,9 @@ jobs:
         with:
           override: false
       - name: Setup golang
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v4
         with:
-          go-version: ~1.19
-      # Go cache for building geth-utils
-      - name: Go cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
+          go-version: ~1.21
       - name: Cargo cache
         uses: actions/cache@v3
         with:

.github/workflows/lints.yml

@@ -38,16 +38,10 @@ jobs:
         with:
           components: rustfmt, clippy
           override: false
-      # Go cache for building geth-utils
-      - name: Go cache
-        uses: actions/cache@v3
+      - name: Setup golang
+        uses: actions/setup-go@v4
         with:
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-          key: lint-${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
+          go-version: ~1.21
       - name: Cargo cache
         uses: actions/cache@v3
         with:

.github/workflows/main-tests.yml

@@ -46,19 +46,9 @@ jobs:
         with:
           override: false
       - name: Setup golang
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v4
         with:
-          go-version: ~1.19
-      # Go cache for building geth-utils
-      - name: Go cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
+          go-version: ~1.21
       - name: Cargo cache
         uses: actions/cache@v3
         with:
@@ -104,19 +94,9 @@ jobs:
         with:
           override: false
       - name: Setup golang
-        uses: actions/setup-go@v3
-        with:
-          go-version: ~1.19
-      # Go cache for building geth-utils
-      - name: Go cache
-        uses: actions/cache@v3
+        uses: actions/setup-go@v4
         with:
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
+          go-version: ~1.21
       - name: Cargo cache
         uses: actions/cache@v3
         with:
@@ -155,16 +135,10 @@ jobs:
           override: false
       - name: Add target
         run: rustup target add x86_64-unknown-linux-gnu
-      # Go cache for building geth-utils
-      - name: Go cache
-        uses: actions/cache@v3
+      - name: Setup golang
+        uses: actions/setup-go@v4
         with:
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
+          go-version: ~1.21
       - name: Cargo cache
         uses: actions/cache@v3
         with:

.github/workflows/test-features.yml

@@ -36,16 +36,10 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           override: false
-
-      # Go cache for building geth-utils
-      - name: Go cache
-        uses: actions/cache@v3
+      - name: Setup golang
+        uses: actions/setup-go@v4
         with:
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-          key: ${{ github.workflow }}-${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-
+          go-version: ~1.21
       - name: Cargo cache
         uses: actions/cache@v3
         with:

Makefile

@@ -77,7 +77,7 @@ stats_evm_circuit: # Print a table with EVM Circuit stats by ExecState/opcode
 stats_copy_circuit: # Print a table with Copy Circuit stats by ExecState/opcode
 	@cargo run --bin stats --features stats -- copy
 
-evm_exec_steps_occupancy: # Print a table for each EVM-CellManager CellType with the top 10 occupancy ExecutionSteps associated
+evm_exec_steps_occupancy: # Print a table for each EVM-CellManager CellType with the top 10 occupancy ExecSteps associated
 	@cargo run --bin stats --features stats -- exec
 
 .PHONY: clippy doc fmt test test_benches test-all evm_bench state_bench circuit_benches evm_exec_steps_occupancy stats_state_circuit stats_evm_circuit stats_copy_circuit help

bin/mpt-test/src/circuit/state_update.rs

@@ -57,13 +57,13 @@ pub struct StateUpdateCircuitConfig<F: Field> {
     /// The MPT table, where the state updates are stored
     pub pi_mpt: MptTable,
 
-    /// Intance column, used to check public inputs
+    /// Instance column, used to check public inputs
     pub instance: Column<Instance>,
 
     /// ONE if the first row, ZERO otherwise
     pub is_first: Column<Fixed>,
 
-    /// ONE if row is paddding, ZERO otherwise
+    /// ONE if row is padding, ZERO otherwise
     pub is_padding: IsZeroConfig<F>,
 
     /// ONE is the last used row, ZERO otherwise
@@ -465,7 +465,7 @@ impl<F: Field> Circuit<F> for StateUpdateCircuit<F> {
                                 ).unwrap()
                             );
 
-                    // at beggining, set the old root and number of proofs
+                    // at beginning, set the old root and number of proofs
 
                     if offset == 0 {
                         pi.push(Some(old_root_lo));

bus-mapping/README.md

@@ -1,54 +1,36 @@
 # ZKEVM Bus-Mapping
 
-![GitHub Workflow Status (branch)](https://img.shields.io/github/workflow/status/appliedzkp/zkevm-circuits/CI%20checks/main?style=for-the-badge)
+The `Bus-Mapping` crate is designed to parse EVM execution traces and manipulate the data they provide to obtain structured witness inputs for the EVM Proof and the State Proof.
 
-`Bus-Mapping` is a crate designed to parse EVM execution traces and manipulate
-all of the data they provide in order to obtain structured witness inputs
-for the EVM Proof and the State Proof.
+## Introduction
 
-### Introduction
-At the moment every node on ethereum has to validate every transaction in
-the ethereum virtual machine. This means that every transaction adds work
-that everyone needs to do to verify Ethereum’s history. Worse still is that
-each transaction needs to be verified by every new node. Which means the
-amount of work a new node needs to do the sync the network is growing
-constantly. We want to build a proof of validity for the Ethereum blocks to
-avoid this.
+Currently, every node on Ethereum must validate every transaction in the Ethereum Virtual Machine (EVM). This means that each transaction adds work that everyone must do to verify Ethereum’s history. Furthermore, each transaction needs to be verified by every new node, leading to a growing amount of work for new nodes to sync the network. To address this, we aim to build a proof of validity for Ethereum blocks.
 
-This means making a proof of validity for the EVM + state reads / writes +
-signatures.
-To simplify we separate our proofs into two components.
+This involves creating a proof of validity for the EVM, including state reads/writes and signatures. To simplify, we divide our proofs into two components:
 
-- State proof: State/memory/stack ops have been performed correctly. This
-does not check if the correct location has been read/written. We allow our
-prover to pick any location here and in the EVM proof confirm it is correct.
+- State Proof: Validates that state/memory/stack operations have been performed correctly. However, it does not verify if the correct location has been read/written. Our prover can select any location here and in the EVM proof confirm its correctness.
+- EVM Proof: Validates that the correct opcode is called at the correct time, checking the validity of these opcodes. It also confirms that for each of these opcodes, the state proof performed the correct operation.
 
-- EVM proof: This checks that the correct opcode is called at the correct
-time. It checks the validity of these opcodes. It also confirms that for
-each of these opcodes the state proof performed the correct operation.
+Only after verifying both proofs can we be confident that the Ethereum block is executed correctly.
 
-Only after verifying both proofs are we confident that that Ethereum block
-is executed correctly.
+## Bus Mapping
 
-### Bus Mapping
 The goal of this crate is to serve as:
-- A parsing lib for EVM execution traces.
-- A way to infer some witness data that can only be constructed once we've
-  analyzed the full exec trace.
-- An easy interface to collect all of the data to witness into the circuits
-  and witness it with few function calls.
-
-### Parsing
-Provided a JSON file or a JSON as a stream of bytes, which contains an
-execution trace from an EVM, you can parse it and construct an
-`ExecutionTrace` instance from it. That will automatically fill all of the
-bus-mapping instances of each
-[`ExecutionStep`](crate::exec_trace::ExecutionStep) plus fill in an
-[`OperationContainer`](crate::operation::container::OperationContainer) with
-all of the Memory, Stack and Storage ops performed by the provided trace.
+
+- A parsing library for EVM execution traces.
+- A way to infer some witness data that can only be constructed once we've analyzed the full exec trace.
+- An easy interface to collect all of the data to witness into the circuits and witness it with few function calls.
+
+## Parsing
+
+Given a JSON file or a JSON stream containing an execution trace from an EVM, you can parse it and construct a [`GethExecTrace`](eth_types::GethExecTrace) instance from it. This will automatically populate all of the bus-mapping instances of each [`ExecStep`](crate::circuit_input_builder::ExecStep) and fill an [`OperationContainer`](crate::operation::OperationContainer) with all of the memory, stack, and storage operations performed by the provided trace.
 
 ```rust
-use bus_mapping::{ExecutionTrace, ExecutionStep, BlockConstants, Error, evm::EvmWord};
+use bus_mapping::mock::BlockData;
+use eth_types::{
+    GethExecTrace, GethExecStep, geth_types::GethData, bytecode
+};
+use mock::test_ctx::{TestContext, helpers::*};
 
 let input_trace = r#"
 [
@@ -98,31 +80,48 @@ let input_trace = r#"
 ]
 "#;
 
-let block_ctants = BlockConstants::new(
-    Word::from(0),
-    pasta_curves::Fp::zero(),
-    pasta_curves::Fp::zero(),
-    pasta_curves::Fp::zero(),
-    pasta_curves::Fp::zero(),
-    pasta_curves::Fp::zero(),
-    pasta_curves::Fp::zero(),
-    pasta_curves::Fp::zero(),
-);
-
-// Here we have the ExecutionTrace completely formed with all of the data to witness structured.
-let obtained_exec_trace = ExecutionTrace::from_trace_bytes(
-    input_trace.as_bytes(),
-    block_ctants,
-).expect("Error on trace generation");
+// We use the [`TestContext`] struct to mock a block.
+let code = bytecode! {
+    // Write 0x6f to storage slot 0
+    PUSH1(0x6fu64)
+    PUSH1(0x00u64)
+    SSTORE
+    // Load storage slot 0
+    PUSH1(0x00u64)
+    SLOAD
+    STOP
+};
+// Get the execution steps from the external tracer
+let block: GethData = TestContext::<2, 1>::new(
+    None,
+    account_0_code_account_1_no_code(code),
+    tx_from_1_to_0,
+    |block, _tx| block.number(0xcafeu64),
+)
+.unwrap()
+.into();
+// Here we update the circuit input with the data from the transaction trace.
+let builder = BlockData::new_from_geth_data(block.clone()).new_circuit_input_builder();
+let builder = builder
+    .handle_block(&block.eth_block, &block.geth_traces)
+    .unwrap();
+let geth_steps: Vec<GethExecStep> = serde_json::from_str(input_trace).unwrap();
+let _geth_trace = GethExecTrace {
+    return_value: "".to_string(),
+    gas: block.eth_block.transactions[0].gas.as_u64(),
+    invalid: false,
+    failed: false,
+    struct_logs: geth_steps,
+};
 
 // Get an ordered vector with all of the Stack operations of this trace.
-let stack_ops = obtained_exec_trace.sorted_stack_ops();
-
+let _stack_ops = builder.block.container.sorted_stack();
 // You can also iterate over the steps of the trace and witness the EVM Proof.
-obtained_exec_trace.steps().iter();
+let _ = builder.block.txs()[0].steps().iter();
 ```
 
-Assume we have the following trace:
+Assuming we have the following trace:
+
 ```text,ignore
 pc  op              stack (top -> down)                  memory
 --  --------------  ----------------------------------   ---------------------------------------
@@ -148,37 +147,28 @@ pc  op              stack (top -> down)                  memory
 ...
 ```
 
-Once you have the trace built (following the code found above) you can
-basically:
-- Get an iterator/vector over the `Stack`, `Memory` or `Storage` operations
-  ordered on the way the State Proof needs.
+Once you have built the trace (following the code above), you can:
+
+- Get an iterator/vector over the `Stack`, `Memory`, or `Storage` operations ordered in the way the State Proof needs.
+
+For the Memory operations, it might look like this:
 
-On that way, we would get something like this for the Memory ops:
 ```text,ignore
-| `key`  | `val`         | `rw`    | `gc` | Note                                     |
-|:------:| ------------- | ------- | ---- | ---------------------------------------- |
-| `0x40` | `0`           | `Write` |      | Init                                     |
-| `0x40` | `0x80`        | `Write` | 0    | Assume written at the begining of `code` |
-| `0x40` | `0x80`        | `Read`  | 4    | `56 MLOAD`                               |
-|   -    |               |         |      |                                          |
-| `0x80` | `0`           | `Write` |      | Init                                     |
-| `0x80` | `0xdeadbeef`  | `Write` | 10   | `63 MSTORE`                              |
-| `0x80` | `0xdeadbeef`  | `Read`  | 16   | `70 MLOAD`                               |
-| `0x80` | `0x1d97c6efb` | `Write` | 24   | `73 MSTORE`                              |
-|   -    |               |         |      |                                          |
-| `0xa0` | `0`           | `Write` |      | Init                                     |
-| `0xa0` | `0xcafeb0ba`  | `Write` | 34   | `83 MSTORE`
+| `key`  | `val`         | `rw`    | `gc` | Note                                      |
+| :----: | ------------- | ------- | ---- | ----------------------------------------- |
+| `0x40` | `0`           | `Write` |      | Init                                      |
+| `0x40` | `0x80`        | `Write` | 0    | Assume written at the beginning of `code` |
+| `0x40` | `0x80`        | `Read`  | 4    | `56 MLOAD`                                |
+|   -    |               |         |      |                                           |
+| `0x80` | `0`           | `Write` |      | Init                                      |
+| `0x80` | `0xdeadbeef`  | `Write` | 10   | `63 MSTORE`                               |
+| `0x80` | `0xdeadbeef`  | `Read`  | 16   | `70 MLOAD`                                |
+| `0x80` | `0x1d97c6efb` | `Write` | 24   | `73 MSTORE`                               |
+|   -    |               |         |      |                                           |
+| `0xa0` | `0`           | `Write` |      | Init                                      |
+| `0xa0` | `0xcafeb0ba`  | `Write` | 34   | `83 MSTORE`                               |
 ```
 
-Where as you see, we group by `memory_address` and then order by
-`global_counter`.
-
-- Iterate over the `ExecutionTrace` itself over
-each `ExecutionStep`'s is formed by and check which Stack/Memory&Storage operations are linked to each step.
-This is also automatically done via the
-[`Opcode`](crate::evm::opcodes::Opcode) trait defined in this crate.
+Here, we group by `memory_address` and then order by `global_counter`.
 
-### Documentation
-For extra documentation, check the book with the specs written for the
-entire ZK-EVM solution.
-See: <https://hackmd.io/@liangcc/zkvmbook/https%3A%2F%2Fhackmd.io%2FAmhZ2ryITxicmhYFyQ0DEw#Bus-Mapping>
+- Iterate over the [`GethExecTrace`](eth_types::GethExecTrace) itself, over each [`ExecStep`](crate::circuit_input_builder::ExecStep) formed by, and check which Stack/Memory&Storage operations are linked to each step. This is also automatically done via the [`Opcode`](crate::evm::opcodes::Opcode) trait defined in this crate.

bus-mapping/src/circuit_input_builder.rs

@@ -84,7 +84,7 @@ impl FeatureConfig {
 #[derive(Debug, Clone, Copy)]
 pub struct FixedCParams {
     /// Maximum number of rw operations in the state circuit (RwTable length /
-    /// nummber of rows). This must be at least the number of rw operations
+    /// number of rows). This must be at least the number of rw operations
     /// + 1, in order to allocate at least a Start row.
     pub max_rws: usize,
     // TODO: evm_rows: Maximum number of rows in the EVM Circuit
@@ -190,7 +190,7 @@ pub struct CircuitInputBuilder<C: CircuitsParams> {
     pub code_db: CodeDB,
     /// Block
     pub block: Block,
-    /// Circuits Setup Paramteres
+    /// Circuits Setup Parameters
     pub circuits_params: C,
     /// Block Context
     pub block_ctx: BlockContext,
@@ -544,7 +544,7 @@ pub fn keccak_inputs(block: &Block, code_db: &CodeDB) -> Result<Vec<Vec<u8>>, Er
 }
 
 /// Generate the keccak inputs required by the SignVerify Chip from the
-/// signature datas.
+/// signature data.
 pub fn keccak_inputs_sign_verify(sigs: &[SignData]) -> Vec<Vec<u8>> {
     let mut inputs = Vec::new();
     for sig in sigs {