478 lines
15 KiB
Go
478 lines
15 KiB
Go
// Copyright 2024 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
|
|
|
|
import (
|
|
"bytes"
|
|
"maps"
|
|
"slices"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/holiman/uint256"
|
|
)
|
|
|
|
var (
|
|
_ journal = (*sparseJournal)(nil)
|
|
)
|
|
|
|
// journalAccount represents the 'journable state' of a types.Account.
|
|
// Which means, all the normal fields except storage root, but also with a
|
|
// destruction-flag.
|
|
type journalAccount struct {
|
|
nonce uint64
|
|
balance uint256.Int
|
|
codeHash []byte // nil == emptyCodeHAsh
|
|
destructed bool
|
|
newContract bool
|
|
}
|
|
|
|
type addrSlot struct {
|
|
addr common.Address
|
|
slot common.Hash
|
|
}
|
|
|
|
type doubleHash struct {
|
|
origin common.Hash
|
|
prev common.Hash
|
|
}
|
|
|
|
// scopedJournal represents all changes within a single callscope. These changes
|
|
// are either all reverted, or all committed -- they cannot be partially applied.
|
|
type scopedJournal struct {
|
|
accountChanges map[common.Address]*journalAccount
|
|
refund int64
|
|
logs []common.Hash
|
|
|
|
accessListAddresses []common.Address
|
|
accessListAddrSlots []addrSlot
|
|
|
|
storageChanges map[common.Address]map[common.Hash]doubleHash
|
|
tStorageChanges map[common.Address]map[common.Hash]common.Hash
|
|
}
|
|
|
|
func newScopedJournal() *scopedJournal {
|
|
return &scopedJournal{
|
|
refund: -1,
|
|
}
|
|
}
|
|
|
|
func (j *scopedJournal) deepCopy() *scopedJournal {
|
|
var cpy = &scopedJournal{
|
|
// The accountChanges copy will copy the pointers to
|
|
// journalAccount objects: thus not actually deep copy those
|
|
// objects. That is fine: we never mutate journalAccount.
|
|
accountChanges: maps.Clone(j.accountChanges),
|
|
refund: j.refund,
|
|
logs: slices.Clone(j.logs),
|
|
accessListAddresses: slices.Clone(j.accessListAddresses),
|
|
accessListAddrSlots: slices.Clone(j.accessListAddrSlots),
|
|
}
|
|
if j.storageChanges != nil {
|
|
cpy.storageChanges = make(map[common.Address]map[common.Hash]doubleHash)
|
|
for addr, changes := range j.storageChanges {
|
|
cpy.storageChanges[addr] = maps.Clone(changes)
|
|
}
|
|
}
|
|
if j.tStorageChanges != nil {
|
|
cpy.tStorageChanges = make(map[common.Address]map[common.Hash]common.Hash)
|
|
for addr, changes := range j.tStorageChanges {
|
|
cpy.tStorageChanges[addr] = maps.Clone(changes)
|
|
}
|
|
}
|
|
return cpy
|
|
}
|
|
|
|
func (j *scopedJournal) journalRefundChange(prev uint64) {
|
|
if j.refund == -1 {
|
|
// We convert from uint64 to int64 here, so that we can use -1
|
|
// to represent "no previous value set".
|
|
// Treating refund as int64 is fine, there's no possibility for
|
|
// refund to ever exceed maxInt64.
|
|
j.refund = int64(prev)
|
|
}
|
|
}
|
|
|
|
// journalAccountChange is the common shared implementation for all account-changes.
|
|
// These changes all fall back to this method:
|
|
// - balance change
|
|
// - nonce change
|
|
// - destruct-change
|
|
// - code change
|
|
// - touch change
|
|
// - creation change (in this case, the account is nil)
|
|
func (j *scopedJournal) journalAccountChange(address common.Address, account *types.StateAccount, destructed, newContract bool) {
|
|
if j.accountChanges == nil {
|
|
j.accountChanges = make(map[common.Address]*journalAccount)
|
|
}
|
|
// If the account has already been journalled, we're done here
|
|
if _, ok := j.accountChanges[address]; ok {
|
|
return
|
|
}
|
|
if account == nil {
|
|
j.accountChanges[address] = nil // created now, previously non-existent
|
|
return
|
|
}
|
|
ja := &journalAccount{
|
|
nonce: account.Nonce,
|
|
balance: *account.Balance,
|
|
destructed: destructed,
|
|
newContract: newContract,
|
|
}
|
|
if !bytes.Equal(account.CodeHash, types.EmptyCodeHash[:]) {
|
|
ja.codeHash = account.CodeHash
|
|
}
|
|
j.accountChanges[address] = ja
|
|
}
|
|
|
|
func (j *scopedJournal) journalLog(txHash common.Hash) {
|
|
j.logs = append(j.logs, txHash)
|
|
}
|
|
|
|
func (j *scopedJournal) journalAccessListAddAccount(addr common.Address) {
|
|
j.accessListAddresses = append(j.accessListAddresses, addr)
|
|
}
|
|
|
|
func (j *scopedJournal) journalAccessListAddSlot(addr common.Address, slot common.Hash) {
|
|
j.accessListAddrSlots = append(j.accessListAddrSlots, addrSlot{addr, slot})
|
|
}
|
|
|
|
func (j *scopedJournal) journalSetState(addr common.Address, key, prev, origin common.Hash) {
|
|
if j.storageChanges == nil {
|
|
j.storageChanges = make(map[common.Address]map[common.Hash]doubleHash)
|
|
}
|
|
changes, ok := j.storageChanges[addr]
|
|
if !ok {
|
|
changes = make(map[common.Hash]doubleHash)
|
|
j.storageChanges[addr] = changes
|
|
}
|
|
// Do not overwrite a previous value!
|
|
if _, ok := changes[key]; !ok {
|
|
changes[key] = doubleHash{origin: origin, prev: prev}
|
|
}
|
|
}
|
|
|
|
func (j *scopedJournal) journalSetTransientState(addr common.Address, key, prev common.Hash) {
|
|
if j.tStorageChanges == nil {
|
|
j.tStorageChanges = make(map[common.Address]map[common.Hash]common.Hash)
|
|
}
|
|
changes, ok := j.tStorageChanges[addr]
|
|
if !ok {
|
|
changes = make(map[common.Hash]common.Hash)
|
|
j.tStorageChanges[addr] = changes
|
|
}
|
|
// Do not overwrite a previous value!
|
|
if _, ok := changes[key]; !ok {
|
|
changes[key] = prev
|
|
}
|
|
}
|
|
|
|
func (j *scopedJournal) revert(s *StateDB) {
|
|
// Revert refund
|
|
if j.refund != -1 {
|
|
s.refund = uint64(j.refund)
|
|
}
|
|
// Revert storage changes
|
|
for addr, changes := range j.storageChanges {
|
|
obj := s.getStateObject(addr)
|
|
for key, val := range changes {
|
|
obj.setState(key, val.prev, val.origin)
|
|
}
|
|
}
|
|
// Revert t-store changes
|
|
for addr, changes := range j.tStorageChanges {
|
|
for key, val := range changes {
|
|
s.setTransientState(addr, key, val)
|
|
}
|
|
}
|
|
|
|
// Revert changes to accounts
|
|
for addr, data := range j.accountChanges {
|
|
if data == nil { // Reverting a create
|
|
delete(s.stateObjects, addr)
|
|
continue
|
|
}
|
|
obj := s.getStateObject(addr)
|
|
obj.setNonce(data.nonce)
|
|
// Setting 'code' to nil means it will be loaded from disk
|
|
// next time it is needed. We avoid nilling it unless required
|
|
journalHash := data.codeHash
|
|
if data.codeHash == nil {
|
|
if !bytes.Equal(obj.CodeHash(), types.EmptyCodeHash[:]) {
|
|
obj.setCode(types.EmptyCodeHash, nil)
|
|
}
|
|
} else {
|
|
if !bytes.Equal(obj.CodeHash(), journalHash) {
|
|
// TODO @holiman set the code back!
|
|
obj.setCode(common.BytesToHash(data.codeHash), nil)
|
|
}
|
|
}
|
|
obj.setBalance(&data.balance)
|
|
obj.selfDestructed = data.destructed
|
|
obj.newContract = data.newContract
|
|
}
|
|
// Revert logs
|
|
for _, txhash := range j.logs {
|
|
logs := s.logs[txhash]
|
|
if len(logs) == 1 {
|
|
delete(s.logs, txhash)
|
|
} else {
|
|
s.logs[txhash] = logs[:len(logs)-1]
|
|
}
|
|
s.logSize--
|
|
}
|
|
// Revert access list additions
|
|
for i := len(j.accessListAddrSlots) - 1; i >= 0; i-- {
|
|
item := j.accessListAddrSlots[i]
|
|
s.accessList.DeleteSlot(item.addr, item.slot)
|
|
}
|
|
for i := len(j.accessListAddresses) - 1; i >= 0; i-- {
|
|
s.accessList.DeleteAddress(j.accessListAddresses[i])
|
|
}
|
|
}
|
|
|
|
func (j *scopedJournal) merge(parent *scopedJournal) {
|
|
if parent.refund == -1 {
|
|
parent.refund = j.refund
|
|
}
|
|
// Merge changes to accounts
|
|
if parent.accountChanges == nil {
|
|
parent.accountChanges = j.accountChanges
|
|
} else {
|
|
for addr, data := range j.accountChanges {
|
|
if _, present := parent.accountChanges[addr]; present {
|
|
// Nothing to do here, it's already stored in parent scope
|
|
continue
|
|
}
|
|
parent.accountChanges[addr] = data
|
|
}
|
|
}
|
|
// Merge logs
|
|
parent.logs = append(parent.logs, j.logs...)
|
|
|
|
// Merge access list additions
|
|
parent.accessListAddrSlots = append(parent.accessListAddrSlots, j.accessListAddrSlots...)
|
|
parent.accessListAddresses = append(parent.accessListAddresses, j.accessListAddresses...)
|
|
|
|
if parent.storageChanges == nil {
|
|
parent.storageChanges = j.storageChanges
|
|
} else {
|
|
// Merge storage changes
|
|
for addr, changes := range j.storageChanges {
|
|
prevChanges, ok := parent.storageChanges[addr]
|
|
if !ok {
|
|
parent.storageChanges[addr] = changes
|
|
continue
|
|
}
|
|
for k, v := range changes {
|
|
if _, ok := prevChanges[k]; !ok {
|
|
prevChanges[k] = v
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if parent.tStorageChanges == nil {
|
|
parent.tStorageChanges = j.tStorageChanges
|
|
} else {
|
|
// Merge t-store changes
|
|
for addr, changes := range j.tStorageChanges {
|
|
prevChanges, ok := parent.tStorageChanges[addr]
|
|
if !ok {
|
|
parent.tStorageChanges[addr] = changes
|
|
continue
|
|
}
|
|
for k, v := range changes {
|
|
if _, ok := prevChanges[k]; !ok {
|
|
prevChanges[k] = v
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (j *scopedJournal) addDirtyAccounts(set map[common.Address]any) {
|
|
// Changes due to account changes
|
|
for addr := range j.accountChanges {
|
|
set[addr] = []interface{}{}
|
|
}
|
|
// Changes due to storage changes
|
|
for addr := range j.storageChanges {
|
|
set[addr] = []interface{}{}
|
|
}
|
|
}
|
|
|
|
// sparseJournal contains the list of state modifications applied since the last state
|
|
// commit. These are tracked to be able to be reverted in the case of an execution
|
|
// exception or request for reversal.
|
|
type sparseJournal struct {
|
|
entries []*scopedJournal // Current changes tracked by the journal
|
|
ripeMagic bool
|
|
}
|
|
|
|
// newJournal creates a new initialized journal.
|
|
func newSparseJournal() *sparseJournal {
|
|
s := new(sparseJournal)
|
|
s.snapshot() // create snaphot zero
|
|
return s
|
|
}
|
|
|
|
// reset clears the journal, after this operation the journal can be used
|
|
// anew. It is semantically similar to calling 'newJournal', but the underlying
|
|
// slices can be reused
|
|
func (j *sparseJournal) reset() {
|
|
j.entries = j.entries[:0]
|
|
j.ripeMagic = false
|
|
j.snapshot()
|
|
}
|
|
|
|
func (j *sparseJournal) copy() journal {
|
|
cp := &sparseJournal{
|
|
entries: make([]*scopedJournal, 0, len(j.entries)),
|
|
ripeMagic: j.ripeMagic,
|
|
}
|
|
for _, entry := range j.entries {
|
|
cp.entries = append(cp.entries, entry.deepCopy())
|
|
}
|
|
return cp
|
|
}
|
|
|
|
// snapshot starts a new journal scope which can be reverted or discarded.
|
|
// OBS: A call to Snapshot is _required_ in order to initialize the journalling,
|
|
// invoking the journal-methods without having invoked Snapshot will lead to
|
|
// panic.
|
|
func (j *sparseJournal) snapshot() {
|
|
j.entries = append(j.entries, newScopedJournal())
|
|
}
|
|
|
|
// revertSnapshot reverts all state changes made since the last call to snapshot().
|
|
func (j *sparseJournal) revertSnapshot(s *StateDB) {
|
|
id := len(j.entries) - 1
|
|
j.entries[id].revert(s)
|
|
j.entries = j.entries[:id]
|
|
if id == 0 {
|
|
j.snapshot()
|
|
}
|
|
}
|
|
|
|
// discardSnapshot removes the latest snapshot; after calling this
|
|
// method, it is no longer possible to revert to that particular snapshot, the
|
|
// changes are considered part of the parent scope.
|
|
func (j *sparseJournal) discardSnapshot() {
|
|
id := len(j.entries) - 1
|
|
// here we must merge the 'id' with it's parent.
|
|
if id == 0 {
|
|
// If a transaction is applied successfully, the statedb.Finalize will
|
|
// end by clearing and resetting the journal. Invoking a discardSnapshot
|
|
// afterwards will land here: calling discard on an empty journal.
|
|
// This is fine
|
|
return
|
|
}
|
|
entry := j.entries[id]
|
|
parent := j.entries[id-1]
|
|
entry.merge(parent)
|
|
j.entries = j.entries[:id]
|
|
}
|
|
|
|
func (j *sparseJournal) journalAccountChange(addr common.Address, account *types.StateAccount, destructed, newContract bool) {
|
|
j.entries[len(j.entries)-1].journalAccountChange(addr, account, destructed, newContract)
|
|
}
|
|
|
|
func (j *sparseJournal) nonceChange(addr common.Address, account *types.StateAccount, destructed, newContract bool) {
|
|
j.journalAccountChange(addr, account, destructed, newContract)
|
|
}
|
|
|
|
func (j *sparseJournal) balanceChange(addr common.Address, account *types.StateAccount, destructed, newContract bool) {
|
|
j.journalAccountChange(addr, account, destructed, newContract)
|
|
}
|
|
|
|
func (j *sparseJournal) setCode(addr common.Address, account *types.StateAccount, prev []byte) {
|
|
// TODO @holiman: Actually store the prev, and later on set it back on revert.
|
|
j.journalAccountChange(addr, account, false, true)
|
|
}
|
|
|
|
func (j *sparseJournal) createObject(addr common.Address) {
|
|
// Creating an account which is destructed, hence already exists, is not
|
|
// allowed, hence we know destructed == 'false'.
|
|
// Also, if we are creating the account now, it cannot yet be a
|
|
// newContract (that might come later)
|
|
j.journalAccountChange(addr, nil, false, false)
|
|
}
|
|
|
|
func (j *sparseJournal) createContract(addr common.Address, account *types.StateAccount) {
|
|
// Creating an account which is destructed, hence already exists, is not
|
|
// allowed, hence we know it to be 'false'.
|
|
// Also: if we create the contract now, it cannot be previously created
|
|
j.journalAccountChange(addr, account, false, false)
|
|
}
|
|
|
|
func (j *sparseJournal) destruct(addr common.Address, account *types.StateAccount) {
|
|
// destructing an already destructed account must not be journalled. Hence we
|
|
// know it to be 'false'.
|
|
// Also: if we're allowed to destruct it, it must be `newContract:true`, OR
|
|
// the concept of newContract is unused and moot.
|
|
j.journalAccountChange(addr, account, false, true)
|
|
}
|
|
|
|
// var ripemd = common.HexToAddress("0000000000000000000000000000000000000003")
|
|
func (j *sparseJournal) touchChange(addr common.Address, account *types.StateAccount, destructed, newContract bool) {
|
|
j.journalAccountChange(addr, account, destructed, newContract)
|
|
if addr == ripemd {
|
|
// Explicitly put it in the dirty-cache one extra time. Ripe magic.
|
|
j.ripeMagic = true
|
|
}
|
|
}
|
|
|
|
func (j *sparseJournal) logChange(txHash common.Hash) {
|
|
j.entries[len(j.entries)-1].journalLog(txHash)
|
|
}
|
|
|
|
func (j *sparseJournal) refundChange(prev uint64) {
|
|
j.entries[len(j.entries)-1].journalRefundChange(prev)
|
|
}
|
|
|
|
func (j *sparseJournal) accessListAddAccount(addr common.Address) {
|
|
j.entries[len(j.entries)-1].journalAccessListAddAccount(addr)
|
|
}
|
|
|
|
func (j *sparseJournal) accessListAddSlot(addr common.Address, slot common.Hash) {
|
|
j.entries[len(j.entries)-1].journalAccessListAddSlot(addr, slot)
|
|
}
|
|
|
|
func (j *sparseJournal) storageChange(addr common.Address, key, prev, origin common.Hash) {
|
|
j.entries[len(j.entries)-1].journalSetState(addr, key, prev, origin)
|
|
}
|
|
|
|
func (j *sparseJournal) transientStateChange(addr common.Address, key, prev common.Hash) {
|
|
j.entries[len(j.entries)-1].journalSetTransientState(addr, key, prev)
|
|
}
|
|
|
|
func (j *sparseJournal) dirtyAccounts() []common.Address {
|
|
// The dirty-set should encompass all layers
|
|
var dirty = make(map[common.Address]any)
|
|
for _, scope := range j.entries {
|
|
scope.addDirtyAccounts(dirty)
|
|
}
|
|
if j.ripeMagic {
|
|
dirty[ripemd] = []interface{}{}
|
|
}
|
|
var dirtyList = make([]common.Address, 0, len(dirty))
|
|
for addr := range dirty {
|
|
dirtyList = append(dirtyList, addr)
|
|
}
|
|
return dirtyList
|
|
}
|