github.com/authcall/reference-optimistic-geth@v0.0.0-20220816224302-06313bfeb8d2/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/rawdb"
    29  	"github.com/ethereum/go-ethereum/core/state/snapshot"
    30  	"github.com/ethereum/go-ethereum/core/types"
    31  	"github.com/ethereum/go-ethereum/crypto"
    32  	"github.com/ethereum/go-ethereum/log"
    33  	"github.com/ethereum/go-ethereum/metrics"
    34  	"github.com/ethereum/go-ethereum/rlp"
    35  	"github.com/ethereum/go-ethereum/trie"
    36  )
    37  
    38  type revision struct {
    39  	id           int
    40  	journalIndex int
    41  }
    42  
    43  var (
    44  	// emptyRoot is the known root hash of an empty trie.
    45  	emptyRoot = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
    46  )
    47  
    48  type proofList [][]byte
    49  
    50  func (n *proofList) Put(key []byte, value []byte) error {
    51  	*n = append(*n, value)
    52  	return nil
    53  }
    54  
    55  func (n *proofList) Delete(key []byte) error {
    56  	panic("not supported")
    57  }
    58  
    59  // StateDB structs within the ethereum protocol are used to store anything
    60  // within the merkle trie. StateDBs take care of caching and storing
    61  // nested states. It's the general query interface to retrieve:
    62  // * Contracts
    63  // * Accounts
    64  type StateDB struct {
    65  	db         Database
    66  	prefetcher *triePrefetcher
    67  	trie       Trie
    68  	hasher     crypto.KeccakState
    69  
    70  	// originalRoot is the pre-state root, before any changes were made.
    71  	// It will be updated when the Commit is called.
    72  	originalRoot common.Hash
    73  
    74  	snaps         *snapshot.Tree
    75  	snap          snapshot.Snapshot
    76  	snapDestructs map[common.Hash]struct{}
    77  	snapAccounts  map[common.Hash][]byte
    78  	snapStorage   map[common.Hash]map[common.Hash][]byte
    79  
    80  	// This map holds 'live' objects, which will get modified while processing a state transition.
    81  	stateObjects        map[common.Address]*stateObject
    82  	stateObjectsPending map[common.Address]struct{} // State objects finalized but not yet written to the trie
    83  	stateObjectsDirty   map[common.Address]struct{} // State objects modified in the current execution
    84  
    85  	// DB error.
    86  	// State objects are used by the consensus core and VM which are
    87  	// unable to deal with database-level errors. Any error that occurs
    88  	// during a database read is memoized here and will eventually be returned
    89  	// by StateDB.Commit.
    90  	dbErr error
    91  
    92  	// The refund counter, also used by state transitioning.
    93  	refund uint64
    94  
    95  	thash   common.Hash
    96  	txIndex int
    97  	logs    map[common.Hash][]*types.Log
    98  	logSize uint
    99  
   100  	preimages map[common.Hash][]byte
   101  
   102  	// Per-transaction access list
   103  	accessList *accessList
   104  
   105  	// Journal of state modifications. This is the backbone of
   106  	// Snapshot and RevertToSnapshot.
   107  	journal        *journal
   108  	validRevisions []revision
   109  	nextRevisionId int
   110  
   111  	// Measurements gathered during execution for debugging purposes
   112  	AccountReads         time.Duration
   113  	AccountHashes        time.Duration
   114  	AccountUpdates       time.Duration
   115  	AccountCommits       time.Duration
   116  	StorageReads         time.Duration
   117  	StorageHashes        time.Duration
   118  	StorageUpdates       time.Duration
   119  	StorageCommits       time.Duration
   120  	SnapshotAccountReads time.Duration
   121  	SnapshotStorageReads time.Duration
   122  	SnapshotCommits      time.Duration
   123  
   124  	AccountUpdated int
   125  	StorageUpdated int
   126  	AccountDeleted int
   127  	StorageDeleted int
   128  }
   129  
   130  // New creates a new state from a given trie.
   131  func New(root common.Hash, db Database, snaps *snapshot.Tree) (*StateDB, error) {
   132  	tr, err := db.OpenTrie(root)
   133  	if err != nil {
   134  		return nil, err
   135  	}
   136  	sdb := &StateDB{
   137  		db:                  db,
   138  		trie:                tr,
   139  		originalRoot:        root,
   140  		snaps:               snaps,
   141  		stateObjects:        make(map[common.Address]*stateObject),
   142  		stateObjectsPending: make(map[common.Address]struct{}),
   143  		stateObjectsDirty:   make(map[common.Address]struct{}),
   144  		logs:                make(map[common.Hash][]*types.Log),
   145  		preimages:           make(map[common.Hash][]byte),
   146  		journal:             newJournal(),
   147  		accessList:          newAccessList(),
   148  		hasher:              crypto.NewKeccakState(),
   149  	}
   150  	if sdb.snaps != nil {
   151  		if sdb.snap = sdb.snaps.Snapshot(root); sdb.snap != nil {
   152  			sdb.snapDestructs = make(map[common.Hash]struct{})
   153  			sdb.snapAccounts = make(map[common.Hash][]byte)
   154  			sdb.snapStorage = make(map[common.Hash]map[common.Hash][]byte)
   155  		}
   156  	}
   157  	return sdb, nil
   158  }
   159  
   160  // StartPrefetcher initializes a new trie prefetcher to pull in nodes from the
   161  // state trie concurrently while the state is mutated so that when we reach the
   162  // commit phase, most of the needed data is already hot.
   163  func (s *StateDB) StartPrefetcher(namespace string) {
   164  	if s.prefetcher != nil {
   165  		s.prefetcher.close()
   166  		s.prefetcher = nil
   167  	}
   168  	if s.snap != nil {
   169  		s.prefetcher = newTriePrefetcher(s.db, s.originalRoot, namespace)
   170  	}
   171  }
   172  
   173  // StopPrefetcher terminates a running prefetcher and reports any leftover stats
   174  // from the gathered metrics.
   175  func (s *StateDB) StopPrefetcher() {
   176  	if s.prefetcher != nil {
   177  		s.prefetcher.close()
   178  		s.prefetcher = nil
   179  	}
   180  }
   181  
   182  // setError remembers the first non-nil error it is called with.
   183  func (s *StateDB) setError(err error) {
   184  	if s.dbErr == nil {
   185  		s.dbErr = err
   186  	}
   187  }
   188  
   189  func (s *StateDB) Error() error {
   190  	return s.dbErr
   191  }
   192  
   193  func (s *StateDB) AddLog(log *types.Log) {
   194  	s.journal.append(addLogChange{txhash: s.thash})
   195  
   196  	log.TxHash = s.thash
   197  	log.TxIndex = uint(s.txIndex)
   198  	log.Index = s.logSize
   199  	s.logs[s.thash] = append(s.logs[s.thash], log)
   200  	s.logSize++
   201  }
   202  
   203  func (s *StateDB) GetLogs(hash common.Hash, blockHash common.Hash) []*types.Log {
   204  	logs := s.logs[hash]
   205  	for _, l := range logs {
   206  		l.BlockHash = blockHash
   207  	}
   208  	return logs
   209  }
   210  
   211  func (s *StateDB) Logs() []*types.Log {
   212  	var logs []*types.Log
   213  	for _, lgs := range s.logs {
   214  		logs = append(logs, lgs...)
   215  	}
   216  	return logs
   217  }
   218  
   219  // AddPreimage records a SHA3 preimage seen by the VM.
   220  func (s *StateDB) AddPreimage(hash common.Hash, preimage []byte) {
   221  	if _, ok := s.preimages[hash]; !ok {
   222  		s.journal.append(addPreimageChange{hash: hash})
   223  		pi := make([]byte, len(preimage))
   224  		copy(pi, preimage)
   225  		s.preimages[hash] = pi
   226  	}
   227  }
   228  
   229  // Preimages returns a list of SHA3 preimages that have been submitted.
   230  func (s *StateDB) Preimages() map[common.Hash][]byte {
   231  	return s.preimages
   232  }
   233  
   234  // AddRefund adds gas to the refund counter
   235  func (s *StateDB) AddRefund(gas uint64) {
   236  	s.journal.append(refundChange{prev: s.refund})
   237  	s.refund += gas
   238  }
   239  
   240  // SubRefund removes gas from the refund counter.
   241  // This method will panic if the refund counter goes below zero
   242  func (s *StateDB) SubRefund(gas uint64) {
   243  	s.journal.append(refundChange{prev: s.refund})
   244  	if gas > s.refund {
   245  		panic(fmt.Sprintf("Refund counter below zero (gas: %d > refund: %d)", gas, s.refund))
   246  	}
   247  	s.refund -= gas
   248  }
   249  
   250  // Exist reports whether the given account address exists in the state.
   251  // Notably this also returns true for suicided accounts.
   252  func (s *StateDB) Exist(addr common.Address) bool {
   253  	return s.getStateObject(addr) != nil
   254  }
   255  
   256  // Empty returns whether the state object is either non-existent
   257  // or empty according to the EIP161 specification (balance = nonce = code = 0)
   258  func (s *StateDB) Empty(addr common.Address) bool {
   259  	so := s.getStateObject(addr)
   260  	return so == nil || so.empty()
   261  }
   262  
   263  // GetBalance retrieves the balance from the given address or 0 if object not found
   264  func (s *StateDB) GetBalance(addr common.Address) *big.Int {
   265  	stateObject := s.getStateObject(addr)
   266  	if stateObject != nil {
   267  		return stateObject.Balance()
   268  	}
   269  	return common.Big0
   270  }
   271  
   272  func (s *StateDB) GetNonce(addr common.Address) uint64 {
   273  	stateObject := s.getStateObject(addr)
   274  	if stateObject != nil {
   275  		return stateObject.Nonce()
   276  	}
   277  
   278  	return 0
   279  }
   280  
   281  // TxIndex returns the current transaction index set by Prepare.
   282  func (s *StateDB) TxIndex() int {
   283  	return s.txIndex
   284  }
   285  
   286  func (s *StateDB) GetCode(addr common.Address) []byte {
   287  	stateObject := s.getStateObject(addr)
   288  	if stateObject != nil {
   289  		return stateObject.Code(s.db)
   290  	}
   291  	return nil
   292  }
   293  
   294  func (s *StateDB) GetCodeSize(addr common.Address) int {
   295  	stateObject := s.getStateObject(addr)
   296  	if stateObject != nil {
   297  		return stateObject.CodeSize(s.db)
   298  	}
   299  	return 0
   300  }
   301  
   302  func (s *StateDB) GetCodeHash(addr common.Address) common.Hash {
   303  	stateObject := s.getStateObject(addr)
   304  	if stateObject == nil {
   305  		return common.Hash{}
   306  	}
   307  	return common.BytesToHash(stateObject.CodeHash())
   308  }
   309  
   310  // GetState retrieves a value from the given account's storage trie.
   311  func (s *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash {
   312  	stateObject := s.getStateObject(addr)
   313  	if stateObject != nil {
   314  		return stateObject.GetState(s.db, hash)
   315  	}
   316  	return common.Hash{}
   317  }
   318  
   319  // GetProof returns the Merkle proof for a given account.
   320  func (s *StateDB) GetProof(addr common.Address) ([][]byte, error) {
   321  	return s.GetProofByHash(crypto.Keccak256Hash(addr.Bytes()))
   322  }
   323  
   324  // GetProofByHash returns the Merkle proof for a given account.
   325  func (s *StateDB) GetProofByHash(addrHash common.Hash) ([][]byte, error) {
   326  	var proof proofList
   327  	err := s.trie.Prove(addrHash[:], 0, &proof)
   328  	return proof, err
   329  }
   330  
   331  // GetStorageProof returns the Merkle proof for given storage slot.
   332  func (s *StateDB) GetStorageProof(a common.Address, key common.Hash) ([][]byte, error) {
   333  	var proof proofList
   334  	trie := s.StorageTrie(a)
   335  	if trie == nil {
   336  		return proof, errors.New("storage trie for requested address does not exist")
   337  	}
   338  	err := trie.Prove(crypto.Keccak256(key.Bytes()), 0, &proof)
   339  	return proof, err
   340  }
   341  
   342  // GetCommittedState retrieves a value from the given account's committed storage trie.
   343  func (s *StateDB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash {
   344  	stateObject := s.getStateObject(addr)
   345  	if stateObject != nil {
   346  		return stateObject.GetCommittedState(s.db, hash)
   347  	}
   348  	return common.Hash{}
   349  }
   350  
   351  // Database retrieves the low level database supporting the lower level trie ops.
   352  func (s *StateDB) Database() Database {
   353  	return s.db
   354  }
   355  
   356  // StorageTrie returns the storage trie of an account.
   357  // The return value is a copy and is nil for non-existent accounts.
   358  func (s *StateDB) StorageTrie(addr common.Address) Trie {
   359  	stateObject := s.getStateObject(addr)
   360  	if stateObject == nil {
   361  		return nil
   362  	}
   363  	cpy := stateObject.deepCopy(s)
   364  	cpy.updateTrie(s.db)
   365  	return cpy.getTrie(s.db)
   366  }
   367  
   368  func (s *StateDB) HasSuicided(addr common.Address) bool {
   369  	stateObject := s.getStateObject(addr)
   370  	if stateObject != nil {
   371  		return stateObject.suicided
   372  	}
   373  	return false
   374  }
   375  
   376  /*
   377   * SETTERS
   378   */
   379  
   380  // AddBalance adds amount to the account associated with addr.
   381  func (s *StateDB) AddBalance(addr common.Address, amount *big.Int) {
   382  	stateObject := s.GetOrNewStateObject(addr)
   383  	if stateObject != nil {
   384  		stateObject.AddBalance(amount)
   385  	}
   386  }
   387  
   388  // SubBalance subtracts amount from the account associated with addr.
   389  func (s *StateDB) SubBalance(addr common.Address, amount *big.Int) {
   390  	stateObject := s.GetOrNewStateObject(addr)
   391  	if stateObject != nil {
   392  		stateObject.SubBalance(amount)
   393  	}
   394  }
   395  
   396  func (s *StateDB) SetBalance(addr common.Address, amount *big.Int) {
   397  	stateObject := s.GetOrNewStateObject(addr)
   398  	if stateObject != nil {
   399  		stateObject.SetBalance(amount)
   400  	}
   401  }
   402  
   403  func (s *StateDB) SetNonce(addr common.Address, nonce uint64) {
   404  	stateObject := s.GetOrNewStateObject(addr)
   405  	if stateObject != nil {
   406  		stateObject.SetNonce(nonce)
   407  	}
   408  }
   409  
   410  func (s *StateDB) SetCode(addr common.Address, code []byte) {
   411  	stateObject := s.GetOrNewStateObject(addr)
   412  	if stateObject != nil {
   413  		stateObject.SetCode(crypto.Keccak256Hash(code), code)
   414  	}
   415  }
   416  
   417  func (s *StateDB) SetState(addr common.Address, key, value common.Hash) {
   418  	stateObject := s.GetOrNewStateObject(addr)
   419  	if stateObject != nil {
   420  		stateObject.SetState(s.db, key, value)
   421  	}
   422  }
   423  
   424  // SetStorage replaces the entire storage for the specified account with given
   425  // storage. This function should only be used for debugging.
   426  func (s *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common.Hash) {
   427  	stateObject := s.GetOrNewStateObject(addr)
   428  	if stateObject != nil {
   429  		stateObject.SetStorage(storage)
   430  	}
   431  }
   432  
   433  // Suicide marks the given account as suicided.
   434  // This clears the account balance.
   435  //
   436  // The account's state object is still available until the state is committed,
   437  // getStateObject will return a non-nil account after Suicide.
   438  func (s *StateDB) Suicide(addr common.Address) bool {
   439  	stateObject := s.getStateObject(addr)
   440  	if stateObject == nil {
   441  		return false
   442  	}
   443  	s.journal.append(suicideChange{
   444  		account:     &addr,
   445  		prev:        stateObject.suicided,
   446  		prevbalance: new(big.Int).Set(stateObject.Balance()),
   447  	})
   448  	stateObject.markSuicided()
   449  	stateObject.data.Balance = new(big.Int)
   450  
   451  	return true
   452  }
   453  
   454  //
   455  // Setting, updating & deleting state object methods.
   456  //
   457  
   458  // updateStateObject writes the given object to the trie.
   459  func (s *StateDB) updateStateObject(obj *stateObject) {
   460  	// Track the amount of time wasted on updating the account from the trie
   461  	if metrics.EnabledExpensive {
   462  		defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now())
   463  	}
   464  	// Encode the account and update the account trie
   465  	addr := obj.Address()
   466  	if err := s.trie.TryUpdateAccount(addr[:], &obj.data); err != nil {
   467  		s.setError(fmt.Errorf("updateStateObject (%x) error: %v", addr[:], err))
   468  	}
   469  
   470  	// If state snapshotting is active, cache the data til commit. Note, this
   471  	// update mechanism is not symmetric to the deletion, because whereas it is
   472  	// enough to track account updates at commit time, deletions need tracking
   473  	// at transaction boundary level to ensure we capture state clearing.
   474  	if s.snap != nil {
   475  		s.snapAccounts[obj.addrHash] = snapshot.SlimAccountRLP(obj.data.Nonce, obj.data.Balance, obj.data.Root, obj.data.CodeHash)
   476  	}
   477  }
   478  
   479  // deleteStateObject removes the given object from the state trie.
   480  func (s *StateDB) deleteStateObject(obj *stateObject) {
   481  	// Track the amount of time wasted on deleting the account from the trie
   482  	if metrics.EnabledExpensive {
   483  		defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now())
   484  	}
   485  	// Delete the account from the trie
   486  	addr := obj.Address()
   487  	if err := s.trie.TryDelete(addr[:]); err != nil {
   488  		s.setError(fmt.Errorf("deleteStateObject (%x) error: %v", addr[:], err))
   489  	}
   490  }
   491  
   492  // getStateObject retrieves a state object given by the address, returning nil if
   493  // the object is not found or was deleted in this execution context. If you need
   494  // to differentiate between non-existent/just-deleted, use getDeletedStateObject.
   495  func (s *StateDB) getStateObject(addr common.Address) *stateObject {
   496  	if obj := s.getDeletedStateObject(addr); obj != nil && !obj.deleted {
   497  		return obj
   498  	}
   499  	return nil
   500  }
   501  
   502  // getDeletedStateObject is similar to getStateObject, but instead of returning
   503  // nil for a deleted state object, it returns the actual object with the deleted
   504  // flag set. This is needed by the state journal to revert to the correct s-
   505  // destructed object instead of wiping all knowledge about the state object.
   506  func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {
   507  	// Prefer live objects if any is available
   508  	if obj := s.stateObjects[addr]; obj != nil {
   509  		return obj
   510  	}
   511  	// If no live objects are available, attempt to use snapshots
   512  	var data *types.StateAccount
   513  	if s.snap != nil {
   514  		start := time.Now()
   515  		acc, err := s.snap.Account(crypto.HashData(s.hasher, addr.Bytes()))
   516  		if metrics.EnabledExpensive {
   517  			s.SnapshotAccountReads += time.Since(start)
   518  		}
   519  		if err == nil {
   520  			if acc == nil {
   521  				return nil
   522  			}
   523  			data = &types.StateAccount{
   524  				Nonce:    acc.Nonce,
   525  				Balance:  acc.Balance,
   526  				CodeHash: acc.CodeHash,
   527  				Root:     common.BytesToHash(acc.Root),
   528  			}
   529  			if len(data.CodeHash) == 0 {
   530  				data.CodeHash = emptyCodeHash
   531  			}
   532  			if data.Root == (common.Hash{}) {
   533  				data.Root = emptyRoot
   534  			}
   535  		}
   536  	}
   537  	// If snapshot unavailable or reading from it failed, load from the database
   538  	if data == nil {
   539  		start := time.Now()
   540  		enc, err := s.trie.TryGet(addr.Bytes())
   541  		if metrics.EnabledExpensive {
   542  			s.AccountReads += time.Since(start)
   543  		}
   544  		if err != nil {
   545  			s.setError(fmt.Errorf("getDeleteStateObject (%x) error: %v", addr.Bytes(), err))
   546  			return nil
   547  		}
   548  		if len(enc) == 0 {
   549  			return nil
   550  		}
   551  		data = new(types.StateAccount)
   552  		if err := rlp.DecodeBytes(enc, data); err != nil {
   553  			log.Error("Failed to decode state object", "addr", addr, "err", err)
   554  			return nil
   555  		}
   556  	}
   557  	// Insert into the live set
   558  	obj := newObject(s, addr, *data)
   559  	s.setStateObject(obj)
   560  	return obj
   561  }
   562  
   563  func (s *StateDB) setStateObject(object *stateObject) {
   564  	s.stateObjects[object.Address()] = object
   565  }
   566  
   567  // GetOrNewStateObject retrieves a state object or create a new state object if nil.
   568  func (s *StateDB) GetOrNewStateObject(addr common.Address) *stateObject {
   569  	stateObject := s.getStateObject(addr)
   570  	if stateObject == nil {
   571  		stateObject, _ = s.createObject(addr)
   572  	}
   573  	return stateObject
   574  }
   575  
   576  // createObject creates a new state object. If there is an existing account with
   577  // the given address, it is overwritten and returned as the second return value.
   578  func (s *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) {
   579  	prev = s.getDeletedStateObject(addr) // Note, prev might have been deleted, we need that!
   580  
   581  	var prevdestruct bool
   582  	if s.snap != nil && prev != nil {
   583  		_, prevdestruct = s.snapDestructs[prev.addrHash]
   584  		if !prevdestruct {
   585  			s.snapDestructs[prev.addrHash] = struct{}{}
   586  		}
   587  	}
   588  	newobj = newObject(s, addr, types.StateAccount{})
   589  	if prev == nil {
   590  		s.journal.append(createObjectChange{account: &addr})
   591  	} else {
   592  		s.journal.append(resetObjectChange{prev: prev, prevdestruct: prevdestruct})
   593  	}
   594  	s.setStateObject(newobj)
   595  	if prev != nil && !prev.deleted {
   596  		return newobj, prev
   597  	}
   598  	return newobj, nil
   599  }
   600  
   601  // CreateAccount explicitly creates a state object. If a state object with the address
   602  // already exists the balance is carried over to the new account.
   603  //
   604  // CreateAccount is called during the EVM CREATE operation. The situation might arise that
   605  // a contract does the following:
   606  //
   607  //   1. sends funds to sha(account ++ (nonce + 1))
   608  //   2. tx_create(sha(account ++ nonce)) (note that this gets the address of 1)
   609  //
   610  // Carrying over the balance ensures that Ether doesn't disappear.
   611  func (s *StateDB) CreateAccount(addr common.Address) {
   612  	newObj, prev := s.createObject(addr)
   613  	if prev != nil {
   614  		newObj.setBalance(prev.data.Balance)
   615  	}
   616  }
   617  
   618  func (db *StateDB) ForEachStorage(addr common.Address, cb func(key, value common.Hash) bool) error {
   619  	so := db.getStateObject(addr)
   620  	if so == nil {
   621  		return nil
   622  	}
   623  	it := trie.NewIterator(so.getTrie(db.db).NodeIterator(nil))
   624  
   625  	for it.Next() {
   626  		key := common.BytesToHash(db.trie.GetKey(it.Key))
   627  		if value, dirty := so.dirtyStorage[key]; dirty {
   628  			if !cb(key, value) {
   629  				return nil
   630  			}
   631  			continue
   632  		}
   633  
   634  		if len(it.Value) > 0 {
   635  			_, content, _, err := rlp.Split(it.Value)
   636  			if err != nil {
   637  				return err
   638  			}
   639  			if !cb(key, common.BytesToHash(content)) {
   640  				return nil
   641  			}
   642  		}
   643  	}
   644  	return nil
   645  }
   646  
   647  // Copy creates a deep, independent copy of the state.
   648  // Snapshots of the copied state cannot be applied to the copy.
   649  func (s *StateDB) Copy() *StateDB {
   650  	// Copy all the basic fields, initialize the memory ones
   651  	state := &StateDB{
   652  		db:                  s.db,
   653  		trie:                s.db.CopyTrie(s.trie),
   654  		originalRoot:        s.originalRoot,
   655  		stateObjects:        make(map[common.Address]*stateObject, len(s.journal.dirties)),
   656  		stateObjectsPending: make(map[common.Address]struct{}, len(s.stateObjectsPending)),
   657  		stateObjectsDirty:   make(map[common.Address]struct{}, len(s.journal.dirties)),
   658  		refund:              s.refund,
   659  		logs:                make(map[common.Hash][]*types.Log, len(s.logs)),
   660  		logSize:             s.logSize,
   661  		preimages:           make(map[common.Hash][]byte, len(s.preimages)),
   662  		journal:             newJournal(),
   663  		hasher:              crypto.NewKeccakState(),
   664  	}
   665  	// Copy the dirty states, logs, and preimages
   666  	for addr := range s.journal.dirties {
   667  		// As documented [here](https://github.com/ethereum/go-ethereum/pull/16485#issuecomment-380438527),
   668  		// and in the Finalise-method, there is a case where an object is in the journal but not
   669  		// in the stateObjects: OOG after touch on ripeMD prior to Byzantium. Thus, we need to check for
   670  		// nil
   671  		if object, exist := s.stateObjects[addr]; exist {
   672  			// Even though the original object is dirty, we are not copying the journal,
   673  			// so we need to make sure that anyside effect the journal would have caused
   674  			// during a commit (or similar op) is already applied to the copy.
   675  			state.stateObjects[addr] = object.deepCopy(state)
   676  
   677  			state.stateObjectsDirty[addr] = struct{}{}   // Mark the copy dirty to force internal (code/state) commits
   678  			state.stateObjectsPending[addr] = struct{}{} // Mark the copy pending to force external (account) commits
   679  		}
   680  	}
   681  	// Above, we don't copy the actual journal. This means that if the copy is copied, the
   682  	// loop above will be a no-op, since the copy's journal is empty.
   683  	// Thus, here we iterate over stateObjects, to enable copies of copies
   684  	for addr := range s.stateObjectsPending {
   685  		if _, exist := state.stateObjects[addr]; !exist {
   686  			state.stateObjects[addr] = s.stateObjects[addr].deepCopy(state)
   687  		}
   688  		state.stateObjectsPending[addr] = struct{}{}
   689  	}
   690  	for addr := range s.stateObjectsDirty {
   691  		if _, exist := state.stateObjects[addr]; !exist {
   692  			state.stateObjects[addr] = s.stateObjects[addr].deepCopy(state)
   693  		}
   694  		state.stateObjectsDirty[addr] = struct{}{}
   695  	}
   696  	for hash, logs := range s.logs {
   697  		cpy := make([]*types.Log, len(logs))
   698  		for i, l := range logs {
   699  			cpy[i] = new(types.Log)
   700  			*cpy[i] = *l
   701  		}
   702  		state.logs[hash] = cpy
   703  	}
   704  	for hash, preimage := range s.preimages {
   705  		state.preimages[hash] = preimage
   706  	}
   707  	// Do we need to copy the access list? In practice: No. At the start of a
   708  	// transaction, the access list is empty. In practice, we only ever copy state
   709  	// _between_ transactions/blocks, never in the middle of a transaction.
   710  	// However, it doesn't cost us much to copy an empty list, so we do it anyway
   711  	// to not blow up if we ever decide copy it in the middle of a transaction
   712  	state.accessList = s.accessList.Copy()
   713  
   714  	// If there's a prefetcher running, make an inactive copy of it that can
   715  	// only access data but does not actively preload (since the user will not
   716  	// know that they need to explicitly terminate an active copy).
   717  	if s.prefetcher != nil {
   718  		state.prefetcher = s.prefetcher.copy()
   719  	}
   720  	if s.snaps != nil {
   721  		// In order for the miner to be able to use and make additions
   722  		// to the snapshot tree, we need to copy that aswell.
   723  		// Otherwise, any block mined by ourselves will cause gaps in the tree,
   724  		// and force the miner to operate trie-backed only
   725  		state.snaps = s.snaps
   726  		state.snap = s.snap
   727  		// deep copy needed
   728  		state.snapDestructs = make(map[common.Hash]struct{})
   729  		for k, v := range s.snapDestructs {
   730  			state.snapDestructs[k] = v
   731  		}
   732  		state.snapAccounts = make(map[common.Hash][]byte)
   733  		for k, v := range s.snapAccounts {
   734  			state.snapAccounts[k] = v
   735  		}
   736  		state.snapStorage = make(map[common.Hash]map[common.Hash][]byte)
   737  		for k, v := range s.snapStorage {
   738  			temp := make(map[common.Hash][]byte)
   739  			for kk, vv := range v {
   740  				temp[kk] = vv
   741  			}
   742  			state.snapStorage[k] = temp
   743  		}
   744  	}
   745  	return state
   746  }
   747  
   748  // Snapshot returns an identifier for the current revision of the state.
   749  func (s *StateDB) Snapshot() int {
   750  	id := s.nextRevisionId
   751  	s.nextRevisionId++
   752  	s.validRevisions = append(s.validRevisions, revision{id, s.journal.length()})
   753  	return id
   754  }
   755  
   756  // RevertToSnapshot reverts all state changes made since the given revision.
   757  func (s *StateDB) RevertToSnapshot(revid int) {
   758  	// Find the snapshot in the stack of valid snapshots.
   759  	idx := sort.Search(len(s.validRevisions), func(i int) bool {
   760  		return s.validRevisions[i].id >= revid
   761  	})
   762  	if idx == len(s.validRevisions) || s.validRevisions[idx].id != revid {
   763  		panic(fmt.Errorf("revision id %v cannot be reverted", revid))
   764  	}
   765  	snapshot := s.validRevisions[idx].journalIndex
   766  
   767  	// Replay the journal to undo changes and remove invalidated snapshots
   768  	s.journal.revert(s, snapshot)
   769  	s.validRevisions = s.validRevisions[:idx]
   770  }
   771  
   772  // GetRefund returns the current value of the refund counter.
   773  func (s *StateDB) GetRefund() uint64 {
   774  	return s.refund
   775  }
   776  
   777  // Finalise finalises the state by removing the s destructed objects and clears
   778  // the journal as well as the refunds. Finalise, however, will not push any updates
   779  // into the tries just yet. Only IntermediateRoot or Commit will do that.
   780  func (s *StateDB) Finalise(deleteEmptyObjects bool) {
   781  	addressesToPrefetch := make([][]byte, 0, len(s.journal.dirties))
   782  	for addr := range s.journal.dirties {
   783  		obj, exist := s.stateObjects[addr]
   784  		if !exist {
   785  			// ripeMD is 'touched' at block 1714175, in tx 0x1237f737031e40bcde4a8b7e717b2d15e3ecadfe49bb1bbc71ee9deb09c6fcf2
   786  			// That tx goes out of gas, and although the notion of 'touched' does not exist there, the
   787  			// touch-event will still be recorded in the journal. Since ripeMD is a special snowflake,
   788  			// it will persist in the journal even though the journal is reverted. In this special circumstance,
   789  			// it may exist in `s.journal.dirties` but not in `s.stateObjects`.
   790  			// Thus, we can safely ignore it here
   791  			continue
   792  		}
   793  		if obj.suicided || (deleteEmptyObjects && obj.empty()) {
   794  			obj.deleted = true
   795  
   796  			// If state snapshotting is active, also mark the destruction there.
   797  			// Note, we can't do this only at the end of a block because multiple
   798  			// transactions within the same block might self destruct and then
   799  			// ressurrect an account; but the snapshotter needs both events.
   800  			if s.snap != nil {
   801  				s.snapDestructs[obj.addrHash] = struct{}{} // We need to maintain account deletions explicitly (will remain set indefinitely)
   802  				delete(s.snapAccounts, obj.addrHash)       // Clear out any previously updated account data (may be recreated via a ressurrect)
   803  				delete(s.snapStorage, obj.addrHash)        // Clear out any previously updated storage data (may be recreated via a ressurrect)
   804  			}
   805  		} else {
   806  			obj.finalise(true) // Prefetch slots in the background
   807  		}
   808  		s.stateObjectsPending[addr] = struct{}{}
   809  		s.stateObjectsDirty[addr] = struct{}{}
   810  
   811  		// At this point, also ship the address off to the precacher. The precacher
   812  		// will start loading tries, and when the change is eventually committed,
   813  		// the commit-phase will be a lot faster
   814  		addressesToPrefetch = append(addressesToPrefetch, common.CopyBytes(addr[:])) // Copy needed for closure
   815  	}
   816  	if s.prefetcher != nil && len(addressesToPrefetch) > 0 {
   817  		s.prefetcher.prefetch(common.Hash{}, s.originalRoot, addressesToPrefetch)
   818  	}
   819  	// Invalidate journal because reverting across transactions is not allowed.
   820  	s.clearJournalAndRefund()
   821  }
   822  
   823  // IntermediateRoot computes the current root hash of the state trie.
   824  // It is called in between transactions to get the root hash that
   825  // goes into transaction receipts.
   826  func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
   827  	// Finalise all the dirty storage states and write them into the tries
   828  	s.Finalise(deleteEmptyObjects)
   829  
   830  	// If there was a trie prefetcher operating, it gets aborted and irrevocably
   831  	// modified after we start retrieving tries. Remove it from the statedb after
   832  	// this round of use.
   833  	//
   834  	// This is weird pre-byzantium since the first tx runs with a prefetcher and
   835  	// the remainder without, but pre-byzantium even the initial prefetcher is
   836  	// useless, so no sleep lost.
   837  	prefetcher := s.prefetcher
   838  	if s.prefetcher != nil {
   839  		defer func() {
   840  			s.prefetcher.close()
   841  			s.prefetcher = nil
   842  		}()
   843  	}
   844  	// Although naively it makes sense to retrieve the account trie and then do
   845  	// the contract storage and account updates sequentially, that short circuits
   846  	// the account prefetcher. Instead, let's process all the storage updates
   847  	// first, giving the account prefeches just a few more milliseconds of time
   848  	// to pull useful data from disk.
   849  	for addr := range s.stateObjectsPending {
   850  		if obj := s.stateObjects[addr]; !obj.deleted {
   851  			obj.updateRoot(s.db)
   852  		}
   853  	}
   854  	// Now we're about to start to write changes to the trie. The trie is so far
   855  	// _untouched_. We can check with the prefetcher, if it can give us a trie
   856  	// which has the same root, but also has some content loaded into it.
   857  	if prefetcher != nil {
   858  		if trie := prefetcher.trie(common.Hash{}, s.originalRoot); trie != nil {
   859  			s.trie = trie
   860  		}
   861  	}
   862  	usedAddrs := make([][]byte, 0, len(s.stateObjectsPending))
   863  	for addr := range s.stateObjectsPending {
   864  		if obj := s.stateObjects[addr]; obj.deleted {
   865  			s.deleteStateObject(obj)
   866  			s.AccountDeleted += 1
   867  		} else {
   868  			s.updateStateObject(obj)
   869  			s.AccountUpdated += 1
   870  		}
   871  		usedAddrs = append(usedAddrs, common.CopyBytes(addr[:])) // Copy needed for closure
   872  	}
   873  	if prefetcher != nil {
   874  		prefetcher.used(common.Hash{}, s.originalRoot, usedAddrs)
   875  	}
   876  	if len(s.stateObjectsPending) > 0 {
   877  		s.stateObjectsPending = make(map[common.Address]struct{})
   878  	}
   879  	// Track the amount of time wasted on hashing the account trie
   880  	if metrics.EnabledExpensive {
   881  		defer func(start time.Time) { s.AccountHashes += time.Since(start) }(time.Now())
   882  	}
   883  	return s.trie.Hash()
   884  }
   885  
   886  // Prepare sets the current transaction hash and index which are
   887  // used when the EVM emits new state logs.
   888  func (s *StateDB) Prepare(thash common.Hash, ti int) {
   889  	s.thash = thash
   890  	s.txIndex = ti
   891  }
   892  
   893  func (s *StateDB) clearJournalAndRefund() {
   894  	if len(s.journal.entries) > 0 {
   895  		s.journal = newJournal()
   896  		s.refund = 0
   897  	}
   898  	s.validRevisions = s.validRevisions[:0] // Snapshots can be created without journal entires
   899  }
   900  
   901  // Commit writes the state to the underlying in-memory trie database.
   902  func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error) {
   903  	if s.dbErr != nil {
   904  		return common.Hash{}, fmt.Errorf("commit aborted due to earlier error: %v", s.dbErr)
   905  	}
   906  	// Finalize any pending changes and merge everything into the tries
   907  	s.IntermediateRoot(deleteEmptyObjects)
   908  
   909  	// Commit objects to the trie, measuring the elapsed time
   910  	var storageCommitted int
   911  	codeWriter := s.db.TrieDB().DiskDB().NewBatch()
   912  	for addr := range s.stateObjectsDirty {
   913  		if obj := s.stateObjects[addr]; !obj.deleted {
   914  			// Write any contract code associated with the state object
   915  			if obj.code != nil && obj.dirtyCode {
   916  				rawdb.WriteCode(codeWriter, common.BytesToHash(obj.CodeHash()), obj.code)
   917  				obj.dirtyCode = false
   918  			}
   919  			// Write any storage changes in the state object to its storage trie
   920  			committed, err := obj.CommitTrie(s.db)
   921  			if err != nil {
   922  				return common.Hash{}, err
   923  			}
   924  			storageCommitted += committed
   925  		}
   926  	}
   927  	if len(s.stateObjectsDirty) > 0 {
   928  		s.stateObjectsDirty = make(map[common.Address]struct{})
   929  	}
   930  	if codeWriter.ValueSize() > 0 {
   931  		if err := codeWriter.Write(); err != nil {
   932  			log.Crit("Failed to commit dirty codes", "error", err)
   933  		}
   934  	}
   935  	// Write the account trie changes, measuing the amount of wasted time
   936  	var start time.Time
   937  	if metrics.EnabledExpensive {
   938  		start = time.Now()
   939  	}
   940  	// The onleaf func is called _serially_, so we can reuse the same account
   941  	// for unmarshalling every time.
   942  	var account types.StateAccount
   943  	root, accountCommitted, err := s.trie.Commit(func(_ [][]byte, _ []byte, leaf []byte, parent common.Hash, _ []byte) error {
   944  		if err := rlp.DecodeBytes(leaf, &account); err != nil {
   945  			return nil
   946  		}
   947  		if account.Root != emptyRoot {
   948  			s.db.TrieDB().Reference(account.Root, parent)
   949  		}
   950  		return nil
   951  	})
   952  	if err != nil {
   953  		return common.Hash{}, err
   954  	}
   955  	if metrics.EnabledExpensive {
   956  		s.AccountCommits += time.Since(start)
   957  
   958  		accountUpdatedMeter.Mark(int64(s.AccountUpdated))
   959  		storageUpdatedMeter.Mark(int64(s.StorageUpdated))
   960  		accountDeletedMeter.Mark(int64(s.AccountDeleted))
   961  		storageDeletedMeter.Mark(int64(s.StorageDeleted))
   962  		accountCommittedMeter.Mark(int64(accountCommitted))
   963  		storageCommittedMeter.Mark(int64(storageCommitted))
   964  		s.AccountUpdated, s.AccountDeleted = 0, 0
   965  		s.StorageUpdated, s.StorageDeleted = 0, 0
   966  	}
   967  	// If snapshotting is enabled, update the snapshot tree with this new version
   968  	if s.snap != nil {
   969  		if metrics.EnabledExpensive {
   970  			defer func(start time.Time) { s.SnapshotCommits += time.Since(start) }(time.Now())
   971  		}
   972  		// Only update if there's a state transition (skip empty Clique blocks)
   973  		if parent := s.snap.Root(); parent != root {
   974  			if err := s.snaps.Update(root, parent, s.snapDestructs, s.snapAccounts, s.snapStorage); err != nil {
   975  				log.Warn("Failed to update snapshot tree", "from", parent, "to", root, "err", err)
   976  			}
   977  			// Keep 128 diff layers in the memory, persistent layer is 129th.
   978  			// - head layer is paired with HEAD state
   979  			// - head-1 layer is paired with HEAD-1 state
   980  			// - head-127 layer(bottom-most diff layer) is paired with HEAD-127 state
   981  			if err := s.snaps.Cap(root, 128); err != nil {
   982  				log.Warn("Failed to cap snapshot tree", "root", root, "layers", 128, "err", err)
   983  			}
   984  		}
   985  		s.snap, s.snapDestructs, s.snapAccounts, s.snapStorage = nil, nil, nil, nil
   986  	}
   987  	s.originalRoot = root
   988  	return root, err
   989  }
   990  
   991  // PrepareAccessList handles the preparatory steps for executing a state transition with
   992  // regards to both EIP-2929 and EIP-2930:
   993  //
   994  // - Add sender to access list (2929)
   995  // - Add destination to access list (2929)
   996  // - Add precompiles to access list (2929)
   997  // - Add the contents of the optional tx access list (2930)
   998  //
   999  // This method should only be called if Berlin/2929+2930 is applicable at the current number.
  1000  func (s *StateDB) PrepareAccessList(sender common.Address, dst *common.Address, precompiles []common.Address, list types.AccessList) {
  1001  	// Clear out any leftover from previous executions
  1002  	s.accessList = newAccessList()
  1003  
  1004  	s.AddAddressToAccessList(sender)
  1005  	if dst != nil {
  1006  		s.AddAddressToAccessList(*dst)
  1007  		// If it's a create-tx, the destination will be added inside evm.create
  1008  	}
  1009  	for _, addr := range precompiles {
  1010  		s.AddAddressToAccessList(addr)
  1011  	}
  1012  	for _, el := range list {
  1013  		s.AddAddressToAccessList(el.Address)
  1014  		for _, key := range el.StorageKeys {
  1015  			s.AddSlotToAccessList(el.Address, key)
  1016  		}
  1017  	}
  1018  }
  1019  
  1020  // AddAddressToAccessList adds the given address to the access list
  1021  func (s *StateDB) AddAddressToAccessList(addr common.Address) {
  1022  	if s.accessList.AddAddress(addr) {
  1023  		s.journal.append(accessListAddAccountChange{&addr})
  1024  	}
  1025  }
  1026  
  1027  // AddSlotToAccessList adds the given (address, slot)-tuple to the access list
  1028  func (s *StateDB) AddSlotToAccessList(addr common.Address, slot common.Hash) {
  1029  	addrMod, slotMod := s.accessList.AddSlot(addr, slot)
  1030  	if addrMod {
  1031  		// In practice, this should not happen, since there is no way to enter the
  1032  		// scope of 'address' without having the 'address' become already added
  1033  		// to the access list (via call-variant, create, etc).
  1034  		// Better safe than sorry, though
  1035  		s.journal.append(accessListAddAccountChange{&addr})
  1036  	}
  1037  	if slotMod {
  1038  		s.journal.append(accessListAddSlotChange{
  1039  			address: &addr,
  1040  			slot:    &slot,
  1041  		})
  1042  	}
  1043  }
  1044  
  1045  // AddressInAccessList returns true if the given address is in the access list.
  1046  func (s *StateDB) AddressInAccessList(addr common.Address) bool {
  1047  	return s.accessList.ContainsAddress(addr)
  1048  }
  1049  
  1050  // SlotInAccessList returns true if the given (address, slot)-tuple is in the access list.
  1051  func (s *StateDB) SlotInAccessList(addr common.Address, slot common.Hash) (addressPresent bool, slotPresent bool) {
  1052  	return s.accessList.Contains(addr, slot)
  1053  }