[proof-chunk] Instantiate circuits with Chunk from bus-mapping

bus-mapping/src/circuit_input_builder/block.rs

@@ -1,9 +1,6 @@
 //! Block-related utility module
 
-use super::{
-    chunk::ChunkContext, execution::ExecState, transaction::Transaction, CopyEvent, ExecStep,
-    ExpEvent,
-};
+use super::{execution::ExecState, transaction::Transaction, CopyEvent, ExecStep, ExpEvent};
 use crate::{
     operation::{OperationContainer, RWCounter},
     Error,
@@ -16,7 +13,7 @@ use std::collections::HashMap;
 pub struct BlockContext {
     /// Used to track the global counter in every operation in the block.
     /// Contains the next available value.
-    pub(crate) rwc: RWCounter,
+    pub rwc: RWCounter,
     /// Map call_id to (tx_index, call_index) (where tx_index is the index used
     /// in Block.txs and call_index is the index used in Transaction.
     /// calls).
@@ -42,24 +39,9 @@ impl BlockContext {
     }
 }
 
-/// Block-wise execution steps that don't belong to any Transaction.
-#[derive(Debug)]
-pub struct BlockSteps {
-    /// EndBlock step that is repeated after the last transaction and before
-    /// reaching the last EVM row.
-    pub end_block_not_last: ExecStep,
-    /// Last EndBlock step that appears in the last EVM row.
-    pub end_block_last: ExecStep,
-    /// TODO Define and move chunk related step to Chunk struct
-    /// Begin op of a chunk
-    pub begin_chunk: ExecStep,
-    /// End op of a chunk
-    pub end_chunk: Option<ExecStep>,
-}
-
 // TODO: Remove fields that are duplicated in`eth_block`
 /// Circuit Input related to a block.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Block {
     /// chain id
     pub chain_id: Word,
@@ -84,10 +66,11 @@ pub struct Block {
     pub container: OperationContainer,
     /// Transactions contained in the block
     pub txs: Vec<Transaction>,
-    /// Block-wise steps
-    pub block_steps: BlockSteps,
-    /// Chunk context
-    pub chunk_context: ChunkContext,
+    /// End block step
+    pub end_block: ExecStep,
+
+    // /// Chunk context
+    // pub chunk_context: ChunkContext,
     /// Copy events in this block.
     pub copy_events: Vec<CopyEvent>,
     /// Inputs to the SHA3 opcode
@@ -131,25 +114,10 @@ impl Block {
             prev_state_root,
             container: OperationContainer::new(),
             txs: Vec::new(),
-            block_steps: BlockSteps {
-                begin_chunk: ExecStep {
-                    exec_state: ExecState::BeginChunk,
-                    ..ExecStep::default()
-                },
-                end_block_not_last: ExecStep {
-                    exec_state: ExecState::EndBlock,
-                    ..ExecStep::default()
-                },
-                end_block_last: ExecStep {
-                    exec_state: ExecState::EndBlock,
-                    ..ExecStep::default()
-                },
-                end_chunk: Some(ExecStep {
-                    exec_state: ExecState::EndChunk,
-                    ..ExecStep::default()
-                }),
+            end_block: ExecStep {
+                exec_state: ExecState::EndBlock,
+                ..ExecStep::default()
             },
-            chunk_context: ChunkContext::new(0, 1),
             copy_events: Vec::new(),
             exp_events: Vec::new(),
             sha3_inputs: Vec::new(),

bus-mapping/src/circuit_input_builder/call.rs

@@ -123,7 +123,7 @@ impl Call {
 }
 
 /// Context of a [`Call`].
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub struct CallContext {
     /// Index of call
     pub index: usize,
@@ -151,7 +151,7 @@ impl CallContext {
 /// [`Operation::reversible`](crate::operation::Operation::reversible) that
 /// happened in them, that will be reverted at once when the call that initiated
 /// this reversion group eventually ends with failure (and thus reverts).
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub struct ReversionGroup {
     /// List of `index` and `reversible_write_counter_offset` of calls belong to
     /// this group. `reversible_write_counter_offset` is the number of

bus-mapping/src/circuit_input_builder/chunk.rs

@@ -1,57 +1,88 @@
+use super::{ExecStep, FixedCParams};
 use crate::operation::RWCounter;
 
-/// Context of a [`ChunkContext`].
+#[derive(Debug, Default, Clone)]
+pub struct Chunk {
+    /// current context
+    pub ctx: ChunkContext,
+    /// fixed param for the chunk
+    pub fixed_param: FixedCParams,
+    /// Begin op of a chunk
+    pub begin_chunk: Option<ExecStep>,
+    /// End op of a chunk
+    pub end_chunk: Option<ExecStep>,
+    /// Padding step that is repeated after the last transaction and before
+    /// reaching the last EVM row.
+    pub padding: Option<ExecStep>,
+}
+
+/// Context of chunking, used to track the current chunk index and inner rw counter
+/// also the global rw counter from start to end.
 #[derive(Debug, Clone)]
 pub struct ChunkContext {
+    /// Index of current chunk, start from 0
+    pub idx: usize,
     /// Used to track the inner chunk counter in every operation in the chunk.
     /// Contains the next available value.
     pub rwc: RWCounter,
-    /// index of current chunk, start from 0
-    pub chunk_index: usize,
-    /// number of chunks
+    /// Number of chunks
     pub total_chunks: usize,
-    /// initial rw counter
+    /// Initial global rw counter
     pub initial_rwc: usize,
-    /// end rw counter
+    /// End global rw counter
     pub end_rwc: usize,
+    /// If this block is chunked dynamically
+    pub is_dynamic: bool,
 }
 
 impl Default for ChunkContext {
     fn default() -> Self {
-        Self::new(0, 1)
+        Self::new(1, false)
     }
 }
 
 impl ChunkContext {
     /// Create a new Self
-    pub fn new(chunk_index: usize, total_chunks: usize) -> Self {
+    pub fn new(total_chunks: usize, is_dynamic: bool) -> Self {
         Self {
             rwc: RWCounter::new(),
-            chunk_index,
+            idx: 0,
             total_chunks,
             initial_rwc: 1, // rw counter start from 1
             end_rwc: 0,     // end_rwc should be set in later phase
+            is_dynamic,
         }
     }
 
-    /// new Self with one chunk
+    /// New chunking context with one chunk
     pub fn new_one_chunk() -> Self {
         Self {
             rwc: RWCounter::new(),
-            chunk_index: 0,
+            idx: 0,
             total_chunks: 1,
             initial_rwc: 1, // rw counter start from 1
             end_rwc: 0,     // end_rwc should be set in later phase
+            is_dynamic: false,
         }
     }
 
-    /// is first chunk
+    /// Proceed the context to next chunk, record the initial rw counter
+    /// update the chunk idx and reset the inner rw counter
+    pub fn bump(&mut self, initial_rwc: usize) {
+        assert!(self.idx + 1 < self.total_chunks, "Exceed total chunks");
+        self.idx += 1;
+        self.rwc = RWCounter::new();
+        self.initial_rwc = initial_rwc;
+        self.end_rwc = 0;
+    }
+
+    /// Is first chunk
     pub fn is_first_chunk(&self) -> bool {
-        self.chunk_index == 0
+        self.idx == 0
     }
 
-    /// is last chunk
+    /// Is last chunk
     pub fn is_last_chunk(&self) -> bool {
-        self.total_chunks - self.chunk_index - 1 == 0
+        self.total_chunks - self.idx - 1 == 0
     }
 }

bus-mapping/src/circuit_input_builder/execution.rs

@@ -134,6 +134,8 @@ pub enum ExecState {
     BeginTx,
     /// Virtual step End Tx
     EndTx,
+    /// Virtual step Padding
+    Padding,
     /// Virtual step End Block
     EndBlock,
     /// Virtual step End Chunk

bus-mapping/src/circuit_input_builder/input_state_ref.rs

@@ -10,8 +10,8 @@ use crate::{
     exec_trace::OperationRef,
     operation::{
         AccountField, AccountOp, CallContextField, CallContextOp, MemoryOp, Op, OpEnum, Operation,
-        RWCounter, StackOp, Target, TxAccessListAccountOp, TxLogField, TxLogOp, TxReceiptField,
-        TxReceiptOp, RW,
+        StackOp, Target, TxAccessListAccountOp, TxLogField, TxLogOp, TxReceiptField, TxReceiptOp,
+        RW,
     },
     state_db::{CodeDB, StateDB},
     Error,
@@ -37,7 +37,7 @@ pub struct CircuitInputStateRef<'a> {
     /// Block Context
     pub block_ctx: &'a mut BlockContext,
     /// Chunk Context
-    pub chunk_ctx: Option<&'a mut ChunkContext>,
+    pub chunk_ctx: &'a mut ChunkContext,
     /// Transaction
     pub tx: &'a mut Transaction,
     /// Transaction Context
@@ -52,9 +52,7 @@ impl<'a> CircuitInputStateRef<'a> {
             geth_step,
             call_ctx,
             self.block_ctx.rwc,
-            self.chunk_ctx
-                .as_ref()
-                .map_or_else(RWCounter::new, |chunk_ctx| chunk_ctx.rwc),
+            self.chunk_ctx.rwc,
             call_ctx.reversible_write_counter,
             self.tx_ctx.log_id,
         ))
@@ -66,10 +64,7 @@ impl<'a> CircuitInputStateRef<'a> {
             exec_state: ExecState::BeginTx,
             gas_left: self.tx.gas(),
             rwc: self.block_ctx.rwc,
-            rwc_inner_chunk: self
-                .chunk_ctx
-                .as_ref()
-                .map_or_else(RWCounter::new, |chunk_ctx| chunk_ctx.rwc),
+            rwc_inner_chunk: self.chunk_ctx.rwc,
             ..Default::default()
         }
     }
@@ -105,10 +100,7 @@ impl<'a> CircuitInputStateRef<'a> {
                 0
             },
             rwc: self.block_ctx.rwc,
-            rwc_inner_chunk: self
-                .chunk_ctx
-                .as_ref()
-                .map_or_else(RWCounter::new, |chunk_ctx| chunk_ctx.rwc),
+            rwc_inner_chunk: self.chunk_ctx.rwc,
             // For tx without code execution
             reversible_write_counter: if let Some(call_ctx) = self.tx_ctx.calls().last() {
                 call_ctx.reversible_write_counter
@@ -132,9 +124,7 @@ impl<'a> CircuitInputStateRef<'a> {
         }
         let op_ref = self.block.container.insert(Operation::new(
             self.block_ctx.rwc.inc_pre(),
-            self.chunk_ctx
-                .as_mut()
-                .map_or_else(RWCounter::new, |chunk_ctx| chunk_ctx.rwc.inc_pre()),
+            self.chunk_ctx.rwc.inc_pre(),
             rw,
             op,
         ));
@@ -200,9 +190,7 @@ impl<'a> CircuitInputStateRef<'a> {
         self.check_apply_op(&op.clone().into_enum());
         let op_ref = self.block.container.insert(Operation::new_reversible(
             self.block_ctx.rwc.inc_pre(),
-            self.chunk_ctx
-                .as_mut()
-                .map_or_else(RWCounter::new, |chunk_ctx| chunk_ctx.rwc.inc_pre()),
+            self.chunk_ctx.rwc.inc_pre(),
             RW::WRITE,
             op,
         ));
@@ -1005,9 +993,7 @@ impl<'a> CircuitInputStateRef<'a> {
                 self.check_apply_op(&op);
                 let rev_op_ref = self.block.container.insert_op_enum(
                     self.block_ctx.rwc.inc_pre(),
-                    self.chunk_ctx
-                        .as_mut()
-                        .map_or_else(RWCounter::new, |chunk_ctx| chunk_ctx.rwc.inc_pre()),
+                    self.chunk_ctx.rwc.inc_pre(),
                     RW::WRITE,
                     false,
                     op,

bus-mapping/src/circuit_input_builder/transaction.rs

@@ -12,7 +12,7 @@ use crate::{
 
 use super::{call::ReversionGroup, Call, CallContext, CallKind, CodeSource, ExecStep};
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 /// Context of a [`Transaction`] which can mutate in an [`ExecStep`].
 pub struct TransactionContext {
     /// Unique identifier of transaction of the block. The value is `index + 1`.

bus-mapping/src/mock.rs

@@ -87,8 +87,15 @@ impl BlockData<FixedCParams> {
 }
 
 impl BlockData<DynamicCParams> {
-    /// Create a new block from the given Geth data with default CircuitsParams.
+    /// Create a new block with one chunk
+    /// from the given Geth data with default CircuitsParams.
     pub fn new_from_geth_data(geth_data: GethData) -> Self {
+        Self::new_from_geth_data_chunked(geth_data, 1)
+    }
+
+    /// Create a new block with given number of chunks
+    /// from the given Geth data with default CircuitsParams.
+    pub fn new_from_geth_data_chunked(geth_data: GethData, total_chunks: usize) -> Self {
         let (sdb, code_db) = Self::init_dbs(&geth_data);
 
         Self {
@@ -98,7 +105,7 @@ impl BlockData<DynamicCParams> {
             history_hashes: geth_data.history_hashes,
             eth_block: geth_data.eth_block,
             geth_traces: geth_data.geth_traces,
-            circuits_params: DynamicCParams {},
+            circuits_params: DynamicCParams { total_chunks },
         }
     }
 }

circuit-benchmarks/Cargo.toml

@@ -23,5 +23,5 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 
 [features]
-default = []
+default = ["benches"]
 benches = []