Struct Handler

pub struct Handler<'a, H, EXT, DB>
where
    H: Host + 'a,
    DB: Database,
{
    pub cfg: HandlerCfg,
    pub instruction_table: InstructionTables<'a, H>,
    pub registers: Vec<HandleRegisters<'a, EXT, DB>>,
    pub validation: ValidationHandler<'a, EXT, DB>,
    pub pre_execution: PreExecutionHandler<'a, EXT, DB>,
    pub post_execution: PostExecutionHandler<'a, EXT, DB>,
    pub execution: ExecutionHandler<'a, EXT, DB>,
}

Handler acts as a proxy and allow to define different behavior for different sections of the code. This allows nice integration of different chains or to disable some mainnet behavior.

Fields

cfg: HandlerCfg

Handler configuration.

instruction_table: InstructionTables<'a, H>

Instruction table type.

registers: Vec<HandleRegisters<'a, EXT, DB>>

Registers that will be called on initialization.

validation: ValidationHandler<'a, EXT, DB>

Validity handles.

pre_execution: PreExecutionHandler<'a, EXT, DB>

Pre execution handle.

post_execution: PostExecutionHandler<'a, EXT, DB>

Post Execution handle.

execution: ExecutionHandler<'a, EXT, DB>

Execution loop that handles frames.

Implementations

impl<'a, EXT, DB> Handler<'a, Context<EXT, DB>, EXT, DB>

where DB: Database,

pub fn new(cfg: HandlerCfg) -> Handler<'a, Context<EXT, DB>, EXT, DB>

Created new Handler with given configuration.

Internally it calls mainnet_with_spec with the given spec id. Or optimism_with_spec if the optimism feature is enabled and cfg.is_optimism is set.

pub fn mainnet<SPEC>() -> Handler<'a, Context<EXT, DB>, EXT, DB>

where SPEC: Spec,

Default handler for Ethereum mainnet.

pub fn is_optimism(&self) -> bool

Returns true if the optimism feature is enabled and flag is set to true.

pub fn optimism<SPEC>() -> Handler<'a, Context<EXT, DB>, EXT, DB>

where SPEC: Spec,

Available on crate feature optimism only.

Handler for optimism

pub fn optimism_with_spec( spec_id: SpecId, ) -> Handler<'a, Context<EXT, DB>, EXT, DB>

Available on crate feature optimism only.

Optimism with spec. Similar to Self::mainnet_with_spec.

pub fn mainnet_with_spec( spec_id: SpecId, ) -> Handler<'a, Context<EXT, DB>, EXT, DB>

Creates handler with variable spec id, inside it will call mainnet::<SPEC> for appropriate spec.

pub fn cfg(&self) -> HandlerCfg

Specification ID.

pub fn spec_id(&self) -> SpecId

Returns specification ID.

pub fn execute_frame( &self, frame: &mut Frame, shared_memory: &mut SharedMemory, context: &mut Context<EXT, DB>, ) -> Result<InterpreterAction, EVMError<<DB as Database>::Error>>

Executes call frame.

pub fn take_instruction_table( &mut self, ) -> InstructionTables<'a, Context<EXT, DB>>

Take instruction table.

pub fn set_instruction_table( &mut self, table: InstructionTables<'a, Context<EXT, DB>>, )

Set instruction table.

pub fn pre_execution(&self) -> &PreExecutionHandler<'a, EXT, DB>

Returns reference to pre execution handler.

pub fn post_execution(&self) -> &PostExecutionHandler<'a, EXT, DB>

Returns reference to pre execution handler.

pub fn execution(&self) -> &ExecutionHandler<'a, EXT, DB>

Returns reference to frame handler.

pub fn validation(&self) -> &ValidationHandler<'a, EXT, DB>

Returns reference to validation handler.

pub fn append_handler_register( &mut self, register: HandleRegisters<'a, EXT, DB>, )

Append handle register.

pub fn append_handler_register_plain( &mut self, register: for<'a> fn(_: &mut Handler<'a, Context<EXT, DB>, EXT, DB>), )

Append plain handle register.

pub fn append_handler_register_box( &mut self, register: Box<dyn for<'e> Fn(&mut Handler<'e, Context<EXT, DB>, EXT, DB>) + 'a>, )

Append boxed handle register.

pub fn pop_handle_register(&mut self) -> Option<HandleRegisters<'a, EXT, DB>>

Pop last handle register and reapply all registers that are left.

pub fn create_handle_generic<SPEC>( &mut self, ) -> Handler<'a, Context<EXT, DB>, EXT, DB>

where SPEC: Spec,

Creates the Handler with Generic Spec.

pub fn modify_spec_id(&mut self, spec_id: SpecId)

Creates the Handler with variable SpecId, inside it will call function with Generic Spec.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 4512 bytes