Struct bus_mapping::circuit_input_builder::CircuitInputBuilder

pub struct CircuitInputBuilder<C: CircuitsParams> {
    pub sdb: StateDB,
    pub code_db: CodeDB,
    pub block: Block,
    pub chunks: Vec<Chunk>,
    pub block_ctx: BlockContext,
    pub chunk_ctx: ChunkContext,
    pub circuits_params: C,
    pub feature_config: FeatureConfig,
}

Builder to generate a complete circuit input from data gathered from a geth instance. This structure is the centre of the crate and is intended to be the only entry point to it. The CircuitInputBuilder works in several steps:

1. Take a [eth_types::Block] to build the circuit input associated with the block. 2. For each [eth_types::Transaction] in the block, take the eth_types::GethExecTrace to build the circuit input associated with each transaction, and the bus-mapping operations associated with each [eth_types::GethExecStep] in the eth_types::GethExecTrace. 3. If Rws generated during Transactions exceed the max_rws threshold, separate witness into multiple chunks.

The generated bus-mapping operations are: StackOps, MemoryOps and StorageOp, which correspond to each OpcodeIds used in each ExecTrace step so that the State Proof witnesses are already generated on a structured manner and ready to be added into the State circuit.

Fields

sdb: StateDB

StateDB key-value DB

code_db: CodeDB

Map of account codes by code hash

block: Block

Block

chunks: Vec<Chunk>

Chunk

block_ctx: BlockContext

Block Context

chunk_ctx: ChunkContext

Chunk Context

circuits_params: C

Circuits Setup Parameters before chunking

feature_config: FeatureConfig

Feature config

Implementations

impl<'a, C: CircuitsParams> CircuitInputBuilder<C>

pub fn new( sdb: StateDB, code_db: CodeDB, block: Block, params: C, feature_config: FeatureConfig ) -> Self

Create a new CircuitInputBuilder from the given eth_block and constants.

pub fn set_total_chunk(&mut self, total_chunks: usize)

Set the total number of chunks for existing CircuitInputBuilder, API for chunking the existing tests then run with a specific chunk

pub fn state_ref( &'a mut self, tx: &'a mut Transaction, tx_ctx: &'a mut TransactionContext ) -> CircuitInputStateRef<'_>

Obtain a mutable reference to the state that the CircuitInputBuilder maintains, contextualized to a particular transaction and a particular execution step in that transaction.

pub fn new_tx( &mut self, id: u64, eth_tx: &Transaction, is_success: bool ) -> Result<Transaction, Error>

Create a new Transaction from a [eth_types::Transaction].

pub fn set_value_ops_call_context_rwc_eor(&mut self)

Iterate over all generated CallContext RwCounterEndOfReversion operations and set the correct value. This is required because when we generate the RwCounterEndOfReversion operation in gen_associated_ops we don’t know yet which value it will take, so we put a placeholder; so we do it here after the values are known.

pub fn commit_chunk_ctx( &mut self, to_next: bool, next_tx_index: usize, next_copy_index: usize, last_call: Option<Call> )

Set the end status of a chunk including the current globle rwc and commit the current chunk context, proceed to the next chunk if needed

pub fn get_chunk_mut(&mut self, i: usize) -> &mut Chunk

Get the i-th mutable chunk

pub fn get_chunk(&self, i: usize) -> Chunk

Get the i-th chunk

pub fn cur_chunk(&self) -> Chunk

Get the current chunk

pub fn cur_chunk_mut(&mut self) -> &mut Chunk

Get a mutable reference of current chunk

pub fn prev_chunk(&self) -> Option<Chunk>

Get the previous chunk

pub fn chunk_rws(&self) -> usize

Total Rw in this chunk

impl CircuitInputBuilder<FixedCParams>

pub fn begin_handle_block( &mut self, eth_block: &Block<Transaction>, geth_traces: &[GethExecTrace] ) -> Result<(Option<ExecStep>, Option<Call>), Error>

First part of handle_block, only called by fixed Builder

pub fn handle_block( self, eth_block: &Block<Transaction>, geth_traces: &[GethExecTrace] ) -> Result<CircuitInputBuilder<FixedCParams>, Error>

Handle a block by handling each transaction to generate all the associated operations.

impl<C: CircuitsParams> CircuitInputBuilder<C>

pub fn last_exec_step_rws_reserved(&self) -> usize

return the rw row reserved for end_block/end_chunk

impl CircuitInputBuilder<DynamicCParams>

pub fn handle_block( self, eth_block: &Block<Transaction>, geth_traces: &[GethExecTrace] ) -> Result<CircuitInputBuilder<FixedCParams>, Error>

Handle a block by handling each transaction to generate all the associated operations. Dry run the block to determined the target FixedCParams from to total number of chunks.

Trait Implementations

impl<C: Clone + CircuitsParams> Clone for CircuitInputBuilder<C>

fn clone(&self) -> CircuitInputBuilder<C>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug + CircuitsParams> Debug for CircuitInputBuilder<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.