1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243 |
- // 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 (
- "errors"
- "fmt"
- "math/big"
- "sort"
- "sync"
- "time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- )
- type revision struct {
- id int
- journalIndex int
- }
- var (
- // emptyRoot is the known root hash of an empty trie.
- emptyRoot = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
- )
- type proofList [][]byte
- func (n *proofList) Put(key []byte, value []byte) error {
- *n = append(*n, value)
- return nil
- }
- func (n *proofList) Delete(key []byte) error {
- panic("not supported")
- }
- // StateDB structs 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
- prefetcher *triePrefetcher
- originalRoot common.Hash // The pre-state root, before any changes were made
- trie Trie
- hasher crypto.KeccakState
- snaps *snapshot.Tree
- snap snapshot.Snapshot
- snapDestructs map[common.Hash]struct{}
- snapAccounts map[common.Hash][]byte
- snapStorage map[common.Hash]map[common.Hash][]byte
- mutex sync.Mutex
- journalMutex sync.Mutex
- // Quorum - a trie to hold extra account information that cannot be stored in the accounts trie
- accountExtraDataTrie Trie
- // This map holds 'live' objects, which will get modified while processing a state transition.
- stateObjects map[common.Address]*stateObject
- stateObjectsPending map[common.Address]struct{} // State objects finalized but not yet written to the trie
- stateObjectsDirty map[common.Address]struct{} // State objects modified in the current execution
- // 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 uint64
- thash, bhash common.Hash
- txIndex int
- logs map[common.Hash][]*types.Log
- logSize uint
- preimages map[common.Hash][]byte
- // Per-transaction access list
- accessList *accessList
- // Journal of state modifications. This is the backbone of
- // Snapshot and RevertToSnapshot.
- journal *journal
- validRevisions []revision
- nextRevisionId int
- // Measurements gathered during execution for debugging purposes
- AccountReads time.Duration
- AccountHashes time.Duration
- AccountUpdates time.Duration
- AccountCommits time.Duration
- StorageReads time.Duration
- StorageHashes time.Duration
- StorageUpdates time.Duration
- StorageCommits time.Duration
- SnapshotAccountReads time.Duration
- SnapshotStorageReads time.Duration
- SnapshotCommits time.Duration
- }
- // New creates a new state from a given trie.
- func New(root common.Hash, db Database, snaps *snapshot.Tree) (*StateDB, error) {
- tr, err := db.OpenTrie(root)
- if err != nil {
- return nil, err
- }
- // Quorum - Privacy Enhancements - retrieve the privacy metadata root corresponding to the account state root
- extraDataRoot := db.AccountExtraDataLinker().GetAccountExtraDataRoot(root)
- log.Debug("Account Extra Data root", "hash", extraDataRoot)
- accountExtraDataTrie, err := db.OpenTrie(extraDataRoot)
- if err != nil {
- return nil, fmt.Errorf("Unable to open privacy metadata trie: %v", err)
- }
- // End Quorum - Privacy Enhancements
- sdb := &StateDB{
- db: db,
- trie: tr,
- originalRoot: root,
- snaps: snaps,
- stateObjects: make(map[common.Address]*stateObject),
- stateObjectsPending: make(map[common.Address]struct{}),
- stateObjectsDirty: make(map[common.Address]struct{}),
- logs: make(map[common.Hash][]*types.Log),
- preimages: make(map[common.Hash][]byte),
- journal: newJournal(),
- accessList: newAccessList(),
- hasher: crypto.NewKeccakState(),
- // Quorum - Privacy Enhancements
- accountExtraDataTrie: accountExtraDataTrie,
- }
- if sdb.snaps != nil {
- if sdb.snap = sdb.snaps.Snapshot(root); sdb.snap != nil {
- sdb.snapDestructs = make(map[common.Hash]struct{})
- sdb.snapAccounts = make(map[common.Hash][]byte)
- sdb.snapStorage = make(map[common.Hash]map[common.Hash][]byte)
- }
- }
- return sdb, nil
- }
- // StartPrefetcher initializes a new trie prefetcher to pull in nodes from the
- // state trie concurrently while the state is mutated so that when we reach the
- // commit phase, most of the needed data is already hot.
- func (s *StateDB) StartPrefetcher(namespace string) {
- if s.prefetcher != nil {
- s.prefetcher.close()
- s.prefetcher = nil
- }
- if s.snap != nil {
- s.prefetcher = newTriePrefetcher(s.db, s.originalRoot, namespace)
- }
- }
- // StopPrefetcher terminates a running prefetcher and reports any leftover stats
- // from the gathered metrics.
- func (s *StateDB) StopPrefetcher() {
- if s.prefetcher != nil {
- s.prefetcher.close()
- s.prefetcher = nil
- }
- }
- // setError remembers the first non-nil error it is called with.
- func (s *StateDB) setError(err error) {
- if s.dbErr == nil {
- s.dbErr = err
- }
- }
- func (s *StateDB) Error() error {
- return s.dbErr
- }
- func (s *StateDB) AddLog(log *types.Log) {
- s.journal.append(addLogChange{txhash: s.thash})
- log.TxHash = s.thash
- log.BlockHash = s.bhash
- log.TxIndex = uint(s.txIndex)
- log.Index = s.logSize
- s.logs[s.thash] = append(s.logs[s.thash], log)
- s.logSize++
- }
- func (s *StateDB) GetLogs(hash common.Hash) []*types.Log {
- return s.logs[hash]
- }
- func (s *StateDB) Logs() []*types.Log {
- var logs []*types.Log
- for _, lgs := range s.logs {
- logs = append(logs, lgs...)
- }
- return logs
- }
- // AddPreimage records a SHA3 preimage seen by the VM.
- func (s *StateDB) AddPreimage(hash common.Hash, preimage []byte) {
- if _, ok := s.preimages[hash]; !ok {
- s.journal.append(addPreimageChange{hash: hash})
- pi := make([]byte, len(preimage))
- copy(pi, preimage)
- s.preimages[hash] = pi
- }
- }
- // Preimages returns a list of SHA3 preimages that have been submitted.
- func (s *StateDB) Preimages() map[common.Hash][]byte {
- return s.preimages
- }
- // AddRefund adds gas to the refund counter
- func (s *StateDB) AddRefund(gas uint64) {
- s.journal.append(refundChange{prev: s.refund})
- s.refund += gas
- }
- // SubRefund removes gas from the refund counter.
- // This method will panic if the refund counter goes below zero
- func (s *StateDB) SubRefund(gas uint64) {
- s.journal.append(refundChange{prev: s.refund})
- if gas > s.refund {
- panic(fmt.Sprintf("Refund counter below zero (gas: %d > refund: %d)", gas, s.refund))
- }
- s.refund -= gas
- }
- // Exist reports whether the given account address exists in the state.
- // Notably this also returns true for suicided accounts.
- func (s *StateDB) Exist(addr common.Address) bool {
- return s.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 (s *StateDB) Empty(addr common.Address) bool {
- so := s.getStateObject(addr)
- return so == nil || so.empty()
- }
- // GetBalance retrieves the balance from the given address or 0 if object not found
- func (s *StateDB) GetBalance(addr common.Address) *big.Int {
- stateObject := s.getStateObject(addr)
- if stateObject != nil {
- return stateObject.Balance()
- }
- return common.Big0
- }
- func (s *StateDB) GetNonce(addr common.Address) uint64 {
- stateObject := s.getStateObject(addr)
- if stateObject != nil {
- return stateObject.Nonce()
- }
- return 0
- }
- // Quorum
- func (s *StateDB) GetPrivacyMetadata(addr common.Address) (*PrivacyMetadata, error) {
- stateObject := s.getStateObject(addr)
- if stateObject != nil {
- return stateObject.PrivacyMetadata()
- }
- return nil, nil
- }
- // Quorum
- func (s *StateDB) GetCommittedStatePrivacyMetadata(addr common.Address) (*PrivacyMetadata, error) {
- stateObject := s.getStateObject(addr)
- if stateObject != nil {
- return stateObject.GetCommittedPrivacyMetadata()
- }
- return nil, nil
- }
- // Quorum
- func (self *StateDB) GetManagedParties(addr common.Address) ([]string, error) {
- stateObject := self.getStateObject(addr)
- if stateObject != nil {
- return stateObject.ManagedParties()
- }
- return nil, nil
- }
- func (s *StateDB) GetRLPEncodedStateObject(addr common.Address) ([]byte, error) {
- stateObject := s.getStateObject(addr)
- if stateObject == nil {
- return nil, fmt.Errorf("no state found for %s", addr.Hex())
- }
- // When calculating the execution hash or simulating the transaction the stateOject state is not committed/updated
- // In order to reflect the updated state invoke stateObject.updateRoot on a copy of the state object.
- if len(stateObject.pendingStorage) > 0 || len(stateObject.dirtyStorage) > 0 || stateObject.dirtyCode {
- cpy := stateObject.deepCopy(s)
- cpy.updateRoot(s.db)
- return rlp.EncodeToBytes(cpy)
- }
- return rlp.EncodeToBytes(stateObject)
- }
- // Reset clears out all ephemeral state objects from the state db, but keeps
- // the underlying state trie to avoid reloading data for the next operations.
- func (s *StateDB) Reset(root common.Hash) error {
- tr, err := s.db.OpenTrie(root)
- if err != nil {
- return err
- }
- s.trie = tr
- s.mutex.Lock()
- s.stateObjects = make(map[common.Address]*stateObject)
- s.stateObjectsPending = make(map[common.Address]struct{})
- s.stateObjectsDirty = make(map[common.Address]struct{})
- s.mutex.Unlock()
- s.thash = common.Hash{}
- s.bhash = common.Hash{}
- s.txIndex = 0
- s.logs = make(map[common.Hash][]*types.Log)
- s.logSize = 0
- s.preimages = make(map[common.Hash][]byte)
- s.clearJournalAndRefund()
- if s.snaps != nil {
- s.snapAccounts, s.snapDestructs, s.snapStorage = nil, nil, nil
- if s.snap = s.snaps.Snapshot(root); s.snap != nil {
- s.snapDestructs = make(map[common.Hash]struct{})
- s.snapAccounts = make(map[common.Hash][]byte)
- s.snapStorage = make(map[common.Hash]map[common.Hash][]byte)
- }
- }
- s.accessList = newAccessList()
- return nil
- }
- // End Quorum
- // TxIndex returns the current transaction index set by Prepare.
- func (s *StateDB) TxIndex() int {
- return s.txIndex
- }
- // BlockHash returns the current block hash set by Prepare.
- func (s *StateDB) BlockHash() common.Hash {
- return s.bhash
- }
- func (s *StateDB) GetCode(addr common.Address) []byte {
- stateObject := s.getStateObject(addr)
- if stateObject != nil {
- return stateObject.Code(s.db)
- }
- return nil
- }
- func (s *StateDB) GetCodeSize(addr common.Address) int {
- stateObject := s.getStateObject(addr)
- if stateObject != nil {
- return stateObject.CodeSize(s.db)
- }
- return 0
- }
- func (s *StateDB) GetCodeHash(addr common.Address) common.Hash {
- stateObject := s.getStateObject(addr)
- if stateObject == nil {
- return common.Hash{}
- }
- return common.BytesToHash(stateObject.CodeHash())
- }
- // GetState retrieves a value from the given account's storage trie.
- func (s *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash {
- stateObject := s.getStateObject(addr)
- if stateObject != nil {
- return stateObject.GetState(s.db, hash)
- }
- return common.Hash{}
- }
- // GetProof returns the Merkle proof for a given account.
- func (s *StateDB) GetProof(addr common.Address) ([][]byte, error) {
- return s.GetProofByHash(crypto.Keccak256Hash(addr.Bytes()))
- }
- // GetProofByHash returns the Merkle proof for a given account.
- func (s *StateDB) GetProofByHash(addrHash common.Hash) ([][]byte, error) {
- var proof proofList
- err := s.trie.Prove(addrHash[:], 0, &proof)
- return proof, err
- }
- // GetStorageProof returns the Merkle proof for given storage slot.
- func (s *StateDB) GetStorageProof(a common.Address, key common.Hash) ([][]byte, error) {
- var proof proofList
- trie := s.StorageTrie(a)
- if trie == nil {
- return proof, errors.New("storage trie for requested address does not exist")
- }
- err := trie.Prove(crypto.Keccak256(key.Bytes()), 0, &proof)
- return proof, err
- }
- // GetStorageProofByHash returns the Merkle proof for given storage slot.
- func (s *StateDB) GetStorageProofByHash(a common.Address, key common.Hash) ([][]byte, error) {
- var proof proofList
- trie := s.StorageTrie(a)
- if trie == nil {
- return proof, errors.New("storage trie for requested address does not exist")
- }
- err := trie.Prove(crypto.Keccak256(key.Bytes()), 0, &proof)
- return proof, err
- }
- // GetCommittedState retrieves a value from the given account's committed storage trie.
- func (s *StateDB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash {
- stateObject := s.getStateObject(addr)
- if stateObject != nil {
- return stateObject.GetCommittedState(s.db, hash)
- }
- return common.Hash{}
- }
- // Database retrieves the low level database supporting the lower level trie ops.
- func (s *StateDB) Database() Database {
- return s.db
- }
- // StorageTrie returns the storage trie of an account.
- // The return value is a copy and is nil for non-existent accounts.
- func (s *StateDB) StorageTrie(addr common.Address) Trie {
- stateObject := s.getStateObject(addr)
- if stateObject == nil {
- return nil
- }
- cpy := stateObject.deepCopy(s)
- cpy.updateTrie(s.db)
- return cpy.getTrie(s.db)
- }
- func (s *StateDB) HasSuicided(addr common.Address) bool {
- stateObject := s.getStateObject(addr)
- if stateObject != nil {
- return stateObject.suicided
- }
- return false
- }
- // Quorum
- // GetStorageRoot returns the root of the storage associated with the given address.
- func (s *StateDB) GetStorageRoot(addr common.Address) (common.Hash, error) {
- so := s.getStateObject(addr)
- if so == nil {
- return common.Hash{}, fmt.Errorf("can't find state object")
- }
- return so.storageRoot(s.db), nil
- }
- /*
- * SETTERS
- */
- // AddBalance adds amount to the account associated with addr.
- func (s *StateDB) AddBalance(addr common.Address, amount *big.Int) {
- stateObject := s.GetOrNewStateObject(addr)
- if stateObject != nil {
- stateObject.AddBalance(amount)
- }
- }
- // SubBalance subtracts amount from the account associated with addr.
- func (s *StateDB) SubBalance(addr common.Address, amount *big.Int) {
- stateObject := s.GetOrNewStateObject(addr)
- if stateObject != nil {
- stateObject.SubBalance(amount)
- }
- }
- func (s *StateDB) SetBalance(addr common.Address, amount *big.Int) {
- stateObject := s.GetOrNewStateObject(addr)
- if stateObject != nil {
- stateObject.SetBalance(amount)
- }
- }
- func (s *StateDB) SetNonce(addr common.Address, nonce uint64) {
- stateObject := s.GetOrNewStateObject(addr)
- if stateObject != nil {
- stateObject.SetNonce(nonce)
- }
- }
- func (s *StateDB) SetPrivacyMetadata(addr common.Address, metadata *PrivacyMetadata) {
- stateObject := s.GetOrNewStateObject(addr)
- if stateObject != nil {
- stateObject.SetStatePrivacyMetadata(metadata)
- }
- }
- func (self *StateDB) SetManagedParties(addr common.Address, managedParties []string) {
- stateObject := self.GetOrNewStateObject(addr)
- if stateObject != nil && len(managedParties) > 0 {
- stateObject.SetManagedParties(managedParties)
- }
- }
- func (s *StateDB) SetCode(addr common.Address, code []byte) {
- stateObject := s.GetOrNewStateObject(addr)
- if stateObject != nil {
- stateObject.SetCode(crypto.Keccak256Hash(code), code)
- }
- }
- func (s *StateDB) SetState(addr common.Address, key, value common.Hash) {
- stateObject := s.GetOrNewStateObject(addr)
- if stateObject != nil {
- stateObject.SetState(s.db, key, value)
- }
- }
- // SetStorage replaces the entire storage for the specified account with given
- // storage. This function should only be used for debugging.
- func (s *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common.Hash) {
- stateObject := s.GetOrNewStateObject(addr)
- if stateObject != nil {
- stateObject.SetStorage(storage)
- }
- }
- // 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 (s *StateDB) Suicide(addr common.Address) bool {
- stateObject := s.getStateObject(addr)
- if stateObject == nil {
- return false
- }
- s.journal.append(suicideChange{
- account: &addr,
- prev: stateObject.suicided,
- prevbalance: new(big.Int).Set(stateObject.Balance()),
- })
- stateObject.markSuicided()
- stateObject.data.Balance = new(big.Int)
- return true
- }
- //
- // Setting, updating & deleting state object methods.
- //
- // updateStateObject writes the given object to the trie.
- // Quorum:
- // - update AccountExtraData trie
- func (s *StateDB) updateStateObject(obj *stateObject) {
- // Track the amount of time wasted on updating the account from the trie
- if metrics.EnabledExpensive {
- defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now())
- }
- // Encode the account and update the account trie
- addr := obj.Address()
- data, err := rlp.EncodeToBytes(obj)
- if err != nil {
- panic(fmt.Errorf("can't encode object at %x: %v", addr[:], err))
- }
- if err = s.trie.TryUpdate(addr[:], data); err != nil {
- s.setError(fmt.Errorf("updateStateObject (%x) error: %v", addr[:], err))
- }
- // If state snapshotting is active, cache the data til commit. Note, this
- // update mechanism is not symmetric to the deletion, because whereas it is
- // enough to track account updates at commit time, deletions need tracking
- // at transaction boundary level to ensure we capture state clearing.
- if s.snap != nil {
- s.snapAccounts[obj.addrHash] = snapshot.SlimAccountRLP(obj.data.Nonce, obj.data.Balance, obj.data.Root, obj.data.CodeHash)
- }
- // Quorum - Privacy Enhancements - update the privacy metadata trie in case the privacy metadata is dirty
- if err != nil {
- return
- }
- if obj.dirtyAccountExtraData && obj.accountExtraData != nil {
- extraDataBytes, err := rlp.EncodeToBytes(obj.accountExtraData)
- if err != nil {
- panic(fmt.Errorf("can't encode privacy metadata at %x: %v", addr[:], err))
- }
- err = s.accountExtraDataTrie.TryUpdate(addr[:], extraDataBytes)
- if err != nil {
- s.setError(err)
- return
- }
- }
- }
- // deleteStateObject removes the given object from the state trie.
- // Quorum:
- // - delete the data from the extra data trie corresponding to the account address
- func (s *StateDB) deleteStateObject(obj *stateObject) {
- // Track the amount of time wasted on deleting the account from the trie
- if metrics.EnabledExpensive {
- defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now())
- }
- // Delete the account from the trie
- addr := obj.Address()
- if err := s.trie.TryDelete(addr[:]); err != nil {
- s.setError(fmt.Errorf("deleteStateObject (%x) error: %v", addr[:], err))
- return
- }
- s.setError(s.accountExtraDataTrie.TryDelete(addr[:]))
- }
- // getStateObject retrieves a state object given by the address, returning nil if
- // the object is not found or was deleted in this execution context. If you need
- // to differentiate between non-existent/just-deleted, use getDeletedStateObject.
- func (s *StateDB) getStateObject(addr common.Address) *stateObject {
- if obj := s.getDeletedStateObject(addr); obj != nil && !obj.deleted {
- return obj
- }
- return nil
- }
- // getDeletedStateObject is similar to getStateObject, but instead of returning
- // nil for a deleted state object, it returns the actual object with the deleted
- // flag set. This is needed by the state journal to revert to the correct s-
- // destructed object instead of wiping all knowledge about the state object.
- func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {
- // Prefer live objects if any is available
- if obj := s.stateObjects[addr]; obj != nil {
- return obj
- }
- // If no live objects are available, attempt to use snapshots
- var (
- data *Account
- err error
- )
- if s.snap != nil {
- if metrics.EnabledExpensive {
- defer func(start time.Time) { s.SnapshotAccountReads += time.Since(start) }(time.Now())
- }
- var acc *snapshot.Account
- if acc, err = s.snap.Account(crypto.HashData(s.hasher, addr.Bytes())); err == nil {
- if acc == nil {
- return nil
- }
- data = &Account{
- Nonce: acc.Nonce,
- Balance: acc.Balance,
- CodeHash: acc.CodeHash,
- Root: common.BytesToHash(acc.Root),
- }
- if len(data.CodeHash) == 0 {
- data.CodeHash = emptyCodeHash
- }
- if data.Root == (common.Hash{}) {
- data.Root = emptyRoot
- }
- }
- }
- // If snapshot unavailable or reading from it failed, load from the database
- if s.snap == nil || err != nil {
- if metrics.EnabledExpensive {
- defer func(start time.Time) { s.AccountReads += time.Since(start) }(time.Now())
- }
- enc, err := s.trie.TryGet(addr.Bytes())
- if err != nil {
- s.setError(fmt.Errorf("getDeleteStateObject (%x) error: %v", addr.Bytes(), err))
- return nil
- }
- if len(enc) == 0 {
- return nil
- }
- data = new(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(s, addr, *data)
- s.setStateObject(obj)
- return obj
- }
- func (s *StateDB) setStateObject(object *stateObject) {
- defer s.mutex.Unlock()
- s.mutex.Lock()
- s.stateObjects[object.Address()] = object
- }
- // GetOrNewStateObject retrieves a state object or create a new state object if nil.
- func (s *StateDB) GetOrNewStateObject(addr common.Address) *stateObject {
- stateObject := s.getStateObject(addr)
- if stateObject == nil {
- stateObject, _ = s.createObject(addr)
- }
- return stateObject
- }
- // 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 (s *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) {
- prev = s.getDeletedStateObject(addr) // Note, prev might have been deleted, we need that!
- var prevdestruct bool
- if s.snap != nil && prev != nil {
- _, prevdestruct = s.snapDestructs[prev.addrHash]
- if !prevdestruct {
- s.snapDestructs[prev.addrHash] = struct{}{}
- }
- }
- newobj = newObject(s, addr, Account{})
- newobj.setNonce(0) // sets the object to dirty
- if prev == nil {
- s.journal.append(createObjectChange{account: &addr})
- } else {
- s.journal.append(resetObjectChange{prev: prev, prevdestruct: prevdestruct})
- }
- s.setStateObject(newobj)
- if prev != nil && !prev.deleted {
- return newobj, prev
- }
- return newobj, nil
- }
- // 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 (s *StateDB) CreateAccount(addr common.Address) {
- newObj, prev := s.createObject(addr)
- if prev != nil {
- newObj.setBalance(prev.data.Balance)
- }
- }
- func (db *StateDB) ForEachStorage(addr common.Address, cb func(key, value common.Hash) bool) error {
- so := db.getStateObject(addr)
- if so == nil {
- return nil
- }
- it := trie.NewIterator(so.getTrie(db.db).NodeIterator(nil))
- for it.Next() {
- key := common.BytesToHash(db.trie.GetKey(it.Key))
- if value, dirty := so.dirtyStorage[key]; dirty {
- if !cb(key, value) {
- return nil
- }
- continue
- }
- if len(it.Value) > 0 {
- _, content, _, err := rlp.Split(it.Value)
- if err != nil {
- return err
- }
- if !cb(key, common.BytesToHash(content)) {
- return nil
- }
- }
- }
- return nil
- }
- // Copy creates a deep, independent copy of the state.
- // Snapshots of the copied state cannot be applied to the copy.
- func (s *StateDB) Copy() *StateDB {
- s.journalMutex.Lock()
- journal := s.journal
- s.journalMutex.Unlock()
- journal.mutex.Lock()
- size := len(journal.dirties)
- dirties := make([]common.Address, 0, size)
- for addr := range journal.dirties {
- dirties = append(dirties, addr)
- }
- journal.mutex.Unlock()
- // Copy all the basic fields, initialize the memory ones
- state := &StateDB{
- db: s.db,
- trie: s.db.CopyTrie(s.trie),
- stateObjects: make(map[common.Address]*stateObject, size),
- stateObjectsPending: make(map[common.Address]struct{}, len(s.stateObjectsPending)),
- stateObjectsDirty: make(map[common.Address]struct{}, size),
- refund: s.refund,
- logs: make(map[common.Hash][]*types.Log, len(s.logs)),
- logSize: s.logSize,
- preimages: make(map[common.Hash][]byte, len(s.preimages)),
- journal: newJournal(),
- hasher: crypto.NewKeccakState(),
- // Quorum - Privacy Enhancements
- accountExtraDataTrie: s.db.CopyTrie(s.accountExtraDataTrie),
- }
- s.mutex.Lock()
- // Copy the dirty states, logs, and preimages
- for _, addr := range dirties {
- // As documented [here](https://github.com/ethereum/go-ethereum/pull/16485#issuecomment-380438527),
- // and in the Finalise-method, there is a case where an object is in the journal but not
- // in the stateObjects: OOG after touch on ripeMD prior to Byzantium. Thus, we need to check for
- // nil
- if object, exist := s.stateObjects[addr]; exist {
- // Even though the original object is dirty, we are not copying the journal,
- // so we need to make sure that anyside effect the journal would have caused
- // during a commit (or similar op) is already applied to the copy.
- state.stateObjects[addr] = object.deepCopy(state)
- state.stateObjectsDirty[addr] = struct{}{} // Mark the copy dirty to force internal (code/state) commits
- state.stateObjectsPending[addr] = struct{}{} // Mark the copy pending to force external (account) commits
- }
- }
- // Above, we don't copy the actual journal. This means that if the copy is copied, the
- // loop above will be a no-op, since the copy's journal is empty.
- // Thus, here we iterate over stateObjects, to enable copies of copies
- for addr := range s.stateObjectsPending {
- if _, exist := state.stateObjects[addr]; !exist {
- state.stateObjects[addr] = s.stateObjects[addr].deepCopy(state)
- }
- state.stateObjectsPending[addr] = struct{}{}
- }
- for addr := range s.stateObjectsDirty {
- if _, exist := state.stateObjects[addr]; !exist {
- state.stateObjects[addr] = s.stateObjects[addr].deepCopy(state)
- }
- state.stateObjectsDirty[addr] = struct{}{}
- }
- s.mutex.Unlock()
- for hash, logs := range s.logs {
- cpy := make([]*types.Log, len(logs))
- for i, l := range logs {
- cpy[i] = new(types.Log)
- *cpy[i] = *l
- }
- state.logs[hash] = cpy
- }
- for hash, preimage := range s.preimages {
- state.preimages[hash] = preimage
- }
- // Do we need to copy the access list? In practice: No. At the start of a
- // transaction, the access list is empty. In practice, we only ever copy state
- // _between_ transactions/blocks, never in the middle of a transaction.
- // However, it doesn't cost us much to copy an empty list, so we do it anyway
- // to not blow up if we ever decide copy it in the middle of a transaction
- state.accessList = s.accessList.Copy()
- // If there's a prefetcher running, make an inactive copy of it that can
- // only access data but does not actively preload (since the user will not
- // know that they need to explicitly terminate an active copy).
- if s.prefetcher != nil {
- state.prefetcher = s.prefetcher.copy()
- }
- if s.snaps != nil {
- // In order for the miner to be able to use and make additions
- // to the snapshot tree, we need to copy that aswell.
- // Otherwise, any block mined by ourselves will cause gaps in the tree,
- // and force the miner to operate trie-backed only
- state.snaps = s.snaps
- state.snap = s.snap
- // deep copy needed
- state.snapDestructs = make(map[common.Hash]struct{})
- for k, v := range s.snapDestructs {
- state.snapDestructs[k] = v
- }
- state.snapAccounts = make(map[common.Hash][]byte)
- for k, v := range s.snapAccounts {
- state.snapAccounts[k] = v
- }
- state.snapStorage = make(map[common.Hash]map[common.Hash][]byte)
- for k, v := range s.snapStorage {
- temp := make(map[common.Hash][]byte)
- for kk, vv := range v {
- temp[kk] = vv
- }
- state.snapStorage[k] = temp
- }
- }
- return state
- }
- // Snapshot returns an identifier for the current revision of the state.
- func (s *StateDB) Snapshot() int {
- id := s.nextRevisionId
- s.nextRevisionId++
- s.validRevisions = append(s.validRevisions, revision{id, s.journal.length()})
- return id
- }
- // RevertToSnapshot reverts all state changes made since the given revision.
- func (s *StateDB) RevertToSnapshot(revid int) {
- // Find the snapshot in the stack of valid snapshots.
- idx := sort.Search(len(s.validRevisions), func(i int) bool {
- return s.validRevisions[i].id >= revid
- })
- if idx == len(s.validRevisions) || s.validRevisions[idx].id != revid {
- panic(fmt.Errorf("revision id %v cannot be reverted", revid))
- }
- snapshot := s.validRevisions[idx].journalIndex
- // Replay the journal to undo changes and remove invalidated snapshots
- s.journal.revert(s, snapshot)
- s.validRevisions = s.validRevisions[:idx]
- }
- // GetRefund returns the current value of the refund counter.
- func (s *StateDB) GetRefund() uint64 {
- return s.refund
- }
- // Finalise finalises the state by removing the s destructed objects and clears
- // the journal as well as the refunds. Finalise, however, will not push any updates
- // into the tries just yet. Only IntermediateRoot or Commit will do that.
- func (s *StateDB) Finalise(deleteEmptyObjects bool) {
- addressesToPrefetch := make([][]byte, 0, len(s.journal.dirties))
- s.journal.mutex.Lock()
- dirties := make([]common.Address, 0, len(s.journal.dirties))
- for addr := range s.journal.dirties {
- dirties = append(dirties, addr)
- }
- s.journal.mutex.Unlock()
- for _, addr := range dirties {
- obj, exist := s.stateObjects[addr]
- if !exist {
- // ripeMD is 'touched' at block 1714175, in tx 0x1237f737031e40bcde4a8b7e717b2d15e3ecadfe49bb1bbc71ee9deb09c6fcf2
- // That tx goes out of gas, and although the notion of 'touched' does not exist there, the
- // touch-event will still be recorded in the journal. Since ripeMD is a special snowflake,
- // it will persist in the journal even though the journal is reverted. In this special circumstance,
- // it may exist in `s.journal.dirties` but not in `s.stateObjects`.
- // Thus, we can safely ignore it here
- continue
- }
- if obj.suicided || (deleteEmptyObjects && obj.empty()) {
- obj.deleted = true
- // If state snapshotting is active, also mark the destruction there.
- // Note, we can't do this only at the end of a block because multiple
- // transactions within the same block might self destruct and then
- // ressurrect an account; but the snapshotter needs both events.
- if s.snap != nil {
- s.snapDestructs[obj.addrHash] = struct{}{} // We need to maintain account deletions explicitly (will remain set indefinitely)
- delete(s.snapAccounts, obj.addrHash) // Clear out any previously updated account data (may be recreated via a ressurrect)
- delete(s.snapStorage, obj.addrHash) // Clear out any previously updated storage data (may be recreated via a ressurrect)
- }
- } else {
- obj.finalise(true) // Prefetch slots in the background
- }
- s.mutex.Lock()
- s.stateObjectsPending[addr] = struct{}{}
- s.stateObjectsDirty[addr] = struct{}{}
- s.mutex.Unlock()
- // At this point, also ship the address off to the precacher. The precacher
- // will start loading tries, and when the change is eventually committed,
- // the commit-phase will be a lot faster
- addressesToPrefetch = append(addressesToPrefetch, common.CopyBytes(addr[:])) // Copy needed for closure
- }
- if s.prefetcher != nil && len(addressesToPrefetch) > 0 {
- s.prefetcher.prefetch(s.originalRoot, addressesToPrefetch)
- }
- // Invalidate journal because reverting across transactions is not allowed.
- s.clearJournalAndRefund()
- }
- // 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 {
- // Finalise all the dirty storage states and write them into the tries
- s.Finalise(deleteEmptyObjects)
- s.mutex.Lock()
- defer s.mutex.Unlock()
- // If there was a trie prefetcher operating, it gets aborted and irrevocably
- // modified after we start retrieving tries. Remove it from the statedb after
- // this round of use.
- //
- // This is weird pre-byzantium since the first tx runs with a prefetcher and
- // the remainder without, but pre-byzantium even the initial prefetcher is
- // useless, so no sleep lost.
- prefetcher := s.prefetcher
- if s.prefetcher != nil {
- defer func() {
- s.prefetcher.close()
- s.prefetcher = nil
- }()
- }
- // Although naively it makes sense to retrieve the account trie and then do
- // the contract storage and account updates sequentially, that short circuits
- // the account prefetcher. Instead, let's process all the storage updates
- // first, giving the account prefeches just a few more milliseconds of time
- // to pull useful data from disk.
- for addr := range s.stateObjectsPending {
- if obj := s.stateObjects[addr]; !obj.deleted {
- obj.updateRoot(s.db)
- }
- }
- // Now we're about to start to write changes to the trie. The trie is so far
- // _untouched_. We can check with the prefetcher, if it can give us a trie
- // which has the same root, but also has some content loaded into it.
- if prefetcher != nil {
- if trie := prefetcher.trie(s.originalRoot); trie != nil {
- s.trie = trie
- }
- }
- usedAddrs := make([][]byte, 0, len(s.stateObjectsPending))
- for addr := range s.stateObjectsPending {
- if obj := s.stateObjects[addr]; obj.deleted {
- s.deleteStateObject(obj)
- } else {
- s.updateStateObject(obj)
- }
- usedAddrs = append(usedAddrs, common.CopyBytes(addr[:])) // Copy needed for closure
- }
- if prefetcher != nil {
- prefetcher.used(s.originalRoot, usedAddrs)
- }
- if len(s.stateObjectsPending) > 0 {
- s.stateObjectsPending = make(map[common.Address]struct{})
- }
- // Track the amount of time wasted on hashing the account trie
- if metrics.EnabledExpensive {
- defer func(start time.Time) { s.AccountHashes += time.Since(start) }(time.Now())
- }
- 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 (s *StateDB) Prepare(thash, bhash common.Hash, ti int) {
- s.thash = thash
- s.bhash = bhash
- s.txIndex = ti
- s.accessList = newAccessList()
- }
- func (s *StateDB) clearJournalAndRefund() {
- defer s.journalMutex.Unlock()
- s.journalMutex.Lock()
- if len(s.journal.entries) > 0 {
- s.journal = newJournal()
- s.refund = 0
- }
- s.validRevisions = s.validRevisions[:0] // Snapshots can be created without journal entires
- }
- // Commit writes the state to the underlying in-memory trie database.
- // Quorum:
- // - linking state root and the AccountExtraData root
- func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error) {
- if s.dbErr != nil {
- return common.Hash{}, fmt.Errorf("commit aborted due to earlier error: %v", s.dbErr)
- }
- // Finalize any pending changes and merge everything into the tries
- s.IntermediateRoot(deleteEmptyObjects)
- s.mutex.Lock()
- // Commit objects to the trie, measuring the elapsed time
- codeWriter := s.db.TrieDB().DiskDB().NewBatch()
- for addr := range s.stateObjectsDirty {
- if obj := s.stateObjects[addr]; !obj.deleted {
- // Write any contract code associated with the state object
- if obj.code != nil && obj.dirtyCode {
- rawdb.WriteCode(codeWriter, common.BytesToHash(obj.CodeHash()), obj.code)
- obj.dirtyCode = false
- }
- // Write any storage changes in the state object to its storage trie
- if err := obj.CommitTrie(s.db); err != nil {
- return common.Hash{}, err
- }
- }
- }
- if len(s.stateObjectsDirty) > 0 {
- s.stateObjectsDirty = make(map[common.Address]struct{})
- }
- s.mutex.Unlock()
- if codeWriter.ValueSize() > 0 {
- if err := codeWriter.Write(); err != nil {
- log.Crit("Failed to commit dirty codes", "error", err)
- }
- }
- // Write the account trie changes, measuing the amount of wasted time
- var start time.Time
- if metrics.EnabledExpensive {
- start = time.Now()
- }
- // The onleaf func is called _serially_, so we can reuse the same account
- // for unmarshalling every time.
- var account Account
- root, err := s.trie.Commit(func(_ [][]byte, _ []byte, leaf []byte, parent common.Hash) error {
- if err := rlp.DecodeBytes(leaf, &account); err != nil {
- return nil
- }
- if account.Root != emptyRoot {
- s.db.TrieDB().Reference(account.Root, parent)
- }
- return nil
- })
- if metrics.EnabledExpensive {
- s.AccountCommits += time.Since(start)
- }
- // If snapshotting is enabled, update the snapshot tree with this new version
- if s.snap != nil {
- if metrics.EnabledExpensive {
- defer func(start time.Time) { s.SnapshotCommits += time.Since(start) }(time.Now())
- }
- // Only update if there's a state transition (skip empty Clique blocks)
- if parent := s.snap.Root(); parent != root {
- if err := s.snaps.Update(root, parent, s.snapDestructs, s.snapAccounts, s.snapStorage); err != nil {
- log.Warn("Failed to update snapshot tree", "from", parent, "to", root, "err", err)
- }
- // Keep 128 diff layers in the memory, persistent layer is 129th.
- // - head layer is paired with HEAD state
- // - head-1 layer is paired with HEAD-1 state
- // - head-127 layer(bottom-most diff layer) is paired with HEAD-127 state
- if err := s.snaps.Cap(root, 128); err != nil {
- log.Warn("Failed to cap snapshot tree", "root", root, "layers", 128, "err", err)
- }
- }
- s.snap, s.snapDestructs, s.snapAccounts, s.snapStorage = nil, nil, nil, nil
- }
- // Quorum
- // linking the state root and the AccountExtraData root
- if err == nil {
- // commit the AccountExtraData trie
- extraDataRoot, err := s.accountExtraDataTrie.Commit(nil)
- if err != nil {
- return common.Hash{}, fmt.Errorf("unable to commit the AccountExtraData trie: %v", err)
- }
- log.Debug("AccountExtraData root after trie commit", "root", extraDataRoot)
- // link the new state root to the AccountExtraData root
- err = s.db.AccountExtraDataLinker().Link(root, extraDataRoot)
- if err != nil {
- return common.Hash{}, fmt.Errorf("Unable to link the state root to the privacy metadata root: %v", err)
- }
- // add a reference from the AccountExtraData root to the state root so that when the state root is written
- // to the DB the the AccountExtraData root is also written
- s.db.TrieDB().Reference(extraDataRoot, root)
- }
- return root, err
- }
- // PrepareAccessList handles the preparatory steps for executing a state transition with
- // regards to both EIP-2929 and EIP-2930:
- //
- // - Add sender to access list (2929)
- // - Add destination to access list (2929)
- // - Add precompiles to access list (2929)
- // - Add the contents of the optional tx access list (2930)
- //
- // This method should only be called if Yolov3/Berlin/2929+2930 is applicable at the current number.
- func (s *StateDB) PrepareAccessList(sender common.Address, dst *common.Address, precompiles []common.Address, list types.AccessList) {
- s.AddAddressToAccessList(sender)
- if dst != nil {
- s.AddAddressToAccessList(*dst)
- // If it's a create-tx, the destination will be added inside evm.create
- }
- for _, addr := range precompiles {
- s.AddAddressToAccessList(addr)
- }
- for _, el := range list {
- s.AddAddressToAccessList(el.Address)
- for _, key := range el.StorageKeys {
- s.AddSlotToAccessList(el.Address, key)
- }
- }
- }
- // AddAddressToAccessList adds the given address to the access list
- func (s *StateDB) AddAddressToAccessList(addr common.Address) {
- if s.accessList.AddAddress(addr) {
- s.journal.append(accessListAddAccountChange{&addr})
- }
- }
- // AddSlotToAccessList adds the given (address, slot)-tuple to the access list
- func (s *StateDB) AddSlotToAccessList(addr common.Address, slot common.Hash) {
- addrMod, slotMod := s.accessList.AddSlot(addr, slot)
- if addrMod {
- // In practice, this should not happen, since there is no way to enter the
- // scope of 'address' without having the 'address' become already added
- // to the access list (via call-variant, create, etc).
- // Better safe than sorry, though
- s.journal.append(accessListAddAccountChange{&addr})
- }
- if slotMod {
- s.journal.append(accessListAddSlotChange{
- address: &addr,
- slot: &slot,
- })
- }
- }
- // AddressInAccessList returns true if the given address is in the access list.
- func (s *StateDB) AddressInAccessList(addr common.Address) bool {
- return s.accessList.ContainsAddress(addr)
- }
- // SlotInAccessList returns true if the given (address, slot)-tuple is in the access list.
- func (s *StateDB) SlotInAccessList(addr common.Address, slot common.Hash) (addressPresent bool, slotPresent bool) {
- return s.accessList.Contains(addr, slot)
- }
|