trie

package
v1.14.14 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 19, 2024 License: GPL-3.0 Imports: 24 Imported by: 0

Documentation

Overview

Package trie implements Merkle Patricia Tries.

Index

Constants

View Source 
const (
	PUSH1  = byte(0x60)
	PUSH32 = byte(0x7f)
)

Copy the values here so as to avoid an import cycle

Variables

View Source 
var ErrAlreadyProcessed = errors.New("already processed")

ErrAlreadyProcessed is returned by the trie sync when it's requested to process a node it already processed previously.

View Source 
var ErrCommitted = errors.New("trie is already committed")

ErrCommitted is returned when an already committed trie is requested for usage. The potential usages can be `Get`, `Update`, `Delete`, `NodeIterator`, `Prove` and so on.

View Source 
var ErrNotRequested = errors.New("not requested")

ErrNotRequested is returned by the trie sync when it's requested to process a node it did not request.

Functions

func ForGatherChildren 

func ForGatherChildren(node []byte, onChild func(common.Hash))

ForGatherChildren decodes the provided node and traverses the children inside.

func ResolvePath 

func ResolvePath(path []byte) (common.Hash, []byte)

ResolvePath resolves the provided composite node path by separating the path in account trie if it's existent.

func VerifyProof 

func VerifyProof(rootHash common.Hash, key []byte, proofDb ethdb.KeyValueReader) (value []byte, err error)

VerifyProof checks merkle proofs. The given proof must contain the value for key in a trie with the given root hash. VerifyProof returns an error if the proof contains invalid trie nodes or the wrong value.

func VerifyRangeProof 

func VerifyRangeProof(rootHash common.Hash, firstKey []byte, keys [][]byte, values [][]byte, proof ethdb.KeyValueReader) (bool, error)

VerifyRangeProof checks whether the given leaf nodes and edge proof can prove the given trie leaves range is matched with the specific root. Besides, the range should be consecutive (no gap inside) and monotonic increasing.

Note the given proof actually contains two edge proofs. Both of them can be non-existent proofs. For example the first proof is for a non-existent key 0x03, the last proof is for a non-existent key 0x10. The given batch leaves are [0x04, 0x05, .. 0x09]. It's still feasible to prove the given batch is valid.

The firstKey is paired with firstProof, not necessarily the same as keys[0] (unless firstProof is an existent proof). Similarly, lastKey and lastProof are paired.

Expect the normal case, this function can also be used to verify the following range proofs:

  • All elements proof. In this case the proof can be nil, but the range should be all the leaves in the trie.

  • One element proof. In this case no matter the edge proof is a non-existent proof or not, we can always verify the correctness of the proof.

  • Zero element proof. In this case a single non-existent proof is enough to prove. Besides, if there are still some other leaves available on the right side, then an error will be returned.

Except returning the error to indicate the proof is valid or not, the function will also return a flag to indicate whether there exists more accounts/slots in the trie.

Note: This method does not verify that the proof is of minimal form. If the input proofs are 'bloated' with neighbour leaves or random data, aside from the 'useful' data, then the proof will still be accepted.

Types

type ChunkedCode 

type ChunkedCode []byte

ChunkedCode represents a sequence of 32-bytes chunks of code (31 bytes of which are actual code, and 1 byte is the pushdata offset).

func ChunkifyCode 

func ChunkifyCode(code []byte) ChunkedCode

ChunkifyCode generates the chunked version of an array representing EVM bytecode

type CodeSyncResult 

type CodeSyncResult struct {
	Hash common.Hash // Hash the originally unknown bytecode
	Data []byte      // Data content of the retrieved bytecode
}

CodeSyncResult is a response with requested bytecode along with its hash.

type ID 

type ID struct {
	StateRoot common.Hash // The root of the corresponding state(block.root)
	Owner     common.Hash // The contract address hash which the trie belongs to
	Root      common.Hash // The root hash of trie
}

ID is the identifier for uniquely identifying a trie.

func StateTrieID 

func StateTrieID(root common.Hash) *ID

StateTrieID constructs an identifier for state trie with the provided state root.

func StorageTrieID 

func StorageTrieID(stateRoot common.Hash, owner common.Hash, root common.Hash) *ID

StorageTrieID constructs an identifier for storage trie which belongs to a certain state and contract specified by the stateRoot and owner.

func TrieID 

func TrieID(root common.Hash) *ID

TrieID constructs an identifier for a standard trie(not a second-layer trie) with provided root. It's mostly used in tests and some other tries like CHT trie.

type Iterator 

type Iterator struct {
	Key   []byte // Current data key on which the iterator is positioned on
	Value []byte // Current data value on which the iterator is positioned on
	Err   error
	// contains filtered or unexported fields
}

Iterator is a key-value trie iterator that traverses a Trie.

func NewIterator 

func NewIterator(it NodeIterator) *Iterator

NewIterator creates a new key-value iterator from a node iterator. Note that the value returned by the iterator is raw. If the content is encoded (e.g. storage value is RLP-encoded), it's caller's duty to decode it.

func (*Iterator) Next 

func (it *Iterator) Next() bool

Next moves the iterator forward one key-value entry.

func (*Iterator) Prove 

func (it *Iterator) Prove() [][]byte

Prove generates the Merkle proof for the leaf node the iterator is currently positioned on.

type LeafCallback 

type LeafCallback func(keys [][]byte, path []byte, leaf []byte, parent common.Hash, parentPath []byte) error

LeafCallback is a callback type invoked when a trie operation reaches a leaf node.

The keys is a path tuple identifying a particular trie node either in a single trie (account) or a layered trie (account -> storage). Each key in the tuple is in the raw format(32 bytes).

The path is a composite hexary path identifying the trie node. All the key bytes are converted to the hexary nibbles and composited with the parent path if the trie node is in a layered trie.

It's used by state sync and commit to allow handling external references between account and storage tries. And also it's used in the state healing for extracting the raw states(leaf nodes) with corresponding paths.

type MissingNodeError 

type MissingNodeError struct {
	Owner    common.Hash // owner of the trie if it's 2-layered trie
	NodeHash common.Hash // hash of the missing node
	Path     []byte      // hex-encoded path to the missing node
	// contains filtered or unexported fields
}

MissingNodeError is returned by the trie functions (Get, Update, Delete) in the case where a trie node is not present in the local database. It contains information necessary for retrieving the missing node.

func (*MissingNodeError) Error 

func (err *MissingNodeError) Error() string

func (*MissingNodeError) Unwrap 

func (err *MissingNodeError) Unwrap() error

Unwrap returns the concrete error for missing trie node which allows us for further analysis outside.

type NodeIterator 

type NodeIterator interface {
	// Next moves the iterator to the next node. If the parameter is false, any child
	// nodes will be skipped.
	Next(bool) bool

	// Error returns the error status of the iterator.
	Error() error

	// Hash returns the hash of the current node.
	Hash() common.Hash

	// Parent returns the hash of the parent of the current node. The hash may be the one
	// grandparent if the immediate parent is an internal node with no hash.
	Parent() common.Hash

	// Path returns the hex-encoded path to the current node.
	// Callers must not retain references to the return value after calling Next.
	// For leaf nodes, the last element of the path is the 'terminator symbol' 0x10.
	Path() []byte

	// NodeBlob returns the rlp-encoded value of the current iterated node.
	// If the node is an embedded node in its parent, nil is returned then.
	NodeBlob() []byte

	// Leaf returns true iff the current node is a leaf node.
	Leaf() bool

	// LeafKey returns the key of the leaf. The method panics if the iterator is not
	// positioned at a leaf. Callers must not retain references to the value after
	// calling Next.
	LeafKey() []byte

	// LeafBlob returns the content of the leaf. The method panics if the iterator
	// is not positioned at a leaf. Callers must not retain references to the value
	// after calling Next.
	LeafBlob() []byte

	// LeafProof returns the Merkle proof of the leaf. The method panics if the
	// iterator is not positioned at a leaf. Callers must not retain references
	// to the value after calling Next.
	LeafProof() [][]byte

	// AddResolver sets a node resolver to use for looking up trie nodes before
	// reaching into the real persistent layer.
	//
	// This is not required for normal operation, rather is an optimization for
	// cases where trie nodes can be recovered from some external mechanism without
	// reading from disk. In those cases, this resolver allows short circuiting
	// accesses and returning them from memory.
	//
	// Before adding a similar mechanism to any other place in Geth, consider
	// making trie.Database an interface and wrapping at that level. It's a huge
	// refactor, but it could be worth it if another occurrence arises.
	AddResolver(NodeResolver)
}

NodeIterator is an iterator to traverse the trie pre-order.

func NewDifferenceIterator 

func NewDifferenceIterator(a, b NodeIterator) (NodeIterator, *int)

NewDifferenceIterator constructs a NodeIterator that iterates over elements in b that are not in a. Returns the iterator, and a pointer to an integer recording the number of nodes seen.

func NewUnionIterator 

func NewUnionIterator(iters []NodeIterator) (NodeIterator, *int)

NewUnionIterator constructs a NodeIterator that iterates over elements in the union of the provided NodeIterators. Returns the iterator, and a pointer to an integer recording the number of nodes visited.

type NodeResolver 

type NodeResolver func(owner common.Hash, path []byte, hash common.Hash) []byte

NodeResolver is used for looking up trie nodes before reaching into the real persistent layer. This is not mandatory, rather is an optimization for cases where trie nodes can be recovered from some external mechanism without reading from disk. In those cases, this resolver allows short circuiting accesses and returning them from memory.

type NodeSyncResult 

type NodeSyncResult struct {
	Path string // Path of the originally unknown trie node
	Data []byte // Data content of the retrieved trie node
}

NodeSyncResult is a response with requested trie node along with its node path.

type OnTrieNode 

type OnTrieNode func(path []byte, hash common.Hash, blob []byte)

OnTrieNode is a callback method invoked when a trie node is committed by the stack trie. The node is only committed if it's considered complete.

The caller should not modify the contents of the returned path and blob slice, and their contents may be changed after the call. It is up to the `onTrieNode` receiver function to deep-copy the data if it wants to retain it after the call ends.

type SecureTrie 

type SecureTrie = StateTrie

SecureTrie is the old name of StateTrie. Deprecated: use StateTrie.

func NewSecure 

func NewSecure(stateRoot common.Hash, owner common.Hash, root common.Hash, db database.NodeDatabase) (*SecureTrie, error)

NewSecure creates a new StateTrie. Deprecated: use NewStateTrie.

type StackTrie 

type StackTrie struct {
	// contains filtered or unexported fields
}

StackTrie is a trie implementation that expects keys to be inserted in order. Once it determines that a subtree will no longer be inserted into, it will hash it and free up the memory it uses.

func NewStackTrie 

func NewStackTrie(onTrieNode OnTrieNode) *StackTrie

NewStackTrie allocates and initializes an empty trie. The committed nodes will be discarded immediately if no callback is configured.

func (*StackTrie) Hash 

func (t *StackTrie) Hash() common.Hash

Hash will firstly hash the entire trie if it's still not hashed and then commit all leftover nodes to the associated database. Actually most of the trie nodes have been committed already. The main purpose here is to commit the nodes on right boundary.

func (*StackTrie) Reset 

func (t *StackTrie) Reset()

Reset resets the stack trie object to empty state.

func (*StackTrie) TrieKey 

func (t *StackTrie) TrieKey(key []byte) []byte

TrieKey returns the internal key representation for the given user key.

func (*StackTrie) Update 

func (t *StackTrie) Update(key, value []byte) error

Update inserts a (key, value) pair into the stack trie.

type StateTrie 

type StateTrie struct {
	// contains filtered or unexported fields
}

StateTrie wraps a trie with key hashing. In a stateTrie trie, all access operations hash the key using keccak256. This prevents calling code from creating long chains of nodes that increase the access time.

Contrary to a regular trie, a StateTrie can only be created with New and must have an attached database. The database also stores the preimage of each key if preimage recording is enabled.

StateTrie is not safe for concurrent use.

func NewStateTrie 

func NewStateTrie(id *ID, db database.NodeDatabase) (*StateTrie, error)

NewStateTrie creates a trie with an existing root node from a backing database.

If root is the zero hash or the sha3 hash of an empty string, the trie is initially empty. Otherwise, New will panic if db is nil and returns MissingNodeError if the root node cannot be found.

func (*StateTrie) Commit 

func (t *StateTrie) Commit(collectLeaf bool) (common.Hash, *trienode.NodeSet)

Commit collects all dirty nodes in the trie and replaces them with the corresponding node hash. All collected nodes (including dirty leaves if collectLeaf is true) will be encapsulated into a nodeset for return. The returned nodeset can be nil if the trie is clean (nothing to commit). All cached preimages will be also flushed if preimages recording is enabled. Once the trie is committed, it's not usable anymore. A new trie must be created with new root and updated trie database for following usage

func (*StateTrie) Copy 

func (t *StateTrie) Copy() *StateTrie

Copy returns a copy of StateTrie.

func (*StateTrie) DeleteAccount 

func (t *StateTrie) DeleteAccount(address common.Address) error

DeleteAccount abstracts an account deletion from the trie.

func (*StateTrie) DeleteStorage 

func (t *StateTrie) DeleteStorage(_ common.Address, key []byte) error

DeleteStorage removes any existing storage slot from the trie. If the specified trie node is not in the trie, nothing will be changed. If a node is not found in the database, a MissingNodeError is returned.

func (*StateTrie) GetAccount 

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

GetAccount attempts to retrieve an account with provided account address. If the specified account is not in the trie, nil will be returned. If a trie node is not found in the database, a MissingNodeError is returned.

func (*StateTrie) GetAccountByHash 

func (t *StateTrie) GetAccountByHash(addrHash common.Hash) (*types.StateAccount, error)

GetAccountByHash does the same thing as GetAccount, however it expects an account hash that is the hash of address. This constitutes an abstraction leak, since the client code needs to know the key format.

func (*StateTrie) GetKey 

func (t *StateTrie) GetKey(shaKey []byte) []byte

GetKey returns the sha3 preimage of a hashed key that was previously used to store a value.

func (*StateTrie) GetNode 

func (t *StateTrie) GetNode(path []byte) ([]byte, int, error)

GetNode attempts to retrieve a trie node by compact-encoded path. It is not possible to use keybyte-encoding as the path might contain odd nibbles. If the specified trie node is not in the trie, nil will be returned. If a trie node is not found in the database, a MissingNodeError is returned.

func (*StateTrie) GetStorage 

func (t *StateTrie) GetStorage(_ common.Address, key []byte) ([]byte, error)

GetStorage attempts to retrieve a storage slot with provided account address and slot key. The value bytes must not be modified by the caller. If the specified storage slot is not in the trie, nil will be returned. If a trie node is not found in the database, a MissingNodeError is returned.

func (*StateTrie) Hash 

func (t *StateTrie) Hash() common.Hash

Hash returns the root hash of StateTrie. It does not write to the database and can be used even if the trie doesn't have one.

func (*StateTrie) IsVerkle 

func (t *StateTrie) IsVerkle() bool

func (*StateTrie) MustDelete 

func (t *StateTrie) MustDelete(key []byte)

MustDelete removes any existing value for key from the trie. This function will omit any encountered error but just print out an error message.

func (*StateTrie) MustGet 

func (t *StateTrie) MustGet(key []byte) []byte

MustGet returns the value for key stored in the trie. The value bytes must not be modified by the caller.

This function will omit any encountered error but just print out an error message.

func (*StateTrie) MustNodeIterator 

func (t *StateTrie) MustNodeIterator(start []byte) NodeIterator

MustNodeIterator is a wrapper of NodeIterator and will omit any encountered error but just print out an error message.

func (*StateTrie) MustUpdate 

func (t *StateTrie) MustUpdate(key, value []byte)

MustUpdate associates key with value in the trie. Subsequent calls to Get will return value. If value has length zero, any existing value is deleted from the trie and calls to Get will return nil.

The value bytes must not be modified by the caller while they are stored in the trie.

This function will omit any encountered error but just print out an error message.

func (*StateTrie) NodeIterator 

func (t *StateTrie) NodeIterator(start []byte) (NodeIterator, error)

NodeIterator returns an iterator that returns nodes of the underlying trie. Iteration starts at the key after the given start key.

func (*StateTrie) Prove 

func (t *StateTrie) Prove(key []byte, proofDb ethdb.KeyValueWriter) error

Prove constructs a merkle proof for key. The result contains all encoded nodes on the path to the value at key. The value itself is also included in the last node and can be retrieved by verifying the proof.

If the trie does not contain a value for key, the returned proof contains all nodes of the longest existing prefix of the key (at least the root node), ending with the node that proves the absence of the key.

func (*StateTrie) UpdateAccount 

func (t *StateTrie) UpdateAccount(address common.Address, acc *types.StateAccount, _ int) error

UpdateAccount will abstract the write of an account to the secure trie.

func (*StateTrie) UpdateContractCode 

func (t *StateTrie) UpdateContractCode(_ common.Address, _ common.Hash, _ []byte) error

func (*StateTrie) UpdateStorage 

func (t *StateTrie) UpdateStorage(_ common.Address, key, value []byte) error

UpdateStorage associates key with value in the trie. Subsequent calls to Get will return value. If value has length zero, any existing value is deleted from the trie and calls to Get will return nil.

The value bytes must not be modified by the caller while they are stored in the trie.

If a node is not found in the database, a MissingNodeError is returned.

func (*StateTrie) Witness 

func (t *StateTrie) Witness() map[string]struct{}

Witness returns a set containing all trie nodes that have been accessed.

type Sync 

type Sync struct {
	// contains filtered or unexported fields
}

Sync is the main state trie synchronisation scheduler, which provides yet unknown trie hashes to retrieve, accepts node data associated with said hashes and reconstructs the trie step by step until all is done.

func NewSync 

func NewSync(root common.Hash, database ethdb.KeyValueReader, callback LeafCallback, scheme string) *Sync

NewSync creates a new trie data download scheduler.

func (*Sync) AddCodeEntry 

func (s *Sync) AddCodeEntry(hash common.Hash, path []byte, parent common.Hash, parentPath []byte)

AddCodeEntry schedules the direct retrieval of a contract code that should not be interpreted as a trie node, but rather accepted and stored into the database as is.

func (*Sync) AddSubTrie 

func (s *Sync) AddSubTrie(root common.Hash, path []byte, parent common.Hash, parentPath []byte, callback LeafCallback)

AddSubTrie registers a new trie to the sync code, rooted at the designated parent for completion tracking. The given path is a unique node path in hex format and contain all the parent path if it's layered trie node.

func (*Sync) Commit 

func (s *Sync) Commit(dbw ethdb.Batch) error

Commit flushes the data stored in the internal membatch out to persistent storage, returning any occurred error. The whole data set will be flushed in an atomic database batch.

func (*Sync) MemSize 

func (s *Sync) MemSize() uint64

MemSize returns an estimated size (in bytes) of the data held in the membatch.

func (*Sync) Missing 

func (s *Sync) Missing(max int) ([]string, []common.Hash, []common.Hash)

Missing retrieves the known missing nodes from the trie for retrieval. To aid both eth/6x style fast sync and snap/1x style state sync, the paths of trie nodes are returned too, as well as separate hash list for codes.

func (*Sync) Pending 

func (s *Sync) Pending() int

Pending returns the number of state entries currently pending for download.

func (*Sync) ProcessCode 

func (s *Sync) ProcessCode(result CodeSyncResult) error

ProcessCode injects the received data for requested item. Note it can happen that the single response commits two pending requests(e.g. there are two requests one for code and one for node but the hash is same). In this case the second response for the same hash will be treated as "non-requested" item or "already-processed" item but there is no downside.

func (*Sync) ProcessNode 

func (s *Sync) ProcessNode(result NodeSyncResult) error

ProcessNode injects the received data for requested item. Note it can happen that the single response commits two pending requests(e.g. there are two requests one for code and one for node but the hash is same). In this case the second response for the same hash will be treated as "non-requested" item or "already-processed" item but there is no downside.

type SyncPath 

type SyncPath [][]byte

SyncPath is a path tuple identifying a particular trie node either in a single trie (account) or a layered trie (account -> storage).

Content wise the tuple either has 1 element if it addresses a node in a single trie or 2 elements if it addresses a node in a stacked trie.

To support aiming arbitrary trie nodes, the path needs to support odd nibble lengths. To avoid transferring expanded hex form over the network, the last part of the tuple (which needs to index into the middle of a trie) is compact encoded. In case of a 2-tuple, the first item is always 32 bytes so that is simple binary encoded.

Examples:

  • Path 0x9 -> {0x19}
  • Path 0x99 -> {0x0099}
  • Path 0x01234567890123456789012345678901012345678901234567890123456789019 -> {0x0123456789012345678901234567890101234567890123456789012345678901, 0x19}
  • Path 0x012345678901234567890123456789010123456789012345678901234567890199 -> {0x0123456789012345678901234567890101234567890123456789012345678901, 0x0099}

func NewSyncPath 

func NewSyncPath(path []byte) SyncPath

NewSyncPath converts an expanded trie path from nibble form into a compact version that can be sent over the network.

type Trie 

type Trie struct {
	// contains filtered or unexported fields
}

Trie is a Merkle Patricia Trie. Use New to create a trie that sits on top of a database. Whenever trie performs a commit operation, the generated nodes will be gathered and returned in a set. Once the trie is committed, it's not usable anymore. Callers have to re-create the trie with new root based on the updated trie database.

Trie is not safe for concurrent use.

func New 

func New(id *ID, db database.NodeDatabase) (*Trie, error)

New creates the trie instance with provided trie id and the read-only database. The state specified by trie id must be available, otherwise an error will be returned. The trie root specified by trie id can be zero hash or the sha3 hash of an empty string, then trie is initially empty, otherwise, the root node must be present in database or returns a MissingNodeError if not.

func NewEmpty 

func NewEmpty(db database.NodeDatabase) *Trie

NewEmpty is a shortcut to create empty tree. It's mostly used in tests.

func (*Trie) Commit 

func (t *Trie) Commit(collectLeaf bool) (common.Hash, *trienode.NodeSet)

Commit collects all dirty nodes in the trie and replaces them with the corresponding node hash. All collected nodes (including dirty leaves if collectLeaf is true) will be encapsulated into a nodeset for return. The returned nodeset can be nil if the trie is clean (nothing to commit). Once the trie is committed, it's not usable anymore. A new trie must be created with new root and updated trie database for following usage

func (*Trie) Copy 

func (t *Trie) Copy() *Trie

Copy returns a copy of Trie.

func (*Trie) Delete 

func (t *Trie) Delete(key []byte) error

Delete removes any existing value for key from the trie.

If the requested node is not present in trie, no error will be returned. If the trie is corrupted, a MissingNodeError is returned.

func (*Trie) Get 

func (t *Trie) Get(key []byte) ([]byte, error)

Get returns the value for key stored in the trie. The value bytes must not be modified by the caller.

If the requested node is not present in trie, no error will be returned. If the trie is corrupted, a MissingNodeError is returned.

func (*Trie) GetNode 

func (t *Trie) GetNode(path []byte) ([]byte, int, error)

GetNode retrieves a trie node by compact-encoded path. It is not possible to use keybyte-encoding as the path might contain odd nibbles.

If the requested node is not present in trie, no error will be returned. If the trie is corrupted, a MissingNodeError is returned.

func (*Trie) Hash 

func (t *Trie) Hash() common.Hash

Hash returns the root hash of the trie. It does not write to the database and can be used even if the trie doesn't have one.

func (*Trie) MustDelete 

func (t *Trie) MustDelete(key []byte)

MustDelete is a wrapper of Delete and will omit any encountered error but just print out an error message.

func (*Trie) MustGet 

func (t *Trie) MustGet(key []byte) []byte

MustGet is a wrapper of Get and will omit any encountered error but just print out an error message.

func (*Trie) MustGetNode 

func (t *Trie) MustGetNode(path []byte) ([]byte, int)

MustGetNode is a wrapper of GetNode and will omit any encountered error but just print out an error message.

func (*Trie) MustNodeIterator 

func (t *Trie) MustNodeIterator(start []byte) NodeIterator

MustNodeIterator is a wrapper of NodeIterator and will omit any encountered error but just print out an error message.

func (*Trie) MustUpdate 

func (t *Trie) MustUpdate(key, value []byte)

MustUpdate is a wrapper of Update and will omit any encountered error but just print out an error message.

func (*Trie) NodeIterator 

func (t *Trie) NodeIterator(start []byte) (NodeIterator, error)

NodeIterator returns an iterator that returns nodes of the trie. Iteration starts at the key after the given start key.

func (*Trie) Prove 

func (t *Trie) Prove(key []byte, proofDb ethdb.KeyValueWriter) error

Prove constructs a merkle proof for key. The result contains all encoded nodes on the path to the value at key. The value itself is also included in the last node and can be retrieved by verifying the proof.

If the trie does not contain a value for key, the returned proof contains all nodes of the longest existing prefix of the key (at least the root node), ending with the node that proves the absence of the key.

func (*Trie) Reset 

func (t *Trie) Reset()

Reset drops the referenced root node and cleans all internal state.

func (*Trie) Update 

func (t *Trie) Update(key, value []byte) error

Update associates key with value in the trie. Subsequent calls to Get will return value. If value has length zero, any existing value is deleted from the trie and calls to Get will return nil.

The value bytes must not be modified by the caller while they are stored in the trie.

If the requested node is not present in trie, no error will be returned. If the trie is corrupted, a MissingNodeError is returned.

func (*Trie) Witness 

func (t *Trie) Witness() map[string]struct{}

Witness returns a set containing all trie nodes that have been accessed.

type VerkleTrie 

type VerkleTrie struct {
	// contains filtered or unexported fields
}

VerkleTrie is a wrapper around VerkleNode that implements the trie.Trie interface so that Verkle trees can be reused verbatim.

func NewVerkleTrie 

func NewVerkleTrie(root common.Hash, db database.NodeDatabase, cache *utils.PointCache) (*VerkleTrie, error)

NewVerkleTrie constructs a verkle tree based on the specified root hash.

func (*VerkleTrie) Commit 

func (t *VerkleTrie) Commit(_ bool) (common.Hash, *trienode.NodeSet)

Commit writes all nodes to the tree's memory database.

func (*VerkleTrie) Copy 

func (t *VerkleTrie) Copy() *VerkleTrie

Copy returns a deep-copied verkle tree.

func (*VerkleTrie) DeleteAccount 

func (t *VerkleTrie) DeleteAccount(addr common.Address) error

DeleteAccount leaves the account untouched, as no account deletion can happen in verkle. There is a special corner case, in which an account that is prefunded, CREATE2-d and then SELFDESTRUCT-d should see its funds drained. EIP161 says that account should be removed, but this is verboten by the verkle spec. This contains a workaround in which the method checks for this corner case, and if so, overwrites the balance with 0. This will be removed once the spec has been clarified.

func (*VerkleTrie) DeleteStorage 

func (t *VerkleTrie) DeleteStorage(addr common.Address, key []byte) error

DeleteStorage implements state.Trie, deleting the specified storage slot from the trie. If the storage slot was not existent in the trie, no error will be returned. If the trie is corrupted, an error will be returned.

func (*VerkleTrie) FlatdbNodeResolver 

func (t *VerkleTrie) FlatdbNodeResolver(path []byte) ([]byte, error)

func (*VerkleTrie) GetAccount 

func (t *VerkleTrie) GetAccount(addr common.Address) (*types.StateAccount, error)

GetAccount implements state.Trie, retrieving the account with the specified account address. If the specified account is not in the verkle tree, nil will be returned. If the tree is corrupted, an error will be returned.

func (*VerkleTrie) GetKey 

func (t *VerkleTrie) GetKey(key []byte) []byte

GetKey returns the sha3 preimage of a hashed key that was previously used to store a value.

func (*VerkleTrie) GetStorage 

func (t *VerkleTrie) GetStorage(addr common.Address, key []byte) ([]byte, error)

GetStorage implements state.Trie, retrieving the storage slot with the specified account address and storage key. If the specified slot is not in the verkle tree, nil will be returned. If the tree is corrupted, an error will be returned.

func (*VerkleTrie) Hash 

func (t *VerkleTrie) Hash() common.Hash

Hash returns the root hash of the tree. It does not write to the database and can be used even if the tree doesn't have one.

func (*VerkleTrie) IsVerkle 

func (t *VerkleTrie) IsVerkle() bool

IsVerkle indicates if the trie is a Verkle trie.

func (*VerkleTrie) NodeIterator 

func (t *VerkleTrie) NodeIterator(startKey []byte) (NodeIterator, error)

NodeIterator implements state.Trie, returning an iterator that returns nodes of the trie. Iteration starts at the key after the given start key.

TODO(gballet, rjl493456442) implement it.

func (*VerkleTrie) Proof 

func (t *VerkleTrie) Proof(posttrie *VerkleTrie, keys [][]byte) (*verkle.VerkleProof, verkle.StateDiff, error)

Proof builds and returns the verkle multiproof for keys, built against the pre tree. The post tree is passed in order to add the post values to that proof.

func (*VerkleTrie) Prove 

func (t *VerkleTrie) Prove(key []byte, proofDb ethdb.KeyValueWriter) error

Prove implements state.Trie, constructing a Merkle proof for key. The result contains all encoded nodes on the path to the value at key. The value itself is also included in the last node and can be retrieved by verifying the proof.

If the trie does not contain a value for key, the returned proof contains all nodes of the longest existing prefix of the key (at least the root), ending with the node that proves the absence of the key.

TODO(gballet, rjl493456442) implement it.

func (*VerkleTrie) RollBackAccount 

func (t *VerkleTrie) RollBackAccount(addr common.Address) error

RollBackAccount removes the account info + code from the tree, unlike DeleteAccount that will overwrite it with 0s. The first 64 storage slots are also removed.

func (*VerkleTrie) ToDot 

func (t *VerkleTrie) ToDot() string

func (*VerkleTrie) UpdateAccount 

func (t *VerkleTrie) UpdateAccount(addr common.Address, acc *types.StateAccount, codeLen int) error

UpdateAccount implements state.Trie, writing the provided account into the tree. If the tree is corrupted, an error will be returned.

func (*VerkleTrie) UpdateContractCode 

func (t *VerkleTrie) UpdateContractCode(addr common.Address, codeHash common.Hash, code []byte) error

UpdateContractCode implements state.Trie, writing the provided contract code into the trie. Note that the code-size *must* be already saved by a previous UpdateAccount call.

func (*VerkleTrie) UpdateStorage 

func (t *VerkleTrie) UpdateStorage(address common.Address, key, value []byte) error

UpdateStorage implements state.Trie, writing the provided storage slot into the tree. If the tree is corrupted, an error will be returned.

func (*VerkleTrie) Witness 

func (t *VerkleTrie) Witness() map[string]struct{}

Witness returns a set containing all trie nodes that have been accessed.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.