Documentation
¶
Overview ¶
Package trie implements Merkle Patricia Tries.
Index ¶
- Variables
- func VerifyProof(rootHash common.Hash, key []byte, proofDb ethdb.KeyValueReader) (value []byte, err error)
- func VerifyRangeProof(rootHash common.Hash, firstKey []byte, lastKey []byte, keys [][]byte, ...) (error, bool)
- type Config
- type Database
- func (db *Database) Cap(limit common.StorageSize) error
- func (db *Database) Commit(node common.Hash, report bool, callback func(common.Hash)) error
- func (db *Database) Dereference(root common.Hash)
- func (db *Database) DiskDB() ethdb.KeyValueStore
- func (db *Database) Node(hash common.Hash) ([]byte, error)
- func (db *Database) Nodes() []common.Hash
- func (db *Database) Reference(child common.Hash, parent common.Hash)
- func (db *Database) SaveCache(dir string) error
- func (db *Database) SaveCachePeriodically(dir string, interval time.Duration, stopCh <-chan struct{})
- func (db *Database) Size() (common.StorageSize, common.StorageSize)
- type Iterator
- type LeafCallback
- type MissingNodeError
- type NodeIterator
- type SecureTrie
- func (t *SecureTrie) Commit(onleaf LeafCallback) (root common.Hash, err error)
- func (t *SecureTrie) Copy() *SecureTrie
- func (t *SecureTrie) Delete(key []byte)
- func (t *SecureTrie) Get(key []byte) []byte
- func (t *SecureTrie) GetKey(shaKey []byte) []byte
- func (t *SecureTrie) Hash() common.Hash
- func (t *SecureTrie) NodeIterator(start []byte) NodeIterator
- func (t *SecureTrie) Prove(key []byte, fromLevel uint, proofDb ethdb.KeyValueWriter) error
- func (t *SecureTrie) TryDelete(key []byte) error
- func (t *SecureTrie) TryGet(key []byte) ([]byte, error)
- func (t *SecureTrie) TryGetNode(path []byte) ([]byte, int, error)
- func (t *SecureTrie) TryUpdate(key, value []byte) error
- func (t *SecureTrie) Update(key, value []byte)
- type StackTrie
- type Sync
- func (s *Sync) AddCodeEntry(hash common.Hash, path []byte, parent common.Hash)
- func (s *Sync) AddSubTrie(root common.Hash, path []byte, parent common.Hash, callback LeafCallback)
- func (s *Sync) Commit(dbw ethdb.Batch) error
- func (s *Sync) Missing(max int) (nodes []common.Hash, paths []SyncPath, codes []common.Hash)
- func (s *Sync) Pending() int
- func (s *Sync) Process(result SyncResult) error
- type SyncBloom
- type SyncPath
- type SyncResult
- type Trie
- func (t *Trie) Commit(onleaf LeafCallback) (root common.Hash, err error)
- func (t *Trie) Delete(key []byte)
- func (t *Trie) Get(key []byte) []byte
- func (t *Trie) Hash() common.Hash
- func (t *Trie) NodeIterator(start []byte) NodeIterator
- func (t *Trie) Prove(key []byte, fromLevel uint, proofDb ethdb.KeyValueWriter) error
- func (t *Trie) Reset()
- func (t *Trie) TryDelete(key []byte) error
- func (t *Trie) TryGet(key []byte) ([]byte, error)
- func (t *Trie) TryGetNode(path []byte) ([]byte, int, error)
- func (t *Trie) TryUpdate(key, value []byte) error
- func (t *Trie) Update(key, value []byte)
Constants ¶
This section is empty.
Variables ¶
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.
var ErrCommitDisabled = errors.New("no database for committing")
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 VerifyProof ¶ added in v1.3.1
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 ¶ added in v1.10.1
func VerifyRangeProof(rootHash common.Hash, firstKey []byte, lastKey []byte, keys [][]byte, values [][]byte, proof ethdb.KeyValueReader) (error, bool)
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.
Types ¶
type Config ¶ added in v1.10.1
type Config struct { Cache int // Memory allowance (MB) to use for caching trie nodes in memory Journal string // Journal of clean cache to survive node restarts Preimages bool // Flag whether the preimage of trie key is recorded }
Config defines all necessary options for database.
type Database ¶ added in v1.3.1
type Database struct {
// contains filtered or unexported fields
}
Database is an intermediate write layer between the trie data structures and the disk database. The aim is to accumulate trie writes in-memory and only periodically flush a couple tries to disk, garbage collecting the remainder.
Note, the trie Database is **not** thread safe in its mutations, but it **is** thread safe in providing individual, independent node access. The rationale behind this split design is to provide read access to RPC handlers and sync servers even while the trie is executing expensive garbage collection.
func NewDatabase ¶ added in v1.8.0
func NewDatabase(diskdb ethdb.KeyValueStore) *Database
NewDatabase creates a new trie database to store ephemeral trie content before its written out to disk or garbage collected. No read cache is created, so all data retrievals will hit the underlying disk database.
func NewDatabaseWithConfig ¶ added in v1.10.1
func NewDatabaseWithConfig(diskdb ethdb.KeyValueStore, config *Config) *Database
NewDatabaseWithConfig creates a new trie database to store ephemeral trie content before its written out to disk or garbage collected. It also acts as a read cache for nodes loaded from disk.
func (*Database) Cap ¶ added in v1.8.11
func (db *Database) Cap(limit common.StorageSize) error
Cap iteratively flushes old but still referenced trie nodes until the total memory usage goes below the given threshold.
Note, this method is a non-synchronized mutator. It is unsafe to call this concurrently with other mutators.
func (*Database) Commit ¶ added in v1.8.0
Commit iterates over all the children of a particular node, writes them out to disk, forcefully tearing down all references in both directions. As a side effect, all pre-images accumulated up to this point are also written.
Note, this method is a non-synchronized mutator. It is unsafe to call this concurrently with other mutators.
func (*Database) Dereference ¶ added in v1.8.0
Dereference removes an existing reference from a root node.
func (*Database) DiskDB ¶ added in v1.8.0
func (db *Database) DiskDB() ethdb.KeyValueStore
DiskDB retrieves the persistent storage backing the trie database.
func (*Database) Node ¶ added in v1.8.0
Node retrieves an encoded cached trie node from memory. If it cannot be found cached, the method queries the persistent database for the content.
func (*Database) Nodes ¶ added in v1.8.0
Nodes retrieves the hashes of all the nodes cached within the memory database. This method is extremely expensive and should only be used to validate internal states in test code.
func (*Database) Reference ¶ added in v1.8.0
Reference adds a new reference from a parent node to a child node. This function is used to add reference between internal trie node and external node(e.g. storage trie root), all internal trie nodes are referenced together by database itself.
func (*Database) SaveCache ¶ added in v1.10.1
SaveCache atomically saves fast cache data to the given dir using all available CPU cores.
func (*Database) SaveCachePeriodically ¶ added in v1.10.1
func (db *Database) SaveCachePeriodically(dir string, interval time.Duration, stopCh <-chan struct{})
SaveCachePeriodically atomically saves fast cache data to the given dir with the specified interval. All dump operation will only use a single CPU core.
func (*Database) Size ¶ added in v1.8.0
func (db *Database) Size() (common.StorageSize, common.StorageSize)
Size returns the current storage size of the memory cache in front of the persistent database layer.
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.
type LeafCallback ¶ added in v1.8.0
LeafCallback is a callback type invoked when a trie operation reaches a leaf node. It's used by state sync and commit to allow handling external references between account and storage tries.
type MissingNodeError ¶ added in v1.4.0
type MissingNodeError struct { NodeHash common.Hash // hash of the missing node Path []byte // hex-encoded path to the missing node }
MissingNodeError is returned by the trie functions (TryGet, TryUpdate, TryDelete) 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 ¶ added in v1.4.0
func (err *MissingNodeError) Error() string
type NodeIterator ¶ added in v1.4.0
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 // 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 }
NodeIterator is an iterator to traverse the trie pre-order.
func NewDifferenceIterator ¶ added in v1.6.0
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 ¶ added in v1.6.0
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 SecureTrie ¶ added in v0.9.17
type SecureTrie struct {
// contains filtered or unexported fields
}
SecureTrie wraps a trie with key hashing. In a secure 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 SecureTrie can only be created with New and must have an attached database. The database also stores the preimage of each key.
SecureTrie is not safe for concurrent use.
func NewSecure ¶ added in v0.9.17
func NewSecure(root common.Hash, db *Database) (*SecureTrie, error)
NewSecure creates a trie with an existing root node from a backing database and optional intermediate in-memory node pool.
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.
Accessing the trie loads nodes from the database or node pool on demand. Loaded nodes are kept around until their 'cache generation' expires. A new cache generation is created by each call to Commit. cachelimit sets the number of past cache generations to keep.
func (*SecureTrie) Commit ¶ added in v1.4.0
func (t *SecureTrie) Commit(onleaf LeafCallback) (root common.Hash, err error)
Commit writes all nodes and the secure hash pre-images to the trie's database. Nodes are stored with their sha3 hash as the key.
Committing flushes nodes from memory. Subsequent Get calls will load nodes from the database.
func (*SecureTrie) Copy ¶ added in v0.9.17
func (t *SecureTrie) Copy() *SecureTrie
Copy returns a copy of SecureTrie.
func (*SecureTrie) Delete ¶ added in v0.9.17
func (t *SecureTrie) Delete(key []byte)
Delete removes any existing value for key from the trie.
func (*SecureTrie) Get ¶ added in v0.9.17
func (t *SecureTrie) Get(key []byte) []byte
Get returns the value for key stored in the trie. The value bytes must not be modified by the caller.
func (*SecureTrie) GetKey ¶ added in v0.9.17
func (t *SecureTrie) GetKey(shaKey []byte) []byte
GetKey returns the sha3 preimage of a hashed key that was previously used to store a value.
func (*SecureTrie) Hash ¶ added in v1.4.14
func (t *SecureTrie) Hash() common.Hash
Hash returns the root hash of SecureTrie. It does not write to the database and can be used even if the trie doesn't have one.
func (*SecureTrie) NodeIterator ¶ added in v1.4.14
func (t *SecureTrie) NodeIterator(start []byte) NodeIterator
NodeIterator returns an iterator that returns nodes of the underlying trie. Iteration starts at the key after the given start key.
func (*SecureTrie) Prove ¶ added in v1.8.0
func (t *SecureTrie) Prove(key []byte, fromLevel uint, 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 (*SecureTrie) TryDelete ¶ added in v1.4.0
func (t *SecureTrie) TryDelete(key []byte) error
TryDelete removes any existing value for key from the trie. If a node was not found in the database, a MissingNodeError is returned.
func (*SecureTrie) TryGet ¶ added in v1.4.0
func (t *SecureTrie) TryGet(key []byte) ([]byte, error)
TryGet returns the value for key stored in the trie. The value bytes must not be modified by the caller. If a node was not found in the database, a MissingNodeError is returned.
func (*SecureTrie) TryGetNode ¶ added in v1.10.1
func (t *SecureTrie) TryGetNode(path []byte) ([]byte, int, error)
TryGetNode 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.
func (*SecureTrie) TryUpdate ¶ added in v1.4.0
func (t *SecureTrie) TryUpdate(key, value []byte) error
TryUpdate 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 was not found in the database, a MissingNodeError is returned.
func (*SecureTrie) Update ¶ added in v0.9.17
func (t *SecureTrie) Update(key, value []byte)
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.
type StackTrie ¶ added in v1.10.1
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 ¶ added in v1.10.1
func NewStackTrie(db ethdb.KeyValueStore) *StackTrie
NewStackTrie allocates and initializes an empty trie.
func (*StackTrie) Commit ¶ added in v1.10.1
Commit will firstly hash the entrie trie if it's still not hashed and then commit all nodes to the associated database. Actually most of the trie nodes MAY have been committed already. The main purpose here is to commit the root node.
The associated database is expected, otherwise the whole commit functionality should be disabled.
type Sync ¶ added in v1.8.10
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 ¶ added in v1.8.10
func NewSync(root common.Hash, database ethdb.KeyValueReader, callback LeafCallback, bloom *SyncBloom) *Sync
NewSync creates a new trie data download scheduler.
func (*Sync) AddCodeEntry ¶ added in v1.10.1
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 ¶ added in v1.8.10
AddSubTrie registers a new trie to the sync code, rooted at the designated parent.
func (*Sync) Commit ¶ added in v1.8.10
Commit flushes the data stored in the internal membatch out to persistent storage, returning any occurred error.
func (*Sync) Missing ¶ added in v1.8.10
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 ¶ added in v1.8.10
Pending returns the number of state entries currently pending for download.
func (*Sync) Process ¶ added in v1.8.10
func (s *Sync) Process(result SyncResult) error
Process injects the received data for requested item. Note it can happpen 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 SyncBloom ¶ added in v1.9.0
type SyncBloom struct {
// contains filtered or unexported fields
}
SyncBloom is a bloom filter used during fast sync to quickly decide if a trie node or contract code already exists on disk or not. It self populates from the provided disk database on creation in a background thread and will only start returning live results once that's finished.
func NewSyncBloom ¶ added in v1.9.0
NewSyncBloom creates a new bloom filter of the given size (in megabytes) and initializes it from the database. The bloom is hard coded to use 3 filters.
func (*SyncBloom) Close ¶ added in v1.9.0
Close terminates any background initializer still running and releases all the memory allocated for the bloom.
type SyncPath ¶ added in v1.10.1
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}
type SyncResult ¶ added in v1.3.1
type SyncResult struct { Hash common.Hash // Hash of the originally unknown trie node Data []byte // Data content of the retrieved node }
SyncResult is a response with requested data along with it's hash.
type Trie ¶
type Trie struct {
// contains filtered or unexported fields
}
Trie is a Merkle Patricia Trie. The zero value is an empty trie with no database. Use New to create a trie that sits on top of a database.
Trie is not safe for concurrent use.
func New ¶
New creates a trie with an existing root node from db.
If root is the zero hash or the sha3 hash of an empty string, the trie is initially empty and does not require a database. Otherwise, New will panic if db is nil and returns a MissingNodeError if root does not exist in the database. Accessing the trie loads nodes from db on demand.
func (*Trie) Commit ¶ added in v0.8.4
func (t *Trie) Commit(onleaf LeafCallback) (root common.Hash, err error)
Commit writes all nodes to the trie's memory database, tracking the internal and external (for account tries) references.
func (*Trie) Get ¶
Get returns the value for key stored in the trie. The value bytes must not be modified by the caller.
func (*Trie) Hash ¶ added in v0.8.4
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) NodeIterator ¶ added in v1.6.1
func (t *Trie) NodeIterator(start []byte) NodeIterator
NodeIterator returns an iterator that returns nodes of the trie. Iteration starts at the key after the given start key.
func (*Trie) Prove ¶ added in v1.3.1
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 ¶ added in v0.8.4
func (t *Trie) Reset()
Reset drops the referenced root node and cleans all internal state.
func (*Trie) TryDelete ¶ added in v1.4.0
TryDelete removes any existing value for key from the trie. If a node was not found in the database, a MissingNodeError is returned.
func (*Trie) TryGet ¶ added in v1.4.0
TryGet returns the value for key stored in the trie. The value bytes must not be modified by the caller. If a node was not found in the database, a MissingNodeError is returned.
func (*Trie) TryGetNode ¶ added in v1.10.1
TryGetNode 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.
func (*Trie) TryUpdate ¶ added in v1.4.0
TryUpdate 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 was not found in the database, a MissingNodeError is returned.
func (*Trie) Update ¶
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.