Enum PrecompilesMap

pub enum PrecompilesMap {
    Builtin(Cow<'static, Precompiles>),
    Dynamic(DynPrecompiles),
}

A mapping of precompile contracts that can be either static (builtin) or dynamic.

This is an optimization that allows us to keep using the static precompiles until we need to modify them, at which point we convert to the dynamic representation.

Variants

Builtin(Cow<'static, Precompiles>)

Static builtin precompiles.

Dynamic(DynPrecompiles)

Dynamic precompiles that can be modified at runtime.

Implementations

impl PrecompilesMap

pub fn from_static(precompiles: &'static Precompiles) -> PrecompilesMap

Creates the PrecompilesMap from a static reference.

pub fn new(precompiles: Cow<'static, Precompiles>) -> PrecompilesMap

Creates a new set of precompiles for a spec.

pub fn map_precompile<F>(&mut self, address: &Address, f: F)

where F: FnOnce(DynPrecompile) -> DynPrecompile + Send + Sync + 'static,

Maps a precompile at the given address using the provided function.

pub fn map_precompiles<F>(&mut self, f: F)

where F: FnMut(&Address, DynPrecompile) -> DynPrecompile,

Maps all precompiles using the provided function.

pub fn apply_precompile<F>(&mut self, address: &Address, f: F)

where F: FnOnce(Option<DynPrecompile>) -> Option<DynPrecompile>,

Applies a new precompile at the given address.

pub fn ensure_dynamic_precompiles(&mut self) -> &mut DynPrecompiles

Ensures that precompiles are in their dynamic representation. If they are already dynamic, this is a no-op. Returns a mutable reference to the dynamic precompiles.

pub fn addresses(&self) -> impl Iterator<Item = &Address>

Returns an iterator over references to precompile addresses.

pub fn get(&self, address: &Address) -> Option<impl Precompile>

Gets a reference to the precompile at the given address.

Trait Implementations

impl Clone for PrecompilesMap

fn clone(&self) -> PrecompilesMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PrecompilesMap

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

Formats the value using the given formatter.

impl From<EthPrecompiles> for PrecompilesMap

fn from(value: EthPrecompiles) -> PrecompilesMap

Converts to this type from the input type.

impl<CTX> PrecompileProvider<CTX> for PrecompilesMap

where CTX: ContextTr,

type Output = InterpreterResult

fn set_spec(&mut self, _spec: <<CTX as ContextTr>::Cfg as Cfg>::Spec) -> bool

Sets the spec id and returns true if the spec id was changed. Initial call to set_spec will always return true.

fn run( &mut self, context: &mut CTX, address: &Address, inputs: &InputsImpl, _is_static: bool, gas_limit: u64, ) -> Result<Option<InterpreterResult>, String>

Run the precompile.

fn warm_addresses(&self) -> Box<impl Iterator<Item = Address>>

Get the warm addresses.

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

Check if the address is a precompile.

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: 88 bytes

Size for each variant:

• Builtin: 80 bytes
• Dynamic: 80 bytes