State

Introduction

The state contains all information that is preserved between transactions.

It consists of a main account trie and storage tries for each contract.

There is a distinction between an account that does not exist and EMPTY_ACCOUNT.

Module Contents

Classes

State

Contains all information that is preserved between transactions.

Functions

close_state

Free resources held by the state. Used by optimized implementations to

begin_transaction

Start a state transaction.

commit_transaction

Commit a state transaction.

rollback_transaction

Rollback a state transaction, resetting the state to the point when the

get_account

Get the Account object at an address. Returns EMPTY_ACCOUNT if there

get_account_optional

Get the Account object at an address. Returns None (rather than

set_account

Set the Account object at an address. Setting to None deletes

destroy_account

Completely remove the account at address and all of its storage.

destroy_storage

Completely remove the storage at address.

get_storage

Get a value at a storage key on an account. Returns U256(0) if the

set_storage

Set a value at a storage key on an account. Setting to U256(0) deletes

storage_root

Calculate the storage root of an account.

state_root

Calculate the state root.

account_exists

Checks if an account exists in the state trie

account_has_code_or_nonce

Checks if an account has non zero nonce or non empty code

is_account_empty

Checks if an account has zero nonce, empty code and zero balance.

account_exists_and_is_empty

Checks if an account exists and has zero nonce, empty code and zero

is_account_alive

Check whether is an account is both in the state and non empty.

modify_state

Modify an Account in the State.

move_ether

Move funds between accounts.

set_account_balance

Sets the balance of an account.

touch_account

Initializes an account to state.

increment_nonce

Increments the nonce of an account.

set_code

Sets Account code.

create_ether

Add newly created ether to an account.

get_storage_original

Get the original value in a storage slot i.e. the value before the current

Module Details

State

Contains all information that is preserved between transactions.

class State
_main_trie :ethereum.constantinople.trie.Trie[ethereum.constantinople.eth_types.Address, Optional[ethereum.constantinople.eth_types.Account]]:ethereum.istanbul.trie.Trie[ethereum.istanbul.eth_types.Address, Optional[ethereum.istanbul.eth_types.Account]]
_storage_tries :Dict[ethereum.constantinople.eth_types.Address, ethereum.constantinople.trie.Trie[ethereum.base_types.Bytes,:Dict[ethereum.istanbul.eth_types.Address, ethereum.istanbul.trie.Trie[ethereum.base_types.Bytes, ethereum.base_types.U256]]
_snapshots :List[Tuple[ethereum.constantinople.trie.Trie[ethereum.constantinople.eth_types.Address, Optional[ethereum.constantinople.eth_types.Account]], Dict[ethereum.constantinople.eth_types.Address, ethereum.constantinople.trie.Trie[ethereum.base_types.Bytes,:List[Tuple[ethereum.istanbul.trie.Trie[ethereum.istanbul.eth_types.Address, Optional[ethereum.istanbul.eth_types.Account]], Dict[ethereum.istanbul.eth_types.Address, ethereum.istanbul.trie.Trie[ethereum.base_types.Bytes, ethereum.base_types.U256]]]]

close_state

close_state(state)

Free resources held by the state. Used by optimized implementations to release file descriptors.

def close_state(state: State) -> None:
    del state._main_trie
    del state._storage_tries
    del state._snapshots

begin_transaction

begin_transaction(state)

Start a state transaction.

Transactions are entirely implicit and can be nested. It is not possible to calculate the state root during a transaction.

Parameters

state (State) – The state.

def begin_transaction(state: State) -> None:
    state._snapshots.append(
        (
            copy_trie(state._main_trie),
            {k: copy_trie(t) for (k, t) in state._storage_tries.items()},
        )
    )

commit_transaction

commit_transaction(state)

Commit a state transaction.

Parameters

state (State) – The state.

def commit_transaction(state: State) -> None:
    state._snapshots.pop()

rollback_transaction

rollback_transaction(state)

Rollback a state transaction, resetting the state to the point when the corresponding start_transaction() call was made.

Parameters

state (State) – The state.

def rollback_transaction(state: State) -> None:
    state._main_trie, state._storage_tries = state._snapshots.pop()

get_account

get_account(state, address)

Get the Account object at an address. Returns EMPTY_ACCOUNT if there is no account at the address.

Use get_account_optional() if you care about the difference between a non-existent account and EMPTY_ACCOUNT.

Parameters
  • state (State) – The state

  • address (Address) – Address to lookup.

Returns

account – Account at address.

Return type

Account

def get_account(state: State, address: Address) -> Account:
    account = get_account_optional(state, address)
    if isinstance(account, Account):
        return account
    else:
        return EMPTY_ACCOUNT

get_account_optional

get_account_optional(state, address)

Get the Account object at an address. Returns None (rather than EMPTY_ACCOUNT) if there is no account at the address.

Parameters
  • state (State) – The state

  • address (Address) – Address to lookup.

Returns

account – Account at address.

Return type

Account

def get_account_optional(state: State, address: Address) -> Optional[Account]:
    account = trie_get(state._main_trie, address)
    return account

set_account

set_account(state, address, account)

Set the Account object at an address. Setting to None deletes the account (but not its storage, see destroy_account()).

Parameters
  • state (State) – The state

  • address (Address) – Address to set.

  • account (Account) – Account to set at address.

def set_account(
    state: State, address: Address, account: Optional[Account]
) -> None:
    trie_set(state._main_trie, address, account)

destroy_account

destroy_account(state, address)

Completely remove the account at address and all of its storage.

This function is made available exclusively for the SELFDESTRUCT opcode. It is expected that SELFDESTRUCT will be disabled in a future hardfork and this function will be removed.

Parameters
  • state (State) – The state

  • address (Address) – Address of account to destroy.

def destroy_account(state: State, address: Address) -> None:
    destroy_storage(state, address)
    set_account(state, address, None)

destroy_storage

destroy_storage(state, address)

Completely remove the storage at address.

Parameters
  • state (State) – The state

  • address (Address) – Address of account whose storage is to be deleted.

def destroy_storage(state: State, address: Address) -> None:
    if address in state._storage_tries:
        del state._storage_tries[address]

get_storage

get_storage(state, address, key)

Get a value at a storage key on an account. Returns U256(0) if the storage key has not been set previously.

Parameters
  • state (State) – The state

  • address (Address) – Address of the account.

  • key (Bytes) – Key to lookup.

Returns

value – Value at the key.

Return type

U256

def get_storage(state: State, address: Address, key: Bytes) -> U256:
    trie = state._storage_tries.get(address)
    if trie is None:
        return U256(0)

    value = trie_get(trie, key)

    assert isinstance(value, U256)
    return value

set_storage

set_storage(state, address, key, value)

Set a value at a storage key on an account. Setting to U256(0) deletes the key.

Parameters
  • state (State) – The state

  • address (Address) – Address of the account.

  • key (Bytes) – Key to set.

  • value (U256) – Value to set at the key.

def set_storage(
    state: State, address: Address, key: Bytes, value: U256
) -> None:
    assert trie_get(state._main_trie, address) is not None

    trie = state._storage_tries.get(address)
    if trie is None:
        trie = Trie(secured=True, default=U256(0))
        state._storage_tries[address] = trie
    trie_set(trie, key, value)
    if trie._data == {}:
        del state._storage_tries[address]

storage_root

storage_root(state, address)

Calculate the storage root of an account.

Parameters
  • state – The state

  • address – Address of the account.

Returns

root – Storage root of the account.

Return type

Root

def storage_root(state: State, address: Address) -> Root:
    assert state._snapshots == []
    if address in state._storage_tries:
        return root(state._storage_tries[address])
    else:
        return EMPTY_TRIE_ROOT

state_root

state_root(state)

Calculate the state root.

Parameters

state – The current state.

Returns

root – The state root.

Return type

Root

def state_root(state: State) -> Root:
    assert state._snapshots == []

    def get_storage_root(address: Address) -> Root:
        return storage_root(state, address)

    return root(state._main_trie, get_storage_root=get_storage_root)

account_exists

account_exists(state, address)

Checks if an account exists in the state trie

Parameters
  • state – The state

  • address – Address of the account that needs to be checked.

Returns

account_exists – True if account exists in the state trie, False otherwise

Return type

bool

def account_exists(state: State, address: Address) -> bool:
    return get_account_optional(state, address) is not None

account_has_code_or_nonce

account_has_code_or_nonce(state, address)

Checks if an account has non zero nonce or non empty code

Parameters
  • state – The state

  • address – Address of the account that needs to be checked.

Returns

has_code_or_nonce – True if if an account has non zero nonce or non empty code, False otherwise.

Return type

bool

def account_has_code_or_nonce(state: State, address: Address) -> bool:
    account = get_account(state, address)
    return account.nonce != Uint(0) or account.code != b""

is_account_empty

is_account_empty(state, address)

Checks if an account has zero nonce, empty code and zero balance.

Parameters
  • state – The state

  • address – Address of the account that needs to be checked.

Returns

is_empty – True if if an account has zero nonce, empty code and zero balance, False otherwise.

Return type

bool

def is_account_empty(state: State, address: Address) -> bool:
    account = get_account(state, address)
    return (
        account.nonce == Uint(0)
        and account.code == b""
        and account.balance == 0
    )

account_exists_and_is_empty

account_exists_and_is_empty(state, address)

Checks if an account exists and has zero nonce, empty code and zero balance.

Parameters
  • state – The state

  • address – Address of the account that needs to be checked.

Returns

exists_and_is_empty – True if an account exists and has zero nonce, empty code and zero balance, False otherwise.

Return type

bool

def account_exists_and_is_empty(state: State, address: Address) -> bool:
    account = get_account_optional(state, address)
    return (
        account is not None
        and account.nonce == Uint(0)
        and account.code == b""
        and account.balance == 0
    )

is_account_alive

is_account_alive(state, address)

Check whether is an account is both in the state and non empty.

Parameters
  • state – The state

  • address – Address of the account that needs to be checked.

Returns

is_alive – True if the account is alive.

Return type

bool

def is_account_alive(state: State, address: Address) -> bool:
    account = get_account_optional(state, address)
    if account is None:
        return False
    else:
        return not (
            account.nonce == Uint(0)
            and account.code == b""
            and account.balance == 0
        )

modify_state

modify_state(state, address, f)

Modify an Account in the State.

def modify_state(
    state: State, address: Address, f: Callable[[Account], None]
) -> None:
    set_account(state, address, modify(get_account(state, address), f))

move_ether

move_ether(state, sender_address, recipient_address, amount)

Move funds between accounts.

def move_ether(
    state: State,
    sender_address: Address,
    recipient_address: Address,
    amount: U256,
) -> None:

    def reduce_sender_balance(sender: Account) -> None:
        ensure(sender.balance >= amount, AssertionError)
        sender.balance -= amount

    def increase_recipient_balance(recipient: Account) -> None:
        recipient.balance += amount

    modify_state(state, sender_address, reduce_sender_balance)
    modify_state(state, recipient_address, increase_recipient_balance)

set_account_balance

set_account_balance(state, address, amount)

Sets the balance of an account.

Parameters
  • state – The current state.

  • address – Address of the account whose nonce needs to be incremented.

  • amount – The amount that needs to set in balance.

def set_account_balance(state: State, address: Address, amount: U256) -> None:

    def set_balance(account: Account) -> None:
        account.balance = amount

    modify_state(state, address, set_balance)

touch_account

touch_account(state, address)

Initializes an account to state.

Parameters
  • state – The current state.

  • address – The address of the account that need to initialised.

def touch_account(state: State, address: Address) -> None:
    if not account_exists(state, address):
        set_account(state, address, EMPTY_ACCOUNT)

increment_nonce

increment_nonce(state, address)

Increments the nonce of an account.

Parameters
  • state – The current state.

  • address – Address of the account whose nonce needs to be incremented.

def increment_nonce(state: State, address: Address) -> None:

    def increase_nonce(sender: Account) -> None:
        sender.nonce += 1

    modify_state(state, address, increase_nonce)

set_code

set_code(state, address, code)

Sets Account code.

Parameters
  • state – The current state.

  • address – Address of the account whose code needs to be update.

  • code – The bytecode that needs to be set.

def set_code(state: State, address: Address, code: Bytes) -> None:

    def write_code(sender: Account) -> None:
        sender.code = code

    modify_state(state, address, write_code)

create_ether

create_ether(state, address, amount)

Add newly created ether to an account.

Parameters
  • state – The current state.

  • address – Address of the account to which ether is added.

  • amount – The amount of ether to be added to the account of interest.

def create_ether(state: State, address: Address, amount: U256) -> None:

    def increase_balance(account: Account) -> None:
        account.balance += amount

    modify_state(state, address, increase_balance)

get_storage_original

get_storage_original(state, address, key)

Get the original value in a storage slot i.e. the value before the current transaction began. This function reads the value from the snapshots taken before executing the transaction.

Parameters
  • state – The current state.

  • address – Address of the account to read the value from.

  • key – Key of the storage slot.

def get_storage_original(state: State, address: Address, key: Bytes) -> U256:
    _, original_trie = state._snapshots[0]
    original_account_trie = original_trie.get(address)

    if original_account_trie is None:
        original_value = U256(0)
    else:
        original_value = trie_get(original_account_trie, key)

    assert isinstance(original_value, U256)

    return original_value