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