mirror of
https://gitlab.com/pulsechaincom/go-pulse.git
synced 2024-12-22 19:40:36 +00:00
a13e920af0
Make it so each iterator has exactly one public constructor: - NodeIterators can be created through a method. - Iterators can be created through NewIterator on any NodeIterator.
510 lines
16 KiB
Go
510 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
|
|
}
|
|
|
|
// Iterator returns an iterator over all mappings in the trie.
|
|
func (t *Trie) NodeIterator() NodeIterator {
|
|
return newNodeIterator(t)
|
|
}
|
|
|
|
// 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)
|
|
}
|