github.com/skoak/go-ethereum@v1.9.7/core/state/statedb.go (about)

     1  // Copyright 2014 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-ethereum library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  // Package state provides a caching layer atop the Ethereum state trie.
    18  package state
    19  
    20  import (
    21  	"errors"
    22  	"fmt"
    23  	"math/big"
    24  	"sort"
    25  	"time"
    26  
    27  	"github.com/ethereum/go-ethereum/common"
    28  	"github.com/ethereum/go-ethereum/core/types"
    29  	"github.com/ethereum/go-ethereum/crypto"
    30  	"github.com/ethereum/go-ethereum/log"
    31  	"github.com/ethereum/go-ethereum/metrics"
    32  	"github.com/ethereum/go-ethereum/rlp"
    33  	"github.com/ethereum/go-ethereum/trie"
    34  )
    35  
    36  type revision struct {
    37  	id           int
    38  	journalIndex int
    39  }
    40  
    41  var (
    42  	// emptyRoot is the known root hash of an empty trie.
    43  	emptyRoot = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
    44  
    45  	// emptyCode is the known hash of the empty EVM bytecode.
    46  	emptyCode = crypto.Keccak256Hash(nil)
    47  )
    48  
    49  type proofList [][]byte
    50  
    51  func (n *proofList) Put(key []byte, value []byte) error {
    52  	*n = append(*n, value)
    53  	return nil
    54  }
    55  
    56  func (n *proofList) Delete(key []byte) error {
    57  	panic("not supported")
    58  }
    59  
    60  // StateDBs within the ethereum protocol are used to store anything
    61  // within the merkle trie. StateDBs take care of caching and storing
    62  // nested states. It's the general query interface to retrieve:
    63  // * Contracts
    64  // * Accounts
    65  type StateDB struct {
    66  	db   Database
    67  	trie Trie
    68  
    69  	// This map holds 'live' objects, which will get modified while processing a state transition.
    70  	stateObjects        map[common.Address]*stateObject
    71  	stateObjectsPending map[common.Address]struct{} // State objects finalized but not yet written to the trie
    72  	stateObjectsDirty   map[common.Address]struct{} // State objects modified in the current execution
    73  
    74  	// DB error.
    75  	// State objects are used by the consensus core and VM which are
    76  	// unable to deal with database-level errors. Any error that occurs
    77  	// during a database read is memoized here and will eventually be returned
    78  	// by StateDB.Commit.
    79  	dbErr error
    80  
    81  	// The refund counter, also used by state transitioning.
    82  	refund uint64
    83  
    84  	thash, bhash common.Hash
    85  	txIndex      int
    86  	logs         map[common.Hash][]*types.Log
    87  	logSize      uint
    88  
    89  	preimages map[common.Hash][]byte
    90  
    91  	// Journal of state modifications. This is the backbone of
    92  	// Snapshot and RevertToSnapshot.
    93  	journal        *journal
    94  	validRevisions []revision
    95  	nextRevisionId int
    96  
    97  	// Measurements gathered during execution for debugging purposes
    98  	AccountReads   time.Duration
    99  	AccountHashes  time.Duration
   100  	AccountUpdates time.Duration
   101  	AccountCommits time.Duration
   102  	StorageReads   time.Duration
   103  	StorageHashes  time.Duration
   104  	StorageUpdates time.Duration
   105  	StorageCommits time.Duration
   106  }
   107  
   108  // Create a new state from a given trie.
   109  func New(root common.Hash, db Database) (*StateDB, error) {
   110  	tr, err := db.OpenTrie(root)
   111  	if err != nil {
   112  		return nil, err
   113  	}
   114  	return &StateDB{
   115  		db:                  db,
   116  		trie:                tr,
   117  		stateObjects:        make(map[common.Address]*stateObject),
   118  		stateObjectsPending: make(map[common.Address]struct{}),
   119  		stateObjectsDirty:   make(map[common.Address]struct{}),
   120  		logs:                make(map[common.Hash][]*types.Log),
   121  		preimages:           make(map[common.Hash][]byte),
   122  		journal:             newJournal(),
   123  	}, nil
   124  }
   125  
   126  // setError remembers the first non-nil error it is called with.
   127  func (self *StateDB) setError(err error) {
   128  	if self.dbErr == nil {
   129  		self.dbErr = err
   130  	}
   131  }
   132  
   133  func (self *StateDB) Error() error {
   134  	return self.dbErr
   135  }
   136  
   137  // Reset clears out all ephemeral state objects from the state db, but keeps
   138  // the underlying state trie to avoid reloading data for the next operations.
   139  func (self *StateDB) Reset(root common.Hash) error {
   140  	tr, err := self.db.OpenTrie(root)
   141  	if err != nil {
   142  		return err
   143  	}
   144  	self.trie = tr
   145  	self.stateObjects = make(map[common.Address]*stateObject)
   146  	self.stateObjectsPending = make(map[common.Address]struct{})
   147  	self.stateObjectsDirty = make(map[common.Address]struct{})
   148  	self.thash = common.Hash{}
   149  	self.bhash = common.Hash{}
   150  	self.txIndex = 0
   151  	self.logs = make(map[common.Hash][]*types.Log)
   152  	self.logSize = 0
   153  	self.preimages = make(map[common.Hash][]byte)
   154  	self.clearJournalAndRefund()
   155  	return nil
   156  }
   157  
   158  func (self *StateDB) AddLog(log *types.Log) {
   159  	self.journal.append(addLogChange{txhash: self.thash})
   160  
   161  	log.TxHash = self.thash
   162  	log.BlockHash = self.bhash
   163  	log.TxIndex = uint(self.txIndex)
   164  	log.Index = self.logSize
   165  	self.logs[self.thash] = append(self.logs[self.thash], log)
   166  	self.logSize++
   167  }
   168  
   169  func (self *StateDB) GetLogs(hash common.Hash) []*types.Log {
   170  	return self.logs[hash]
   171  }
   172  
   173  func (self *StateDB) Logs() []*types.Log {
   174  	var logs []*types.Log
   175  	for _, lgs := range self.logs {
   176  		logs = append(logs, lgs...)
   177  	}
   178  	return logs
   179  }
   180  
   181  // AddPreimage records a SHA3 preimage seen by the VM.
   182  func (self *StateDB) AddPreimage(hash common.Hash, preimage []byte) {
   183  	if _, ok := self.preimages[hash]; !ok {
   184  		self.journal.append(addPreimageChange{hash: hash})
   185  		pi := make([]byte, len(preimage))
   186  		copy(pi, preimage)
   187  		self.preimages[hash] = pi
   188  	}
   189  }
   190  
   191  // Preimages returns a list of SHA3 preimages that have been submitted.
   192  func (self *StateDB) Preimages() map[common.Hash][]byte {
   193  	return self.preimages
   194  }
   195  
   196  // AddRefund adds gas to the refund counter
   197  func (self *StateDB) AddRefund(gas uint64) {
   198  	self.journal.append(refundChange{prev: self.refund})
   199  	self.refund += gas
   200  }
   201  
   202  // SubRefund removes gas from the refund counter.
   203  // This method will panic if the refund counter goes below zero
   204  func (self *StateDB) SubRefund(gas uint64) {
   205  	self.journal.append(refundChange{prev: self.refund})
   206  	if gas > self.refund {
   207  		panic("Refund counter below zero")
   208  	}
   209  	self.refund -= gas
   210  }
   211  
   212  // Exist reports whether the given account address exists in the state.
   213  // Notably this also returns true for suicided accounts.
   214  func (self *StateDB) Exist(addr common.Address) bool {
   215  	return self.getStateObject(addr) != nil
   216  }
   217  
   218  // Empty returns whether the state object is either non-existent
   219  // or empty according to the EIP161 specification (balance = nonce = code = 0)
   220  func (self *StateDB) Empty(addr common.Address) bool {
   221  	so := self.getStateObject(addr)
   222  	return so == nil || so.empty()
   223  }
   224  
   225  // Retrieve the balance from the given address or 0 if object not found
   226  func (self *StateDB) GetBalance(addr common.Address) *big.Int {
   227  	stateObject := self.getStateObject(addr)
   228  	if stateObject != nil {
   229  		return stateObject.Balance()
   230  	}
   231  	return common.Big0
   232  }
   233  
   234  func (self *StateDB) GetNonce(addr common.Address) uint64 {
   235  	stateObject := self.getStateObject(addr)
   236  	if stateObject != nil {
   237  		return stateObject.Nonce()
   238  	}
   239  
   240  	return 0
   241  }
   242  
   243  // TxIndex returns the current transaction index set by Prepare.
   244  func (self *StateDB) TxIndex() int {
   245  	return self.txIndex
   246  }
   247  
   248  // BlockHash returns the current block hash set by Prepare.
   249  func (self *StateDB) BlockHash() common.Hash {
   250  	return self.bhash
   251  }
   252  
   253  func (self *StateDB) GetCode(addr common.Address) []byte {
   254  	stateObject := self.getStateObject(addr)
   255  	if stateObject != nil {
   256  		return stateObject.Code(self.db)
   257  	}
   258  	return nil
   259  }
   260  
   261  func (self *StateDB) GetCodeSize(addr common.Address) int {
   262  	stateObject := self.getStateObject(addr)
   263  	if stateObject == nil {
   264  		return 0
   265  	}
   266  	if stateObject.code != nil {
   267  		return len(stateObject.code)
   268  	}
   269  	size, err := self.db.ContractCodeSize(stateObject.addrHash, common.BytesToHash(stateObject.CodeHash()))
   270  	if err != nil {
   271  		self.setError(err)
   272  	}
   273  	return size
   274  }
   275  
   276  func (self *StateDB) GetCodeHash(addr common.Address) common.Hash {
   277  	stateObject := self.getStateObject(addr)
   278  	if stateObject == nil {
   279  		return common.Hash{}
   280  	}
   281  	return common.BytesToHash(stateObject.CodeHash())
   282  }
   283  
   284  // GetState retrieves a value from the given account's storage trie.
   285  func (self *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash {
   286  	stateObject := self.getStateObject(addr)
   287  	if stateObject != nil {
   288  		return stateObject.GetState(self.db, hash)
   289  	}
   290  	return common.Hash{}
   291  }
   292  
   293  // GetProof returns the MerkleProof for a given Account
   294  func (self *StateDB) GetProof(a common.Address) ([][]byte, error) {
   295  	var proof proofList
   296  	err := self.trie.Prove(crypto.Keccak256(a.Bytes()), 0, &proof)
   297  	return [][]byte(proof), err
   298  }
   299  
   300  // GetProof returns the StorageProof for given key
   301  func (self *StateDB) GetStorageProof(a common.Address, key common.Hash) ([][]byte, error) {
   302  	var proof proofList
   303  	trie := self.StorageTrie(a)
   304  	if trie == nil {
   305  		return proof, errors.New("storage trie for requested address does not exist")
   306  	}
   307  	err := trie.Prove(crypto.Keccak256(key.Bytes()), 0, &proof)
   308  	return [][]byte(proof), err
   309  }
   310  
   311  // GetCommittedState retrieves a value from the given account's committed storage trie.
   312  func (self *StateDB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash {
   313  	stateObject := self.getStateObject(addr)
   314  	if stateObject != nil {
   315  		return stateObject.GetCommittedState(self.db, hash)
   316  	}
   317  	return common.Hash{}
   318  }
   319  
   320  // Database retrieves the low level database supporting the lower level trie ops.
   321  func (self *StateDB) Database() Database {
   322  	return self.db
   323  }
   324  
   325  // StorageTrie returns the storage trie of an account.
   326  // The return value is a copy and is nil for non-existent accounts.
   327  func (self *StateDB) StorageTrie(addr common.Address) Trie {
   328  	stateObject := self.getStateObject(addr)
   329  	if stateObject == nil {
   330  		return nil
   331  	}
   332  	cpy := stateObject.deepCopy(self)
   333  	return cpy.updateTrie(self.db)
   334  }
   335  
   336  func (self *StateDB) HasSuicided(addr common.Address) bool {
   337  	stateObject := self.getStateObject(addr)
   338  	if stateObject != nil {
   339  		return stateObject.suicided
   340  	}
   341  	return false
   342  }
   343  
   344  /*
   345   * SETTERS
   346   */
   347  
   348  // AddBalance adds amount to the account associated with addr.
   349  func (self *StateDB) AddBalance(addr common.Address, amount *big.Int) {
   350  	stateObject := self.GetOrNewStateObject(addr)
   351  	if stateObject != nil {
   352  		stateObject.AddBalance(amount)
   353  	}
   354  }
   355  
   356  // SubBalance subtracts amount from the account associated with addr.
   357  func (self *StateDB) SubBalance(addr common.Address, amount *big.Int) {
   358  	stateObject := self.GetOrNewStateObject(addr)
   359  	if stateObject != nil {
   360  		stateObject.SubBalance(amount)
   361  	}
   362  }
   363  
   364  func (self *StateDB) SetBalance(addr common.Address, amount *big.Int) {
   365  	stateObject := self.GetOrNewStateObject(addr)
   366  	if stateObject != nil {
   367  		stateObject.SetBalance(amount)
   368  	}
   369  }
   370  
   371  func (self *StateDB) SetNonce(addr common.Address, nonce uint64) {
   372  	stateObject := self.GetOrNewStateObject(addr)
   373  	if stateObject != nil {
   374  		stateObject.SetNonce(nonce)
   375  	}
   376  }
   377  
   378  func (self *StateDB) SetCode(addr common.Address, code []byte) {
   379  	stateObject := self.GetOrNewStateObject(addr)
   380  	if stateObject != nil {
   381  		stateObject.SetCode(crypto.Keccak256Hash(code), code)
   382  	}
   383  }
   384  
   385  func (self *StateDB) SetState(addr common.Address, key, value common.Hash) {
   386  	stateObject := self.GetOrNewStateObject(addr)
   387  	if stateObject != nil {
   388  		stateObject.SetState(self.db, key, value)
   389  	}
   390  }
   391  
   392  // SetStorage replaces the entire storage for the specified account with given
   393  // storage. This function should only be used for debugging.
   394  func (self *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common.Hash) {
   395  	stateObject := self.GetOrNewStateObject(addr)
   396  	if stateObject != nil {
   397  		stateObject.SetStorage(storage)
   398  	}
   399  }
   400  
   401  // Suicide marks the given account as suicided.
   402  // This clears the account balance.
   403  //
   404  // The account's state object is still available until the state is committed,
   405  // getStateObject will return a non-nil account after Suicide.
   406  func (self *StateDB) Suicide(addr common.Address) bool {
   407  	stateObject := self.getStateObject(addr)
   408  	if stateObject == nil {
   409  		return false
   410  	}
   411  	self.journal.append(suicideChange{
   412  		account:     &addr,
   413  		prev:        stateObject.suicided,
   414  		prevbalance: new(big.Int).Set(stateObject.Balance()),
   415  	})
   416  	stateObject.markSuicided()
   417  	stateObject.data.Balance = new(big.Int)
   418  
   419  	return true
   420  }
   421  
   422  //
   423  // Setting, updating & deleting state object methods.
   424  //
   425  
   426  // updateStateObject writes the given object to the trie.
   427  func (s *StateDB) updateStateObject(obj *stateObject) {
   428  	// Track the amount of time wasted on updating the account from the trie
   429  	if metrics.EnabledExpensive {
   430  		defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now())
   431  	}
   432  	// Encode the account and update the account trie
   433  	addr := obj.Address()
   434  
   435  	data, err := rlp.EncodeToBytes(obj)
   436  	if err != nil {
   437  		panic(fmt.Errorf("can't encode object at %x: %v", addr[:], err))
   438  	}
   439  	s.setError(s.trie.TryUpdate(addr[:], data))
   440  }
   441  
   442  // deleteStateObject removes the given object from the state trie.
   443  func (s *StateDB) deleteStateObject(obj *stateObject) {
   444  	// Track the amount of time wasted on deleting the account from the trie
   445  	if metrics.EnabledExpensive {
   446  		defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now())
   447  	}
   448  	// Delete the account from the trie
   449  	addr := obj.Address()
   450  	s.setError(s.trie.TryDelete(addr[:]))
   451  }
   452  
   453  // getStateObject retrieves a state object given by the address, returning nil if
   454  // the object is not found or was deleted in this execution context. If you need
   455  // to differentiate between non-existent/just-deleted, use getDeletedStateObject.
   456  func (s *StateDB) getStateObject(addr common.Address) *stateObject {
   457  	if obj := s.getDeletedStateObject(addr); obj != nil && !obj.deleted {
   458  		return obj
   459  	}
   460  	return nil
   461  }
   462  
   463  // getDeletedStateObject is similar to getStateObject, but instead of returning
   464  // nil for a deleted state object, it returns the actual object with the deleted
   465  // flag set. This is needed by the state journal to revert to the correct self-
   466  // destructed object instead of wiping all knowledge about the state object.
   467  func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {
   468  	// Prefer live objects if any is available
   469  	if obj := s.stateObjects[addr]; obj != nil {
   470  		return obj
   471  	}
   472  	// Track the amount of time wasted on loading the object from the database
   473  	if metrics.EnabledExpensive {
   474  		defer func(start time.Time) { s.AccountReads += time.Since(start) }(time.Now())
   475  	}
   476  	// Load the object from the database
   477  	enc, err := s.trie.TryGet(addr[:])
   478  	if len(enc) == 0 {
   479  		s.setError(err)
   480  		return nil
   481  	}
   482  	var data Account
   483  	if err := rlp.DecodeBytes(enc, &data); err != nil {
   484  		log.Error("Failed to decode state object", "addr", addr, "err", err)
   485  		return nil
   486  	}
   487  	// Insert into the live set
   488  	obj := newObject(s, addr, data)
   489  	s.setStateObject(obj)
   490  	return obj
   491  }
   492  
   493  func (self *StateDB) setStateObject(object *stateObject) {
   494  	self.stateObjects[object.Address()] = object
   495  }
   496  
   497  // Retrieve a state object or create a new state object if nil.
   498  func (self *StateDB) GetOrNewStateObject(addr common.Address) *stateObject {
   499  	stateObject := self.getStateObject(addr)
   500  	if stateObject == nil {
   501  		stateObject, _ = self.createObject(addr)
   502  	}
   503  	return stateObject
   504  }
   505  
   506  // createObject creates a new state object. If there is an existing account with
   507  // the given address, it is overwritten and returned as the second return value.
   508  func (self *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) {
   509  	prev = self.getDeletedStateObject(addr) // Note, prev might have been deleted, we need that!
   510  
   511  	newobj = newObject(self, addr, Account{})
   512  	newobj.setNonce(0) // sets the object to dirty
   513  	if prev == nil {
   514  		self.journal.append(createObjectChange{account: &addr})
   515  	} else {
   516  		self.journal.append(resetObjectChange{prev: prev})
   517  	}
   518  	self.setStateObject(newobj)
   519  	return newobj, prev
   520  }
   521  
   522  // CreateAccount explicitly creates a state object. If a state object with the address
   523  // already exists the balance is carried over to the new account.
   524  //
   525  // CreateAccount is called during the EVM CREATE operation. The situation might arise that
   526  // a contract does the following:
   527  //
   528  //   1. sends funds to sha(account ++ (nonce + 1))
   529  //   2. tx_create(sha(account ++ nonce)) (note that this gets the address of 1)
   530  //
   531  // Carrying over the balance ensures that Ether doesn't disappear.
   532  func (self *StateDB) CreateAccount(addr common.Address) {
   533  	newObj, prev := self.createObject(addr)
   534  	if prev != nil {
   535  		newObj.setBalance(prev.data.Balance)
   536  	}
   537  }
   538  
   539  func (db *StateDB) ForEachStorage(addr common.Address, cb func(key, value common.Hash) bool) error {
   540  	so := db.getStateObject(addr)
   541  	if so == nil {
   542  		return nil
   543  	}
   544  	it := trie.NewIterator(so.getTrie(db.db).NodeIterator(nil))
   545  
   546  	for it.Next() {
   547  		key := common.BytesToHash(db.trie.GetKey(it.Key))
   548  		if value, dirty := so.dirtyStorage[key]; dirty {
   549  			if !cb(key, value) {
   550  				return nil
   551  			}
   552  			continue
   553  		}
   554  
   555  		if len(it.Value) > 0 {
   556  			_, content, _, err := rlp.Split(it.Value)
   557  			if err != nil {
   558  				return err
   559  			}
   560  			if !cb(key, common.BytesToHash(content)) {
   561  				return nil
   562  			}
   563  		}
   564  	}
   565  	return nil
   566  }
   567  
   568  // Copy creates a deep, independent copy of the state.
   569  // Snapshots of the copied state cannot be applied to the copy.
   570  func (self *StateDB) Copy() *StateDB {
   571  	// Copy all the basic fields, initialize the memory ones
   572  	state := &StateDB{
   573  		db:                  self.db,
   574  		trie:                self.db.CopyTrie(self.trie),
   575  		stateObjects:        make(map[common.Address]*stateObject, len(self.journal.dirties)),
   576  		stateObjectsPending: make(map[common.Address]struct{}, len(self.stateObjectsPending)),
   577  		stateObjectsDirty:   make(map[common.Address]struct{}, len(self.journal.dirties)),
   578  		refund:              self.refund,
   579  		logs:                make(map[common.Hash][]*types.Log, len(self.logs)),
   580  		logSize:             self.logSize,
   581  		preimages:           make(map[common.Hash][]byte, len(self.preimages)),
   582  		journal:             newJournal(),
   583  	}
   584  	// Copy the dirty states, logs, and preimages
   585  	for addr := range self.journal.dirties {
   586  		// As documented [here](https://github.com/ethereum/go-ethereum/pull/16485#issuecomment-380438527),
   587  		// and in the Finalise-method, there is a case where an object is in the journal but not
   588  		// in the stateObjects: OOG after touch on ripeMD prior to Byzantium. Thus, we need to check for
   589  		// nil
   590  		if object, exist := self.stateObjects[addr]; exist {
   591  			// Even though the original object is dirty, we are not copying the journal,
   592  			// so we need to make sure that anyside effect the journal would have caused
   593  			// during a commit (or similar op) is already applied to the copy.
   594  			state.stateObjects[addr] = object.deepCopy(state)
   595  
   596  			state.stateObjectsDirty[addr] = struct{}{}   // Mark the copy dirty to force internal (code/state) commits
   597  			state.stateObjectsPending[addr] = struct{}{} // Mark the copy pending to force external (account) commits
   598  		}
   599  	}
   600  	// Above, we don't copy the actual journal. This means that if the copy is copied, the
   601  	// loop above will be a no-op, since the copy's journal is empty.
   602  	// Thus, here we iterate over stateObjects, to enable copies of copies
   603  	for addr := range self.stateObjectsPending {
   604  		if _, exist := state.stateObjects[addr]; !exist {
   605  			state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state)
   606  		}
   607  		state.stateObjectsPending[addr] = struct{}{}
   608  	}
   609  	for addr := range self.stateObjectsDirty {
   610  		if _, exist := state.stateObjects[addr]; !exist {
   611  			state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state)
   612  		}
   613  		state.stateObjectsDirty[addr] = struct{}{}
   614  	}
   615  	for hash, logs := range self.logs {
   616  		cpy := make([]*types.Log, len(logs))
   617  		for i, l := range logs {
   618  			cpy[i] = new(types.Log)
   619  			*cpy[i] = *l
   620  		}
   621  		state.logs[hash] = cpy
   622  	}
   623  	for hash, preimage := range self.preimages {
   624  		state.preimages[hash] = preimage
   625  	}
   626  	return state
   627  }
   628  
   629  // Snapshot returns an identifier for the current revision of the state.
   630  func (self *StateDB) Snapshot() int {
   631  	id := self.nextRevisionId
   632  	self.nextRevisionId++
   633  	self.validRevisions = append(self.validRevisions, revision{id, self.journal.length()})
   634  	return id
   635  }
   636  
   637  // RevertToSnapshot reverts all state changes made since the given revision.
   638  func (self *StateDB) RevertToSnapshot(revid int) {
   639  	// Find the snapshot in the stack of valid snapshots.
   640  	idx := sort.Search(len(self.validRevisions), func(i int) bool {
   641  		return self.validRevisions[i].id >= revid
   642  	})
   643  	if idx == len(self.validRevisions) || self.validRevisions[idx].id != revid {
   644  		panic(fmt.Errorf("revision id %v cannot be reverted", revid))
   645  	}
   646  	snapshot := self.validRevisions[idx].journalIndex
   647  
   648  	// Replay the journal to undo changes and remove invalidated snapshots
   649  	self.journal.revert(self, snapshot)
   650  	self.validRevisions = self.validRevisions[:idx]
   651  }
   652  
   653  // GetRefund returns the current value of the refund counter.
   654  func (self *StateDB) GetRefund() uint64 {
   655  	return self.refund
   656  }
   657  
   658  // Finalise finalises the state by removing the self destructed objects and clears
   659  // the journal as well as the refunds. Finalise, however, will not push any updates
   660  // into the tries just yet. Only IntermediateRoot or Commit will do that.
   661  func (s *StateDB) Finalise(deleteEmptyObjects bool) {
   662  	for addr := range s.journal.dirties {
   663  		obj, exist := s.stateObjects[addr]
   664  		if !exist {
   665  			// ripeMD is 'touched' at block 1714175, in tx 0x1237f737031e40bcde4a8b7e717b2d15e3ecadfe49bb1bbc71ee9deb09c6fcf2
   666  			// That tx goes out of gas, and although the notion of 'touched' does not exist there, the
   667  			// touch-event will still be recorded in the journal. Since ripeMD is a special snowflake,
   668  			// it will persist in the journal even though the journal is reverted. In this special circumstance,
   669  			// it may exist in `s.journal.dirties` but not in `s.stateObjects`.
   670  			// Thus, we can safely ignore it here
   671  			continue
   672  		}
   673  		if obj.suicided || (deleteEmptyObjects && obj.empty()) {
   674  			obj.deleted = true
   675  		} else {
   676  			obj.finalise()
   677  		}
   678  		s.stateObjectsPending[addr] = struct{}{}
   679  		s.stateObjectsDirty[addr] = struct{}{}
   680  	}
   681  	// Invalidate journal because reverting across transactions is not allowed.
   682  	s.clearJournalAndRefund()
   683  }
   684  
   685  // IntermediateRoot computes the current root hash of the state trie.
   686  // It is called in between transactions to get the root hash that
   687  // goes into transaction receipts.
   688  func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
   689  	// Finalise all the dirty storage states and write them into the tries
   690  	s.Finalise(deleteEmptyObjects)
   691  
   692  	for addr := range s.stateObjectsPending {
   693  		obj := s.stateObjects[addr]
   694  		if obj.deleted {
   695  			s.deleteStateObject(obj)
   696  		} else {
   697  			obj.updateRoot(s.db)
   698  			s.updateStateObject(obj)
   699  		}
   700  	}
   701  	if len(s.stateObjectsPending) > 0 {
   702  		s.stateObjectsPending = make(map[common.Address]struct{})
   703  	}
   704  	// Track the amount of time wasted on hashing the account trie
   705  	if metrics.EnabledExpensive {
   706  		defer func(start time.Time) { s.AccountHashes += time.Since(start) }(time.Now())
   707  	}
   708  	return s.trie.Hash()
   709  }
   710  
   711  // Prepare sets the current transaction hash and index and block hash which is
   712  // used when the EVM emits new state logs.
   713  func (self *StateDB) Prepare(thash, bhash common.Hash, ti int) {
   714  	self.thash = thash
   715  	self.bhash = bhash
   716  	self.txIndex = ti
   717  }
   718  
   719  func (s *StateDB) clearJournalAndRefund() {
   720  	if len(s.journal.entries) > 0 {
   721  		s.journal = newJournal()
   722  		s.refund = 0
   723  	}
   724  	s.validRevisions = s.validRevisions[:0] // Snapshots can be created without journal entires
   725  }
   726  
   727  // Commit writes the state to the underlying in-memory trie database.
   728  func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error) {
   729  	// Finalize any pending changes and merge everything into the tries
   730  	s.IntermediateRoot(deleteEmptyObjects)
   731  
   732  	// Commit objects to the trie, measuring the elapsed time
   733  	for addr := range s.stateObjectsDirty {
   734  		if obj := s.stateObjects[addr]; !obj.deleted {
   735  			// Write any contract code associated with the state object
   736  			if obj.code != nil && obj.dirtyCode {
   737  				s.db.TrieDB().InsertBlob(common.BytesToHash(obj.CodeHash()), obj.code)
   738  				obj.dirtyCode = false
   739  			}
   740  			// Write any storage changes in the state object to its storage trie
   741  			if err := obj.CommitTrie(s.db); err != nil {
   742  				return common.Hash{}, err
   743  			}
   744  		}
   745  	}
   746  	if len(s.stateObjectsDirty) > 0 {
   747  		s.stateObjectsDirty = make(map[common.Address]struct{})
   748  	}
   749  	// Write the account trie changes, measuing the amount of wasted time
   750  	if metrics.EnabledExpensive {
   751  		defer func(start time.Time) { s.AccountCommits += time.Since(start) }(time.Now())
   752  	}
   753  	return s.trie.Commit(func(leaf []byte, parent common.Hash) error {
   754  		var account Account
   755  		if err := rlp.DecodeBytes(leaf, &account); err != nil {
   756  			return nil
   757  		}
   758  		if account.Root != emptyRoot {
   759  			s.db.TrieDB().Reference(account.Root, parent)
   760  		}
   761  		code := common.BytesToHash(account.CodeHash)
   762  		if code != emptyCode {
   763  			s.db.TrieDB().Reference(code, parent)
   764  		}
   765  		return nil
   766  	})
   767  }