[proof chunk] refactor evm_circuit/state_circuit to support proof chunk

bus-mapping/src/circuit_input_builder.rs

@@ -14,7 +14,7 @@ use self::access::gen_state_access_trace;
 use crate::{
     error::Error,
     evm::opcodes::{gen_associated_ops, gen_associated_steps},
-    operation::{CallContextField, Operation, RWCounter, StartOp, RW},
+    operation::{CallContextField, Op, Operation, OperationContainer, RWCounter, RW},
     rpc::GethClient,
     state_db::{self, CodeDB, StateDB},
 };
@@ -293,11 +293,6 @@ impl CircuitInputBuilder<FixedCParams> {
             );
         }
 
-        let mut push_op = |step: &mut ExecStep, rwc: RWCounter, rw: RW, op: StartOp| {
-            let op_ref = state.block.container.insert(Operation::new(rwc, rw, op));
-            step.bus_mapping_instance.push(op_ref);
-        };
-
         // rwc index start from 1
         let total_rws = state.block_ctx.rwc.0 - 1;
         // We need at least 1 extra Start row
@@ -310,27 +305,51 @@ impl CircuitInputBuilder<FixedCParams> {
                 max_rws
             );
         }
-        let (padding_start, padding_end) = (1, max_rws - total_rws); // rw counter start from 1
-        push_op(
-            &mut end_block_last,
-            RWCounter(padding_start),
-            RW::READ,
-            StartOp {},
-        );
-        if padding_end != padding_start {
-            push_op(
-                &mut end_block_last,
-                RWCounter(padding_end),
-                RW::READ,
-                StartOp {},
-            );
-        }
+        // TODO only push StartOp in first chunk
+        // push_op(
+        //     &mut state.block.container,
+        //     &mut end_block_last,
+        //     RWCounter(1),
+        //     RW::READ,
+        //     StartOp {},
+        // );
+        // if max_rws - total_rws > 1 {
+        // let (padding_start, padding_end) = (max_rws - total_rws, max_rws); // rw counter
+        // start from 1 push_op(
+        //     &mut state.block.container,
+        //     &mut end_block_last,
+        //     RWCounter(padding_start),
+        //     RW::READ,
+        //     PaddingOp {},
+        // );
+        // if padding_end != padding_start {
+        //     push_op(
+        //         &mut state.block.container,
+        //         &mut end_block_last,
+        //         RWCounter(padding_end),
+        //         RW::READ,
+        //         PaddingOp {},
+        //     );
+        // }
+        // }
 
         self.block.block_steps.end_block_not_last = end_block_not_last;
         self.block.block_steps.end_block_last = end_block_last;
     }
 }
 
+#[allow(dead_code)]
+fn push_op<T: Op>(
+    container: &mut OperationContainer,
+    step: &mut ExecStep,
+    rwc: RWCounter,
+    rw: RW,
+    op: T,
+) {
+    let op_ref = container.insert(Operation::new(rwc, rw, op));
+    step.bus_mapping_instance.push(op_ref);
+}
+
 impl<C: CircuitsParams> CircuitInputBuilder<C> {
     /// First part of handle_block, common for dynamic and static circuit parameters.
     pub fn begin_handle_block(
@@ -393,11 +412,12 @@ impl CircuitInputBuilder<DynamicCParams> {
                 * 2
                 + 4; // disabled and unused rows.
 
-            let total_rws_before_padding: usize =
+            // TODO fix below logic for multiple rw_table chunks
+            let total_rws_before_end_block: usize =
                 <RWCounter as Into<usize>>::into(self.block_ctx.rwc) - 1; // -1 since rwc start from index `1`
-            let max_rws_after_padding = total_rws_before_padding
-                + 1 // fill 1 to have exactly one StartOp padding in below `set_end_block`
-                + if total_rws_before_padding > 0 { 1 /*end_block -> CallContextFieldTag::TxId lookup*/ } else { 0 };
+            let max_rws_after_padding = total_rws_before_end_block
+                + 1 // +1 for RW::Start padding in offset 0
+                + if total_rws_before_end_block > 0 { 1 /*end_block -> CallContextFieldTag::TxId lookup*/ } else { 0 };
             // Computing the number of rows for the EVM circuit requires the size of ExecStep,
             // which is determined in the code of zkevm-circuits and cannot be imported here.
             // When the evm circuit receives a 0 value it dynamically computes the minimum

bus-mapping/src/exec_trace.rs

@@ -14,6 +14,7 @@ impl fmt::Debug for OperationRef {
             "OperationRef{{ {}, {} }}",
             match self.0 {
                 Target::Start => "Start",
+                Target::Padding => "Padding",
                 Target::Memory => "Memory",
                 Target::Stack => "Stack",
                 Target::Storage => "Storage",

bus-mapping/src/operation.rs

@@ -93,7 +93,7 @@ impl RWCounter {
 /// Enum used to differenciate between EVM Stack, Memory and Storage operations.
 #[derive(Debug, Clone, PartialEq, Eq, Copy, EnumIter, Hash)]
 pub enum Target {
-    /// Start is a padding operation.
+    /// Start operation in the first row
     Start = 1,
     /// Means the target of the operation is the Memory.
     Memory,
@@ -115,6 +115,8 @@ pub enum Target {
     TxReceipt,
     /// Means the target of the operation is the TxLog.
     TxLog,
+    /// padding operation.
+    Padding,
 }
 
 impl_expr!(Target);
@@ -885,6 +887,32 @@ impl Op for StartOp {
     }
 }
 
+/// Represent a Padding padding operation
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct PaddingOp {}
+
+impl PartialOrd for PaddingOp {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for PaddingOp {
+    fn cmp(&self, _other: &Self) -> Ordering {
+        Ordering::Equal
+    }
+}
+
+impl Op for PaddingOp {
+    fn into_enum(self) -> OpEnum {
+        OpEnum::Padding(self)
+    }
+
+    fn reverse(&self) -> Self {
+        unreachable!("Padding can't be reverted")
+    }
+}
+
 /// Represents TxReceipt read/write operation.
 #[derive(Clone, PartialEq, Eq)]
 pub struct TxReceiptOp {
@@ -955,6 +983,8 @@ pub enum OpEnum {
     TxLog(TxLogOp),
     /// Start
     Start(StartOp),
+    /// Start
+    Padding(PaddingOp),
 }
 
 /// Operation is a Wrapper over a type that implements Op with a RWCounter.

bus-mapping/src/operation/container.rs

@@ -1,7 +1,7 @@
 use super::{
-    AccountOp, CallContextOp, MemoryOp, Op, OpEnum, Operation, RWCounter, StackOp, StartOp,
-    StorageOp, Target, TxAccessListAccountOp, TxAccessListAccountStorageOp, TxLogOp, TxReceiptOp,
-    TxRefundOp, RW,
+    AccountOp, CallContextOp, MemoryOp, Op, OpEnum, Operation, PaddingOp, RWCounter, StackOp,
+    StartOp, StorageOp, Target, TxAccessListAccountOp, TxAccessListAccountStorageOp, TxLogOp,
+    TxReceiptOp, TxRefundOp, RW,
 };
 use crate::exec_trace::OperationRef;
 use itertools::Itertools;
@@ -44,6 +44,8 @@ pub struct OperationContainer {
     pub tx_log: Vec<Operation<TxLogOp>>,
     /// Operations of Start
     pub start: Vec<Operation<StartOp>>,
+    /// Operations of Padding
+    pub padding: Vec<Operation<PaddingOp>>,
 }
 
 impl Default for OperationContainer {
@@ -68,6 +70,7 @@ impl OperationContainer {
             tx_receipt: Vec::new(),
             tx_log: Vec::new(),
             start: Vec::new(),
+            padding: Vec::new(),
         }
     }
 
@@ -164,6 +167,10 @@ impl OperationContainer {
                 self.start.push(Operation::new(rwc, rw, op));
                 OperationRef::from((Target::Start, self.start.len() - 1))
             }
+            OpEnum::Padding(op) => {
+                self.padding.push(Operation::new(rwc, rw, op));
+                OperationRef::from((Target::Padding, self.padding.len() - 1))
+            }
         }
     }
 

circuit-benchmarks/src/state_circuit.rs

@@ -39,7 +39,15 @@ mod tests {
             .parse()
             .expect("Cannot parse DEGREE env var as u32");
 
-        let empty_circuit = StateCircuit::<Fr>::new(RwMap::default(), 1 << 16);
+        let empty_circuit = StateCircuit::<Fr>::new(
+            RwMap::default(),
+            1 << 16,
+            Fr::from(1),
+            Fr::from(1),
+            Fr::from(1),
+            Fr::from(1),
+            0,
+        );
 
         // Initialize the polynomial commitment parameters
         let mut rng = XorShiftRng::from_seed([

gadgets/Cargo.toml

@@ -11,6 +11,7 @@ sha3 = "0.7.2"
 eth-types = { path = "../eth-types" }
 digest = "0.7.6"
 strum = "0.24"
+itertools = "0.10"
 
 [dev-dependencies]
 rand_xorshift = "0.3"

gadgets/src/lib.rs

@@ -16,6 +16,7 @@ pub mod binary_number;
 pub mod is_zero;
 pub mod less_than;
 pub mod mul_add;
+pub mod permutation;
 pub mod util;
 
 use eth_types::Field;