Enum CastSubcommand

pub enum CastSubcommand {
    MaxInt {
        type: String,
    },
    MinInt {
        type: String,
    },
    MaxUint {
        type: String,
    },
    AddressZero,
    HashZero,
    FromUtf8 {
        text: Option<String>,
    },
    ConcatHex {
        data: Vec<String>,
    },
    FromBin,
    ToHexdata {
        input: Option<String>,
    },
    ToCheckSumAddress {
        address: Option<Address>,
    },
    ToAscii {
        hexdata: Option<String>,
    },
    ToUtf8 {
        hexdata: Option<String>,
    },
    FromFixedPoint {
        decimals: Option<String>,
        value: Option<String>,
    },
    ToBytes32 {
        bytes: Option<String>,
    },
    ToFixedPoint {
        decimals: Option<String>,
        value: Option<String>,
    },
    ToUint256 {
        value: Option<String>,
    },
    ToInt256 {
        value: Option<String>,
    },
    LeftShift {
        value: String,
        bits: String,
        base_in: Option<String>,
        base_out: String,
    },
    RightShift {
        value: String,
        bits: String,
        base_in: Option<String>,
        base_out: String,
    },
    ToUnit {
        value: Option<String>,
        unit: String,
    },
    ParseUnits {
        value: Option<String>,
        unit: u8,
    },
    FormatUnits {
        value: Option<String>,
        unit: u8,
    },
    ToWei {
        value: Option<String>,
        unit: String,
    },
    FromWei {
        value: Option<String>,
        unit: String,
    },
    ToRlp {
        value: Option<String>,
    },
    FromRlp {
        value: Option<String>,
        as_int: bool,
    },
    ToHex(ToBaseArgs),
    ToDec(ToBaseArgs),
    ToBase {
        base: ToBaseArgs,
        base_out: Option<String>,
    },
    AccessList(AccessListArgs),
    Logs(LogsArgs),
    Block {
        block: Option<BlockId>,
        field: Option<String>,
        full: bool,
        rpc: RpcOpts,
    },
    BlockNumber {
        block: Option<BlockId>,
        rpc: RpcOpts,
    },
    Call(CallArgs),
    CalldataEncode {
        sig: String,
        args: Vec<String>,
    },
    Chain {
        rpc: RpcOpts,
    },
    ChainId {
        rpc: RpcOpts,
    },
    Client {
        rpc: RpcOpts,
    },
    ComputeAddress {
        address: Option<Address>,
        nonce: Option<u64>,
        rpc: RpcOpts,
    },
    Disassemble {
        bytecode: Option<String>,
    },
    MakeTx(MakeTxArgs),
    Namehash {
        name: Option<String>,
    },
    Tx {
        tx_hash: String,
        field: Option<String>,
        raw: bool,
        rpc: RpcOpts,
    },
    Receipt {
        tx_hash: String,
        field: Option<String>,
        confirmations: u64,
        cast_async: bool,
        rpc: RpcOpts,
    },
    SendTx(SendTxArgs),
    PublishTx {
        raw_tx: String,
        cast_async: bool,
        rpc: RpcOpts,
    },
    Estimate(EstimateArgs),
    DecodeCalldata {
        sig: String,
        calldata: String,
    },
    DecodeString {
        data: String,
    },
    DecodeEvent {
        sig: Option<String>,
        data: String,
    },
    DecodeError {
        sig: Option<String>,
        data: String,
    },
    DecodeAbi {
        sig: String,
        calldata: String,
        input: bool,
    },
    AbiEncode {
        sig: String,
        packed: bool,
        args: Vec<String>,
    },
    Index {
        key_type: String,
        key: String,
        slot_number: String,
    },
    IndexErc7201 {
        id: Option<String>,
        formula_id: String,
    },
    Implementation {
        block: Option<BlockId>,
        beacon: bool,
        who: NameOrAddress,
        rpc: RpcOpts,
    },
    Admin {
        block: Option<BlockId>,
        who: NameOrAddress,
        rpc: RpcOpts,
    },
    FourByte {
        selector: Option<String>,
    },
    FourByteCalldata {
        calldata: Option<String>,
    },
    FourByteEvent {
        topic: Option<String>,
    },
    UploadSignature {
        signatures: Vec<String>,
    },
    PrettyCalldata {
        calldata: Option<String>,
        offline: bool,
    },
    Age {
        block: Option<BlockId>,
        rpc: RpcOpts,
    },
    Balance {
        block: Option<BlockId>,
        who: NameOrAddress,
        ether: bool,
        rpc: RpcOpts,
        erc20: Option<Address>,
    },
    BaseFee {
        block: Option<BlockId>,
        rpc: RpcOpts,
    },
    Code {
        block: Option<BlockId>,
        who: NameOrAddress,
        disassemble: bool,
        rpc: RpcOpts,
    },
    Codesize {
        block: Option<BlockId>,
        who: NameOrAddress,
        rpc: RpcOpts,
    },
    GasPrice {
        rpc: RpcOpts,
    },
    SigEvent {
        event_string: Option<String>,
    },
    Keccak {
        data: Option<String>,
    },
    HashMessage {
        message: Option<String>,
    },
    ResolveName {
        who: Option<String>,
        verify: bool,
        rpc: RpcOpts,
    },
    LookupAddress {
        who: Option<Address>,
        verify: bool,
        rpc: RpcOpts,
    },
    Storage(StorageArgs),
    Proof {
        address: NameOrAddress,
        slots: Vec<B256>,
        block: Option<BlockId>,
        rpc: RpcOpts,
    },
    Nonce {
        block: Option<BlockId>,
        who: NameOrAddress,
        rpc: RpcOpts,
    },
    Codehash {
        block: Option<BlockId>,
        who: NameOrAddress,
        slots: Vec<B256>,
        rpc: RpcOpts,
    },
    StorageRoot {
        block: Option<BlockId>,
        who: NameOrAddress,
        slots: Vec<B256>,
        rpc: RpcOpts,
    },
    Source {
        address: String,
        flatten: bool,
        directory: Option<PathBuf>,
        etherscan: EtherscanOpts,
        explorer_api_url: Option<String>,
        explorer_url: Option<String>,
    },
    Wallet {
        command: WalletSubcommands,
    },
    CreationCode(CreationCodeArgs),
    Artifact(ArtifactArgs),
    ConstructorArgs(ConstructorArgsArgs),
    Interface(InterfaceArgs),
    Bind(BindArgs),
    Sig {
        sig: Option<String>,
        optimize: Option<usize>,
    },
    Create2(Create2Args),
    FindBlock(FindBlockArgs),
    Completions {
        shell: Shell,
    },
    GenerateFigSpec,
    Run(RunArgs),
    Rpc(RpcArgs),
    FormatBytes32String {
        string: Option<String>,
    },
    ParseBytes32String {
        bytes: Option<String>,
    },
    ParseBytes32Address {
        bytes: Option<String>,
    },
    DecodeTransaction {
        tx: Option<String>,
    },
    Selectors {
        bytecode: Option<String>,
        resolve: bool,
    },
    DecodeEof {
        eof: Option<String>,
    },
    TxPool {
        command: TxPoolSubcommands,
    },
}

Variants

MaxInt

Prints the maximum value of the given integer type.

Fields

type: String

The integer type to get the maximum value of.

MinInt

Prints the minimum value of the given integer type.

Fields

type: String

The integer type to get the minimum value of.

MaxUint

Prints the maximum value of the given integer type.

Fields

type: String

The unsigned integer type to get the maximum value of.

AddressZero

Prints the zero address.

HashZero

Prints the zero hash.

FromUtf8

Convert UTF8 text to hex.

Fields

text: Option<String>

The text to convert.

ConcatHex

Concatenate hex strings.

Fields

data: Vec<String>

The data to concatenate.

FromBin

Convert binary data into hex data.

ToHexdata

Normalize the input to lowercase, 0x-prefixed hex.

The input can be:

• mixed case hex with or without 0x prefix
• 0x prefixed hex, concatenated with a ‘:’
• an absolute path to file
• @tag, where the tag is defined in an environment variable

Fields

input: Option<String>

The input to normalize.

ToCheckSumAddress

Convert an address to a checksummed format (EIP-55).

Fields

address: Option<Address>

The address to convert.

ToAscii

Convert hex data to an ASCII string.

Fields

hexdata: Option<String>

The hex data to convert.

ToUtf8

Convert hex data to a utf-8 string.

Fields

hexdata: Option<String>

The hex data to convert.

FromFixedPoint

Convert a fixed point number into an integer.

Fields

decimals: Option<String>

The number of decimals to use.

value: Option<String>

The value to convert.

ToBytes32

Right-pads hex data to 32 bytes.

Fields

bytes: Option<String>

The hex data to convert.

ToFixedPoint

Convert an integer into a fixed point number.

Fields

decimals: Option<String>

The number of decimals to use.

value: Option<String>

The value to convert.

ToUint256

Convert a number to a hex-encoded uint256.

Fields

value: Option<String>

The value to convert.

ToInt256

Convert a number to a hex-encoded int256.

Fields

value: Option<String>

The value to convert.

LeftShift

Perform a left shifting operation

Fields

value: String

The value to shift.

bits: String

The number of bits to shift.

base_in: Option<String>

The input base.

base_out: String

The output base.

RightShift

Perform a right shifting operation

Fields

value: String

The value to shift.

bits: String

The number of bits to shift.

base_in: Option<String>

The input base,

base_out: String

The output base,

ToUnit

Convert an ETH amount into another unit (ether, gwei or wei).

Examples:

• 1ether wei
• “1 ether” wei
• 1ether
• 1 gwei
• 1gwei ether

Fields

value: Option<String>

The value to convert.

unit: String

The unit to convert to (ether, gwei, wei).

ParseUnits

Convert a number from decimal to smallest unit with arbitrary decimals.

Examples:

• 1.0 6 (for USDC, result: 1000000)
• 2.5 12 (for 12 decimals token, result: 2500000000000)
• 1.23 3 (for 3 decimals token, result: 1230)

Fields

value: Option<String>

The value to convert.

unit: u8

The unit to convert to.

FormatUnits

Format a number from smallest unit to decimal with arbitrary decimals.

Examples:

• 1000000 6 (for USDC, result: 1.0)
• 2500000000000 12 (for 12 decimals, result: 2.5)
• 1230 3 (for 3 decimals, result: 1.23)

Fields

value: Option<String>

The value to format.

unit: u8

The unit to format to.

ToWei

Convert an ETH amount to wei.

Consider using –to-unit.

Fields

value: Option<String>

The value to convert.

unit: String

The unit to convert from (ether, gwei, wei).

FromWei

Convert wei into an ETH amount.

Consider using –to-unit.

Fields

value: Option<String>

The value to convert.

unit: String

The unit to convert from (ether, gwei, wei).

ToRlp

RLP encodes hex data, or an array of hex data.

Accepts a hex-encoded string, or an array of hex-encoded strings. Can be arbitrarily recursive.

Examples:

• cast to-rlp "[]" -> 0xc0
• cast to-rlp "0x22" -> 0x22
• cast to-rlp "[\"0x61\"]" -> 0xc161
• cast to-rlp "[\"0xf1\", \"f2\"]" -> 0xc481f181f2

Fields

value: Option<String>

The value to convert.

This is a hex-encoded string, or an array of hex-encoded strings. Can be arbitrarily recursive.

FromRlp

Decodes RLP hex-encoded data.

Fields

value: Option<String>

The RLP hex-encoded data.

as_int: bool

Decode the RLP data as int

ToHex(ToBaseArgs)

Converts a number of one base to another

ToDec(ToBaseArgs)

Converts a number of one base to decimal

ToBase

Converts a number of one base to another

Fields

base: ToBaseArgs

base_out: Option<String>

The output base.

AccessList(AccessListArgs)

Create an access list for a transaction.

Logs(LogsArgs)

Get logs by signature or topic.

Block

Get information about a block.

Fields

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

field: Option<String>

If specified, only get the given field of the block.

full: bool

rpc: RpcOpts

BlockNumber

Get the latest block number.

Fields

block: Option<BlockId>

The hash or tag to query. If not specified, the latest number is returned.

rpc: RpcOpts

Call(CallArgs)

Perform a call on an account without publishing a transaction.

CalldataEncode

ABI-encode a function with arguments.

Fields

sig: String

The function signature in the format <name>(<in-types>)(<out-types>)

args: Vec<String>

The arguments to encode.

Chain

Get the symbolic name of the current chain.

Fields

rpc: RpcOpts

ChainId

Get the Ethereum chain ID.

Fields

rpc: RpcOpts

Client

Get the current client version.

Fields

rpc: RpcOpts

ComputeAddress

Compute the contract address from a given nonce and deployer address.

Fields

address: Option<Address>

The deployer address.

nonce: Option<u64>

The nonce of the deployer address.

rpc: RpcOpts

Disassemble

Disassembles a hex-encoded bytecode into a human-readable representation.

Fields

bytecode: Option<String>

The hex-encoded bytecode.

MakeTx(MakeTxArgs)

Build and sign a transaction.

Namehash

Calculate the ENS namehash of a name.

Fields

name: Option<String>

Tx

Get information about a transaction.

Fields

tx_hash: String

The transaction hash.

field: Option<String>

If specified, only get the given field of the transaction. If “raw”, the RLP encoded transaction will be printed.

raw: bool

Print the raw RLP encoded transaction.

rpc: RpcOpts

Receipt

Get the transaction receipt for a transaction.

Fields

tx_hash: String

The transaction hash.

field: Option<String>

If specified, only get the given field of the transaction.

confirmations: u64

The number of confirmations until the receipt is fetched

cast_async: bool

Exit immediately if the transaction was not found.

rpc: RpcOpts

SendTx(SendTxArgs)

Sign and publish a transaction.

PublishTx

Publish a raw transaction to the network.

Fields

raw_tx: String

The raw transaction

cast_async: bool

Only print the transaction hash and exit immediately.

rpc: RpcOpts

Estimate(EstimateArgs)

Estimate the gas cost of a transaction.

DecodeCalldata

Decode ABI-encoded input data.

Similar to abi-decode --input, but function selector MUST be prefixed in calldata string

Fields

sig: String

The function signature in the format <name>(<in-types>)(<out-types>).

calldata: String

The ABI-encoded calldata.

DecodeString

Decode ABI-encoded string.

Similar to calldata-decode --input, but the function argument is a string

Fields

data: String

The ABI-encoded string.

DecodeEvent

Decode event data.

Fields

sig: Option<String>

The event signature. If none provided then tries to decode from local cache or https://api.openchain.xyz.

data: String

The event data to decode.

DecodeError

Decode custom error data.

Fields

sig: Option<String>

The error signature. If none provided then tries to decode from local cache or https://api.openchain.xyz.

data: String

The error data to decode.

DecodeAbi

Decode ABI-encoded input or output data.

Defaults to decoding output data. To decode input data pass –input.

When passing --input, function selector must NOT be prefixed in calldata string

Fields

sig: String

The function signature in the format <name>(<in-types>)(<out-types>).

calldata: String

The ABI-encoded calldata.

input: bool

Whether to decode the input or output data.

AbiEncode

ABI encode the given function argument, excluding the selector.

Fields

sig: String

The function signature.

packed: bool

Whether to use packed encoding.

args: Vec<String>

The arguments of the function.

Index

Compute the storage slot for an entry in a mapping.

Fields

key_type: String

The mapping key type.

key: String

The mapping key.

slot_number: String

The storage slot of the mapping.

IndexErc7201

Compute storage slots as specified by ERC-7201: Namespaced Storage Layout.

Fields

id: Option<String>

The arbitrary identifier.

formula_id: String

The formula ID. Currently the only supported formula is erc7201.

Implementation

Fetch the EIP-1967 implementation for a contract Can read from the implementation slot or the beacon slot.

Fields

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

beacon: bool

Fetch the implementation from the beacon slot.

If not specified, the implementation slot is used.

who: NameOrAddress

The address for which the implementation will be fetched.

rpc: RpcOpts

Admin

Fetch the EIP-1967 admin account

Fields

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

who: NameOrAddress

The address from which the admin account will be fetched.

rpc: RpcOpts

FourByte

Get the function signatures for the given selector from https://openchain.xyz.

Fields

selector: Option<String>

The function selector.

FourByteCalldata

Decode ABI-encoded calldata using https://openchain.xyz.

Fields

calldata: Option<String>

The ABI-encoded calldata.

FourByteEvent

Get the event signature for a given topic 0 from https://openchain.xyz.

Fields

topic: Option<String>

Topic 0

UploadSignature

Upload the given signatures to https://openchain.xyz.

Example inputs:

• “transfer(address,uint256)”
• “function transfer(address,uint256)”
• “function transfer(address,uint256)” “event Transfer(address,address,uint256)”
• “./out/Contract.sol/Contract.json”

Fields

signatures: Vec<String>

The signatures to upload.

Prefix with ‘function’, ‘event’, or ‘error’. Defaults to function if no prefix given. Can also take paths to contract artifact JSON.

PrettyCalldata

Pretty print calldata.

Tries to decode the calldata using https://openchain.xyz unless –offline is passed.

Fields

calldata: Option<String>

The calldata.

offline: bool

Skip the https://openchain.xyz lookup.

Age

Get the timestamp of a block.

Fields

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

rpc: RpcOpts

Balance

Get the balance of an account in wei.

Fields

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

who: NameOrAddress

The account to query.

ether: bool

Format the balance in ether.

rpc: RpcOpts

erc20: Option<Address>

erc20 address to query, with the method balanceOf(address) return (uint256), alias with ‘–erc721’

BaseFee

Get the basefee of a block.

Fields

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

rpc: RpcOpts

Code

Get the runtime bytecode of a contract.

Fields

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

who: NameOrAddress

The contract address.

disassemble: bool

Disassemble bytecodes.

rpc: RpcOpts

Codesize

Get the runtime bytecode size of a contract.

Fields

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

who: NameOrAddress

The contract address.

rpc: RpcOpts

GasPrice

Get the current gas price.

Fields

rpc: RpcOpts

SigEvent

Generate event signatures from event string.

Fields

event_string: Option<String>

The event string.

Keccak

Hash arbitrary data using Keccak-256.

Fields

data: Option<String>

The data to hash.

HashMessage

Hash a message according to EIP-191.

Fields

message: Option<String>

The message to hash.

ResolveName

Perform an ENS lookup.

Fields

who: Option<String>

The name to lookup.

verify: bool

Perform a reverse lookup to verify that the name is correct.

rpc: RpcOpts

LookupAddress

Perform an ENS reverse lookup.

Fields

who: Option<Address>

The account to perform the lookup for.

verify: bool

Perform a normal lookup to verify that the address is correct.

rpc: RpcOpts

Storage(StorageArgs)

Get the raw value of a contract’s storage slot.

Proof

Generate a storage proof for a given storage slot.

Fields

address: NameOrAddress

The contract address.

slots: Vec<B256>

The storage slot numbers (hex or decimal).

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

rpc: RpcOpts

Nonce

Get the nonce for an account.

Fields

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

who: NameOrAddress

The address to get the nonce for.

rpc: RpcOpts

Codehash

Get the codehash for an account.

Fields

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

who: NameOrAddress

The address to get the codehash for.

slots: Vec<B256>

The storage slot numbers (hex or decimal).

rpc: RpcOpts

StorageRoot

Get the storage root for an account.

Fields

block: Option<BlockId>

The block height to query at.

Can also be the tags earliest, finalized, safe, latest, or pending.

who: NameOrAddress

The address to get the storage root for.

slots: Vec<B256>

The storage slot numbers (hex or decimal).

rpc: RpcOpts

Source

Get the source code of a contract from a block explorer.

Fields

address: String

The contract’s address.

flatten: bool

Whether to flatten the source code.

directory: Option<PathBuf>

The output directory/file to expand source tree into.

etherscan: EtherscanOpts

explorer_api_url: Option<String>

Alternative explorer API URL to use that adheres to the Etherscan API. If not provided, defaults to Etherscan.

explorer_url: Option<String>

Alternative explorer browser URL.

Wallet

Wallet management utilities.

Fields

command: WalletSubcommands

CreationCode(CreationCodeArgs)

Download a contract creation code from Etherscan and RPC.

Artifact(ArtifactArgs)

Generate an artifact file, that can be used to deploy a contract locally.

ConstructorArgs(ConstructorArgsArgs)

Display constructor arguments used for the contract initialization.

Interface(InterfaceArgs)

Generate a Solidity interface from a given ABI.

Currently does not support ABI encoder v2.

Bind(BindArgs)

Generate a rust binding from a given ABI.

Sig

Get the selector for a function.

Fields

sig: Option<String>

The function signature, e.g. transfer(address,uint256).

optimize: Option<usize>

Optimize signature to contain provided amount of leading zeroes in selector.

Create2(Create2Args)

Generate a deterministic contract address using CREATE2.

FindBlock(FindBlockArgs)

Get the block number closest to the provided timestamp.

Completions

Generate shell completions script.

Fields

shell: Shell

GenerateFigSpec

Generate Fig autocompletion spec.

Run(RunArgs)

Runs a published transaction in a local environment and prints the trace.

Rpc(RpcArgs)

Perform a raw JSON-RPC request.

FormatBytes32String

Formats a string into bytes32 encoding.

Fields

string: Option<String>

The string to format.

ParseBytes32String

Parses a string from bytes32 encoding.

Fields

bytes: Option<String>

The string to parse.

ParseBytes32Address

Fields

bytes: Option<String>

DecodeTransaction

Decodes a raw signed EIP 2718 typed transaction

Fields

tx: Option<String>

Selectors

Extracts function selectors and arguments from bytecode

Fields

bytecode: Option<String>

The hex-encoded bytecode.

resolve: bool

Resolve the function signatures for the extracted selectors using https://openchain.xyz

DecodeEof

Decodes EOF container bytes

Fields

eof: Option<String>

TxPool

Inspect the TxPool of a node.

Fields

command: TxPoolSubcommands

Trait Implementations

impl FromArgMatches for CastSubcommand

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for CastSubcommand

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand

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

Size for each variant:

• MaxInt: 32 bytes
• MinInt: 32 bytes
• MaxUint: 32 bytes
• AddressZero: 0 bytes
• HashZero: 0 bytes
• FromUtf8: 32 bytes
• ConcatHex: 32 bytes
• FromBin: 0 bytes
• ToHexdata: 32 bytes
• ToCheckSumAddress: 29 bytes
• ToAscii: 32 bytes
• ToUtf8: 32 bytes
• FromFixedPoint: 56 bytes
• ToBytes32: 32 bytes
• ToFixedPoint: 56 bytes
• ToUint256: 32 bytes
• ToInt256: 32 bytes
• LeftShift: 104 bytes
• RightShift: 104 bytes
• ToUnit: 56 bytes
• ParseUnits: 40 bytes
• FormatUnits: 40 bytes
• ToWei: 56 bytes
• FromWei: 56 bytes
• ToRlp: 32 bytes
• FromRlp: 40 bytes
• ToHex: 56 bytes
• ToDec: 56 bytes
• ToBase: 80 bytes
• AccessList: 888 bytes
• Logs: 544 bytes
• Block: 176 bytes
• BlockNumber: 144 bytes
• Call: 1048 bytes
• CalldataEncode: 56 bytes
• Chain: 104 bytes
• ChainId: 104 bytes
• Client: 104 bytes
• ComputeAddress: 144 bytes
• Disassemble: 32 bytes
• MakeTx: 952 bytes
• Namehash: 32 bytes
• Tx: 160 bytes
• Receipt: 168 bytes
• SendTx: 976 bytes
• PublishTx: 136 bytes
• Estimate: 1000 bytes
• DecodeCalldata: 56 bytes
• DecodeString: 32 bytes
• DecodeEvent: 56 bytes
• DecodeError: 56 bytes
• DecodeAbi: 64 bytes
• AbiEncode: 64 bytes
• Index: 80 bytes
• IndexErc7201: 56 bytes
• Implementation: 184 bytes
• Admin: 176 bytes
• FourByte: 32 bytes
• FourByteCalldata: 32 bytes
• FourByteEvent: 32 bytes
• UploadSignature: 32 bytes
• PrettyCalldata: 40 bytes
• Age: 144 bytes
• Balance: 200 bytes
• BaseFee: 144 bytes
• Code: 184 bytes
• Codesize: 176 bytes
• GasPrice: 104 bytes
• SigEvent: 32 bytes
• Keccak: 32 bytes
• HashMessage: 32 bytes
• ResolveName: 136 bytes
• LookupAddress: 128 bytes
• Storage: 696 bytes
• Proof: 200 bytes
• Nonce: 176 bytes
• Codehash: 200 bytes
• StorageRoot: 200 bytes
• Source: 152 bytes
• Wallet: 392 bytes
• CreationCode: 192 bytes
• Artifact: 216 bytes
• ConstructorArgs: 192 bytes
• Interface: 144 bytes
• Bind: 152 bytes
• Sig: 48 bytes
• Create2: 248 bytes
• FindBlock: 112 bytes
• Completions: 9 bytes
• GenerateFigSpec: 0 bytes
• Run: 224 bytes
• Rpc: 160 bytes
• FormatBytes32String: 32 bytes
• ParseBytes32String: 32 bytes
• ParseBytes32Address: 32 bytes
• DecodeTransaction: 32 bytes
• Selectors: 40 bytes
• DecodeEof: 32 bytes
• TxPool: 128 bytes