01808421e2
This changes the StorageTrie method to return an error when the trie is not available. It used to return an 'empty trie' in this case, but that's not possible anymore under PBSS.
241 lines
7.3 KiB
Go
241 lines
7.3 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 state
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/log"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
"github.com/ethereum/go-ethereum/trie"
|
|
)
|
|
|
|
// DumpConfig is a set of options to control what portions of the state will be
|
|
// iterated and collected.
|
|
type DumpConfig struct {
|
|
SkipCode bool
|
|
SkipStorage bool
|
|
OnlyWithAddresses bool
|
|
Start []byte
|
|
Max uint64
|
|
}
|
|
|
|
// DumpCollector interface which the state trie calls during iteration
|
|
type DumpCollector interface {
|
|
// OnRoot is called with the state root
|
|
OnRoot(common.Hash)
|
|
// OnAccount is called once for each account in the trie
|
|
OnAccount(common.Address, DumpAccount)
|
|
}
|
|
|
|
// DumpAccount represents an account in the state.
|
|
type DumpAccount struct {
|
|
Balance string `json:"balance"`
|
|
Nonce uint64 `json:"nonce"`
|
|
Root hexutil.Bytes `json:"root"`
|
|
CodeHash hexutil.Bytes `json:"codeHash"`
|
|
Code hexutil.Bytes `json:"code,omitempty"`
|
|
Storage map[common.Hash]string `json:"storage,omitempty"`
|
|
Address *common.Address `json:"address,omitempty"` // Address only present in iterative (line-by-line) mode
|
|
SecureKey hexutil.Bytes `json:"key,omitempty"` // If we don't have address, we can output the key
|
|
|
|
}
|
|
|
|
// Dump represents the full dump in a collected format, as one large map.
|
|
type Dump struct {
|
|
Root string `json:"root"`
|
|
Accounts map[common.Address]DumpAccount `json:"accounts"`
|
|
}
|
|
|
|
// OnRoot implements DumpCollector interface
|
|
func (d *Dump) OnRoot(root common.Hash) {
|
|
d.Root = fmt.Sprintf("%x", root)
|
|
}
|
|
|
|
// OnAccount implements DumpCollector interface
|
|
func (d *Dump) OnAccount(addr common.Address, account DumpAccount) {
|
|
d.Accounts[addr] = account
|
|
}
|
|
|
|
// IteratorDump is an implementation for iterating over data.
|
|
type IteratorDump struct {
|
|
Root string `json:"root"`
|
|
Accounts map[common.Address]DumpAccount `json:"accounts"`
|
|
Next []byte `json:"next,omitempty"` // nil if no more accounts
|
|
}
|
|
|
|
// OnRoot implements DumpCollector interface
|
|
func (d *IteratorDump) OnRoot(root common.Hash) {
|
|
d.Root = fmt.Sprintf("%x", root)
|
|
}
|
|
|
|
// OnAccount implements DumpCollector interface
|
|
func (d *IteratorDump) OnAccount(addr common.Address, account DumpAccount) {
|
|
d.Accounts[addr] = account
|
|
}
|
|
|
|
// iterativeDump is a DumpCollector-implementation which dumps output line-by-line iteratively.
|
|
type iterativeDump struct {
|
|
*json.Encoder
|
|
}
|
|
|
|
// OnAccount implements DumpCollector interface
|
|
func (d iterativeDump) OnAccount(addr common.Address, account DumpAccount) {
|
|
dumpAccount := &DumpAccount{
|
|
Balance: account.Balance,
|
|
Nonce: account.Nonce,
|
|
Root: account.Root,
|
|
CodeHash: account.CodeHash,
|
|
Code: account.Code,
|
|
Storage: account.Storage,
|
|
SecureKey: account.SecureKey,
|
|
Address: nil,
|
|
}
|
|
if addr != (common.Address{}) {
|
|
dumpAccount.Address = &addr
|
|
}
|
|
d.Encode(dumpAccount)
|
|
}
|
|
|
|
// OnRoot implements DumpCollector interface
|
|
func (d iterativeDump) OnRoot(root common.Hash) {
|
|
d.Encode(struct {
|
|
Root common.Hash `json:"root"`
|
|
}{root})
|
|
}
|
|
|
|
// DumpToCollector iterates the state according to the given options and inserts
|
|
// the items into a collector for aggregation or serialization.
|
|
func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey []byte) {
|
|
// Sanitize the input to allow nil configs
|
|
if conf == nil {
|
|
conf = new(DumpConfig)
|
|
}
|
|
var (
|
|
missingPreimages int
|
|
accounts uint64
|
|
start = time.Now()
|
|
logged = time.Now()
|
|
)
|
|
log.Info("Trie dumping started", "root", s.trie.Hash())
|
|
c.OnRoot(s.trie.Hash())
|
|
|
|
it := trie.NewIterator(s.trie.NodeIterator(conf.Start))
|
|
for it.Next() {
|
|
var data types.StateAccount
|
|
if err := rlp.DecodeBytes(it.Value, &data); err != nil {
|
|
panic(err)
|
|
}
|
|
account := DumpAccount{
|
|
Balance: data.Balance.String(),
|
|
Nonce: data.Nonce,
|
|
Root: data.Root[:],
|
|
CodeHash: data.CodeHash,
|
|
SecureKey: it.Key,
|
|
}
|
|
addrBytes := s.trie.GetKey(it.Key)
|
|
if addrBytes == nil {
|
|
// Preimage missing
|
|
missingPreimages++
|
|
if conf.OnlyWithAddresses {
|
|
continue
|
|
}
|
|
account.SecureKey = it.Key
|
|
}
|
|
addr := common.BytesToAddress(addrBytes)
|
|
obj := newObject(s, addr, data)
|
|
if !conf.SkipCode {
|
|
account.Code = obj.Code(s.db)
|
|
}
|
|
if !conf.SkipStorage {
|
|
account.Storage = make(map[common.Hash]string)
|
|
tr, err := obj.getTrie(s.db)
|
|
if err != nil {
|
|
log.Error("Failed to load storage trie", "err", err)
|
|
continue
|
|
}
|
|
storageIt := trie.NewIterator(tr.NodeIterator(nil))
|
|
for storageIt.Next() {
|
|
_, content, _, err := rlp.Split(storageIt.Value)
|
|
if err != nil {
|
|
log.Error("Failed to decode the value returned by iterator", "error", err)
|
|
continue
|
|
}
|
|
account.Storage[common.BytesToHash(s.trie.GetKey(storageIt.Key))] = common.Bytes2Hex(content)
|
|
}
|
|
}
|
|
c.OnAccount(addr, account)
|
|
accounts++
|
|
if time.Since(logged) > 8*time.Second {
|
|
log.Info("Trie dumping in progress", "at", it.Key, "accounts", accounts,
|
|
"elapsed", common.PrettyDuration(time.Since(start)))
|
|
logged = time.Now()
|
|
}
|
|
if conf.Max > 0 && accounts >= conf.Max {
|
|
if it.Next() {
|
|
nextKey = it.Key
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if missingPreimages > 0 {
|
|
log.Warn("Dump incomplete due to missing preimages", "missing", missingPreimages)
|
|
}
|
|
log.Info("Trie dumping complete", "accounts", accounts,
|
|
"elapsed", common.PrettyDuration(time.Since(start)))
|
|
|
|
return nextKey
|
|
}
|
|
|
|
// RawDump returns the entire state an a single large object
|
|
func (s *StateDB) RawDump(opts *DumpConfig) Dump {
|
|
dump := &Dump{
|
|
Accounts: make(map[common.Address]DumpAccount),
|
|
}
|
|
s.DumpToCollector(dump, opts)
|
|
return *dump
|
|
}
|
|
|
|
// Dump returns a JSON string representing the entire state as a single json-object
|
|
func (s *StateDB) Dump(opts *DumpConfig) []byte {
|
|
dump := s.RawDump(opts)
|
|
json, err := json.MarshalIndent(dump, "", " ")
|
|
if err != nil {
|
|
fmt.Println("Dump err", err)
|
|
}
|
|
return json
|
|
}
|
|
|
|
// IterativeDump dumps out accounts as json-objects, delimited by linebreaks on stdout
|
|
func (s *StateDB) IterativeDump(opts *DumpConfig, output *json.Encoder) {
|
|
s.DumpToCollector(iterativeDump{output}, opts)
|
|
}
|
|
|
|
// IteratorDump dumps out a batch of accounts starts with the given start key
|
|
func (s *StateDB) IteratorDump(opts *DumpConfig) IteratorDump {
|
|
iterator := &IteratorDump{
|
|
Accounts: make(map[common.Address]DumpAccount),
|
|
}
|
|
iterator.Next = s.DumpToCollector(iterator, opts)
|
|
return *iterator
|
|
}
|