acmstate

type AccountGetter interface {
	// Get an account by its address return nil if it does not exist (which should not be an error)
	GetAccount(address crypto.Address) (*acm.Account, error)
}

type AccountIterable interface {
	// Iterates through accounts calling passed function once per account, if the consumer
	// returns true the iteration breaks and returns true to indicate it iteration
	// was escaped
	IterateAccounts(consumer func(*acm.Account) error) (err error)
}

type AccountStats struct {
	AccountsWithCode    uint64
	AccountsWithoutCode uint64
}

type AccountStatsGetter interface {
	GetAccountStats() AccountStats
}

type AccountUpdater interface {
	// Updates the fields of updatedAccount by address, creating the account
	// if it does not exist
	UpdateAccount(updatedAccount *acm.Account) error
	// Remove the account at address
	RemoveAccount(address crypto.Address) error
}

type Cache struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type CacheOption func(*Cache) *Cache

type CodeHash [32]byte

type DumpState struct {
	bytes.Buffer
}

type Iterable interface {
	AccountIterable
	StorageIterable
}

type IterableReader interface {
	Iterable
	Reader
}

type IterableReaderWriter interface {
	Iterable
	Reader
	Writer
}

type IterableStatsReader interface {
	Iterable
	Reader
	AccountStatsGetter
}

type MemoryState struct {
	Accounts map[crypto.Address]*acm.Account
	Storage  map[crypto.Address]map[binary.Word256][]byte
	Metadata map[MetadataHash]string
}

type MetadataGetter interface {
	// Get an Metadata by its hash. This is content-addressed
	GetMetadata(metahash MetadataHash) (string, error)
}

type MetadataHash [32]byte

type MetadataSetter interface {
	// Set an Metadata according to it keccak-256 hash.
	SetMetadata(metahash MetadataHash, metadata string) error
}

type Reader interface {
	AccountGetter
	StorageGetter
	MetadataGetter
}

type ReaderWriter interface {
	Reader
	Writer
}

type StorageGetter interface {
	// Retrieve a 32-byte value stored at key for the account at address, return Zero256 if key does not exist but
	// error if address does not
	GetStorage(address crypto.Address, key binary.Word256) (value []byte, err error)
}

type StorageIterable interface {
	// Iterates through the storage of account ad address calling the passed function once per account,
	// if the iterator function returns true the iteration breaks and returns true to indicate it iteration
	// was escaped
	IterateStorage(address crypto.Address, consumer func(key binary.Word256, value []byte) error) (err error)
}

type StorageSetter interface {
	// Store a 32-byte value at key for the account at address, setting to Zero256 removes the key
	SetStorage(address crypto.Address, key binary.Word256, value []byte) error
}

type Writer interface {
	AccountUpdater
	StorageSetter
	MetadataSetter
}