leafage-py

Leafage reads on-chain state at a specified chain and block. Run these examples in a Chaintable Notebook; they also work in Functions. For Function usage, see Data access. The source contains the full implementation.

Create a block context

from leafage import EVM

block = EVM('eth').get_block_by_height(25939934)
evm = EVM('eth', block['id'])

`EVM(chain_id, block_id='latest')`

Parameter	Type	Description
`chain_id`	`str`	Chain ID, such as `eth` for Ethereum mainnet
`block_id`	`str`	Block ID at which to read state; defaults to `'latest'`, the newest block

Account state and contract calls are read at this block. For consistent multiple reads, first resolve a block ID and then reuse the same object.

Block queries

Interface	Parameters	Return value
`evm.get_latest_block()`	None	Latest block dictionary
`evm.get_block_by_height(block_height)`	Integer height	Matching block dictionary
`evm.get_block_by_id(block_id)`	Block ID	Matching block dictionary
`evm.block_exists()`	None	Whether the object’s block is valid, as `bool`

Block dictionaries include id, height, and timestamp. timestamp is Unix time in seconds. Additional fields may vary by chain. Querying another block does not change the object’s own block.

Account state

wallet = '0xd8da6bf26964af9d7eed9e03e53415d37aa96045'
balance_wei = evm.get_balance(wallet)
print(balance_wei)

Interface	Parameters	Return value
`evm.get_balance(addr)`	Address	`int`, native token balance; wei for ETH
`evm.get_nonce(addr)`	Address	`int`, nonce value at the block
`evm.get_code(addr)`	Address	Bytecode string starting with `0x`; `'0x'` when there is no code
`evm.get_storage(addr, slot=0)`	Address and storage slot, as an integer or a `0x` hexadecimal string	32-byte storage value starting with `0x`

Contract calls

`evm.call(contract, method, args=None, *, from_addr=None)`

Parameter	Description
`contract`	Contract address
`method`	Signature with input and output types, such as `balanceOf(address)(uint256)`
`args`	Positional argument list; omit it for no arguments
`from_addr`	Optional caller address for the simulated call context; defaults to the zero address

A single output is returned directly, multiple outputs as a tuple, and no outputs as (); integers are Python int values. Failures raise exceptions.

pool = '0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc'
reserve_usdc, reserve_weth, timestamp = evm.call(
    pool, 'getReserves()(uint112,uint112,uint32)'
)

This reads or simulates a contract call. It does not send a transaction to the chain.

Batch contract calls

from leafage import Call

usdc = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'
symbol, decimals = evm.call_many([
    Call(usdc, 'symbol()(string)'),
    Call(usdc, 'decimals()(uint8)'),
])
print(symbol, decimals)

The output is USDC 6.

`Call(contract, method, args=None, *, from_addr=None)`

Describes one call, with the same parameters as evm.call(). Construction validates the address, signature, and arguments locally and raises ContractCallInvalidInputError for invalid input without sending a request. The same Call can run against different EVM objects.

`evm.call_many(calls, *, raise_on_error=True)`

Returns a list of results in input order, each shaped like an evm.call() result; an empty list returns []. By default, any call that fails to execute or decode raises an exception whose call_index identifies the call. With raise_on_error=False, failed calls return None at their positions and other results are unchanged; invalid input, missing blocks, and service errors still raise.

State overrides

set_block_overrides(value) and set_state_overrides(value) set block and account-state overrides for simulated calls. The corresponding get_*_overrides() methods return current settings. Overrides affect contract calls only, not balance, nonce, code, or storage queries, and they do not change on-chain state. See the Leafage source for field definitions and full examples.

Overview

Quickstart

Guides

Reference