EVM

On-chain Data Sources for EVM chains

Balance

Name: Balance

Type: integer

Gets the ETH balance of an address.

Call

Name: Call

Type: varies

Calls a function and gets the return value.

The type of this source and it's parameters are determined by the signature provided. See the Example tab for more info

source addresses: list<address> = Call {
    contract: 0xface...ddad,
    signature: "function getAddresses(uint256 id) returns (address[])",
    params: tuple(1),
    eth: 1024
};

addresses == list(0xface...ddadd, 0xcafe..1234)

Events

Name: Events

Type: list<tuple<varies>>

Get the parameters of all events with a specific signature emitted by a contract in the evaluated block.

The type of this source depends on the signature of the event. See the Example tab for more information.

Calls

Name: Calls

Type: list<tuple<varies>>

Get the arguments of all function calls with a specific signature to a contract in the evaluated block

The type of this source depends on the signature of the event. See the Example tab for more information.

Historical Events

Name: HistoricalEvents

Type: list<tuple<varies>>

Get the parameters of all events with a specific signature emitted by a contract since genesis.

The type of this source depends on the signature of the event. See the Example tab for more information.

source transfers: list<tuple<address, address, integer>> = HistoricalEvents {
    contract: 0xface...ddad,
    signature: "event Transfer(address indexed from, address indexed to, uint256 value)"
};

Historical Calls

Name: HistoricalCalls

Type: list<tuple<varies>>

Get the arguments of all function calls with a specific signature to a contract since genesis.

The type of this source depends on the signature of the event. See the Example tab for more information.

Storage Access

Name: StorageAccess

Type: varies

Fetches storage data from a contract, starting at a specific slot, and decode the data according to a given signature.

Storage Map Access

Name: StorageMapAccess

Type: varies

Fetches a value from a mapping in storage, given a key, starting at a specific slot, and decode the data according to a given signature.

source data: list<tuple<integer, address>> = StorageMapAccess {
    contract: 0xface...ddad,
    slot: 0x0000...0001, // Must be bytes32
    mapKey: 100
    keySignature: "uint256",
    valueSignature: "(uint256,address)[]"
};

// Given map = mapping (uint256 => (uint256,address)[]),
// Get map[100] from the contract's storage.

Filter Addresses In Trace

Name: FilterAddressesInTrace

Type: list<address>

Given a list of addresses, only return the addresses that are active in this block (appear somewhere in the trace of a transaction)

This is useful when trying to run invariants on a large number of addresses.

The given addresses must come from a "historical" source (some deterministic manipulation over HistoricalEvents or HistoricalCalls)

source depositors: list<address> = [
    ev[0] for ev in
    HistoricalEvents {
        contract: contract,
        signature: "event Deposit(address depositor, uint256 amount)"
    }
];

source relevant: list<address> = FilterAddressesInTrace {
    addresses: depositors
};

State Root

Name: StateRoot

Type: bytes

Get the hash of the state root in a given block.

Storage hash

Name: StorageHash

Type: bytes

Get the the storage hash of a given contract on a given block. StorageHash is the SHA3 of the Merkle-tree root of a contact's storage.

source exampleStorageHash: bytes = StorageHash {
    address: 0x4200000000000000000000000000000000000016,
    block: 117928663,
};

// this value is on optimism
exampleStorageHash == bytes(
    0x5f8f72faa435573ec5a227d7f619b51e127d3dfa2b9688205955248668c11ee6
)

Block Hash

Name: BlockHash

Type: bytes

Get the hash of a specified block.

source optimismBlockHash: bytes = BlockHash {
    block: 117928663,
};

// this value is on optimism
optimismBlockHash == bytes(
    0xa0d256bb83489b7b0bb55530748af684bcb3289ec02895d480e7c8052ac9c0d7
)

PreviousOn Chain NextBeacon Chain

Last updated 9 months ago