Bump onflow/go-ethereum dependency to v1.15.9

fvm/evm/emulator/config.go

@@ -89,7 +89,7 @@ func MakeChainConfig(chainID *big.Int) *gethParams.ChainConfig {
 		// Fork scheduling based on timestamps
 		ShanghaiTime: &zero, // already on Shanghai
 		CancunTime:   &zero, // already on Cancun
-		PragueTime:   nil,   // not on Prague
+		PragueTime:   &zero, // already on Prague
 		VerkleTime:   nil,   // not on Verkle
 	}
 }

fvm/evm/emulator/emulator.go

@@ -66,8 +66,13 @@ func (em *Emulator) NewReadOnlyBlockView(ctx types.BlockContext) (types.ReadOnly
 
 // NewBlockView constructs a new block view (mutable)
 func (em *Emulator) NewBlockView(ctx types.BlockContext) (types.BlockView, error) {
+	cfg := newConfig(ctx)
+	if !ctx.IsPrague {
+		cfg.ChainConfig.PragueTime = nil
+	}
+
 	return &BlockView{
-		config:   newConfig(ctx),
+		config:   cfg,
 		rootAddr: em.rootAddr,
 		ledger:   em.ledger,
 	}, nil
@@ -304,8 +309,9 @@ func (bl *BlockView) DryRunTransaction(
 
 	// use the from as the signer
 	msg.From = from
-	// we need to skip nonce check for dry run
-	msg.SkipAccountChecks = true
+	// we need to skip nonce/eoa check for dry run
+	msg.SkipNonceChecks = true
+	msg.SkipFromEOACheck = true
 
 	// run and return without committing the state changes
 	return proc.run(msg, tx.Hash(), tx.Type())
@@ -317,16 +323,18 @@ func (bl *BlockView) newProcedure() (*procedure, error) {
 		return nil, err
 	}
 	cfg := bl.config
+	evm := gethVM.NewEVM(
+		*cfg.BlockContext,
+		execState,
+		cfg.ChainConfig,
+		cfg.EVMConfig,
+	)
+	evm.SetTxContext(*cfg.TxContext)
+
 	return &procedure{
 		config: cfg,
-		evm: gethVM.NewEVM(
-			*cfg.BlockContext,
-			*cfg.TxContext,
-			execState,
-			cfg.ChainConfig,
-			cfg.EVMConfig,
-		),
-		state: execState,
+		evm:    evm,
+		state:  execState,
 	}, nil
 }
 
@@ -338,6 +346,9 @@ type procedure struct {
 
 // commit commits the changes to the state (with optional finalization)
 func (proc *procedure) commit(finalize bool) (hash.Hash, error) {
+	// Calling `StateDB.Finalise(true)` is currently a no-op, but
+	// we add it here to be more in line with how its envisioned.
+	proc.state.Finalise(true)
 	stateUpdateCommitment, err := proc.state.Commit(finalize)
 	if err != nil {
 		// if known types (state errors) don't do anything and return
@@ -511,11 +522,15 @@ func (proc *procedure) deployAt(
 		proc.state.CreateAccount(callerCommon)
 	}
 	// increment the nonce for the caller
-	proc.state.SetNonce(callerCommon, proc.state.GetNonce(callerCommon)+1)
+	proc.state.SetNonce(
+		callerCommon,
+		proc.state.GetNonce(callerCommon)+1,
+		gethTracing.NonceChangeContractCreator,
+	)
 
 	// setup account
 	proc.state.CreateAccount(addr)
-	proc.state.SetNonce(addr, 1) // (EIP-158)
+	proc.state.SetNonce(addr, 1, gethTracing.NonceChangeNewContract) // (EIP-158)
 	if call.Value.Sign() > 0 {
 		proc.evm.Context.Transfer( // transfer value
 			proc.state,
@@ -530,12 +545,14 @@ func (proc *procedure) deployAt(
 	var err error
 	inter := gethVM.NewEVMInterpreter(proc.evm)
 	contract := gethVM.NewContract(
-		gethVM.AccountRef(callerCommon),
-		gethVM.AccountRef(addr),
+		callerCommon,
+		addr,
 		castedValue,
-		call.GasLimit)
+		call.GasLimit,
+		nil,
+	)
 
-	contract.SetCallCode(&addr, gethCrypto.Keccak256Hash(call.Data), call.Data)
+	contract.SetCallCode(gethCrypto.Keccak256Hash(call.Data), call.Data)
 	// update access list (Berlin)
 	proc.state.AddAddressToAccessList(addr)
 
@@ -639,11 +656,11 @@ func (proc *procedure) run(
 	gasPool := (*gethCore.GasPool)(&proc.config.BlockContext.GasLimit)
 
 	// transit the state
-	execResult, err := gethCore.NewStateTransition(
+	execResult, err := gethCore.ApplyMessage(
 		proc.evm,
 		msg,
 		gasPool,
-	).TransitionDb()
+	)
 	if err != nil {
 		// if the error is a fatal error or a non-fatal state error or a backend err return it
 		// this condition should never happen given all StateDB errors are withheld for the commit time.

fvm/evm/emulator/state/delta.go

@@ -387,18 +387,23 @@ func (d *DeltaView) GetState(sk types.SlotAddress) (gethCommon.Hash, error) {
 	return d.parent.GetState(sk)
 }
 
-// SetState adds sets a value for the given slot of the main storage
-func (d *DeltaView) SetState(sk types.SlotAddress, value gethCommon.Hash) error {
+// SetState sets or adds a value for the given slot of the main storage.
+// It returns the previous value in any case.
+func (d *DeltaView) SetState(
+	sk types.SlotAddress,
+	value gethCommon.Hash,
+) (gethCommon.Hash, error) {
 	lastValue, err := d.GetState(sk)
 	if err != nil {
-		return err
+		return gethCommon.Hash{}, err
 	}
 	// if the value hasn't changed, skip
 	if value == lastValue {
-		return nil
+		return lastValue, nil
 	}
 	d.slots[sk] = value
-	return nil
+
+	return lastValue, nil
 }
 
 // GetStorageRoot returns some sort of storage root for the given address

fvm/evm/emulator/state/delta_test.go

@@ -381,8 +381,9 @@ func TestDeltaView(t *testing.T) {
 
 		// set slot1 with some new value
 		newValue := gethCommon.BytesToHash([]byte{9, 8})
-		err = view.SetState(slot1, newValue)
+		prevValue, err := view.SetState(slot1, newValue)
 		require.NoError(t, err)
+		require.Equal(t, value, prevValue)
 
 		value, err = view.GetState(slot1)
 		require.NoError(t, err)
@@ -694,8 +695,13 @@ func TestDeltaView(t *testing.T) {
 		key := testutils.RandomCommonHash(t)
 		value := testutils.RandomCommonHash(t)
 		sk := types.SlotAddress{Address: addr1, Key: key}
-		err = view.SetState(sk, value)
+
+		stateValue, err := view.GetState(sk)
+		require.NoError(t, err)
+
+		prevValue, err := view.SetState(sk, value)
 		require.NoError(t, err)
+		require.Equal(t, stateValue, prevValue)
 
 		vret, err := view.GetState(sk)
 		require.NoError(t, err)

fvm/evm/emulator/state/stateDB.go

@@ -10,6 +10,7 @@ import (
 	"github.com/onflow/atree"
 	"github.com/onflow/crypto/hash"
 	gethCommon "github.com/onflow/go-ethereum/common"
+	gethState "github.com/onflow/go-ethereum/core/state"
 	gethStateless "github.com/onflow/go-ethereum/core/stateless"
 	gethTracing "github.com/onflow/go-ethereum/core/tracing"
 	gethTypes "github.com/onflow/go-ethereum/core/types"
@@ -102,21 +103,29 @@ func (db *StateDB) IsNewContract(addr gethCommon.Address) bool {
 	return db.latestView().IsNewContract(addr)
 }
 
-// SelfDestruct flags the address for deletion.
+// SelfDestruct flags the address for deletion and returns the previous balance.
 //
-// while this address exists for the rest of transaction,
-// the balance of this account is return zero after the SelfDestruct call.
-func (db *StateDB) SelfDestruct(addr gethCommon.Address) {
+// While this address exists for the rest of the transaction,
+// the balance of this account is cleared after the SelfDestruct call.
+func (db *StateDB) SelfDestruct(addr gethCommon.Address) uint256.Int {
 	db.handleError(fmt.Errorf("legacy self destruct is not supported"))
+	return uint256.Int{}
 }
 
-// Selfdestruct6780 would only follow the self destruct steps if account is a new contract
+// SelfDestruct6780 would only follow the self destruct steps if account is a new contract
 // either just created, or address had balance before but got a contract deployed to it (in this tx).
-func (db *StateDB) Selfdestruct6780(addr gethCommon.Address) {
+// Returns the previous balance and a boolean value denoting whether the address was self destructed.
+func (db *StateDB) SelfDestruct6780(addr gethCommon.Address) (uint256.Int, bool) {
+	balance, err := db.latestView().GetBalance(addr)
+	db.handleError(err)
+
 	if db.IsNewContract(addr) {
 		err := db.latestView().SelfDestruct(addr)
 		db.handleError(err)
+		return *balance, true
 	}
+
+	return *balance, false
 }
 
 // HasSelfDestructed returns true if address is flagged with self destruct.
@@ -126,33 +135,45 @@ func (db *StateDB) HasSelfDestructed(addr gethCommon.Address) bool {
 }
 
 // SubBalance substitutes the amount from the balance of the given address
+// and returns the previous balance.
 func (db *StateDB) SubBalance(
 	addr gethCommon.Address,
 	amount *uint256.Int,
 	reason gethTracing.BalanceChangeReason,
-) {
+) uint256.Int {
 	// negative amounts are not accepted.
 	if amount.Sign() < 0 {
 		db.handleError(types.ErrInvalidBalance)
-		return
+		return uint256.Int{}
 	}
-	err := db.latestView().SubBalance(addr, amount)
+	prevBalance, err := db.latestView().GetBalance(addr)
 	db.handleError(err)
+
+	err = db.latestView().SubBalance(addr, amount)
+	db.handleError(err)
+
+	return *prevBalance
 }
 
-// AddBalance adds the amount from the balance of the given address
+// AddBalance adds the amount to the balance of the given address
+// and returns the previous balance.
 func (db *StateDB) AddBalance(
 	addr gethCommon.Address,
 	amount *uint256.Int,
 	reason gethTracing.BalanceChangeReason,
-) {
+) uint256.Int {
 	// negative amounts are not accepted.
 	if amount.Sign() < 0 {
 		db.handleError(types.ErrInvalidBalance)
-		return
+		return uint256.Int{}
 	}
-	err := db.latestView().AddBalance(addr, amount)
+	prevBalance, err := db.latestView().GetBalance(addr)
 	db.handleError(err)
+
+	err = db.latestView().AddBalance(addr, amount)
+	db.handleError(err)
+
+	return *prevBalance
 }
 
 // GetBalance returns the balance of the given address
@@ -170,7 +191,11 @@ func (db *StateDB) GetNonce(addr gethCommon.Address) uint64 {
 }
 
 // SetNonce sets the nonce value for the given address
-func (db *StateDB) SetNonce(addr gethCommon.Address, nonce uint64) {
+func (db *StateDB) SetNonce(
+	addr gethCommon.Address,
+	nonce uint64,
+	reason gethTracing.NonceChangeReason,
+) {
 	err := db.latestView().SetNonce(addr, nonce)
 	db.handleError(err)
 }
@@ -196,10 +221,14 @@ func (db *StateDB) GetCodeSize(addr gethCommon.Address) int {
 	return codeSize
 }
 
-// SetCode sets the code for the given address
-func (db *StateDB) SetCode(addr gethCommon.Address, code []byte) {
+// SetCode sets the code for the given address, and returns the
+// previous code located at the given address, if any.
+func (db *StateDB) SetCode(addr gethCommon.Address, code []byte) (prev []byte) {
+	prev = db.GetCode(addr)
 	err := db.latestView().SetCode(addr, code)
 	db.handleError(err)
+
+	return prev
 }
 
 // AddRefund adds the amount to the total (gas) refund
@@ -254,10 +283,17 @@ func (db *StateDB) GetStorageRoot(addr gethCommon.Address) gethCommon.Hash {
 	return root
 }
 
-// SetState sets a value for the given storage slot
-func (db *StateDB) SetState(addr gethCommon.Address, key gethCommon.Hash, value gethCommon.Hash) {
-	err := db.latestView().SetState(types.SlotAddress{Address: addr, Key: key}, value)
+// SetState sets a value for the given storage slot.
+// It returns the previous value in any case.
+func (db *StateDB) SetState(
+	addr gethCommon.Address,
+	key gethCommon.Hash,
+	value gethCommon.Hash,
+) gethCommon.Hash {
+	prevState, err := db.latestView().SetState(types.SlotAddress{Address: addr, Key: key}, value)
 	db.handleError(err)
+
+	return prevState
 }
 
 // GetTransientState returns the value for the given key of the transient storage
@@ -481,6 +517,8 @@ func (db *StateDB) Commit(finalize bool) (hash.Hash, error) {
 	return updateCommit, nil
 }
 
+func (db *StateDB) Finalise(deleteEmptyObjects bool) {}
+
 // Finalize flushes all the changes
 // to the permanent storage
 func (db *StateDB) Finalize() error {
@@ -542,6 +580,10 @@ func (s *StateDB) Witness() *gethStateless.Witness {
 	return nil
 }
 
+func (s *StateDB) AccessEvents() *gethState.AccessEvents {
+	return &gethState.AccessEvents{}
+}
+
 func (db *StateDB) latestView() *DeltaView {
 	return db.views[len(db.views)-1]
 }