[giga] fork x/evm (#2697)

## Describe your changes and provide context
create a fork of x/evm under `/giga` and uses this fork for giga
executor's logic in `app.go`

## Testing performed to validate your change
tests are also copied

---------

Co-authored-by: pdrobnjak <drobnjakpavle95@gmail.com>
Co-authored-by: Steven Landers <steven.landers@gmail.com>
Co-authored-by: Steven Landers <steven@seinetwork.io>

Author: 3 people

app/app.go

@@ -134,7 +134,6 @@ import (
 	evmkeeper "github.com/sei-protocol/sei-chain/x/evm/keeper"
 	"github.com/sei-protocol/sei-chain/x/evm/querier"
 	"github.com/sei-protocol/sei-chain/x/evm/replay"
-	evmstate "github.com/sei-protocol/sei-chain/x/evm/state"
 	evmtypes "github.com/sei-protocol/sei-chain/x/evm/types"
 	"github.com/sei-protocol/sei-chain/x/mint"
 	mintclient "github.com/sei-protocol/sei-chain/x/mint/client/cli"
@@ -164,6 +163,9 @@ import (
 	// unnamed import of statik for openapi/swagger UI support
 	_ "github.com/sei-protocol/sei-chain/docs/swagger"
 	ssconfig "github.com/sei-protocol/sei-chain/sei-db/config"
+
+	gigaevmkeeper "github.com/sei-protocol/sei-chain/giga/deps/xevm/keeper"
+	gigaevmstate "github.com/sei-protocol/sei-chain/giga/deps/xevm/state"
 )
 
 // this line is used by starport scaffolding # stargate/wasm/app/enabledProposals
@@ -342,6 +344,7 @@ type App struct {
 	WasmKeeper       wasm.Keeper
 	OracleKeeper     oraclekeeper.Keeper
 	EvmKeeper        evmkeeper.Keeper
+	GigaEvmKeeper    gigaevmkeeper.Keeper
 
 	// make scoped keepers public for test purposes
 	ScopedIBCKeeper      capabilitykeeper.ScopedKeeper
@@ -402,6 +405,12 @@ type App struct {
 
 	benchmarkProposalCh <-chan *abci.ResponsePrepareProposal
 	benchmarkLogger     *benchmarkLogger
+
+	// GigaExecutorEnabled controls whether to use the Giga executor (evmone-based)
+	// instead of geth's interpreter for EVM execution. Experimental feature.
+	GigaExecutorEnabled bool
+	// GigaOCCEnabled controls whether to use OCC with the Giga executor
+	GigaOCCEnabled bool
 }
 
 type AppOption func(*App)
@@ -672,19 +681,23 @@ func New(
 		app.EvmKeeper.EthClient = ethclient.NewClient(rpcclient)
 	}
 
+	app.GigaEvmKeeper = *gigaevmkeeper.NewKeeper(keys[evmtypes.StoreKey],
+		tkeys[evmtypes.TransientStoreKey], app.GetSubspace(evmtypes.ModuleName), app.receiptStore, app.BankKeeper,
+		&app.AccountKeeper, &app.StakingKeeper, app.TransferKeeper,
+		wasmkeeper.NewDefaultPermissionKeeper(app.WasmKeeper), &app.WasmKeeper, &app.UpgradeKeeper)
 	// Read Giga Executor config
 	gigaExecutorConfig, err := gigaconfig.ReadConfig(appOpts)
 	if err != nil {
 		panic(fmt.Sprintf("error reading giga executor config due to %s", err))
 	}
-	app.EvmKeeper.GigaExecutorEnabled = gigaExecutorConfig.Enabled
-	app.EvmKeeper.GigaOCCEnabled = gigaExecutorConfig.OCCEnabled
+	app.GigaExecutorEnabled = gigaExecutorConfig.Enabled
+	app.GigaOCCEnabled = gigaExecutorConfig.OCCEnabled
 	if gigaExecutorConfig.Enabled {
 		evmoneVM, err := gigalib.InitEvmoneVM()
 		if err != nil {
 			panic(fmt.Sprintf("failed to load evmone: %s", err))
 		}
-		app.EvmKeeper.EvmoneVM = evmoneVM
+		app.GigaEvmKeeper.EvmoneVM = evmoneVM
 		if gigaExecutorConfig.OCCEnabled {
 			logger.Info("benchmark: Giga Executor with OCC is ENABLED - using new EVM execution path with parallel execution")
 		} else {
@@ -1469,8 +1482,8 @@ func (app *App) ProcessBlock(ctx sdk.Context, txs [][]byte, req BlockProcessRequ
 	}()
 
 	// Route to Giga Executor when enabled - bypasses Cosmos SDK transaction processing
-	if app.EvmKeeper.GigaExecutorEnabled {
-		if app.EvmKeeper.GigaOCCEnabled {
+	if app.GigaExecutorEnabled {
+		if app.GigaOCCEnabled {
 			return app.ProcessBlockWithGigaExecutorOCC(ctx, txs, req, lastCommit, simulate)
 		}
 		return app.ProcessBlockWithGigaExecutor(ctx, txs, req, lastCommit, simulate)
@@ -1636,7 +1649,7 @@ func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, txIndex int, msg *
 		return nil, fmt.Errorf("failed to convert to eth transaction")
 	}
 
-	chainID := app.EvmKeeper.ChainID(ctx)
+	chainID := app.GigaEvmKeeper.ChainID(ctx)
 
 	// Recover sender using the same logic as preprocess.go (version-based signer selection)
 	sender, seiAddr, pubkey, recoverErr := evmante.RecoverSenderFromEthTx(ctx, ethTx, chainID)
@@ -1648,8 +1661,8 @@ func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, txIndex int, msg *
 	}
 
 	// Associate the address if not already associated (same as EVMPreprocessDecorator)
-	if _, isAssociated := app.EvmKeeper.GetEVMAddress(ctx, seiAddr); !isAssociated {
-		associateHelper := helpers.NewAssociationHelper(&app.EvmKeeper, app.BankKeeper, &app.AccountKeeper)
+	if _, isAssociated := app.GigaEvmKeeper.GetEVMAddress(ctx, seiAddr); !isAssociated {
+		associateHelper := helpers.NewAssociationHelper(&app.GigaEvmKeeper, app.BankKeeper, &app.AccountKeeper)
 		if err := associateHelper.AssociateAddresses(ctx, seiAddr, sender, pubkey); err != nil {
 			return &abci.ExecTxResult{
 				Code: 1,
@@ -1663,14 +1676,14 @@ func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, txIndex int, msg *
 	ctx = ctx.WithTxIndex(txIndex)
 
 	// Create state DB for this transaction
-	stateDB := evmstate.NewDBImpl(ctx, &app.EvmKeeper, false)
+	stateDB := gigaevmstate.NewDBImpl(ctx, &app.GigaEvmKeeper, false)
 	defer stateDB.Cleanup()
 
 	// Get gas pool
-	gp := app.EvmKeeper.GetGasPool()
+	gp := app.GigaEvmKeeper.GetGasPool()
 
 	// Get block context
-	blockCtx, blockCtxErr := app.EvmKeeper.GetVMBlockContext(ctx, gp)
+	blockCtx, blockCtxErr := app.GigaEvmKeeper.GetVMBlockContext(ctx, gp)
 	if blockCtxErr != nil {
 		return &abci.ExecTxResult{
 			Code: 1,
@@ -1679,14 +1692,14 @@ func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, txIndex int, msg *
 	}
 
 	// Get chain config
-	sstore := app.EvmKeeper.GetParams(ctx).SeiSstoreSetGasEip2200
-	cfg := evmtypes.DefaultChainConfig().EthereumConfigWithSstore(app.EvmKeeper.ChainID(ctx), &sstore)
+	sstore := app.GigaEvmKeeper.GetParams(ctx).SeiSstoreSetGasEip2200
+	cfg := evmtypes.DefaultChainConfig().EthereumConfigWithSstore(app.GigaEvmKeeper.ChainID(ctx), &sstore)
 
 	// Create Giga executor VM (wraps evmone)
-	gigaExecutor := gigaexecutor.NewEvmoneExecutor(app.EvmKeeper.EvmoneVM, *blockCtx, stateDB, cfg, vm.Config{}, app.EvmKeeper.CustomPrecompiles(ctx))
+	gigaExecutor := gigaexecutor.NewEvmoneExecutor(app.GigaEvmKeeper.EvmoneVM, *blockCtx, stateDB, cfg, vm.Config{}, app.GigaEvmKeeper.CustomPrecompiles(ctx))
 
 	// Execute the transaction through giga VM
-	execResult, execErr := gigaExecutor.ExecuteTransaction(ethTx, sender, app.EvmKeeper.GetBaseFee(ctx), &gp)
+	execResult, execErr := gigaExecutor.ExecuteTransaction(ethTx, sender, app.GigaEvmKeeper.GetBaseFee(ctx), &gp)
 	if execErr != nil {
 		return &abci.ExecTxResult{
 			Code: 1,
@@ -1722,7 +1735,7 @@ func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, txIndex int, msg *
 		Data:      ethTx.Data(),
 		From:      sender,
 	}
-	receipt, rerr := app.EvmKeeper.WriteReceipt(ctx, stateDB, evmMsg, uint32(ethTx.Type()), ethTx.Hash(), execResult.UsedGas, vmError)
+	receipt, rerr := app.GigaEvmKeeper.WriteReceipt(ctx, stateDB, evmMsg, uint32(ethTx.Type()), ethTx.Hash(), execResult.UsedGas, vmError)
 	if rerr != nil {
 		return &abci.ExecTxResult{
 			Code: 1,

giga/deps/testutil/fuzzing/cosmos.go

@@ -0,0 +1,19 @@
+package fuzzing
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func FuzzDec(i int64, isNil bool) sdk.Dec {
+	if isNil {
+		return sdk.Dec{}
+	}
+	return sdk.NewDec(i)
+}
+
+func FuzzCoin(denom string, isNil bool, i int64) sdk.Coin {
+	if isNil {
+		return sdk.Coin{Denom: denom, Amount: sdk.Int{}}
+	}
+	return sdk.Coin{Denom: denom, Amount: sdk.NewInt(i)}
+}

giga/deps/testutil/keeper/epoch.go

@@ -0,0 +1,57 @@
+package keeper
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/store"
+	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	typesparams "github.com/cosmos/cosmos-sdk/x/params/types"
+	"github.com/sei-protocol/sei-chain/app"
+	"github.com/sei-protocol/sei-chain/x/epoch/keeper"
+	"github.com/sei-protocol/sei-chain/x/epoch/types"
+	"github.com/stretchr/testify/require"
+	"github.com/tendermint/tendermint/libs/log"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	tmdb "github.com/tendermint/tm-db"
+)
+
+func TestApp(t *testing.T) *app.App {
+	return app.Setup(t, false, false, false)
+}
+
+func EpochKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
+	storeKey := sdk.NewKVStoreKey(types.StoreKey)
+	memStoreKey := storetypes.NewMemoryStoreKey(types.MemStoreKey)
+
+	db := tmdb.NewMemDB()
+	stateStore := store.NewCommitMultiStore(db)
+	stateStore.MountStoreWithDB(storeKey, sdk.StoreTypeIAVL, db)
+	stateStore.MountStoreWithDB(memStoreKey, sdk.StoreTypeMemory, nil)
+	require.NoError(t, stateStore.LoadLatestVersion())
+
+	registry := codectypes.NewInterfaceRegistry()
+	cdc := codec.NewProtoCodec(registry)
+
+	paramsSubspace := typesparams.NewSubspace(cdc,
+		codec.NewLegacyAmino(),
+		storeKey,
+		memStoreKey,
+		"EpochParams",
+	)
+	k := keeper.NewKeeper(
+		cdc,
+		storeKey,
+		memStoreKey,
+		paramsSubspace,
+	)
+
+	ctx := sdk.NewContext(stateStore, tmproto.Header{}, false, log.NewNopLogger())
+
+	// Initialize params
+	k.SetParams(ctx, types.DefaultParams())
+
+	return k, ctx
+}

giga/deps/testutil/keeper/evm.go

@@ -0,0 +1,158 @@
+package keeper
+
+import (
+	"encoding/hex"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/cosmos/cosmos-sdk/crypto/hd"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/go-bip39"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+
+	"github.com/sei-protocol/sei-chain/app"
+	evmkeeper "github.com/sei-protocol/sei-chain/giga/deps/xevm/keeper"
+	evmtypes "github.com/sei-protocol/sei-chain/giga/deps/xevm/types"
+	"github.com/stretchr/testify/require"
+)
+
+var EVMTestApp = app.SetupWithDefaultHome(false, true, false)
+var mockKeeper *evmkeeper.Keeper
+var mockCtx sdk.Context
+var mtx = &sync.Mutex{}
+
+func MockEVMKeeperWithPrecompiles() (*evmkeeper.Keeper, sdk.Context) {
+	mtx.Lock()
+	defer mtx.Unlock()
+	if mockKeeper != nil {
+		return mockKeeper, mockCtx
+	}
+	ctx := EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockHeight(8)
+	k := EVMTestApp.GigaEvmKeeper
+	k.InitGenesis(ctx, *evmtypes.DefaultGenesis())
+
+	// mint some coins to a sei address
+	seiAddr, err := sdk.AccAddressFromHex(common.Bytes2Hex([]byte("seiAddr")))
+	if err != nil {
+		panic(err)
+	}
+	err = EVMTestApp.BankKeeper.MintCoins(ctx, "evm", sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(10))))
+	if err != nil {
+		panic(err)
+	}
+	err = EVMTestApp.BankKeeper.SendCoinsFromModuleToAccount(ctx, "evm", seiAddr, sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(10))))
+	if err != nil {
+		panic(err)
+	}
+	mockKeeper = &k
+	mockCtx = ctx
+	return &k, ctx
+}
+
+func MockEVMKeeper(t *testing.T) (*evmkeeper.Keeper, sdk.Context) {
+	testApp := app.Setup(t, false, false, false)
+	ctx := testApp.GetContextForDeliverTx([]byte{}).WithBlockHeight(8).WithBlockTime(time.Now())
+	k := testApp.GigaEvmKeeper
+	k.InitGenesis(ctx, *evmtypes.DefaultGenesis())
+
+	// mint some coins to a sei address
+	seiAddr, err := sdk.AccAddressFromHex(common.Bytes2Hex([]byte("seiAddr")))
+	if err != nil {
+		panic(err)
+	}
+	err = testApp.BankKeeper.MintCoins(ctx, "evm", sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(10))))
+	if err != nil {
+		panic(err)
+	}
+	err = testApp.BankKeeper.SendCoinsFromModuleToAccount(ctx, "evm", seiAddr, sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(10))))
+	if err != nil {
+		panic(err)
+	}
+	return &k, ctx
+}
+
+func MockEVMKeeperPrecompiles(t *testing.T) (*evmkeeper.Keeper, sdk.Context) {
+	testApp := app.Setup(t, false, true, false)
+	ctx := testApp.GetContextForDeliverTx([]byte{}).WithBlockHeight(8).WithBlockTime(time.Now())
+	k := testApp.GigaEvmKeeper
+	k.InitGenesis(ctx, *evmtypes.DefaultGenesis())
+
+	// mint some coins to a sei address
+	seiAddr, err := sdk.AccAddressFromHex(common.Bytes2Hex([]byte("seiAddr")))
+	if err != nil {
+		panic(err)
+	}
+	err = testApp.BankKeeper.MintCoins(ctx, "evm", sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(10))))
+	if err != nil {
+		panic(err)
+	}
+	err = testApp.BankKeeper.SendCoinsFromModuleToAccount(ctx, "evm", seiAddr, sdk.NewCoins(sdk.NewCoin("usei", sdk.NewInt(10))))
+	if err != nil {
+		panic(err)
+	}
+	return &k, ctx
+}
+
+func MockAddressPair() (sdk.AccAddress, common.Address) {
+	return PrivateKeyToAddresses(MockPrivateKey())
+}
+
+func MockPrivateKey() cryptotypes.PrivKey {
+	// Generate a new Sei private key
+	entropySeed, _ := bip39.NewEntropy(256)
+	mnemonic, _ := bip39.NewMnemonic(entropySeed)
+	algo := hd.Secp256k1
+	derivedPriv, _ := algo.Derive()(mnemonic, "", "")
+	return algo.Generate()(derivedPriv)
+}
+
+func PrivateKeyToAddresses(privKey cryptotypes.PrivKey) (sdk.AccAddress, common.Address) {
+	// Encode the private key to hex (i.e. what wallets do behind the scene when users reveal private keys)
+	testPrivHex := hex.EncodeToString(privKey.Bytes())
+
+	// Sign an Ethereum transaction with the hex private key
+	key, _ := crypto.HexToECDSA(testPrivHex)
+	msg := crypto.Keccak256([]byte("foo"))
+	sig, _ := crypto.Sign(msg, key)
+
+	// Recover the public keys from the Ethereum signature
+	recoveredPub, _ := crypto.Ecrecover(msg, sig)
+	pubKey, _ := crypto.UnmarshalPubkey(recoveredPub)
+
+	return sdk.AccAddress(privKey.PubKey().Address()), crypto.PubkeyToAddress(*pubKey)
+}
+
+func UseiCoins(amount int64) sdk.Coins {
+	return sdk.NewCoins(sdk.NewCoin(sdk.MustGetBaseDenom(), sdk.NewInt(amount)))
+}
+
+func WaitForReceipt(t *testing.T, k *evmkeeper.Keeper, ctx sdk.Context, txHash common.Hash) *evmtypes.Receipt {
+	t.Helper()
+	var receipt *evmtypes.Receipt
+	require.Eventually(t, func() bool {
+		var err error
+		receipt, err = k.GetReceipt(ctx, txHash)
+		return err == nil
+	}, 2*time.Second, 10*time.Millisecond)
+	return receipt
+}
+
+func WaitForReceiptFromStore(t *testing.T, k *evmkeeper.Keeper, ctx sdk.Context, txHash common.Hash) *evmtypes.Receipt {
+	t.Helper()
+	var receipt *evmtypes.Receipt
+	require.Eventually(t, func() bool {
+		var err error
+		receipt, err = k.GetReceiptFromReceiptStore(ctx, txHash)
+		return err == nil
+	}, 2*time.Second, 10*time.Millisecond)
+	return receipt
+}
+
+func MustMockReceipt(t *testing.T, k *evmkeeper.Keeper, ctx sdk.Context, txHash common.Hash, receipt *evmtypes.Receipt) {
+	t.Helper()
+	require.NoError(t, k.MockReceipt(ctx, txHash, receipt))
+	WaitForReceipt(t, k, ctx, txHash)
+}