mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2024-12-24 12:37:16 +00:00
9e5f03b6c4
With this commit, core/state's access to the underlying key/value database is mediated through an interface. Database errors are tracked in StateDB and returned by CommitTo or the new Error method. Motivation for this change: We can remove the light client's duplicated copy of core/state. The light client now supports node iteration, so tracing and storage enumeration can work with the light client (not implemented in this commit).
623 lines
19 KiB
Go
623 lines
19 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 provides a caching layer atop the Ethereum state trie.
|
|
package state
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
"sort"
|
|
"sync"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/log"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
"github.com/ethereum/go-ethereum/trie"
|
|
)
|
|
|
|
type revision struct {
|
|
id int
|
|
journalIndex int
|
|
}
|
|
|
|
// StateDBs within the ethereum protocol are used to store anything
|
|
// within the merkle trie. StateDBs take care of caching and storing
|
|
// nested states. It's the general query interface to retrieve:
|
|
// * Contracts
|
|
// * Accounts
|
|
type StateDB struct {
|
|
db Database
|
|
trie Trie
|
|
|
|
// This map holds 'live' objects, which will get modified while processing a state transition.
|
|
stateObjects map[common.Address]*stateObject
|
|
stateObjectsDirty map[common.Address]struct{}
|
|
stateObjectsDestructed map[common.Address]struct{}
|
|
|
|
// DB error.
|
|
// State objects are used by the consensus core and VM which are
|
|
// unable to deal with database-level errors. Any error that occurs
|
|
// during a database read is memoized here and will eventually be returned
|
|
// by StateDB.Commit.
|
|
dbErr error
|
|
|
|
// The refund counter, also used by state transitioning.
|
|
refund *big.Int
|
|
|
|
thash, bhash common.Hash
|
|
txIndex int
|
|
logs map[common.Hash][]*types.Log
|
|
logSize uint
|
|
|
|
preimages map[common.Hash][]byte
|
|
|
|
// Journal of state modifications. This is the backbone of
|
|
// Snapshot and RevertToSnapshot.
|
|
journal journal
|
|
validRevisions []revision
|
|
nextRevisionId int
|
|
|
|
lock sync.Mutex
|
|
}
|
|
|
|
// Create a new state from a given trie
|
|
func New(root common.Hash, db Database) (*StateDB, error) {
|
|
tr, err := db.OpenTrie(root)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StateDB{
|
|
db: db,
|
|
trie: tr,
|
|
stateObjects: make(map[common.Address]*stateObject),
|
|
stateObjectsDirty: make(map[common.Address]struct{}),
|
|
stateObjectsDestructed: make(map[common.Address]struct{}),
|
|
refund: new(big.Int),
|
|
logs: make(map[common.Hash][]*types.Log),
|
|
preimages: make(map[common.Hash][]byte),
|
|
}, nil
|
|
}
|
|
|
|
// setError remembers the first non-nil error it is called with.
|
|
func (self *StateDB) setError(err error) {
|
|
if self.dbErr == nil {
|
|
self.dbErr = err
|
|
}
|
|
}
|
|
|
|
func (self *StateDB) Error() error {
|
|
return self.dbErr
|
|
}
|
|
|
|
// Reset clears out all emphemeral state objects from the state db, but keeps
|
|
// the underlying state trie to avoid reloading data for the next operations.
|
|
func (self *StateDB) Reset(root common.Hash) error {
|
|
tr, err := self.db.OpenTrie(root)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
self.trie = tr
|
|
self.stateObjects = make(map[common.Address]*stateObject)
|
|
self.stateObjectsDirty = make(map[common.Address]struct{})
|
|
self.stateObjectsDestructed = make(map[common.Address]struct{})
|
|
self.thash = common.Hash{}
|
|
self.bhash = common.Hash{}
|
|
self.txIndex = 0
|
|
self.logs = make(map[common.Hash][]*types.Log)
|
|
self.logSize = 0
|
|
self.preimages = make(map[common.Hash][]byte)
|
|
self.clearJournalAndRefund()
|
|
return nil
|
|
}
|
|
|
|
func (self *StateDB) AddLog(log *types.Log) {
|
|
self.journal = append(self.journal, addLogChange{txhash: self.thash})
|
|
|
|
log.TxHash = self.thash
|
|
log.BlockHash = self.bhash
|
|
log.TxIndex = uint(self.txIndex)
|
|
log.Index = self.logSize
|
|
self.logs[self.thash] = append(self.logs[self.thash], log)
|
|
self.logSize++
|
|
}
|
|
|
|
func (self *StateDB) GetLogs(hash common.Hash) []*types.Log {
|
|
return self.logs[hash]
|
|
}
|
|
|
|
func (self *StateDB) Logs() []*types.Log {
|
|
var logs []*types.Log
|
|
for _, lgs := range self.logs {
|
|
logs = append(logs, lgs...)
|
|
}
|
|
return logs
|
|
}
|
|
|
|
// AddPreimage records a SHA3 preimage seen by the VM.
|
|
func (self *StateDB) AddPreimage(hash common.Hash, preimage []byte) {
|
|
if _, ok := self.preimages[hash]; !ok {
|
|
self.journal = append(self.journal, addPreimageChange{hash: hash})
|
|
pi := make([]byte, len(preimage))
|
|
copy(pi, preimage)
|
|
self.preimages[hash] = pi
|
|
}
|
|
}
|
|
|
|
// Preimages returns a list of SHA3 preimages that have been submitted.
|
|
func (self *StateDB) Preimages() map[common.Hash][]byte {
|
|
return self.preimages
|
|
}
|
|
|
|
func (self *StateDB) AddRefund(gas *big.Int) {
|
|
self.journal = append(self.journal, refundChange{prev: new(big.Int).Set(self.refund)})
|
|
self.refund.Add(self.refund, gas)
|
|
}
|
|
|
|
// Exist reports whether the given account address exists in the state.
|
|
// Notably this also returns true for suicided accounts.
|
|
func (self *StateDB) Exist(addr common.Address) bool {
|
|
return self.getStateObject(addr) != nil
|
|
}
|
|
|
|
// Empty returns whether the state object is either non-existent
|
|
// or empty according to the EIP161 specification (balance = nonce = code = 0)
|
|
func (self *StateDB) Empty(addr common.Address) bool {
|
|
so := self.getStateObject(addr)
|
|
return so == nil || so.empty()
|
|
}
|
|
|
|
// Retrieve the balance from the given address or 0 if object not found
|
|
func (self *StateDB) GetBalance(addr common.Address) *big.Int {
|
|
stateObject := self.getStateObject(addr)
|
|
if stateObject != nil {
|
|
return stateObject.Balance()
|
|
}
|
|
return common.Big0
|
|
}
|
|
|
|
func (self *StateDB) GetNonce(addr common.Address) uint64 {
|
|
stateObject := self.getStateObject(addr)
|
|
if stateObject != nil {
|
|
return stateObject.Nonce()
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
func (self *StateDB) GetCode(addr common.Address) []byte {
|
|
stateObject := self.getStateObject(addr)
|
|
if stateObject != nil {
|
|
return stateObject.Code(self.db)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (self *StateDB) GetCodeSize(addr common.Address) int {
|
|
stateObject := self.getStateObject(addr)
|
|
if stateObject == nil {
|
|
return 0
|
|
}
|
|
if stateObject.code != nil {
|
|
return len(stateObject.code)
|
|
}
|
|
size, err := self.db.ContractCodeSize(stateObject.addrHash, common.BytesToHash(stateObject.CodeHash()))
|
|
if err != nil {
|
|
self.setError(err)
|
|
}
|
|
return size
|
|
}
|
|
|
|
func (self *StateDB) GetCodeHash(addr common.Address) common.Hash {
|
|
stateObject := self.getStateObject(addr)
|
|
if stateObject == nil {
|
|
return common.Hash{}
|
|
}
|
|
return common.BytesToHash(stateObject.CodeHash())
|
|
}
|
|
|
|
func (self *StateDB) GetState(a common.Address, b common.Hash) common.Hash {
|
|
stateObject := self.getStateObject(a)
|
|
if stateObject != nil {
|
|
return stateObject.GetState(self.db, b)
|
|
}
|
|
return common.Hash{}
|
|
}
|
|
|
|
// StorageTrie returns the storage trie of an account.
|
|
// The return value is a copy and is nil for non-existent accounts.
|
|
func (self *StateDB) StorageTrie(a common.Address) Trie {
|
|
stateObject := self.getStateObject(a)
|
|
if stateObject == nil {
|
|
return nil
|
|
}
|
|
cpy := stateObject.deepCopy(self, nil)
|
|
return cpy.updateTrie(self.db)
|
|
}
|
|
|
|
func (self *StateDB) HasSuicided(addr common.Address) bool {
|
|
stateObject := self.getStateObject(addr)
|
|
if stateObject != nil {
|
|
return stateObject.suicided
|
|
}
|
|
return false
|
|
}
|
|
|
|
/*
|
|
* SETTERS
|
|
*/
|
|
|
|
// AddBalance adds amount to the account associated with addr
|
|
func (self *StateDB) AddBalance(addr common.Address, amount *big.Int) {
|
|
stateObject := self.GetOrNewStateObject(addr)
|
|
if stateObject != nil {
|
|
stateObject.AddBalance(amount)
|
|
}
|
|
}
|
|
|
|
// SubBalance subtracts amount from the account associated with addr
|
|
func (self *StateDB) SubBalance(addr common.Address, amount *big.Int) {
|
|
stateObject := self.GetOrNewStateObject(addr)
|
|
if stateObject != nil {
|
|
stateObject.SubBalance(amount)
|
|
}
|
|
}
|
|
|
|
func (self *StateDB) SetBalance(addr common.Address, amount *big.Int) {
|
|
stateObject := self.GetOrNewStateObject(addr)
|
|
if stateObject != nil {
|
|
stateObject.SetBalance(amount)
|
|
}
|
|
}
|
|
|
|
func (self *StateDB) SetNonce(addr common.Address, nonce uint64) {
|
|
stateObject := self.GetOrNewStateObject(addr)
|
|
if stateObject != nil {
|
|
stateObject.SetNonce(nonce)
|
|
}
|
|
}
|
|
|
|
func (self *StateDB) SetCode(addr common.Address, code []byte) {
|
|
stateObject := self.GetOrNewStateObject(addr)
|
|
if stateObject != nil {
|
|
stateObject.SetCode(crypto.Keccak256Hash(code), code)
|
|
}
|
|
}
|
|
|
|
func (self *StateDB) SetState(addr common.Address, key common.Hash, value common.Hash) {
|
|
stateObject := self.GetOrNewStateObject(addr)
|
|
if stateObject != nil {
|
|
stateObject.SetState(self.db, key, value)
|
|
}
|
|
}
|
|
|
|
// Suicide marks the given account as suicided.
|
|
// This clears the account balance.
|
|
//
|
|
// The account's state object is still available until the state is committed,
|
|
// getStateObject will return a non-nil account after Suicide.
|
|
func (self *StateDB) Suicide(addr common.Address) bool {
|
|
stateObject := self.getStateObject(addr)
|
|
if stateObject == nil {
|
|
return false
|
|
}
|
|
self.journal = append(self.journal, suicideChange{
|
|
account: &addr,
|
|
prev: stateObject.suicided,
|
|
prevbalance: new(big.Int).Set(stateObject.Balance()),
|
|
})
|
|
stateObject.markSuicided()
|
|
stateObject.data.Balance = new(big.Int)
|
|
self.stateObjectsDestructed[addr] = struct{}{}
|
|
|
|
return true
|
|
}
|
|
|
|
//
|
|
// Setting, updating & deleting state object methods
|
|
//
|
|
|
|
// updateStateObject writes the given object to the trie.
|
|
func (self *StateDB) updateStateObject(stateObject *stateObject) {
|
|
addr := stateObject.Address()
|
|
data, err := rlp.EncodeToBytes(stateObject)
|
|
if err != nil {
|
|
panic(fmt.Errorf("can't encode object at %x: %v", addr[:], err))
|
|
}
|
|
self.setError(self.trie.TryUpdate(addr[:], data))
|
|
}
|
|
|
|
// deleteStateObject removes the given object from the state trie.
|
|
func (self *StateDB) deleteStateObject(stateObject *stateObject) {
|
|
stateObject.deleted = true
|
|
addr := stateObject.Address()
|
|
self.setError(self.trie.TryDelete(addr[:]))
|
|
}
|
|
|
|
// Retrieve a state object given my the address. Returns nil if not found.
|
|
func (self *StateDB) getStateObject(addr common.Address) (stateObject *stateObject) {
|
|
// Prefer 'live' objects.
|
|
if obj := self.stateObjects[addr]; obj != nil {
|
|
if obj.deleted {
|
|
return nil
|
|
}
|
|
return obj
|
|
}
|
|
|
|
// Load the object from the database.
|
|
enc, err := self.trie.TryGet(addr[:])
|
|
if len(enc) == 0 {
|
|
self.setError(err)
|
|
return nil
|
|
}
|
|
var data Account
|
|
if err := rlp.DecodeBytes(enc, &data); err != nil {
|
|
log.Error("Failed to decode state object", "addr", addr, "err", err)
|
|
return nil
|
|
}
|
|
// Insert into the live set.
|
|
obj := newObject(self, addr, data, self.MarkStateObjectDirty)
|
|
self.setStateObject(obj)
|
|
return obj
|
|
}
|
|
|
|
func (self *StateDB) setStateObject(object *stateObject) {
|
|
self.stateObjects[object.Address()] = object
|
|
}
|
|
|
|
// Retrieve a state object or create a new state object if nil
|
|
func (self *StateDB) GetOrNewStateObject(addr common.Address) *stateObject {
|
|
stateObject := self.getStateObject(addr)
|
|
if stateObject == nil || stateObject.deleted {
|
|
stateObject, _ = self.createObject(addr)
|
|
}
|
|
return stateObject
|
|
}
|
|
|
|
// MarkStateObjectDirty adds the specified object to the dirty map to avoid costly
|
|
// state object cache iteration to find a handful of modified ones.
|
|
func (self *StateDB) MarkStateObjectDirty(addr common.Address) {
|
|
self.stateObjectsDirty[addr] = struct{}{}
|
|
}
|
|
|
|
// createObject creates a new state object. If there is an existing account with
|
|
// the given address, it is overwritten and returned as the second return value.
|
|
func (self *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) {
|
|
prev = self.getStateObject(addr)
|
|
newobj = newObject(self, addr, Account{}, self.MarkStateObjectDirty)
|
|
newobj.setNonce(0) // sets the object to dirty
|
|
if prev == nil {
|
|
self.journal = append(self.journal, createObjectChange{account: &addr})
|
|
} else {
|
|
self.journal = append(self.journal, resetObjectChange{prev: prev})
|
|
}
|
|
self.setStateObject(newobj)
|
|
return newobj, prev
|
|
}
|
|
|
|
// CreateAccount explicitly creates a state object. If a state object with the address
|
|
// already exists the balance is carried over to the new account.
|
|
//
|
|
// CreateAccount is called during the EVM CREATE operation. The situation might arise that
|
|
// a contract does the following:
|
|
//
|
|
// 1. sends funds to sha(account ++ (nonce + 1))
|
|
// 2. tx_create(sha(account ++ nonce)) (note that this gets the address of 1)
|
|
//
|
|
// Carrying over the balance ensures that Ether doesn't disappear.
|
|
func (self *StateDB) CreateAccount(addr common.Address) {
|
|
new, prev := self.createObject(addr)
|
|
if prev != nil {
|
|
new.setBalance(prev.data.Balance)
|
|
}
|
|
}
|
|
|
|
func (db *StateDB) ForEachStorage(addr common.Address, cb func(key, value common.Hash) bool) {
|
|
so := db.getStateObject(addr)
|
|
if so == nil {
|
|
return
|
|
}
|
|
|
|
// When iterating over the storage check the cache first
|
|
for h, value := range so.cachedStorage {
|
|
cb(h, value)
|
|
}
|
|
|
|
it := trie.NewIterator(so.getTrie(db.db).NodeIterator(nil))
|
|
for it.Next() {
|
|
// ignore cached values
|
|
key := common.BytesToHash(db.trie.GetKey(it.Key))
|
|
if _, ok := so.cachedStorage[key]; !ok {
|
|
cb(key, common.BytesToHash(it.Value))
|
|
}
|
|
}
|
|
}
|
|
|
|
// Copy creates a deep, independent copy of the state.
|
|
// Snapshots of the copied state cannot be applied to the copy.
|
|
func (self *StateDB) Copy() *StateDB {
|
|
self.lock.Lock()
|
|
defer self.lock.Unlock()
|
|
|
|
// Copy all the basic fields, initialize the memory ones
|
|
state := &StateDB{
|
|
db: self.db,
|
|
trie: self.trie,
|
|
stateObjects: make(map[common.Address]*stateObject, len(self.stateObjectsDirty)),
|
|
stateObjectsDirty: make(map[common.Address]struct{}, len(self.stateObjectsDirty)),
|
|
stateObjectsDestructed: make(map[common.Address]struct{}, len(self.stateObjectsDestructed)),
|
|
refund: new(big.Int).Set(self.refund),
|
|
logs: make(map[common.Hash][]*types.Log, len(self.logs)),
|
|
logSize: self.logSize,
|
|
preimages: make(map[common.Hash][]byte),
|
|
}
|
|
// Copy the dirty states, logs, and preimages
|
|
for addr := range self.stateObjectsDirty {
|
|
state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state, state.MarkStateObjectDirty)
|
|
state.stateObjectsDirty[addr] = struct{}{}
|
|
if self.stateObjects[addr].suicided {
|
|
state.stateObjectsDestructed[addr] = struct{}{}
|
|
}
|
|
}
|
|
for hash, logs := range self.logs {
|
|
state.logs[hash] = make([]*types.Log, len(logs))
|
|
copy(state.logs[hash], logs)
|
|
}
|
|
for hash, preimage := range self.preimages {
|
|
state.preimages[hash] = preimage
|
|
}
|
|
return state
|
|
}
|
|
|
|
// Snapshot returns an identifier for the current revision of the state.
|
|
func (self *StateDB) Snapshot() int {
|
|
id := self.nextRevisionId
|
|
self.nextRevisionId++
|
|
self.validRevisions = append(self.validRevisions, revision{id, len(self.journal)})
|
|
return id
|
|
}
|
|
|
|
// RevertToSnapshot reverts all state changes made since the given revision.
|
|
func (self *StateDB) RevertToSnapshot(revid int) {
|
|
// Find the snapshot in the stack of valid snapshots.
|
|
idx := sort.Search(len(self.validRevisions), func(i int) bool {
|
|
return self.validRevisions[i].id >= revid
|
|
})
|
|
if idx == len(self.validRevisions) || self.validRevisions[idx].id != revid {
|
|
panic(fmt.Errorf("revision id %v cannot be reverted", revid))
|
|
}
|
|
snapshot := self.validRevisions[idx].journalIndex
|
|
|
|
// Replay the journal to undo changes.
|
|
for i := len(self.journal) - 1; i >= snapshot; i-- {
|
|
self.journal[i].undo(self)
|
|
}
|
|
self.journal = self.journal[:snapshot]
|
|
|
|
// Remove invalidated snapshots from the stack.
|
|
self.validRevisions = self.validRevisions[:idx]
|
|
}
|
|
|
|
// GetRefund returns the current value of the refund counter.
|
|
// The return value must not be modified by the caller and will become
|
|
// invalid at the next call to AddRefund.
|
|
func (self *StateDB) GetRefund() *big.Int {
|
|
return self.refund
|
|
}
|
|
|
|
// IntermediateRoot computes the current root hash of the state trie.
|
|
// It is called in between transactions to get the root hash that
|
|
// goes into transaction receipts.
|
|
func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
|
|
for addr := range s.stateObjectsDirty {
|
|
stateObject := s.stateObjects[addr]
|
|
if stateObject.suicided || (deleteEmptyObjects && stateObject.empty()) {
|
|
s.deleteStateObject(stateObject)
|
|
} else {
|
|
stateObject.updateRoot(s.db)
|
|
s.updateStateObject(stateObject)
|
|
}
|
|
}
|
|
// Invalidate journal because reverting across transactions is not allowed.
|
|
s.clearJournalAndRefund()
|
|
return s.trie.Hash()
|
|
}
|
|
|
|
// Prepare sets the current transaction hash and index and block hash which is
|
|
// used when the EVM emits new state logs.
|
|
func (self *StateDB) Prepare(thash, bhash common.Hash, ti int) {
|
|
self.thash = thash
|
|
self.bhash = bhash
|
|
self.txIndex = ti
|
|
}
|
|
|
|
// Finalise finalises the state by removing the self destructed objects
|
|
// in the current stateObjectsDestructed buffer and clears the journal
|
|
// as well as the refunds.
|
|
//
|
|
// Please note that Finalise is used by EIP#98 and is used instead of
|
|
// IntermediateRoot.
|
|
func (s *StateDB) Finalise() {
|
|
for addr := range s.stateObjectsDestructed {
|
|
s.deleteStateObject(s.stateObjects[addr])
|
|
}
|
|
s.clearJournalAndRefund()
|
|
}
|
|
|
|
// DeleteSuicides flags the suicided objects for deletion so that it
|
|
// won't be referenced again when called / queried up on.
|
|
//
|
|
// DeleteSuicides should not be used for consensus related updates
|
|
// under any circumstances.
|
|
func (s *StateDB) DeleteSuicides() {
|
|
// Reset refund so that any used-gas calculations can use this method.
|
|
s.clearJournalAndRefund()
|
|
|
|
for addr := range s.stateObjectsDirty {
|
|
stateObject := s.stateObjects[addr]
|
|
|
|
// If the object has been removed by a suicide
|
|
// flag the object as deleted.
|
|
if stateObject.suicided {
|
|
stateObject.deleted = true
|
|
}
|
|
delete(s.stateObjectsDirty, addr)
|
|
}
|
|
}
|
|
|
|
func (s *StateDB) clearJournalAndRefund() {
|
|
s.journal = nil
|
|
s.validRevisions = s.validRevisions[:0]
|
|
s.refund = new(big.Int)
|
|
}
|
|
|
|
// CommitTo writes the state to the given database.
|
|
func (s *StateDB) CommitTo(dbw trie.DatabaseWriter, deleteEmptyObjects bool) (root common.Hash, err error) {
|
|
defer s.clearJournalAndRefund()
|
|
|
|
// Commit objects to the trie.
|
|
for addr, stateObject := range s.stateObjects {
|
|
_, isDirty := s.stateObjectsDirty[addr]
|
|
switch {
|
|
case stateObject.suicided || (isDirty && deleteEmptyObjects && stateObject.empty()):
|
|
// If the object has been removed, don't bother syncing it
|
|
// and just mark it for deletion in the trie.
|
|
s.deleteStateObject(stateObject)
|
|
case isDirty:
|
|
// Write any contract code associated with the state object
|
|
if stateObject.code != nil && stateObject.dirtyCode {
|
|
if err := dbw.Put(stateObject.CodeHash(), stateObject.code); err != nil {
|
|
return common.Hash{}, err
|
|
}
|
|
stateObject.dirtyCode = false
|
|
}
|
|
// Write any storage changes in the state object to its storage trie.
|
|
if err := stateObject.CommitTrie(s.db, dbw); err != nil {
|
|
return common.Hash{}, err
|
|
}
|
|
// Update the object in the main account trie.
|
|
s.updateStateObject(stateObject)
|
|
}
|
|
delete(s.stateObjectsDirty, addr)
|
|
}
|
|
// Write trie changes.
|
|
root, err = s.trie.CommitTo(dbw)
|
|
log.Debug("Trie cache stats after commit", "misses", trie.CacheMisses(), "unloads", trie.CacheUnloads())
|
|
return root, err
|
|
}
|