Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

state

package

Go to main page

Versions in this module

v1

v1.0.4

Sep 26, 2025

Changes in this version

+ const AccessWitnessReadFlag

+ const AccessWitnessWriteFlag

+ const TriesInMemory

+ func NewHookedState(stateDb *StateDB, hooks *tracing.Hooks) *hookedStateDB

+ type AccessEvents struct

+ func NewAccessEvents(pointCache *utils.PointCache) *AccessEvents

+ func (ae *AccessEvents) AddAccount(addr common.Address, isWrite bool) uint64

+ func (ae *AccessEvents) AddTxDestination(addr common.Address, sendsValue bool)

+ func (ae *AccessEvents) AddTxOrigin(originAddr common.Address)

+ func (ae *AccessEvents) BasicDataGas(addr common.Address, isWrite bool) uint64

+ func (ae *AccessEvents) CodeChunksRangeGas(contractAddr common.Address, startPC, size uint64, codeLen uint64, ...) uint64

+ func (ae *AccessEvents) CodeHashGas(addr common.Address, isWrite bool) uint64

+ func (ae *AccessEvents) ContractCreateInitGas(addr common.Address) uint64

+ func (ae *AccessEvents) ContractCreatePreCheckGas(addr common.Address) uint64

+ func (ae *AccessEvents) Copy() *AccessEvents

+ func (ae *AccessEvents) Keys() [][]byte

+ func (ae *AccessEvents) Merge(other *AccessEvents)

+ func (ae *AccessEvents) MessageCallGas(destination common.Address) uint64

+ func (ae *AccessEvents) SlotGas(addr common.Address, slot common.Hash, isWrite bool) uint64

+ func (ae *AccessEvents) ValueTransferGas(callerAddr, targetAddr common.Address) uint64

+ type CachingDB struct

+ func NewDatabaseForTesting() *CachingDB

+ func (db *CachingDB) ContractCodeWithPrefix(address common.Address, codeHash common.Hash) []byte

+ func (db *CachingDB) NoTries() bool

+ func (db *CachingDB) OpenStorageTrie(stateRoot common.Hash, address common.Address, root common.Hash, self Trie) (Trie, error)

+ func (db *CachingDB) OpenTrie(root common.Hash) (Trie, error)

+ func (db *CachingDB) PointCache() *utils.PointCache

+ func (db *CachingDB) Reader(stateRoot common.Hash) (Reader, error)

+ func (db *CachingDB) Snapshot() *snapshot.Tree

+ func (db *CachingDB) TrieDB() *triedb.Database

+ type ContractCodeReader interface

+ Code func(addr common.Address, codeHash common.Hash) ([]byte, error)

+ CodeSize func(addr common.Address, codeHash common.Hash) (int, error)

type Database

+ NoTries func() bool

+ PointCache func() *utils.PointCache

+ Reader func(root common.Hash) (Reader, error)

+ Snapshot func() *snapshot.Tree

type Dump

+ Next []byte

type DumpAccount

+ AddressHash hexutil.Bytes

+ type DumpConfig struct

+ Max uint64

+ OnlyWithAddresses bool

+ SkipCode bool

+ SkipStorage bool

+ Start []byte

+ StateScheme string

+ type Reader interface

type StateDB

+ AccountDeleted int

+ AccountLoaded int

+ AccountUpdated int

+ StorageDeleted atomic.Int64

+ StorageLoaded int

+ StorageUpdated atomic.Int64

+ TrieDBCommits time.Duration

+ func NewWithSharedPool(root common.Hash, db Database) (*StateDB, error)

+ func (s *StateDB) AccessEvents() *AccessEvents

+ func (s *StateDB) ClearAccessList()

+ func (s *StateDB) CopyDoPrefetch() *StateDB

+ func (s *StateDB) CreateContract(addr common.Address)

+ func (s *StateDB) EnableWriteOnSharedStorage()

+ func (s *StateDB) GetRoot(addr common.Address) common.Hash

+ func (s *StateDB) GetSnap() snapshot.Snapshot

+ func (s *StateDB) GetStorage(address common.Address) *sync.Map

+ func (s *StateDB) GetStorageRoot(addr common.Address) common.Hash

+ func (s *StateDB) GetTransientState(addr common.Address, key common.Hash) common.Hash

+ func (s *StateDB) GetTrie() Trie

+ func (s *StateDB) HasSelfDestructed(addr common.Address) bool

+ func (s *StateDB) MarkFullProcessed()

+ func (s *StateDB) NoTrie() bool

+ func (s *StateDB) PointCache() *utils.PointCache

+ func (s *StateDB) SelfDestruct(addr common.Address) uint256.Int

+ func (s *StateDB) SelfDestruct6780(addr common.Address) (uint256.Int, bool)

+ func (s *StateDB) SetExpectedStateRoot(root common.Hash)

+ func (s *StateDB) SetTransientState(addr common.Address, key, value common.Hash)

+ func (s *StateDB) SetTxContext(thash common.Hash, ti int)

+ func (s *StateDB) TransferPrefetcher(prev *StateDB)

+ func (s *StateDB) TriePrefetchInAdvance(block *types.Block, signer types.Signer)

+ func (s *StateDB) Witness() *stateless.Witness

+ type StateReader interface

+ Account func(addr common.Address) (*types.StateAccount, error)

+ Storage func(addr common.Address, slot common.Hash) (common.Hash, error)

+ type StoragePool struct

+ func NewStoragePool() *StoragePool

type Trie

+ DeleteAccount func(address common.Address) error

+ DeleteStorage func(addr common.Address, key []byte) error

+ GetAccount func(address common.Address) (*types.StateAccount, error)

+ GetStorage func(addr common.Address, key []byte) ([]byte, error)

+ IsVerkle func() bool

+ UpdateAccount func(address common.Address, account *types.StateAccount, codeLen int) error

+ UpdateContractCode func(address common.Address, codeHash common.Hash, code []byte) error

+ UpdateStorage func(addr common.Address, key, value []byte) error

+ Witness func() map[string]struct{}

v1.0.3

Aug 5, 2025

v1.0.2

Apr 9, 2025

Changes in this version

+ func NewStateSync(root common.Hash, database ethdb.KeyValueReader, bloom *trie.SyncBloom, ...) *trie.Sync

+ type Account struct

+ Balance *big.Int

+ CodeHash []byte

+ LockBalance *big.Int

+ Nonce uint64

+ Root common.Hash

+ type Code []byte

+ func (c Code) String() string

+ type Database interface

+ CacheAccount func(root common.Hash, t Trie)

+ CacheStorage func(addrHash common.Hash, root common.Hash, t Trie)

+ ContractCode func(addrHash, codeHash common.Hash) ([]byte, error)

+ ContractCodeSize func(addrHash, codeHash common.Hash) (int, error)

+ CopyTrie func(Trie) Trie

+ OpenStorageTrie func(addrHash, root common.Hash) (Trie, error)

+ OpenTrie func(root common.Hash) (Trie, error)

+ Purge func()

+ TrieDB func() *trie.Database

+ func NewDatabase(db ethdb.Database) Database

+ func NewDatabaseWithConfig(db ethdb.Database, config *trie.Config) Database

+ func NewDatabaseWithConfigAndCache(db ethdb.Database, config *trie.Config) Database

+ type Dump struct

+ Accounts map[common.Address]DumpAccount

+ Root string

+ func (d *Dump) OnAccount(addr common.Address, account DumpAccount)

+ func (d *Dump) OnRoot(root common.Hash)

+ type DumpAccount struct

+ Address *common.Address

+ Balance string

+ Code string

+ CodeHash string

+ LockBalance string

+ Nonce uint64

+ Root string

+ SecureKey hexutil.Bytes

+ Storage map[common.Hash]string

+ type DumpCollector interface

+ OnAccount func(common.Address, DumpAccount)

+ OnRoot func(common.Hash)

+ type IteratorDump struct

+ Accounts map[common.Address]DumpAccount

+ Next []byte

+ Root string

+ func (d *IteratorDump) OnAccount(addr common.Address, account DumpAccount)

+ func (d *IteratorDump) OnRoot(root common.Hash)

+ type NodeIterator struct

+ Error error

+ Hash common.Hash

+ Parent common.Hash

+ func NewNodeIterator(state *StateDB) *NodeIterator

+ func (it *NodeIterator) Next() bool

+ type StateDB struct

+ AccountCommits time.Duration

+ AccountHashes time.Duration

+ AccountReads time.Duration

+ AccountUpdates time.Duration

+ MetricsMux sync.Mutex

+ SnapshotAccountReads time.Duration

+ SnapshotCommits time.Duration

+ SnapshotStorageReads time.Duration

+ StorageCommits time.Duration

+ StorageHashes time.Duration

+ StorageReads time.Duration

+ StorageUpdates time.Duration

+ func New(root common.Hash, db Database, snaps *snapshot.Tree) (*StateDB, error)

+ func (db *StateDB) ForEachStorage(addr common.Address, cb func(key, value common.Hash) bool) error

+ func (s *StateDB) AddAddressToAccessList(addr common.Address)

+ func (s *StateDB) AddBalance(addr common.Address, amount *big.Int)

+ func (s *StateDB) AddLockBalance(addr common.Address, amount *big.Int)

+ func (s *StateDB) AddLog(log *types.Log)

+ func (s *StateDB) AddPreimage(hash common.Hash, preimage []byte)

+ func (s *StateDB) AddRefund(gas uint64)

+ func (s *StateDB) AddSlotToAccessList(addr common.Address, slot common.Hash)

+ func (s *StateDB) AddressInAccessList(addr common.Address) bool

+ func (s *StateDB) BlockHash() common.Hash

+ func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error)

+ func (s *StateDB) Copy() *StateDB

+ func (s *StateDB) CreateAccount(addr common.Address)

+ func (s *StateDB) Database() Database

+ func (s *StateDB) Dump(excludeCode, excludeStorage, excludeMissingPreimages bool) []byte

+ func (s *StateDB) DumpToCollector(c DumpCollector, excludeCode, excludeStorage, excludeMissingPreimages bool, ...) (nextKey []byte)

+ func (s *StateDB) Empty(addr common.Address) bool

+ func (s *StateDB) Erase(addr common.Address) bool

+ func (s *StateDB) Error() error

+ func (s *StateDB) Exist(addr common.Address) bool

+ func (s *StateDB) Finalise(deleteEmptyObjects bool)

+ func (s *StateDB) GetBalance(addr common.Address) *big.Int

+ func (s *StateDB) GetCode(addr common.Address) []byte

+ func (s *StateDB) GetCodeHash(addr common.Address) common.Hash

+ func (s *StateDB) GetCodeSize(addr common.Address) int

+ func (s *StateDB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash

+ func (s *StateDB) GetLockBalance(addr common.Address) *big.Int

+ func (s *StateDB) GetLogs(hash common.Hash) []*types.Log

+ func (s *StateDB) GetNonce(addr common.Address) uint64

+ func (s *StateDB) GetOrNewStateObject(addr common.Address) *StateObject

+ func (s *StateDB) GetProof(addr common.Address) ([][]byte, error)

+ func (s *StateDB) GetProofByHash(addrHash common.Hash) ([][]byte, error)

+ func (s *StateDB) GetRefund() uint64

+ func (s *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash

+ func (s *StateDB) GetStorageProof(a common.Address, key common.Hash) ([][]byte, error)

+ func (s *StateDB) GetStorageProofByHash(a common.Address, key common.Hash) ([][]byte, error)

+ func (s *StateDB) HasSuicided(addr common.Address) bool

+ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash

+ func (s *StateDB) IterativeDump(excludeCode, excludeStorage, excludeMissingPreimages bool, ...)

+ func (s *StateDB) IteratorDump(excludeCode, excludeStorage, excludeMissingPreimages bool, start []byte, ...) IteratorDump

+ func (s *StateDB) Logs() []*types.Log

+ func (s *StateDB) Preimages() map[common.Hash][]byte

+ func (s *StateDB) Prepare(thash, bhash common.Hash, ti int)

+ func (s *StateDB) PrepareAccessList(sender common.Address, dst *common.Address, precompiles []common.Address, ...)

+ func (s *StateDB) RawDump(excludeCode, excludeStorage, excludeMissingPreimages bool) Dump

+ func (s *StateDB) RevertToSnapshot(revid int)

+ func (s *StateDB) SetBalance(addr common.Address, amount *big.Int)

+ func (s *StateDB) SetCode(addr common.Address, code []byte)

+ func (s *StateDB) SetLockBalance(addr common.Address, amount *big.Int)

+ func (s *StateDB) SetNonce(addr common.Address, nonce uint64)

+ func (s *StateDB) SetState(addr common.Address, key, value common.Hash)

+ func (s *StateDB) SetStateObject(object *StateObject)

+ func (s *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common.Hash)

+ func (s *StateDB) SlotInAccessList(addr common.Address, slot common.Hash) (addressPresent bool, slotPresent bool)

+ func (s *StateDB) Snapshot() int

+ func (s *StateDB) StartPrefetcher(namespace string)

+ func (s *StateDB) StopPrefetcher()

+ func (s *StateDB) StorageTrie(addr common.Address) Trie

+ func (s *StateDB) SubBalance(addr common.Address, amount *big.Int)

+ func (s *StateDB) SubLockBalance(addr common.Address, amount *big.Int)

+ func (s *StateDB) SubRefund(gas uint64)

+ func (s *StateDB) Suicide(addr common.Address) bool

+ func (s *StateDB) TryPreload(block *types.Block, signer types.Signer)

+ func (s *StateDB) TxIndex() int

+ type StateObject struct

+ func (s *StateObject) AddBalance(amount *big.Int)

+ func (s *StateObject) AddLockBalance(amount *big.Int)

+ func (s *StateObject) Address() common.Address

+ func (s *StateObject) Balance() *big.Int

+ func (s *StateObject) Code(db Database) []byte

+ func (s *StateObject) CodeHash() []byte

+ func (s *StateObject) CodeSize(db Database) int

+ func (s *StateObject) CommitTrie(db Database) error

+ func (s *StateObject) EncodeRLP(w io.Writer) error

+ func (s *StateObject) GetCommittedState(db Database, key common.Hash) common.Hash

+ func (s *StateObject) GetState(db Database, key common.Hash) common.Hash

+ func (s *StateObject) LockBalance() *big.Int

+ func (s *StateObject) Nonce() uint64

+ func (s *StateObject) ReturnGas(gas *big.Int)

+ func (s *StateObject) SetBalance(amount *big.Int)

+ func (s *StateObject) SetCode(codeHash common.Hash, code []byte)

+ func (s *StateObject) SetLockBalance(amount *big.Int)

+ func (s *StateObject) SetNonce(nonce uint64)

+ func (s *StateObject) SetState(db Database, key, value common.Hash)

+ func (s *StateObject) SetStorage(storage map[common.Hash]common.Hash)

+ func (s *StateObject) SubBalance(amount *big.Int)

+ func (s *StateObject) SubLockBalance(amount *big.Int)

+ func (s *StateObject) Value() *big.Int

+ type Storage map[common.Hash]common.Hash

+ func (s Storage) Copy() Storage

+ func (s Storage) String() (str string)

+ type Trie interface

+ Commit func(onleaf trie.LeafCallback) (common.Hash, error)

+ GetKey func([]byte) []byte

+ Hash func() common.Hash

+ NodeIterator func(startKey []byte) trie.NodeIterator

+ Prove func(key []byte, fromLevel uint, proofDb ethdb.KeyValueWriter) error

+ TryDelete func(key []byte) error

+ TryGet func(key []byte) ([]byte, error)

+ TryUpdate func(key, value []byte) error