123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234 |
- // 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"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- )
- // 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 string `json:"root"`
- CodeHash string `json:"codeHash"`
- Code string `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})
- }
- func (s *StateDB) DumpToCollector(c DumpCollector, excludeCode, excludeStorage, excludeMissingPreimages bool, start []byte, maxResults int) (nextKey []byte) {
- missingPreimages := 0
- c.OnRoot(s.trie.Hash())
- var count int
- it := trie.NewIterator(s.trie.NodeIterator(start))
- for it.Next() {
- var data Account
- if err := rlp.DecodeBytes(it.Value, &data); err != nil {
- panic(err)
- }
- account := DumpAccount{
- Balance: data.Balance.String(),
- Nonce: data.Nonce,
- Root: common.Bytes2Hex(data.Root[:]),
- CodeHash: common.Bytes2Hex(data.CodeHash),
- }
- addrBytes := s.trie.GetKey(it.Key)
- if addrBytes == nil {
- // Preimage missing
- missingPreimages++
- if excludeMissingPreimages {
- continue
- }
- account.SecureKey = it.Key
- }
- addr := common.BytesToAddress(addrBytes)
- obj := newObject(s, addr, data)
- if !excludeCode {
- account.Code = common.Bytes2Hex(obj.Code(s.db))
- }
- if !excludeStorage {
- account.Storage = make(map[common.Hash]string)
- storageIt := trie.NewIterator(obj.getTrie(s.db).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)
- count++
- if maxResults > 0 && count >= maxResults {
- if it.Next() {
- nextKey = it.Key
- }
- break
- }
- }
- if missingPreimages > 0 {
- log.Warn("Dump incomplete due to missing preimages", "missing", missingPreimages)
- }
- return nextKey
- }
- // RawDump returns the entire state an a single large object
- func (s *StateDB) RawDump(excludeCode, excludeStorage, excludeMissingPreimages bool) Dump {
- dump := &Dump{
- Accounts: make(map[common.Address]DumpAccount),
- }
- s.DumpToCollector(dump, excludeCode, excludeStorage, excludeMissingPreimages, nil, 0)
- return *dump
- }
- // Dump returns a JSON string representing the entire state as a single json-object
- func (s *StateDB) Dump(excludeCode, excludeStorage, excludeMissingPreimages bool) []byte {
- dump := s.RawDump(excludeCode, excludeStorage, excludeMissingPreimages)
- json, err := json.MarshalIndent(dump, "", " ")
- if err != nil {
- fmt.Println("Dump err", err)
- }
- return json
- }
- func (self *StateDB) DumpAddress(address common.Address) (DumpAccount, bool) {
- if !self.Exist(address) {
- return DumpAccount{}, false
- }
- obj := self.getStateObject(address)
- account := DumpAccount{
- Balance: obj.data.Balance.String(),
- Nonce: obj.data.Nonce,
- Root: common.Bytes2Hex(obj.data.Root[:]),
- CodeHash: common.Bytes2Hex(obj.data.CodeHash),
- Code: common.Bytes2Hex(obj.Code(self.db)),
- Storage: make(map[common.Hash]string),
- }
- noDataIssue := true
- storageIt := trie.NewIterator(obj.getTrie(self.db).NodeIterator(nil))
- for storageIt.Next() {
- _, content, _, err := rlp.Split(storageIt.Value)
- if err != nil {
- noDataIssue = false
- log.Error("Failed to decode the value returned by iterator", "error", err)
- break
- }
- account.Storage[common.BytesToHash(self.trie.GetKey(storageIt.Key))] = common.Bytes2Hex(content)
- }
- return account, noDataIssue
- }
- // IterativeDump dumps out accounts as json-objects, delimited by linebreaks on stdout
- func (s *StateDB) IterativeDump(excludeCode, excludeStorage, excludeMissingPreimages bool, output *json.Encoder) {
- s.DumpToCollector(iterativeDump{output}, excludeCode, excludeStorage, excludeMissingPreimages, nil, 0)
- }
- // IteratorDump dumps out a batch of accounts starts with the given start key
- func (s *StateDB) IteratorDump(excludeCode, excludeStorage, excludeMissingPreimages bool, start []byte, maxResults int) IteratorDump {
- iterator := &IteratorDump{
- Accounts: make(map[common.Address]DumpAccount),
- }
- iterator.Next = s.DumpToCollector(iterator, excludeCode, excludeStorage, excludeMissingPreimages, start, maxResults)
- return *iterator
- }
|