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 }