Struct PrecompilesMap 

pub struct PrecompilesMap { /* private fields */ }

Available on crate feature evm only.

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.

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 map_pure_precompiles<F>(&mut self, f: F)

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

Maps all pure precompiles using the provided function.

This is a variant of Self::map_precompiles that only applies the transformation to precompiles that are pure, see Precompile::is_pure.

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

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

Applies a transformation to the precompile at the given address.

This method allows you to add, update, or remove a precompile by applying a closure to the existing precompile (if any) at the specified address.

Behavior

The closure receives:

• Some(precompile) if a precompile exists at the address
• None if no precompile exists at the address

Based on what the closure returns:

• Some(precompile) - Insert or replace the precompile at the address
• None - Remove the precompile from the address (if it exists)

Examples

// Add a new precompile
precompiles.apply_precompile(&address, |_| Some(my_precompile));

// Update an existing precompile
precompiles.apply_precompile(&address, |existing| {
    existing.map(|p| wrap_with_logging(p))
});

// Remove a precompile
precompiles.apply_precompile(&address, |_| None);

// Conditionally update
precompiles.apply_precompile(&address, |existing| {
    if let Some(p) = existing {
        Some(modify_precompile(p))
    } else {
        Some(create_default_precompile())
    }
});

pub fn with_mapped_precompile<F>( self, address: &Address, f: F, ) -> PrecompilesMap

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

Builder-style method that maps a precompile at the given address using the provided function.

This is a consuming version of map_precompile that returns Self.

pub fn with_mapped_precompiles<F>(self, f: F) -> PrecompilesMap

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

Builder-style method that maps all precompiles using the provided function.

This is a consuming version of map_precompiles that returns Self.

pub fn with_applied_precompile<F>( self, address: &Address, f: F, ) -> PrecompilesMap

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

Builder-style method that applies a transformation to the precompile at the given address.

This is a consuming version of apply_precompile that returns Self. See apply_precompile for detailed behavior and examples.

pub fn set_precompile_lookup<L>(&mut self, lookup: L)

where L: PrecompileLookup + 'static,

Sets a dynamic precompile lookup function that is called for addresses not found in the static precompile map.

This method allows you to provide runtime-resolved precompiles that aren’t known at initialization time. The lookup function is called whenever a precompile check is performed for an address that doesn’t exist in the main precompile map.

Important Notes

• Priority: Static precompiles take precedence. The lookup function is only called if the address is not found in the main precompile map.
• Gas accounting: Addresses resolved through this lookup are always treated as cold, meaning they incur cold access costs even on repeated calls within the same transaction. See also PrecompileProvider::warm_addresses.
• Performance: The lookup function is called on every precompile check for non-registered addresses, so it should be efficient.

Example

precompiles.set_precompile_lookup(|address| {
    // Dynamically resolve precompiles based on address pattern
    if address.as_slice().starts_with(&[0xDE, 0xAD]) {
        Some(DynPrecompile::new(|input| {
            // Custom precompile logic
            Ok(PrecompileOutput {
                gas_used: 100,
                bytes: Bytes::from("dynamic precompile"),
            })
        }))
    } else {
        None
    }
});

pub fn with_precompile_lookup<L>(self, lookup: L) -> PrecompilesMap

where L: PrecompileLookup + 'static,

Builder-style method to set a dynamic precompile lookup function.

This is a consuming version of set_precompile_lookup that returns Self for method chaining.

See set_precompile_lookup for detailed behavior, important notes, and examples.

pub fn into_dyn_precompiles(self) -> DynPrecompiles

Consumes the type and returns a set of DynPrecompile.

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.

This method first checks the static precompile map, and if not found, falls back to the dynamic lookup function (if set).

Trait Implementations

impl Clone for PrecompilesMap

fn clone(&self) -> PrecompilesMap

Returns a duplicate of the value.

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<BlockEnv, TxEnv, CfgEnv, DB, Chain> PrecompileProvider<Context<BlockEnv, TxEnv, CfgEnv, DB, Journal<DB>, Chain>> for PrecompilesMap

where BlockEnv: Block, TxEnv: Transaction, CfgEnv: Cfg, DB: Database,

type Output = InterpreterResult

The output type returned by precompile execution.

fn set_spec(&mut self, _spec: <CfgEnv 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 Context<BlockEnv, TxEnv, CfgEnv, DB, Journal<DB>, Chain>, 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: 128 bytes