4047ccad2f
The 'step' method is split into two parts, 'peek' and 'push'. peek returns the next state but doesn't make it current. The end of iteration was previously tracked by setting 'trie' to nil. End of iteration is now tracked using the 'iteratorEnd' error, which is slightly cleaner and requires less code.
511 lines
16 KiB
Go
511 lines
16 KiB
Go
// Copyright 2014 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
// Package trie implements Merkle Patricia Tries.
|
|
package trie
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/crypto/sha3"
|
|
"github.com/ethereum/go-ethereum/log"
|
|
"github.com/rcrowley/go-metrics"
|
|
)
|
|
|
|
var (
|
|
// This is the known root hash of an empty trie.
|
|
emptyRoot = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
|
|
// This is the known hash of an empty state trie entry.
|
|
emptyState common.Hash
|
|
)
|
|
|
|
var (
|
|
cacheMissCounter = metrics.NewRegisteredCounter("trie/cachemiss", nil)
|
|
cacheUnloadCounter = metrics.NewRegisteredCounter("trie/cacheunload", nil)
|
|
)
|
|
|
|
// CacheMisses retrieves a global counter measuring the number of cache misses
|
|
// the trie did since process startup. This isn't useful for anything apart from
|
|
// trie debugging purposes.
|
|
func CacheMisses() int64 {
|
|
return cacheMissCounter.Count()
|
|
}
|
|
|
|
// CacheUnloads retrieves a global counter measuring the number of cache unloads
|
|
// the trie did since process startup. This isn't useful for anything apart from
|
|
// trie debugging purposes.
|
|
func CacheUnloads() int64 {
|
|
return cacheUnloadCounter.Count()
|
|
}
|
|
|
|
func init() {
|
|
sha3.NewKeccak256().Sum(emptyState[:0])
|
|
}
|
|
|
|
// Database must be implemented by backing stores for the trie.
|
|
type Database interface {
|
|
DatabaseReader
|
|
DatabaseWriter
|
|
}
|
|
|
|
// DatabaseReader wraps the Get method of a backing store for the trie.
|
|
type DatabaseReader interface {
|
|
Get(key []byte) (value []byte, err error)
|
|
}
|
|
|
|
// DatabaseWriter wraps the Put method of a backing store for the trie.
|
|
type DatabaseWriter interface {
|
|
// Put stores the mapping key->value in the database.
|
|
// Implementations must not hold onto the value bytes, the trie
|
|
// will reuse the slice across calls to Put.
|
|
Put(key, value []byte) error
|
|
}
|
|
|
|
// 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.
|
|
type Trie struct {
|
|
root node
|
|
db Database
|
|
originalRoot common.Hash
|
|
|
|
// Cache generation values.
|
|
// cachegen increase by one with each commit operation.
|
|
// new nodes are tagged with the current generation and unloaded
|
|
// when their generation is older than than cachegen-cachelimit.
|
|
cachegen, cachelimit uint16
|
|
}
|
|
|
|
// SetCacheLimit sets the number of 'cache generations' to keep.
|
|
// A cache generations is created by a call to Commit.
|
|
func (t *Trie) SetCacheLimit(l uint16) {
|
|
t.cachelimit = l
|
|
}
|
|
|
|
// newFlag returns the cache flag value for a newly created node.
|
|
func (t *Trie) newFlag() nodeFlag {
|
|
return nodeFlag{dirty: true, gen: t.cachegen}
|
|
}
|
|
|
|
// 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 New(root common.Hash, db Database) (*Trie, error) {
|
|
trie := &Trie{db: db, originalRoot: root}
|
|
if (root != common.Hash{}) && root != emptyRoot {
|
|
if db == nil {
|
|
panic("trie.New: cannot use existing root without a database")
|
|
}
|
|
rootnode, err := trie.resolveHash(root[:], nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
trie.root = rootnode
|
|
}
|
|
return trie, nil
|
|
}
|
|
|
|
// NodeIterator returns an iterator that returns nodes of the trie. Iteration starts at
|
|
// the key after the given start key.
|
|
func (t *Trie) NodeIterator(start []byte) NodeIterator {
|
|
return newNodeIterator(t, start)
|
|
}
|
|
|
|
// Get returns the value for key stored in the trie.
|
|
// The value bytes must not be modified by the caller.
|
|
func (t *Trie) Get(key []byte) []byte {
|
|
res, err := t.TryGet(key)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
|
|
}
|
|
return res
|
|
}
|
|
|
|
// 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 (t *Trie) TryGet(key []byte) ([]byte, error) {
|
|
key = keybytesToHex(key)
|
|
value, newroot, didResolve, err := t.tryGet(t.root, key, 0)
|
|
if err == nil && didResolve {
|
|
t.root = newroot
|
|
}
|
|
return value, err
|
|
}
|
|
|
|
func (t *Trie) tryGet(origNode node, key []byte, pos int) (value []byte, newnode node, didResolve bool, err error) {
|
|
switch n := (origNode).(type) {
|
|
case nil:
|
|
return nil, nil, false, nil
|
|
case valueNode:
|
|
return n, n, false, nil
|
|
case *shortNode:
|
|
if len(key)-pos < len(n.Key) || !bytes.Equal(n.Key, key[pos:pos+len(n.Key)]) {
|
|
// key not found in trie
|
|
return nil, n, false, nil
|
|
}
|
|
value, newnode, didResolve, err = t.tryGet(n.Val, key, pos+len(n.Key))
|
|
if err == nil && didResolve {
|
|
n = n.copy()
|
|
n.Val = newnode
|
|
n.flags.gen = t.cachegen
|
|
}
|
|
return value, n, didResolve, err
|
|
case *fullNode:
|
|
value, newnode, didResolve, err = t.tryGet(n.Children[key[pos]], key, pos+1)
|
|
if err == nil && didResolve {
|
|
n = n.copy()
|
|
n.flags.gen = t.cachegen
|
|
n.Children[key[pos]] = newnode
|
|
}
|
|
return value, n, didResolve, err
|
|
case hashNode:
|
|
child, err := t.resolveHash(n, key[:pos], key[pos:])
|
|
if err != nil {
|
|
return nil, n, true, err
|
|
}
|
|
value, newnode, _, err := t.tryGet(child, key, pos)
|
|
return value, newnode, true, err
|
|
default:
|
|
panic(fmt.Sprintf("%T: invalid node: %v", origNode, origNode))
|
|
}
|
|
}
|
|
|
|
// 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.
|
|
func (t *Trie) Update(key, value []byte) {
|
|
if err := t.TryUpdate(key, value); err != nil {
|
|
log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
|
|
}
|
|
}
|
|
|
|
// 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 (t *Trie) TryUpdate(key, value []byte) error {
|
|
k := keybytesToHex(key)
|
|
if len(value) != 0 {
|
|
_, n, err := t.insert(t.root, nil, k, valueNode(value))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.root = n
|
|
} else {
|
|
_, n, err := t.delete(t.root, nil, k)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.root = n
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (t *Trie) insert(n node, prefix, key []byte, value node) (bool, node, error) {
|
|
if len(key) == 0 {
|
|
if v, ok := n.(valueNode); ok {
|
|
return !bytes.Equal(v, value.(valueNode)), value, nil
|
|
}
|
|
return true, value, nil
|
|
}
|
|
switch n := n.(type) {
|
|
case *shortNode:
|
|
matchlen := prefixLen(key, n.Key)
|
|
// If the whole key matches, keep this short node as is
|
|
// and only update the value.
|
|
if matchlen == len(n.Key) {
|
|
dirty, nn, err := t.insert(n.Val, append(prefix, key[:matchlen]...), key[matchlen:], value)
|
|
if !dirty || err != nil {
|
|
return false, n, err
|
|
}
|
|
return true, &shortNode{n.Key, nn, t.newFlag()}, nil
|
|
}
|
|
// Otherwise branch out at the index where they differ.
|
|
branch := &fullNode{flags: t.newFlag()}
|
|
var err error
|
|
_, branch.Children[n.Key[matchlen]], err = t.insert(nil, append(prefix, n.Key[:matchlen+1]...), n.Key[matchlen+1:], n.Val)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
_, branch.Children[key[matchlen]], err = t.insert(nil, append(prefix, key[:matchlen+1]...), key[matchlen+1:], value)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
// Replace this shortNode with the branch if it occurs at index 0.
|
|
if matchlen == 0 {
|
|
return true, branch, nil
|
|
}
|
|
// Otherwise, replace it with a short node leading up to the branch.
|
|
return true, &shortNode{key[:matchlen], branch, t.newFlag()}, nil
|
|
|
|
case *fullNode:
|
|
dirty, nn, err := t.insert(n.Children[key[0]], append(prefix, key[0]), key[1:], value)
|
|
if !dirty || err != nil {
|
|
return false, n, err
|
|
}
|
|
n = n.copy()
|
|
n.flags = t.newFlag()
|
|
n.Children[key[0]] = nn
|
|
return true, n, nil
|
|
|
|
case nil:
|
|
return true, &shortNode{key, value, t.newFlag()}, nil
|
|
|
|
case hashNode:
|
|
// We've hit a part of the trie that isn't loaded yet. Load
|
|
// the node and insert into it. This leaves all child nodes on
|
|
// the path to the value in the trie.
|
|
rn, err := t.resolveHash(n, prefix, key)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
dirty, nn, err := t.insert(rn, prefix, key, value)
|
|
if !dirty || err != nil {
|
|
return false, rn, err
|
|
}
|
|
return true, nn, nil
|
|
|
|
default:
|
|
panic(fmt.Sprintf("%T: invalid node: %v", n, n))
|
|
}
|
|
}
|
|
|
|
// Delete removes any existing value for key from the trie.
|
|
func (t *Trie) Delete(key []byte) {
|
|
if err := t.TryDelete(key); err != nil {
|
|
log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
|
|
}
|
|
}
|
|
|
|
// TryDelete removes any existing value for key from the trie.
|
|
// If a node was not found in the database, a MissingNodeError is returned.
|
|
func (t *Trie) TryDelete(key []byte) error {
|
|
k := keybytesToHex(key)
|
|
_, n, err := t.delete(t.root, nil, k)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.root = n
|
|
return nil
|
|
}
|
|
|
|
// delete returns the new root of the trie with key deleted.
|
|
// It reduces the trie to minimal form by simplifying
|
|
// nodes on the way up after deleting recursively.
|
|
func (t *Trie) delete(n node, prefix, key []byte) (bool, node, error) {
|
|
switch n := n.(type) {
|
|
case *shortNode:
|
|
matchlen := prefixLen(key, n.Key)
|
|
if matchlen < len(n.Key) {
|
|
return false, n, nil // don't replace n on mismatch
|
|
}
|
|
if matchlen == len(key) {
|
|
return true, nil, nil // remove n entirely for whole matches
|
|
}
|
|
// The key is longer than n.Key. Remove the remaining suffix
|
|
// from the subtrie. Child can never be nil here since the
|
|
// subtrie must contain at least two other values with keys
|
|
// longer than n.Key.
|
|
dirty, child, err := t.delete(n.Val, append(prefix, key[:len(n.Key)]...), key[len(n.Key):])
|
|
if !dirty || err != nil {
|
|
return false, n, err
|
|
}
|
|
switch child := child.(type) {
|
|
case *shortNode:
|
|
// Deleting from the subtrie reduced it to another
|
|
// short node. Merge the nodes to avoid creating a
|
|
// shortNode{..., shortNode{...}}. Use concat (which
|
|
// always creates a new slice) instead of append to
|
|
// avoid modifying n.Key since it might be shared with
|
|
// other nodes.
|
|
return true, &shortNode{concat(n.Key, child.Key...), child.Val, t.newFlag()}, nil
|
|
default:
|
|
return true, &shortNode{n.Key, child, t.newFlag()}, nil
|
|
}
|
|
|
|
case *fullNode:
|
|
dirty, nn, err := t.delete(n.Children[key[0]], append(prefix, key[0]), key[1:])
|
|
if !dirty || err != nil {
|
|
return false, n, err
|
|
}
|
|
n = n.copy()
|
|
n.flags = t.newFlag()
|
|
n.Children[key[0]] = nn
|
|
|
|
// Check how many non-nil entries are left after deleting and
|
|
// reduce the full node to a short node if only one entry is
|
|
// left. Since n must've contained at least two children
|
|
// before deletion (otherwise it would not be a full node) n
|
|
// can never be reduced to nil.
|
|
//
|
|
// When the loop is done, pos contains the index of the single
|
|
// value that is left in n or -2 if n contains at least two
|
|
// values.
|
|
pos := -1
|
|
for i, cld := range n.Children {
|
|
if cld != nil {
|
|
if pos == -1 {
|
|
pos = i
|
|
} else {
|
|
pos = -2
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if pos >= 0 {
|
|
if pos != 16 {
|
|
// If the remaining entry is a short node, it replaces
|
|
// n and its key gets the missing nibble tacked to the
|
|
// front. This avoids creating an invalid
|
|
// shortNode{..., shortNode{...}}. Since the entry
|
|
// might not be loaded yet, resolve it just for this
|
|
// check.
|
|
cnode, err := t.resolve(n.Children[pos], prefix, []byte{byte(pos)})
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
if cnode, ok := cnode.(*shortNode); ok {
|
|
k := append([]byte{byte(pos)}, cnode.Key...)
|
|
return true, &shortNode{k, cnode.Val, t.newFlag()}, nil
|
|
}
|
|
}
|
|
// Otherwise, n is replaced by a one-nibble short node
|
|
// containing the child.
|
|
return true, &shortNode{[]byte{byte(pos)}, n.Children[pos], t.newFlag()}, nil
|
|
}
|
|
// n still contains at least two values and cannot be reduced.
|
|
return true, n, nil
|
|
|
|
case valueNode:
|
|
return true, nil, nil
|
|
|
|
case nil:
|
|
return false, nil, nil
|
|
|
|
case hashNode:
|
|
// We've hit a part of the trie that isn't loaded yet. Load
|
|
// the node and delete from it. This leaves all child nodes on
|
|
// the path to the value in the trie.
|
|
rn, err := t.resolveHash(n, prefix, key)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
dirty, nn, err := t.delete(rn, prefix, key)
|
|
if !dirty || err != nil {
|
|
return false, rn, err
|
|
}
|
|
return true, nn, nil
|
|
|
|
default:
|
|
panic(fmt.Sprintf("%T: invalid node: %v (%v)", n, n, key))
|
|
}
|
|
}
|
|
|
|
func concat(s1 []byte, s2 ...byte) []byte {
|
|
r := make([]byte, len(s1)+len(s2))
|
|
copy(r, s1)
|
|
copy(r[len(s1):], s2)
|
|
return r
|
|
}
|
|
|
|
func (t *Trie) resolve(n node, prefix, suffix []byte) (node, error) {
|
|
if n, ok := n.(hashNode); ok {
|
|
return t.resolveHash(n, prefix, suffix)
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
func (t *Trie) resolveHash(n hashNode, prefix, suffix []byte) (node, error) {
|
|
cacheMissCounter.Inc(1)
|
|
|
|
enc, err := t.db.Get(n)
|
|
if err != nil || enc == nil {
|
|
return nil, &MissingNodeError{
|
|
RootHash: t.originalRoot,
|
|
NodeHash: common.BytesToHash(n),
|
|
PrefixLen: len(prefix),
|
|
SuffixLen: len(suffix),
|
|
}
|
|
}
|
|
dec := mustDecodeNode(n, enc, t.cachegen)
|
|
return dec, nil
|
|
}
|
|
|
|
// Root returns the root hash of the trie.
|
|
// Deprecated: use Hash instead.
|
|
func (t *Trie) Root() []byte { return t.Hash().Bytes() }
|
|
|
|
// 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 (t *Trie) Hash() common.Hash {
|
|
hash, cached, _ := t.hashRoot(nil)
|
|
t.root = cached
|
|
return common.BytesToHash(hash.(hashNode))
|
|
}
|
|
|
|
// Commit writes all nodes 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 (t *Trie) Commit() (root common.Hash, err error) {
|
|
if t.db == nil {
|
|
panic("Commit called on trie with nil database")
|
|
}
|
|
return t.CommitTo(t.db)
|
|
}
|
|
|
|
// CommitTo writes all nodes to the given database.
|
|
// Nodes are stored with their sha3 hash as the key.
|
|
//
|
|
// Committing flushes nodes from memory. Subsequent Get calls will
|
|
// load nodes from the trie's database. Calling code must ensure that
|
|
// the changes made to db are written back to the trie's attached
|
|
// database before using the trie.
|
|
func (t *Trie) CommitTo(db DatabaseWriter) (root common.Hash, err error) {
|
|
hash, cached, err := t.hashRoot(db)
|
|
if err != nil {
|
|
return (common.Hash{}), err
|
|
}
|
|
t.root = cached
|
|
t.cachegen++
|
|
return common.BytesToHash(hash.(hashNode)), nil
|
|
}
|
|
|
|
func (t *Trie) hashRoot(db DatabaseWriter) (node, node, error) {
|
|
if t.root == nil {
|
|
return hashNode(emptyRoot.Bytes()), nil, nil
|
|
}
|
|
h := newHasher(t.cachegen, t.cachelimit)
|
|
defer returnHasherToPool(h)
|
|
return h.hash(t.root, db, true)
|
|
}
|