flatten evm-only executor package

Author: codchen

giga/evmonly/README.md

@@ -21,7 +21,7 @@ tracking without reintroducing Cosmos keeper dependencies.
 
 ## Current implementation
 
-The `seiv3` package currently provides:
+The `evmonly` package currently provides:
 
 - sequential execution of the ordered block transaction list
 - RLP decoding and sender recovery through go-ethereum signers
@@ -47,9 +47,8 @@ ExecuteBlock(context.Context, BlockRequest) (*BlockResult, error)
 The executor should be commit-neutral. It executes an ordered EVM block and
 returns the state writes and receipts produced by that block. The caller owns
 durable persistence, state commitment, block indexing, and receipt publication.
-The `seiv3` implementation accepts a `StateReader` backend through
-`WithState(...)`; callers can persist the returned `ChangeSet` with a matching
-`StateWriter`.
+The concrete `Executor` accepts a `StateReader` backend through `WithState(...)`;
+callers can persist the returned `ChangeSet` with a matching `StateWriter`.
 
 ## Input block format
 
@@ -116,7 +115,7 @@ state as contract storage owned by that precompile address. With no range reads
 and no side state, precompile reads and writes can then flow through ordinary
 `(address, slot)` storage tracking.
 
-Until that design is implemented, the `seiv3` executor accepts a custom
+Until that design is implemented, the `evmonly` executor accepts a custom
 precompile registry only as a fail-closed placeholder. Calls to registered
 custom precompile addresses return `ErrCustomPrecompilesOpen`.
 

giga/evmonly/seiv3/config.go giga/evmonly/config.gogiga/evmonly/seiv3/config.go renamed to giga/evmonly/config.go

@@ -1,4 +1,4 @@
-package seiv3
+package evmonly
 
 import (
 	"math/big"

giga/evmonly/seiv3/executor.go giga/evmonly/executor.gogiga/evmonly/seiv3/executor.go renamed to giga/evmonly/executor.go

@@ -1,4 +1,4 @@
-package seiv3
+package evmonly
 
 import (
 	"context"
@@ -13,19 +13,18 @@ import (
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/params"
-	"github.com/sei-protocol/sei-chain/giga/evmonly"
 	"github.com/sei-protocol/sei-chain/giga/evmonly/precompiles"
 )
 
 // Executor runs raw EVM transactions against an EVM-native state backend.
 type Executor struct {
 	cfg   Config
-	state evmonly.StateReader
+	state StateReader
 }
 
 type Option func(*Executor)
 
-func WithState(state evmonly.StateReader) Option {
+func WithState(state StateReader) Option {
 	return func(e *Executor) {
 		if state != nil {
 			e.state = state
@@ -36,7 +35,7 @@ func WithState(state evmonly.StateReader) Option {
 func NewExecutor(cfg Config, opts ...Option) *Executor {
 	e := &Executor{
 		cfg:   cfg.WithDefaults(),
-		state: evmonly.NewMemoryState(),
+		state: NewMemoryState(),
 	}
 	for _, opt := range opts {
 		opt(e)
@@ -48,9 +47,9 @@ func (e *Executor) Config() Config {
 	return e.cfg
 }
 
-func (e *Executor) ExecuteBlock(ctx context.Context, req evmonly.BlockRequest) (*evmonly.BlockResult, error) {
+func (e *Executor) ExecuteBlock(ctx context.Context, req BlockRequest) (*BlockResult, error) {
 	if len(req.Txs) == 0 {
-		return &evmonly.BlockResult{}, nil
+		return &BlockResult{}, nil
 	}
 
 	chainConfig := e.chainConfig(req.Context)
@@ -72,8 +71,8 @@ func (e *Executor) ExecuteBlock(ctx context.Context, req evmonly.BlockRequest) (
 	gasPool := new(core.GasPool).AddGas(gasLimit)
 	baseFee := cloneBig(req.Context.BaseFee)
 
-	result := &evmonly.BlockResult{
-		Txs:      make([]evmonly.TxResult, 0, len(parsed)),
+	result := &BlockResult{
+		Txs:      make([]TxResult, 0, len(parsed)),
 		Receipts: make(ethtypes.Receipts, 0, len(parsed)),
 	}
 	for txIndex, p := range parsed {
@@ -101,31 +100,31 @@ func (e *Executor) executeTx(
 	evm *vm.EVM,
 	stateDB *nativeStateDB,
 	gasPool *core.GasPool,
-	block evmonly.BlockContext,
+	block BlockContext,
 	p parsedTx,
 	txIndex int,
 	baseFee *big.Int,
 	signer ethtypes.Signer,
-) (evmonly.TxResult, *ethtypes.Receipt, error) {
+) (TxResult, *ethtypes.Receipt, error) {
 	tx := p.tx
 	if e.cfg.CustomPrecompiles != nil && tx.To() != nil {
 		if _, ok := e.cfg.CustomPrecompiles.Get(*tx.To()); ok {
-			return evmonly.TxResult{Hash: tx.Hash(), Sender: p.sender, To: tx.To(), Err: precompiles.ErrCustomPrecompilesOpen},
+			return TxResult{Hash: tx.Hash(), Sender: p.sender, To: tx.To(), Err: precompiles.ErrCustomPrecompilesOpen},
 				nil,
 				precompiles.ErrCustomPrecompilesOpen
 		}
 	}
 	if !e.cfg.DisableGasPriceCheck && e.cfg.MinGasPrice != nil {
 		if effectiveGasPrice(tx, baseFee).Cmp(e.cfg.MinGasPrice) < 0 {
-			return evmonly.TxResult{Hash: tx.Hash(), Sender: p.sender, To: tx.To(), Err: errInsufficientGasPrice},
+			return TxResult{Hash: tx.Hash(), Sender: p.sender, To: tx.To(), Err: errInsufficientGasPrice},
 				nil,
 				errInsufficientGasPrice
 		}
 	}
 
 	msg, err := core.TransactionToMessage(tx, signer, baseFee)
 	if err != nil {
-		return evmonly.TxResult{Hash: tx.Hash(), Sender: p.sender, To: tx.To(), Err: err}, nil, err
+		return TxResult{Hash: tx.Hash(), Sender: p.sender, To: tx.To(), Err: err}, nil, err
 	}
 	msg.SkipNonceChecks = e.cfg.DisableNonceCheck
 
@@ -134,7 +133,7 @@ func (e *Executor) executeTx(
 	evm.SetTxContext(core.NewEVMTxContext(msg))
 	execResult, err := core.ApplyMessage(evm, msg, gasPool)
 	if err != nil {
-		return evmonly.TxResult{Hash: tx.Hash(), Sender: p.sender, To: tx.To(), Err: err}, nil, err
+		return TxResult{Hash: tx.Hash(), Sender: p.sender, To: tx.To(), Err: err}, nil, err
 	}
 
 	txLogs := append([]*ethtypes.Log(nil), stateDB.logs[logStart:]...)
@@ -165,7 +164,7 @@ func (e *Executor) executeTx(
 	}
 	receipt.Bloom = ethtypes.CreateBloom(receipt)
 
-	txResult := evmonly.TxResult{
+	txResult := TxResult{
 		Hash:              tx.Hash(),
 		Sender:            p.sender,
 		To:                tx.To(),
@@ -179,7 +178,7 @@ func (e *Executor) executeTx(
 	return txResult, receipt, nil
 }
 
-func buildBlockContext(ctx evmonly.BlockContext) vm.BlockContext {
+func buildBlockContext(ctx BlockContext) vm.BlockContext {
 	prevRandao := ctx.PrevRandao
 	baseFee := cloneBig(ctx.BaseFee)
 	blobBaseFee := cloneBig(ctx.BlobBaseFee)
@@ -232,7 +231,7 @@ func customPrecompileMap(registry precompiles.Registry) map[common.Address]vm.Pr
 	return contracts
 }
 
-func (e *Executor) chainConfig(ctx evmonly.BlockContext) *params.ChainConfig {
+func (e *Executor) chainConfig(ctx BlockContext) *params.ChainConfig {
 	var cfg params.ChainConfig
 	if e.cfg.ChainConfig != nil {
 		cfg = *e.cfg.ChainConfig
@@ -259,11 +258,4 @@ func effectiveGasPrice(tx *ethtypes.Transaction, baseFee *big.Int) *big.Int {
 	return tx.GasPrice()
 }
 
-func cloneBig(v *big.Int) *big.Int {
-	if v == nil {
-		return new(big.Int)
-	}
-	return new(big.Int).Set(v)
-}
-
 var errInsufficientGasPrice = fmt.Errorf("insufficient gas price")

giga/evmonly/seiv3/executor_test.go giga/evmonly/executor_test.gogiga/evmonly/seiv3/executor_test.go renamed to giga/evmonly/executor_test.go

@@ -1,4 +1,4 @@
-package seiv3
+package evmonly
 
 import (
 	"context"
@@ -12,14 +12,13 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/stretchr/testify/require"
 
-	"github.com/sei-protocol/sei-chain/giga/evmonly"
 	"github.com/sei-protocol/sei-chain/giga/evmonly/precompiles"
 )
 
 func TestExecutorEmptyBlock(t *testing.T) {
 	executor := NewExecutor(Config{})
 
-	result, err := executor.ExecuteBlock(context.Background(), evmonly.BlockRequest{})
+	result, err := executor.ExecuteBlock(context.Background(), BlockRequest{})
 
 	require.NoError(t, err)
 	require.NotNil(t, result)
@@ -32,13 +31,13 @@ func TestExecutorTransferTx(t *testing.T) {
 	sender := crypto.PubkeyToAddress(key.PublicKey)
 	recipient := common.HexToAddress("0x00000000000000000000000000000000000000a1")
 
-	state := evmonly.NewMemoryState()
+	state := NewMemoryState()
 	state.SetBalance(sender, big.NewInt(200_000_000_000_000))
 
 	rawTx := signLegacyTx(t, key, chainID, 0, &recipient, big.NewInt(7), nil)
 	executor := NewExecutor(Config{}, WithState(state))
 
-	result, err := executor.ExecuteBlock(context.Background(), evmonly.BlockRequest{
+	result, err := executor.ExecuteBlock(context.Background(), BlockRequest{
 		Context: blockContext(chainID),
 		Txs:     [][]byte{rawTx},
 	})
@@ -62,15 +61,15 @@ func TestExecutorCustomPrecompilePlaceholder(t *testing.T) {
 	sender := crypto.PubkeyToAddress(key.PublicKey)
 	customAddr := common.HexToAddress("0x0000000000000000000000000000000000001001")
 
-	state := evmonly.NewMemoryState()
+	state := NewMemoryState()
 	state.SetBalance(sender, big.NewInt(200_000_000_000_000))
 
 	rawTx := signLegacyTx(t, key, chainID, 0, &customAddr, big.NewInt(0), []byte{0x01})
 	executor := NewExecutor(Config{
 		CustomPrecompiles: staticPrecompileRegistry{addr: customAddr},
 	}, WithState(state))
 
-	_, err = executor.ExecuteBlock(context.Background(), evmonly.BlockRequest{
+	_, err = executor.ExecuteBlock(context.Background(), BlockRequest{
 		Context: blockContext(chainID),
 		Txs:     [][]byte{rawTx},
 	})
@@ -96,8 +95,8 @@ func signLegacyTx(t *testing.T, key *ecdsa.PrivateKey, chainID *big.Int, nonce u
 	return raw
 }
 
-func blockContext(chainID *big.Int) evmonly.BlockContext {
-	return evmonly.BlockContext{
+func blockContext(chainID *big.Int) BlockContext {
+	return BlockContext{
 		Number:   1,
 		Time:     1,
 		GasLimit: 30_000_000,

giga/evmonly/seiv3/parser.go giga/evmonly/parser.gogiga/evmonly/seiv3/parser.go renamed to giga/evmonly/parser.go

@@ -1,4 +1,4 @@
-package seiv3
+package evmonly
 
 import (
 	"context"

giga/evmonly/seiv3/state_db.go giga/evmonly/state_db.gogiga/evmonly/seiv3/state_db.go renamed to giga/evmonly/state_db.go

@@ -1,4 +1,4 @@
-package seiv3
+package evmonly
 
 import (
 	"bytes"
@@ -15,14 +15,12 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 	ethutils "github.com/ethereum/go-ethereum/trie/utils"
 	"github.com/holiman/uint256"
-
-	"github.com/sei-protocol/sei-chain/giga/evmonly"
 )
 
 var errInsufficientBalance = errors.New("insufficient balance")
 
 type nativeStateDB struct {
-	source evmonly.StateReader
+	source StateReader
 
 	accounts map[common.Address]*nativeAccount
 	base     map[common.Address]*nativeAccount
@@ -65,9 +63,9 @@ type accessList struct {
 	slots     map[common.Address]map[common.Hash]struct{}
 }
 
-func newNativeStateDB(source evmonly.StateReader) *nativeStateDB {
+func newNativeStateDB(source StateReader) *nativeStateDB {
 	if source == nil {
-		source = evmonly.NewMemoryState()
+		source = NewMemoryState()
 	}
 	return &nativeStateDB{
 		source:          source,
@@ -79,7 +77,7 @@ func newNativeStateDB(source evmonly.StateReader) *nativeStateDB {
 	}
 }
 
-func (s *nativeStateDB) ChangeSet() evmonly.StateChangeSet {
+func (s *nativeStateDB) ChangeSet() StateChangeSet {
 	addresses := make([]common.Address, 0, len(s.accounts))
 	for addr := range s.accounts {
 		addresses = append(addresses, addr)
@@ -88,25 +86,25 @@ func (s *nativeStateDB) ChangeSet() evmonly.StateChangeSet {
 		return bytes.Compare(addresses[i][:], addresses[j][:]) < 0
 	})
 
-	var changes evmonly.StateChangeSet
+	var changes StateChangeSet
 	for _, addr := range addresses {
 		acct := s.accounts[addr]
 		base := s.baseAccount(addr)
 
 		if !acct.Balance.Eq(base.Balance) {
-			changes.Balances = append(changes.Balances, evmonly.BalanceChange{
+			changes.Balances = append(changes.Balances, BalanceChange{
 				Address: addr,
 				Balance: acct.Balance.ToBig(),
 			})
 		}
 		if acct.Nonce != base.Nonce {
-			changes.Nonces = append(changes.Nonces, evmonly.NonceChange{
+			changes.Nonces = append(changes.Nonces, NonceChange{
 				Address: addr,
 				Nonce:   acct.Nonce,
 			})
 		}
 		if !bytes.Equal(acct.Code, base.Code) {
-			changes.Code = append(changes.Code, evmonly.CodeChange{
+			changes.Code = append(changes.Code, CodeChange{
 				Address: addr,
 				Code:    cloneBytes(acct.Code),
 				Delete:  len(acct.Code) == 0,
@@ -119,7 +117,7 @@ func (s *nativeStateDB) ChangeSet() evmonly.StateChangeSet {
 			if oldValue == newValue {
 				continue
 			}
-			changes.Storage = append(changes.Storage, evmonly.StorageChange{
+			changes.Storage = append(changes.Storage, StorageChange{
 				Address: addr,
 				Key:     key,
 				Value:   newValue,
@@ -639,10 +637,3 @@ func uint256FromBig(v *big.Int) *uint256.Int {
 	}
 	return u
 }
-
-func cloneBytes(v []byte) []byte {
-	if len(v) == 0 {
-		return nil
-	}
-	return append([]byte(nil), v...)
-}

giga/evmonly/types.go

@@ -8,8 +8,8 @@ import (
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 )
 
-// Executor is the Cosmos-free block execution boundary for the EVM-only path.
-type Executor interface {
+// BlockExecutor is the Cosmos-free block execution boundary for the EVM-only path.
+type BlockExecutor interface {
 	ExecuteBlock(context.Context, BlockRequest) (*BlockResult, error)
 }