Struct StorageSlotFinder 

pub struct StorageSlotFinder<P, N>
where
    N: Network,
{ /* private fields */ }

A utility for finding storage slots in smart contracts, particularly useful for ERC20 tokens.

This struct helps identify which storage slot contains a specific value by:

1. Creating an access list to find all storage slots accessed by a function call
2. Systematically overriding each slot with an expected value
3. Checking if the function returns the expected value to identify the correct slot

Example

use alloy_contract::StorageSlotFinder;
use alloy_primitives::{address, U256};
use alloy_provider::ProviderBuilder;

let provider = ProviderBuilder::new().connect_anvil();
let token = address!("0x6B175474E89094C44Da98b954EedeAC495271d0F");
let user = address!("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045");

// Find the storage slot for a user's balance
let finder =
    StorageSlotFinder::balance_of(provider, token, user).with_expected_value(U256::from(1000));

if let Some(slot) = finder.find_slot().await? {
    println!("Balance stored at slot: {:?}", slot);
}

Implementations

impl<P, N> StorageSlotFinder<P, N>

where P: Provider<N>, N: Network,

pub fn new( provider: P, contract: Address, calldata: Bytes, expected_value: U256, ) -> Self

Creates a new storage slot finder for a generic function call.

Arguments

• provider - The provider to use for making calls
• contract - The address of the contract to analyze
• calldata - The encoded function call to execute
• expected_value - The value we expect the function to return

For common ERC20 use cases, consider using Self::balance_of instead.

pub fn balance_of(provider: P, token_address: Address, user: Address) -> Self

Convenience constructor for finding the storage slot of an ERC20 balanceOf(address) mapping.

Uses a default expected value of 1337. Call Self::with_expected_value to set a different value.

Arguments

• provider - The provider to use for making calls
• token_address - The address of the ERC20 token contract
• user - The address of the user whose balance slot we’re finding

pub const fn with_expected_value(self, value: U256) -> Self

Configures a specific value that should be used in the state override to identify the slot.

pub fn with_request(self, base_request: N::TransactionRequest) -> Self

Overrides the base request object that will be used for slot detection.

For slot detection the target address of that request is set to the configured contract and the input to the configured input.

pub async fn find_slot(self) -> Result<Option<B256>, TransportError>

Finds the storage slot containing the expected value.

This method:

1. Creates an access list for the function call to identify all storage slots accessed
2. Iterates through each accessed slot on the target contract
3. Overrides each slot with the expected value using state overrides
4. Checks if the function returns the expected value when that slot is overridden
5. Returns the first slot that causes the function to return the expected value

Returns

• Ok(Some(slot)) - The storage slot that contains the value
• Ok(None) - No storage slot was found containing the value
• Err(TransportError) - An error occurred during RPC calls

Note

This method assumes that the value is stored directly in a storage slot without any encoding or hashing. For mappings, the actual storage location might be computed using keccak256 hashing.

Trait Implementations

impl<P: Clone, N> Clone for StorageSlotFinder<P, N>

where N: Network + Clone, N::TransactionRequest: Clone,

fn clone(&self) -> StorageSlotFinder<P, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug, N> Debug for StorageSlotFinder<P, N>

where N: Network + Debug, N::TransactionRequest: Debug,

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

Formats the value using the given formatter.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.