Update that brings go-ethereum with live tracer support (#1375)

* Update that brings `go-ethereum` with live tracer support

This only brings the dependency (will need to wait for a merge + tag of the branch before merging this PR) and the required changes to adapt `DBImpl` to support the new interface.

Relates to:
- sei-protocol/go-ethereum#15
- #1344

* Added missing instrumentation when state changes in `DBImpl`

app/eth_replay.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/client"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/ethereum/go-ethereum/core/tracing"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/params"
 	ethtests "github.com/ethereum/go-ethereum/tests"
@@ -81,7 +82,7 @@ func Replay(a *App) {
 		for _, w := range b.Withdrawals() {
 			amount := new(big.Int).SetUint64(w.Amount)
 			amount = amount.Mul(amount, big.NewInt(params.GWei))
-			s.AddBalance(w.Address, amount)
+			s.AddBalance(w.Address, amount, tracing.BalanceIncreaseWithdrawal)
 		}
 		_, _ = s.Finalize()
 		for _, tx := range b.Txs {

evmrpc/simulate.go

@@ -263,7 +263,7 @@ func (b *Backend) HeaderByNumber(ctx context.Context, bn rpc.BlockNumber) (*etht
 	return b.getHeader(big.NewInt(height)), nil
 }
 
-func (b *Backend) StateAtTransaction(ctx context.Context, block *ethtypes.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, vm.StateDB, tracers.StateReleaseFunc, error) {
+func (b *Backend) StateAtTransaction(ctx context.Context, block *ethtypes.Block, txIndex int, reexec uint64) (*ethtypes.Transaction, vm.BlockContext, vm.StateDB, tracers.StateReleaseFunc, error) {
 	emptyRelease := func() {}
 	// Short circuit if it's genesis block.
 	if block.Number().Int64() == 0 {
@@ -289,7 +289,7 @@ func (b *Backend) StateAtTransaction(ctx context.Context, block *ethtypes.Block,
 		blockContext.Time = block.Time()
 
 		if idx == txIndex {
-			return msg, *blockContext, statedb, emptyRelease, nil
+			return tx, *blockContext, statedb, emptyRelease, nil
 		}
 		// Not yet the searched for transaction, execute on top of the current state
 		vmenv := vm.NewEVM(*blockContext, txContext, statedb, b.ChainConfig(), vm.Config{})

go.mod

@@ -349,7 +349,7 @@ replace (
 	github.com/cosmos/cosmos-sdk => github.com/sei-protocol/sei-cosmos v0.2.79-seiv2-hotfix
 	github.com/cosmos/iavl => github.com/sei-protocol/sei-iavl v0.1.9
 	github.com/cosmos/ibc-go/v3 => github.com/sei-protocol/sei-ibc-go/v3 v3.3.0
-	github.com/ethereum/go-ethereum => github.com/sei-protocol/go-ethereum v1.13.5-sei-12
+	github.com/ethereum/go-ethereum => github.com/sei-protocol/go-ethereum v1.13.5-sei-9.0.20240327165640-6ab0d196bac6
 	github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1
 	github.com/sei-protocol/sei-db => github.com/sei-protocol/sei-db v0.0.35
 	// Latest goleveldb is broken, we have to stick to this version

go.sum

@@ -1343,8 +1343,8 @@ github.com/seccomp/libseccomp-golang v0.9.2-0.20220502022130-f33da4d89646/go.mod
 github.com/securego/gosec/v2 v2.11.0 h1:+PDkpzR41OI2jrw1q6AdXZCbsNGNGT7pQjal0H0cArI=
 github.com/securego/gosec/v2 v2.11.0/go.mod h1:SX8bptShuG8reGC0XS09+a4H2BoWSJi+fscA+Pulbpo=
 github.com/segmentio/fasthash v1.0.3/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY=
-github.com/sei-protocol/go-ethereum v1.13.5-sei-12 h1:sWGD3sV9F3Ilgmn8le8lhpfAwSi6n57I921cYuNvLuo=
-github.com/sei-protocol/go-ethereum v1.13.5-sei-12/go.mod h1:kcRZmuzRn1lVejiFNTz4l4W7imnpq1bDAnuKS/RyhbQ=
+github.com/sei-protocol/go-ethereum v1.13.5-sei-9.0.20240327165640-6ab0d196bac6 h1:AU9VAvZsTGibuzzVmoX3taGOWjPJJct5ypXDg6vKKu0=
+github.com/sei-protocol/go-ethereum v1.13.5-sei-9.0.20240327165640-6ab0d196bac6/go.mod h1:kcRZmuzRn1lVejiFNTz4l4W7imnpq1bDAnuKS/RyhbQ=
 github.com/sei-protocol/goutils v0.0.2 h1:Bfa7Sv+4CVLNM20QcpvGb81B8C5HkQC/kW1CQpIbXDA=
 github.com/sei-protocol/goutils v0.0.2/go.mod h1:iYE2DuJfEnM+APPehr2gOUXfuLuPsVxorcDO+Tzq9q8=
 github.com/sei-protocol/sei-cosmos v0.2.79-seiv2-hotfix h1:Yx2W7/xrGk13rpZfs+bkjx229b9LCbcCpcwTrzbz26Y=

x/evm/module_test.go

@@ -7,6 +7,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/tracing"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	testkeeper "github.com/sei-protocol/sei-chain/testutil/keeper"
 	"github.com/sei-protocol/sei-chain/x/evm"
@@ -28,19 +29,19 @@ func TestABCI(t *testing.T) {
 	m.BeginBlock(ctx, abci.RequestBeginBlock{})
 	// 1st tx
 	s := state.NewDBImpl(ctx.WithTxIndex(1), k, false)
-	s.SubBalance(evmAddr1, big.NewInt(10000000000000))
-	s.AddBalance(evmAddr2, big.NewInt(8000000000000))
+	s.SubBalance(evmAddr1, big.NewInt(10000000000000), tracing.BalanceChangeUnspecified)
+	s.AddBalance(evmAddr2, big.NewInt(8000000000000), tracing.BalanceChangeUnspecified)
 	feeCollectorAddr, err := k.GetFeeCollectorAddress(ctx)
 	require.Nil(t, err)
-	s.AddBalance(feeCollectorAddr, big.NewInt(2000000000000))
+	s.AddBalance(feeCollectorAddr, big.NewInt(2000000000000), tracing.BalanceChangeUnspecified)
 	surplus, err := s.Finalize()
 	require.Nil(t, err)
 	require.Equal(t, sdk.ZeroInt(), surplus)
 	k.AppendToEvmTxDeferredInfo(ctx.WithTxIndex(1), ethtypes.Bloom{}, common.Hash{}, surplus)
 	// 3rd tx
 	s = state.NewDBImpl(ctx.WithTxIndex(3), k, false)
-	s.SubBalance(evmAddr2, big.NewInt(5000000000000))
-	s.AddBalance(evmAddr1, big.NewInt(5000000000000))
+	s.SubBalance(evmAddr2, big.NewInt(5000000000000), tracing.BalanceChangeUnspecified)
+	s.AddBalance(evmAddr1, big.NewInt(5000000000000), tracing.BalanceChangeUnspecified)
 	surplus, err = s.Finalize()
 	require.Nil(t, err)
 	require.Equal(t, sdk.ZeroInt(), surplus)
@@ -54,8 +55,8 @@ func TestABCI(t *testing.T) {
 	m.BeginBlock(ctx, abci.RequestBeginBlock{})
 	// 2nd tx
 	s = state.NewDBImpl(ctx.WithTxIndex(2), k, false)
-	s.SubBalance(evmAddr2, big.NewInt(3000000000000))
-	s.AddBalance(evmAddr1, big.NewInt(2000000000000))
+	s.SubBalance(evmAddr2, big.NewInt(3000000000000), tracing.BalanceChangeUnspecified)
+	s.AddBalance(evmAddr1, big.NewInt(2000000000000), tracing.BalanceChangeUnspecified)
 	surplus, err = s.Finalize()
 	require.Nil(t, err)
 	require.Equal(t, sdk.NewInt(1000000000000), surplus)

x/evm/state/balance.go

@@ -5,16 +5,17 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/tracing"
 	"github.com/sei-protocol/sei-chain/x/evm/types"
 )
 
-func (s *DBImpl) SubBalance(evmAddr common.Address, amt *big.Int) {
+func (s *DBImpl) SubBalance(evmAddr common.Address, amt *big.Int, reason tracing.BalanceChangeReason) {
 	s.k.PrepareReplayedAddr(s.ctx, evmAddr)
 	if amt.Sign() == 0 {
 		return
 	}
 	if amt.Sign() < 0 {
-		s.AddBalance(evmAddr, new(big.Int).Neg(amt))
+		s.AddBalance(evmAddr, new(big.Int).Neg(amt), reason)
 		return
 	}
 
@@ -28,16 +29,25 @@ func (s *DBImpl) SubBalance(evmAddr common.Address, amt *big.Int) {
 	if s.err != nil {
 		return
 	}
+
+	if s.logger != nil && s.logger.OnBalanceChange != nil {
+		// We could modify AddWei instead so it returns us the old/new balance directly.
+		newBalance := s.GetBalance(evmAddr)
+		oldBalance := new(big.Int).Add(newBalance, amt)
+
+		s.logger.OnBalanceChange(evmAddr, oldBalance, newBalance, reason)
+	}
+
 	s.tempStateCurrent.surplus = s.tempStateCurrent.surplus.Add(sdk.NewIntFromBigInt(amt))
 }
 
-func (s *DBImpl) AddBalance(evmAddr common.Address, amt *big.Int) {
+func (s *DBImpl) AddBalance(evmAddr common.Address, amt *big.Int, reason tracing.BalanceChangeReason) {
 	s.k.PrepareReplayedAddr(s.ctx, evmAddr)
 	if amt.Sign() == 0 {
 		return
 	}
 	if amt.Sign() < 0 {
-		s.SubBalance(evmAddr, new(big.Int).Neg(amt))
+		s.SubBalance(evmAddr, new(big.Int).Neg(amt), reason)
 		return
 	}
 
@@ -51,6 +61,15 @@ func (s *DBImpl) AddBalance(evmAddr common.Address, amt *big.Int) {
 	if s.err != nil {
 		return
 	}
+
+	if s.logger != nil && s.logger.OnBalanceChange != nil {
+		// We could modify AddWei instead so it returns us the old/new balance directly.
+		newBalance := s.GetBalance(evmAddr)
+		oldBalance := new(big.Int).Sub(newBalance, amt)
+
+		s.logger.OnBalanceChange(evmAddr, oldBalance, newBalance, reason)
+	}
+
 	s.tempStateCurrent.surplus = s.tempStateCurrent.surplus.Sub(sdk.NewIntFromBigInt(amt))
 }
 
@@ -62,7 +81,7 @@ func (s *DBImpl) GetBalance(evmAddr common.Address) *big.Int {
 }
 
 // should only be called during simulation
-func (s *DBImpl) SetBalance(evmAddr common.Address, amt *big.Int) {
+func (s *DBImpl) SetBalance(evmAddr common.Address, amt *big.Int, reason tracing.BalanceChangeReason) {
 	if !s.simulation {
 		panic("should never call SetBalance in a non-simulation setting")
 	}

x/evm/state/balance_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/ethereum/go-ethereum/core/tracing"
 	testkeeper "github.com/sei-protocol/sei-chain/testutil/keeper"
 	"github.com/sei-protocol/sei-chain/x/evm/state"
 	"github.com/sei-protocol/sei-chain/x/evm/types"
@@ -16,17 +17,17 @@ func TestAddBalance(t *testing.T) {
 	db := state.NewDBImpl(ctx, k, false)
 	seiAddr, evmAddr := testkeeper.MockAddressPair()
 	require.Equal(t, big.NewInt(0), db.GetBalance(evmAddr))
-	db.AddBalance(evmAddr, big.NewInt(0))
+	db.AddBalance(evmAddr, big.NewInt(0), tracing.BalanceChangeUnspecified)
 
 	// set association
 	k.SetAddressMapping(db.Ctx(), seiAddr, evmAddr)
 	require.Equal(t, big.NewInt(0), db.GetBalance(evmAddr))
-	db.AddBalance(evmAddr, big.NewInt(10000000000000))
+	db.AddBalance(evmAddr, big.NewInt(10000000000000), tracing.BalanceChangeUnspecified)
 	require.Nil(t, db.Err())
 	require.Equal(t, db.GetBalance(evmAddr), big.NewInt(10000000000000))
 
 	_, evmAddr2 := testkeeper.MockAddressPair()
-	db.SubBalance(evmAddr2, big.NewInt(-5000000000000)) // should redirect to AddBalance
+	db.SubBalance(evmAddr2, big.NewInt(-5000000000000), tracing.BalanceChangeUnspecified) // should redirect to AddBalance
 	require.Nil(t, db.Err())
 	require.Equal(t, db.GetBalance(evmAddr), big.NewInt(10000000000000))
 	require.Equal(t, db.GetBalance(evmAddr2), big.NewInt(5000000000000))
@@ -37,42 +38,42 @@ func TestSubBalance(t *testing.T) {
 	db := state.NewDBImpl(ctx, k, false)
 	seiAddr, evmAddr := testkeeper.MockAddressPair()
 	require.Equal(t, big.NewInt(0), db.GetBalance(evmAddr))
-	db.SubBalance(evmAddr, big.NewInt(0))
+	db.SubBalance(evmAddr, big.NewInt(0), tracing.BalanceChangeUnspecified)
 
 	// set association
 	k.SetAddressMapping(db.Ctx(), seiAddr, evmAddr)
 	require.Equal(t, big.NewInt(0), db.GetBalance(evmAddr))
 	amt := sdk.NewCoins(sdk.NewCoin(k.GetBaseDenom(ctx), sdk.NewInt(20)))
 	k.BankKeeper().MintCoins(db.Ctx(), types.ModuleName, amt)
 	k.BankKeeper().SendCoinsFromModuleToAccount(db.Ctx(), types.ModuleName, seiAddr, amt)
-	db.SubBalance(evmAddr, big.NewInt(10000000000000))
+	db.SubBalance(evmAddr, big.NewInt(10000000000000), tracing.BalanceChangeUnspecified)
 	require.Nil(t, db.Err())
 	require.Equal(t, db.GetBalance(evmAddr), big.NewInt(10000000000000))
 
 	_, evmAddr2 := testkeeper.MockAddressPair()
 	amt = sdk.NewCoins(sdk.NewCoin(k.GetBaseDenom(ctx), sdk.NewInt(10)))
 	k.BankKeeper().MintCoins(db.Ctx(), types.ModuleName, amt)
 	k.BankKeeper().SendCoinsFromModuleToAccount(db.Ctx(), types.ModuleName, sdk.AccAddress(evmAddr2[:]), amt)
-	db.AddBalance(evmAddr2, big.NewInt(-5000000000000)) // should redirect to SubBalance
+	db.AddBalance(evmAddr2, big.NewInt(-5000000000000), tracing.BalanceChangeUnspecified) // should redirect to SubBalance
 	require.Nil(t, db.Err())
 	require.Equal(t, db.GetBalance(evmAddr), big.NewInt(10000000000000))
 	require.Equal(t, db.GetBalance(evmAddr2), big.NewInt(5000000000000))
 
 	// insufficient balance
-	db.SubBalance(evmAddr2, big.NewInt(10000000000000))
+	db.SubBalance(evmAddr2, big.NewInt(10000000000000), tracing.BalanceChangeUnspecified)
 	require.NotNil(t, db.Err())
 }
 
 func TestSetBalance(t *testing.T) {
 	k, ctx := testkeeper.MockEVMKeeper()
 	db := state.NewDBImpl(ctx, k, true)
 	_, evmAddr := testkeeper.MockAddressPair()
-	db.SetBalance(evmAddr, big.NewInt(10000000000000))
+	db.SetBalance(evmAddr, big.NewInt(10000000000000), tracing.BalanceChangeUnspecified)
 	require.Equal(t, big.NewInt(10000000000000), db.GetBalance(evmAddr))
 
 	seiAddr2, evmAddr2 := testkeeper.MockAddressPair()
 	k.SetAddressMapping(db.Ctx(), seiAddr2, evmAddr2)
-	db.SetBalance(evmAddr2, big.NewInt(10000000000000))
+	db.SetBalance(evmAddr2, big.NewInt(10000000000000), tracing.BalanceChangeUnspecified)
 	require.Equal(t, big.NewInt(10000000000000), db.GetBalance(evmAddr2))
 }
 
@@ -82,55 +83,55 @@ func TestSurplus(t *testing.T) {
 
 	// test negative usei surplus negative wei surplus
 	db := state.NewDBImpl(ctx, k, false)
-	db.AddBalance(evmAddr, big.NewInt(1_000_000_000_001))
+	db.AddBalance(evmAddr, big.NewInt(1_000_000_000_001), tracing.BalanceChangeUnspecified)
 	_, err := db.Finalize()
 	require.NotNil(t, err)
 	require.Contains(t, err.Error(), "negative surplus value")
 
 	// test negative usei surplus positive wei surplus (negative total)
 	db = state.NewDBImpl(ctx, k, false)
-	db.AddBalance(evmAddr, big.NewInt(1_000_000_000_000))
-	db.SubBalance(evmAddr, big.NewInt(1))
+	db.AddBalance(evmAddr, big.NewInt(1_000_000_000_000), tracing.BalanceChangeUnspecified)
+	db.SubBalance(evmAddr, big.NewInt(1), tracing.BalanceChangeUnspecified)
 	_, err = db.Finalize()
 	require.NotNil(t, err)
 	require.Contains(t, err.Error(), "negative surplus value")
 
 	// test negative usei surplus positive wei surplus (positive total)
 	db = state.NewDBImpl(ctx, k, false)
-	db.AddBalance(evmAddr, big.NewInt(1_000_000_000_000))
-	db.SubBalance(evmAddr, big.NewInt(2))
-	db.SubBalance(evmAddr, big.NewInt(999_999_999_999))
+	db.AddBalance(evmAddr, big.NewInt(1_000_000_000_000), tracing.BalanceChangeUnspecified)
+	db.SubBalance(evmAddr, big.NewInt(2), tracing.BalanceChangeUnspecified)
+	db.SubBalance(evmAddr, big.NewInt(999_999_999_999), tracing.BalanceChangeUnspecified)
 	surplus, err := db.Finalize()
 	require.Nil(t, err)
 	require.Equal(t, sdk.OneInt(), surplus)
 
 	// test positive usei surplus negative wei surplus (negative total)
 	db = state.NewDBImpl(ctx, k, false)
-	db.SubBalance(evmAddr, big.NewInt(1_000_000_000_000))
-	db.AddBalance(evmAddr, big.NewInt(2))
-	db.AddBalance(evmAddr, big.NewInt(999_999_999_999))
+	db.SubBalance(evmAddr, big.NewInt(1_000_000_000_000), tracing.BalanceChangeUnspecified)
+	db.AddBalance(evmAddr, big.NewInt(2), tracing.BalanceChangeUnspecified)
+	db.AddBalance(evmAddr, big.NewInt(999_999_999_999), tracing.BalanceChangeUnspecified)
 	_, err = db.Finalize()
 	require.NotNil(t, err)
 	require.Contains(t, err.Error(), "negative surplus value")
 
 	// test positive usei surplus negative wei surplus (positive total)
 	db = state.NewDBImpl(ctx, k, false)
-	db.SubBalance(evmAddr, big.NewInt(1_000_000_000_000))
-	db.AddBalance(evmAddr, big.NewInt(999_999_999_999))
+	db.SubBalance(evmAddr, big.NewInt(1_000_000_000_000), tracing.BalanceChangeUnspecified)
+	db.AddBalance(evmAddr, big.NewInt(999_999_999_999), tracing.BalanceChangeUnspecified)
 	surplus, err = db.Finalize()
 	require.Nil(t, err)
 	require.Equal(t, sdk.OneInt(), surplus)
 
 	// test snapshots
 	db = state.NewDBImpl(ctx, k, false)
-	db.SubBalance(evmAddr, big.NewInt(1_000_000_000_000))
-	db.AddBalance(evmAddr, big.NewInt(999_999_999_999))
+	db.SubBalance(evmAddr, big.NewInt(1_000_000_000_000), tracing.BalanceChangeUnspecified)
+	db.AddBalance(evmAddr, big.NewInt(999_999_999_999), tracing.BalanceChangeUnspecified)
 	db.Snapshot()
-	db.SubBalance(evmAddr, big.NewInt(1_000_000_000_000))
-	db.AddBalance(evmAddr, big.NewInt(999_999_999_999))
+	db.SubBalance(evmAddr, big.NewInt(1_000_000_000_000), tracing.BalanceChangeUnspecified)
+	db.AddBalance(evmAddr, big.NewInt(999_999_999_999), tracing.BalanceChangeUnspecified)
 	db.Snapshot()
-	db.SubBalance(evmAddr, big.NewInt(1_000_000_000_000))
-	db.AddBalance(evmAddr, big.NewInt(999_999_999_999))
+	db.SubBalance(evmAddr, big.NewInt(1_000_000_000_000), tracing.BalanceChangeUnspecified)
+	db.AddBalance(evmAddr, big.NewInt(999_999_999_999), tracing.BalanceChangeUnspecified)
 	surplus, err = db.Finalize()
 	require.Nil(t, err)
 	require.Equal(t, sdk.NewInt(3), surplus)

x/evm/state/check_test.go

@@ -4,6 +4,7 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/ethereum/go-ethereum/core/tracing"
 	testkeeper "github.com/sei-protocol/sei-chain/testutil/keeper"
 	"github.com/sei-protocol/sei-chain/x/evm/state"
 	"github.com/stretchr/testify/require"
@@ -35,11 +36,11 @@ func TestEmpty(t *testing.T) {
 	require.True(t, statedb.Empty(addr))
 
 	// has balance
-	statedb.AddBalance(addr, big.NewInt(1000000000000))
+	statedb.AddBalance(addr, big.NewInt(1000000000000), tracing.BalanceChangeUnspecified)
 	require.False(t, statedb.Empty(addr))
 
 	// has non-zero nonce
-	statedb.SubBalance(addr, big.NewInt(1000000000000))
+	statedb.SubBalance(addr, big.NewInt(1000000000000), tracing.BalanceChangeUnspecified)
 	statedb.SetNonce(addr, 1)
 	require.False(t, statedb.Empty(addr))
 

x/evm/state/code.go

@@ -2,6 +2,7 @@ package state
 
 import (
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 )
 
 func (s *DBImpl) GetCodeHash(addr common.Address) common.Hash {
@@ -16,6 +17,15 @@ func (s *DBImpl) GetCode(addr common.Address) []byte {
 
 func (s *DBImpl) SetCode(addr common.Address, code []byte) {
 	s.k.PrepareReplayedAddr(s.ctx, addr)
+
+	if s.logger != nil && s.logger.OnCodeChange != nil {
+		// The SetCode method could be modified to return the old code/hash directly.
+		oldCode := s.GetCode(addr)
+		oldHash := s.GetCodeHash(addr)
+
+		s.logger.OnCodeChange(addr, oldHash, oldCode, common.Hash(crypto.Keccak256(code)), code)
+	}
+
 	s.k.SetCode(s.ctx, addr, code)
 }
 

x/evm/state/log.go

@@ -12,6 +12,10 @@ type Logs struct {
 func (s *DBImpl) AddLog(l *ethtypes.Log) {
 	l.Index = uint(len(s.GetAllLogs()))
 	s.tempStateCurrent.logs = append(s.tempStateCurrent.logs, l)
+
+	if s.logger != nil && s.logger.OnLog != nil {
+		s.logger.OnLog(l)
+	}
 }
 
 func (s *DBImpl) GetAllLogs() []*ethtypes.Log {

x/evm/state/nonce.go

@@ -11,5 +11,11 @@ func (s *DBImpl) GetNonce(addr common.Address) uint64 {
 
 func (s *DBImpl) SetNonce(addr common.Address, nonce uint64) {
 	s.k.PrepareReplayedAddr(s.ctx, addr)
+
+	if s.logger != nil && s.logger.OnNonceChange != nil {
+		// The SetCode method could be modified to return the old code/hash directly.
+		s.logger.OnNonceChange(addr, s.GetNonce(addr), nonce)
+	}
+
 	s.k.SetNonce(s.ctx, addr, nonce)
 }