Struct bus_mapping::circuit_input_builder::CircuitInputStateRef

pub struct CircuitInputStateRef<'a> {
    pub sdb: &'a mut StateDB,
    pub code_db: &'a mut CodeDB,
    pub block: &'a mut Block,
    pub block_ctx: &'a mut BlockContext,
    pub chunk_ctx: &'a mut ChunkContext,
    pub tx: &'a mut Transaction,
    pub tx_ctx: &'a mut TransactionContext,
    pub max_rws: Option<usize>,
}

Reference to the internal state of the CircuitInputBuilder in a particular ExecStep.

Fields

sdb: &'a mut StateDB

StateDB

code_db: &'a mut CodeDB

CodeDB

block: &'a mut Block

Block

block_ctx: &'a mut BlockContext

Block Context

chunk_ctx: &'a mut ChunkContext

Chunk Context

tx: &'a mut Transaction

Transaction

tx_ctx: &'a mut TransactionContext

Transaction Context

max_rws: Option<usize>

Max rw number limit

Implementations

impl<'a> CircuitInputStateRef<'a>

pub fn new_step(&self, geth_step: &GethExecStep) -> Result<ExecStep, Error>

Create a new step from a GethExecStep

pub fn new_invalid_tx_step(&self) -> ExecStep

Create a new InvalidTx step

pub fn new_begin_tx_step(&self) -> ExecStep

Create a new BeginTx step

pub fn new_end_tx_step(&self) -> ExecStep

Create a new EndTx step

pub fn push_op<T: Op>( &mut self, step: &mut ExecStep, rw: RW, op: T ) -> Result<(), Error>

Push an Operation into the OperationContainer with the next RWCounter and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn check_rw_num_limit(&self) -> Result<(), Error>

Check whether rws will overflow circuit limit.

pub fn call_context_read( &mut self, step: &mut ExecStep, call_id: usize, field: CallContextField, value: Word ) -> Result<(), Error>

Push a read type CallContextOp into the OperationContainer with the next RWCounter and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn call_context_write( &mut self, step: &mut ExecStep, call_id: usize, field: CallContextField, value: Word ) -> Result<(), Error>

Push a write type CallContextOp into the OperationContainer with the next RWCounter and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn push_op_reversible<T: Op>( &mut self, step: &mut ExecStep, op: T ) -> Result<(), Error>

Push an Operation with reversible to be true into the OperationContainer with the next RWCounter and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one. This method should be used in Opcode::gen_associated_ops instead of push_op when the operation is RW::WRITE and it can be reverted (for example, a write StorageOp).

pub fn memory_read( &mut self, step: &mut ExecStep, address: MemoryAddress ) -> Result<u8, Error>

Push a read type MemoryOp into the OperationContainer with the next RWCounter and call_id, and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn memory_read_caller( &mut self, step: &mut ExecStep, address: MemoryAddress ) -> Result<u8, Error>

Almost the same as above memory_read, but read from the caller’s context instead.

pub fn memory_write( &mut self, step: &mut ExecStep, address: MemoryAddress, value: u8 ) -> Result<u8, Error>

Push a write type MemoryOp into the OperationContainer with the next RWCounter and call_id, and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn memory_write_caller( &mut self, step: &mut ExecStep, address: MemoryAddress, value: u8 ) -> Result<u8, Error>

Almost the same as above memory_write, but write to the caller’s context instead.

pub fn stack_write( &mut self, step: &mut ExecStep, address: StackAddress, value: Word ) -> Result<(), Error>

Push a write type StackOp into the OperationContainer with the next RWCounter and call_id, and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn stack_read( &mut self, step: &mut ExecStep, address: StackAddress, value: Word ) -> Result<(), Error>

Push a read type StackOp into the OperationContainer with the next RWCounter and call_id, and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn account_read( &mut self, step: &mut ExecStep, address: Address, field: AccountField, value: Word ) -> Result<(), Error>

Push a read type AccountOp into the OperationContainer with the next RWCounter, and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn account_write( &mut self, step: &mut ExecStep, address: Address, field: AccountField, value: Word, value_prev: Word, reversible: bool ) -> Result<(), Error>

Push a write type AccountOp into the OperationContainer with the next RWCounter, and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn tx_log_write( &mut self, step: &mut ExecStep, tx_id: usize, log_id: usize, field: TxLogField, index: usize, value: Word ) -> Result<(), Error>

Push a write type TxLogOp into the OperationContainer with the next RWCounter, and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn tx_receipt_read( &mut self, step: &mut ExecStep, tx_id: usize, field: TxReceiptField, value: u64 ) -> Result<(), Error>

Push a read type TxReceiptOp into the OperationContainer with the next RWCounter, and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn tx_receipt_write( &mut self, step: &mut ExecStep, tx_id: usize, field: TxReceiptField, value: u64 ) -> Result<(), Error>

Push a write type TxReceiptOp into the OperationContainer with the next RWCounter, and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn tx_accesslist_account_write( &mut self, step: &mut ExecStep, tx_id: usize, address: Address, is_warm: bool, is_warm_prev: bool ) -> Result<(), Error>

Push a write type TxAccessListAccountOp into the OperationContainer with the next RWCounter, and then adds a reference to the stored operation (OperationRef) inside the bus-mapping instance of the current ExecStep. Then increase the block_ctx RWCounter by one.

pub fn tx_access_list_write( &mut self, step: &mut ExecStep, address: Address ) -> Result<(), Error>

Add address to access list for the current transaction.

pub fn transfer( &mut self, step: &mut ExecStep, sender: Address, receiver: Address, receiver_exists: bool, is_create: bool, value: Word, fee: Option<Word> ) -> Result<(), Error>

Push 2 reversible AccountOp to update sender and receiver’s balance by value. If fee is existing (not None), also need to push 1 non-reversible AccountOp to update sender balance by fee.

pub fn transfer_to( &mut self, step: &mut ExecStep, receiver: Address, receiver_exists: bool, is_create: bool, value: Word, reversible: bool ) -> Result<(), Error>

Transfer to an address. Create an account if it is not existed before.

pub fn code(&self, code_hash: H256) -> Result<Vec<u8>, Error>

Fetch and return code for the given code hash from the code DB.

pub fn caller(&self) -> Result<&Call, Error>

Reference to the caller’s Call

pub fn caller_mut(&mut self) -> Result<&mut Call, Error>

Mutable reference to the current call’s caller Call

pub fn call(&self) -> Result<&Call, Error>

Reference to the current Call

pub fn call_mut(&mut self) -> Result<&mut Call, Error>

Mutable reference to the current Call

pub fn caller_ctx(&self) -> Result<&CallContext, Error>

Reference to the current CallContext

pub fn call_ctx(&self) -> Result<&CallContext, Error>

Reference to the current CallContext

pub fn call_ctx_mut(&mut self) -> Result<&mut CallContext, Error>

Mutable reference to the call CallContext

pub fn caller_ctx_mut(&mut self) -> Result<&mut CallContext, Error>

Mutable reference to the caller CallContext

pub fn push_call(&mut self, call: Call)

Push a new Call into the Transaction, and add its index and CallContext in the call_stack of the TransactionContext

pub fn is_precompiled(&self, address: &Address) -> bool

Check if address is a precompiled or not.

pub fn parse_call(&mut self, step: &GethExecStep) -> Result<Call, Error>

Parse Call from a CALL/CREATE* step.

pub fn handle_reversion(&mut self, current_exec_steps: &mut [&mut ExecStep])

Handle a reversion group

pub fn handle_return( &mut self, current_exec_steps: &mut [&mut ExecStep], geth_steps: &[GethExecStep], need_restore: bool ) -> Result<(), Error>

Handle a restore and a return step caused by any opcode that causes a return to the previous call context.

pub fn handle_restore_context( &mut self, exec_step: &mut ExecStep, steps: &[GethExecStep] ) -> Result<(), Error>

Bus mapping for the RestoreContextGadget as used in RETURN.

pub fn push_copy(&mut self, step: &mut ExecStep, event: CopyEvent)

Push a copy event to the state.

pub fn push_exponentiation(&mut self, event: ExpEvent)

Push a exponentiation event to the state.

pub fn push_precompile_event(&mut self, event: PrecompileEvent)

Push an event representing auxiliary data for a precompile call to the state.