From a81e71ac41c830e9af1029a75f90d024ef4080bb Mon Sep 17 00:00:00 2001
From: Tony Chen <codchen03@gmail.com>
Date: Wed, 26 Aug 2026 15:14:54 +0800
Subject: [PATCH] integrate Autobahn with in-memory EVM-only executor

---
 Makefile                                      |   9 +-
 docker/docker-compose.yml                     |   4 +
 .../scripts/step4_config_override.sh          |   7 +
 integration_test/autobahn/autobahn_test.go    | 152 +++++++++-
 sei-tendermint/config/autobahn.go             |   8 +
 .../internal/p2p/evmonly_inmemory_app.go      | 279 ++++++++++++++++++
 .../internal/p2p/evmonly_inmemory_app_test.go |  96 ++++++
 sei-tendermint/internal/rpc/core/blocks.go    |   8 +-
 sei-tendermint/node/setup.go                  |   8 +
 9 files changed, 563 insertions(+), 8 deletions(-)
 create mode 100644 sei-tendermint/internal/p2p/evmonly_inmemory_app.go
 create mode 100644 sei-tendermint/internal/p2p/evmonly_inmemory_app_test.go

diff --git a/Makefile b/Makefile
index 16b333e95c..9bc55d0b27 100644
--- a/Makefile
+++ b/Makefile
@@ -500,11 +500,16 @@ giga-integration-test:
 # Run Autobahn integration tests with an Autobahn-enabled cluster.
 autobahn-integration-test:
 	@# The test drives cluster start/stop itself via TestMain — see
-	@# integration_test/autobahn/autobahn_test.go. GOWORK=off: ignore ambient
-	@# go.work; this target only needs stdlib + sei-tendermint.
+	@# integration_test/autobahn/autobahn_test.go. GOWORK=off ignores an
+	@# ambient go.work so dependency resolution matches the module.
 	@GOWORK=off go test -tags autobahn_integration -v -count=1 -timeout 30m ./integration_test/autobahn/...
 .PHONY: autobahn-integration-test
 
+# Run the minimal in-memory EVM-only executor behind a four-validator Autobahn cluster.
+autobahn-evmonly-integration-test:
+	@AUTOBAHN_EVMONLY_IN_MEMORY=true GOWORK=off go test -tags autobahn_integration -v -count=1 -timeout 30m ./integration_test/autobahn/...
+.PHONY: autobahn-evmonly-integration-test
+
 # Run a mixed-mode cluster: node 0 uses GIGA_EXECUTOR with OCC, nodes 1-3 use standard V2.
 # (node-level GIGA_EXECUTOR/GIGA_OCC values are pinned in docker-compose.giga-mixed.yml)
 # Any determinism divergence between giga and V2 will cause the giga node to halt.
diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml
index b0db261842..247bcb79c5 100644
--- a/docker/docker-compose.yml
+++ b/docker/docker-compose.yml
@@ -20,6 +20,7 @@ services:
       - GIGA_OCC
       - RECEIPT_BACKEND
       - AUTOBAHN
+      - AUTOBAHN_EVMONLY_IN_MEMORY
       - GIGA_STORAGE
       - GIGA_MIGRATE_FROM_MEMIAVL
       - GIGA_FLATKV_ONLY
@@ -55,6 +56,7 @@ services:
       - GIGA_OCC
       - RECEIPT_BACKEND
       - AUTOBAHN
+      - AUTOBAHN_EVMONLY_IN_MEMORY
       - GIGA_STORAGE
       - GIGA_MIGRATE_FROM_MEMIAVL
       - GIGA_FLATKV_ONLY
@@ -86,6 +88,7 @@ services:
       - GIGA_OCC
       - RECEIPT_BACKEND
       - AUTOBAHN
+      - AUTOBAHN_EVMONLY_IN_MEMORY
       - GIGA_STORAGE
       - GIGA_MIGRATE_FROM_MEMIAVL
       - GIGA_FLATKV_ONLY
@@ -121,6 +124,7 @@ services:
       - GIGA_OCC
       - RECEIPT_BACKEND
       - AUTOBAHN
+      - AUTOBAHN_EVMONLY_IN_MEMORY
       - GIGA_STORAGE
       - GIGA_MIGRATE_FROM_MEMIAVL
       - GIGA_FLATKV_ONLY
diff --git a/docker/localnode/scripts/step4_config_override.sh b/docker/localnode/scripts/step4_config_override.sh
index b8a2ad7b96..bed39b96d6 100755
--- a/docker/localnode/scripts/step4_config_override.sh
+++ b/docker/localnode/scripts/step4_config_override.sh
@@ -6,6 +6,7 @@ NODE_ID=${ID:-0}
 GIGA_EXECUTOR=${GIGA_EXECUTOR:-true}
 GIGA_OCC=${GIGA_OCC:-true}
 AUTOBAHN=${AUTOBAHN:-false}
+AUTOBAHN_EVMONLY_IN_MEMORY=${AUTOBAHN_EVMONLY_IN_MEMORY:-false}
 GIGA_STORAGE=${GIGA_STORAGE:-false}
 # GIGA_FLATKV_ONLY=true boots the cluster directly in the terminal v3
 # steady state: all SC writes route to FlatKV and memiavl is not allocated.
@@ -165,6 +166,12 @@ if [ "$AUTOBAHN" = "true" ]; then
 
   # Generate autobahn config using seid
   seid tendermint gen-autobahn-config $NODE_DIRS --output "$AUTOBAHN_CONFIG"
+  if [ "$AUTOBAHN_EVMONLY_IN_MEMORY" = "true" ]; then
+    AUTOBAHN_CONFIG_TMP="$AUTOBAHN_CONFIG.tmp"
+    jq '.evm_only_in_memory = true | del(.persistent_state_dir)' "$AUTOBAHN_CONFIG" > "$AUTOBAHN_CONFIG_TMP"
+    mv "$AUTOBAHN_CONFIG_TMP" "$AUTOBAHN_CONFIG"
+    echo "Enabled Autobahn EVM-only execution with in-memory consensus state for node $NODE_ID"
+  fi
   # Inject autobahn config file path into config.toml
   # Must be placed before any [section] header so TOML parser reads it as a top-level key.
   if grep -q "autobahn-config-file" ~/.sei/config/config.toml; then
diff --git a/integration_test/autobahn/autobahn_test.go b/integration_test/autobahn/autobahn_test.go
index 2857ebde36..24e3bb9311 100644
--- a/integration_test/autobahn/autobahn_test.go
+++ b/integration_test/autobahn/autobahn_test.go
@@ -5,6 +5,7 @@
 // Requires a running autobahn Docker cluster. Run via:
 //
 //	make autobahn-integration-test
+//	make autobahn-evmonly-integration-test
 //
 // Or directly (cluster must already be up):
 //
@@ -13,9 +14,11 @@ package autobahn
 
 import (
 	"bufio"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
+	"math/big"
 	"net/http"
 	"os"
 	"os/exec"
@@ -24,8 +27,15 @@ import (
 	"testing"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common"
+	"golang.org/x/sync/errgroup"
+
+	"github.com/sei-protocol/sei-chain/giga/evmonly/cmd/evmonly-loadtest/scenarios"
+	tmconfig "github.com/sei-protocol/sei-chain/sei-tendermint/config"
 	tmjson "github.com/sei-protocol/sei-chain/sei-tendermint/libs/json"
+	tmhttp "github.com/sei-protocol/sei-chain/sei-tendermint/rpc/client/http"
 	"github.com/sei-protocol/sei-chain/sei-tendermint/rpc/coretypes"
+	tmtypes "github.com/sei-protocol/sei-chain/sei-tendermint/types"
 	"github.com/sei-protocol/sei-chain/testutil/evmtest"
 )
 
@@ -75,6 +85,10 @@ const (
 	// CI runners are slower than local; 1m was tight enough to flake.
 	haltStableTimeout = 2 * time.Minute
 	testRecipientEVM  = "0x1000000000000000000000000000000000000001"
+
+	evmOnlyInMemoryEnv = "AUTOBAHN_EVMONLY_IN_MEMORY"
+	evmOnlyLoadTxs     = 4_000
+	evmOnlyLoadTimeout = 3 * time.Minute
 )
 
 var (
@@ -200,6 +214,21 @@ func assertAutobahnEnabled(t *testing.T) {
 	}
 }
 
+func evmOnlyInMemoryEnabled() bool {
+	return os.Getenv(evmOnlyInMemoryEnv) == "true"
+}
+
+func assertEVMOnlyInMemoryEnabled(t *testing.T) {
+	t.Helper()
+	for _, name := range listRunningNodes(t) {
+		cmd := exec.Command("docker", "exec", name, "sh", "-c",
+			"grep -q 'Autobahn EVM-only in-memory execution enabled' build/generated/logs/seid-*.log")
+		if out, err := cmd.CombinedOutput(); err != nil {
+			t.Fatalf("EVM-only in-memory execution not enabled on %s: %v\n%s", name, err, out)
+		}
+	}
+}
+
 // dockerExec runs `docker exec <container> sh -c <script>` and returns stdout.
 func dockerExec(t *testing.T, container, script string) string {
 	t.Helper()
@@ -337,10 +366,12 @@ func TestMain(m *testing.M) {
 		teardownCluster() // best-effort
 		os.Exit(1)
 	}
-	if err := setupFullnodeNode(); err != nil {
-		fmt.Fprintf(os.Stderr, "fullnode sidecar setup failed: %v\n", err)
-		teardownCluster()
-		os.Exit(1)
+	if !evmOnlyInMemoryEnabled() {
+		if err := setupFullnodeNode(); err != nil {
+			fmt.Fprintf(os.Stderr, "fullnode sidecar setup failed: %v\n", err)
+			teardownCluster()
+			os.Exit(1)
+		}
 	}
 	code := m.Run()
 	teardownCluster()
@@ -564,6 +595,10 @@ func TestAutobahn(t *testing.T) {
 	// validator sets.
 	maxFaults = (clusterSize - 1) / 3
 	t.Logf("cluster size = %d, max tolerated faults = %d (assuming equal weights)", clusterSize, maxFaults)
+	if evmOnlyInMemoryEnabled() {
+		t.Run("EVMOnlyLoad", testEVMOnlyLoad)
+		return
+	}
 
 	t.Run("BlockProduction", testBlockProduction)
 	t.Run("EVMTransfer", testEVMTransfer)
@@ -572,6 +607,115 @@ func TestAutobahn(t *testing.T) {
 	t.Run("Recovery", testRecovery)
 }
 
+type evmOnlyLoadState struct{}
+
+func (evmOnlyLoadState) SetBalance(common.Address, *big.Int)               {}
+func (evmOnlyLoadState) SetCode(common.Address, []byte)                    {}
+func (evmOnlyLoadState) SetState(common.Address, common.Hash, common.Hash) {}
+
+func testEVMOnlyLoad(t *testing.T) {
+	assertAutobahnEnabled(t)
+	assertEVMOnlyInMemoryEnabled(t)
+	if clusterSize != 4 {
+		t.Fatalf("EVM-only Docker load test requires four validators, got %d", clusterSize)
+	}
+
+	workload, err := scenarios.NewTransferWorkload(scenarios.Config{
+		TxsPerBlock:   evmOnlyLoadTxs,
+		ChainID:       new(big.Int).SetUint64(tmconfig.AutobahnEVMOnlyInMemoryChainID),
+		GasPrice:      big.NewInt(1_000_000_000),
+		SenderBalance: new(big.Int).Lsh(big.NewInt(1), 200),
+		TransferValue: big.NewInt(1),
+		TxGasLimit:    21_000,
+	}, evmOnlyLoadState{})
+	if err != nil {
+		t.Fatalf("create EVM-only transfer workload: %v", err)
+	}
+	ctx, cancel := context.WithTimeout(t.Context(), evmOnlyLoadTimeout)
+	defer cancel()
+	block, err := workload.BuildBlock(ctx, 1)
+	if err != nil {
+		t.Fatalf("build EVM-only transfer workload: %v", err)
+	}
+
+	clients := make([]*tmhttp.HTTP, clusterSize)
+	for i := range clients {
+		client, err := tmhttp.New(fmt.Sprintf("http://localhost:%d", 26657+3*i))
+		if err != nil {
+			t.Fatalf("create node %d RPC client: %v", i, err)
+		}
+		clients[i] = client
+	}
+	started := time.Now()
+	group, groupCtx := errgroup.WithContext(ctx)
+	for nodeIndex, client := range clients {
+		nodeIndex, client := nodeIndex, client
+		group.Go(func() error {
+			for txIndex := nodeIndex; txIndex < len(block.Txs); txIndex += len(clients) {
+				response, err := client.BroadcastTxSync(groupCtx, tmtypes.Tx(block.Txs[txIndex]))
+				if err != nil {
+					return fmt.Errorf("broadcast tx %d through node %d: %w", txIndex, nodeIndex, err)
+				}
+				if response.Code != 0 {
+					return fmt.Errorf("broadcast tx %d through node %d: code=%d log=%s", txIndex, nodeIndex, response.Code, response.Log)
+				}
+			}
+			return nil
+		})
+	}
+	if err := group.Wait(); err != nil {
+		t.Fatal(err)
+	}
+
+	lastHeight, included := waitForEVMOnlyTxs(t, ctx, clients[0], len(block.Txs))
+	waitForEVMOnlyHeight(t, ctx, clients, lastHeight)
+	elapsed := time.Since(started)
+	t.Logf("Autobahn finalized %d raw EVM transfers through %d validators in %s (%.0f tx/s)",
+		included, clusterSize, elapsed.Round(time.Millisecond), float64(included)/elapsed.Seconds())
+}
+
+func waitForEVMOnlyTxs(t *testing.T, ctx context.Context, client *tmhttp.HTTP, target int) (int64, int) {
+	t.Helper()
+	nextHeight := int64(1)
+	included := 0
+	for included < target {
+		if err := ctx.Err(); err != nil {
+			t.Fatalf("waiting for %d EVM-only transactions: finalized %d: %v", target, included, err)
+		}
+		latest, err := client.Block(ctx, nil)
+		if err != nil || latest.Block == nil || latest.Block.Height < nextHeight {
+			time.Sleep(100 * time.Millisecond)
+			continue
+		}
+		for nextHeight <= latest.Block.Height {
+			height := nextHeight
+			block, err := client.Block(ctx, &height)
+			if err != nil || block.Block == nil {
+				break
+			}
+			included += len(block.Block.Data.Txs)
+			nextHeight++
+		}
+	}
+	return nextHeight - 1, included
+}
+
+func waitForEVMOnlyHeight(t *testing.T, ctx context.Context, clients []*tmhttp.HTTP, target int64) {
+	t.Helper()
+	for i, client := range clients {
+		for {
+			if err := ctx.Err(); err != nil {
+				t.Fatalf("waiting for node %d to execute EVM-only height %d: %v", i, target, err)
+			}
+			block, err := client.Block(ctx, nil)
+			if err == nil && block.Block != nil && block.Block.Height >= target {
+				break
+			}
+			time.Sleep(100 * time.Millisecond)
+		}
+	}
+}
+
 // restartNode re-invokes the container's seid-start script inside sei-node-<i>.
 // The script backgrounds seid and exits, so `docker exec -d` is the right mode:
 // it returns immediately while seid keeps running.
diff --git a/sei-tendermint/config/autobahn.go b/sei-tendermint/config/autobahn.go
index 87151394ea..dc3fd8e003 100644
--- a/sei-tendermint/config/autobahn.go
+++ b/sei-tendermint/config/autobahn.go
@@ -82,8 +82,16 @@ type AutobahnFileConfig struct {
 	// (see AutobahnBlockDBConfig for field semantics). Ignored when
 	// PersistentStateDir is absent (memblock). Omitted from JSON when empty.
 	BlockDB AutobahnBlockDBConfig `json:"block_db,omitzero"`
+	// EVMOnlyInMemory replaces the Cosmos application used by Autobahn with an
+	// ephemeral EVM-only executor. It exists only for Docker load testing and
+	// must not be enabled on a persistent network.
+	EVMOnlyInMemory bool `json:"evm_only_in_memory,omitzero"`
 }
 
+// AutobahnEVMOnlyInMemoryChainID is the EVM chain ID used by Autobahn's
+// ephemeral EVM-only load-test runtime.
+const AutobahnEVMOnlyInMemoryChainID uint64 = 1337
+
 func (c *AutobahnFileConfig) GetEnableEvmProxy() bool {
 	return c.EnableEvmProxy.Or(true)
 }
diff --git a/sei-tendermint/internal/p2p/evmonly_inmemory_app.go b/sei-tendermint/internal/p2p/evmonly_inmemory_app.go
new file mode 100644
index 0000000000..b445ebe22a
--- /dev/null
+++ b/sei-tendermint/internal/p2p/evmonly_inmemory_app.go
@@ -0,0 +1,279 @@
+package p2p
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/binary"
+	"fmt"
+	"math"
+	"math/big"
+	"runtime"
+
+	"github.com/ethereum/go-ethereum/common"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/holiman/uint256"
+
+	"github.com/sei-protocol/sei-chain/giga/evmonly"
+	gigastore "github.com/sei-protocol/sei-chain/sei-db/state_db/giga"
+	abci "github.com/sei-protocol/sei-chain/sei-tendermint/abci/types"
+	"github.com/sei-protocol/sei-chain/sei-tendermint/internal/proxy"
+	"github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils"
+)
+
+const evmOnlyInMemoryMinGasPrice = 1_000_000_000
+
+var evmOnlyInMemoryBaseBalance = new(big.Int).Lsh(big.NewInt(1), 200)
+
+type evmOnlyInMemoryApplication struct {
+	abci.BaseApplication
+
+	chainID  *big.Int
+	gasLimit uint64
+	store    *evmonly.MemoryStore
+	executor *evmonly.Executor
+	state    utils.Mutex[*evmOnlyInMemoryState]
+}
+
+type evmOnlyInMemoryState struct {
+	nextHeight      int64
+	committedHeight int64
+	appHash         common.Hash
+	parentHash      common.Hash
+	pending         utils.Option[evmOnlyInMemoryPending]
+}
+
+type evmOnlyInMemoryPending struct {
+	height    int64
+	appHash   common.Hash
+	blockHash common.Hash
+}
+
+var _ abci.Application = (*evmOnlyInMemoryApplication)(nil)
+
+// NewEVMOnlyInMemoryProxy returns an ephemeral raw-Ethereum executor for
+// Autobahn Docker load tests.
+func NewEVMOnlyInMemoryProxy(chainID uint64, gasLimit uint64, initialHeight int64) *proxy.Proxy {
+	base := evmOnlyFundedState{}
+	store := evmonly.NewMemoryStore(base)
+	chainConfig := *params.AllDevChainProtocolChanges
+	chainConfig.ChainID = new(big.Int).SetUint64(chainID)
+	app := &evmOnlyInMemoryApplication{
+		chainID:  new(big.Int).SetUint64(chainID),
+		gasLimit: gasLimit,
+		store:    store,
+		executor: evmonly.NewExecutor(evmonly.Config{
+			ChainConfig:         &chainConfig,
+			MinGasPrice:         big.NewInt(evmOnlyInMemoryMinGasPrice),
+			OCCWorkers:          runtime.GOMAXPROCS(0),
+			ParseWorkers:        runtime.GOMAXPROCS(0),
+			BlockResultPoolSize: 1,
+		}, evmonly.WithStore(store, store.EncodeChangeSet)),
+		state: utils.NewMutex(&evmOnlyInMemoryState{nextHeight: initialHeight}),
+	}
+	return proxy.New(app)
+}
+
+func (a *evmOnlyInMemoryApplication) Info() *abci.ResponseInfo {
+	for state := range a.state.Lock() {
+		return &abci.ResponseInfo{
+			Data:             "evmonly-in-memory",
+			LastBlockHeight:  state.committedHeight,
+			LastBlockAppHash: append([]byte(nil), state.appHash[:]...),
+		}
+	}
+	panic("unreachable")
+}
+
+func (a *evmOnlyInMemoryApplication) LastBlockHeight() int64 {
+	for state := range a.state.Lock() {
+		return state.committedHeight
+	}
+	panic("unreachable")
+}
+
+func (a *evmOnlyInMemoryApplication) CheckTx(_ context.Context, req *abci.RequestCheckTxV2) *abci.ResponseCheckTxV2 {
+	tx, sender, err := a.parseTx(req.Tx)
+	if err != nil {
+		return &abci.ResponseCheckTxV2{ResponseCheckTx: &abci.ResponseCheckTx{Code: 1, Log: err.Error()}}
+	}
+	gasWanted, ok := utils.SafeCast[int64](tx.Gas())
+	if !ok {
+		return &abci.ResponseCheckTxV2{ResponseCheckTx: &abci.ResponseCheckTx{Code: 1, Log: "transaction gas limit exceeds int64"}}
+	}
+	return &abci.ResponseCheckTxV2{
+		ResponseCheckTx: &abci.ResponseCheckTx{
+			Code:         abci.CodeTypeOK,
+			GasWanted:    gasWanted,
+			GasEstimated: gasWanted,
+		},
+		IsEVM:            true,
+		EVMNonce:         tx.Nonce(),
+		EVMHash:          tx.Hash(),
+		EVMSenderAddress: sender,
+		SeiSenderAddress: append([]byte(nil), sender[:]...),
+	}
+}
+
+func (a *evmOnlyInMemoryApplication) parseTx(raw []byte) (*ethtypes.Transaction, common.Address, error) {
+	tx := new(ethtypes.Transaction)
+	if err := tx.UnmarshalBinary(raw); err != nil {
+		return nil, common.Address{}, err
+	}
+	if !tx.Protected() {
+		return nil, common.Address{}, fmt.Errorf("unprotected Ethereum transaction")
+	}
+	if tx.ChainId().Cmp(a.chainID) != 0 {
+		return nil, common.Address{}, fmt.Errorf("Ethereum transaction chain ID does not match %s", a.chainID)
+	}
+	if tx.Type() == ethtypes.BlobTxType {
+		return nil, common.Address{}, fmt.Errorf("blob transactions are not supported")
+	}
+	if tx.GasPrice().Cmp(big.NewInt(evmOnlyInMemoryMinGasPrice)) < 0 {
+		return nil, common.Address{}, fmt.Errorf("Ethereum transaction gas price is below %d", evmOnlyInMemoryMinGasPrice)
+	}
+	sender, err := ethtypes.Sender(ethtypes.LatestSignerForChainID(a.chainID), tx)
+	if err != nil {
+		return nil, common.Address{}, err
+	}
+	return tx, sender, nil
+}
+
+func (a *evmOnlyInMemoryApplication) EvmNonce(address common.Address) uint64 {
+	snapshot := a.store.OpenSnapshot()
+	defer snapshot.Close()
+	return snapshot.GetNonce(gigastore.Address(address))
+}
+
+func (a *evmOnlyInMemoryApplication) EvmBalance(address common.Address, _ []byte) uint256.Int {
+	snapshot := a.store.OpenSnapshot()
+	defer snapshot.Close()
+	balance := snapshot.GetBalance(gigastore.Address(address))
+	return *new(uint256.Int).SetBytes(balance[:])
+}
+
+func (a *evmOnlyInMemoryApplication) FinalizeBlock(ctx context.Context, req *abci.RequestFinalizeBlock) (*abci.ResponseFinalizeBlock, error) {
+	height := req.Header.Height
+	if height <= 0 {
+		return nil, fmt.Errorf("EVM-only block height must be positive: %d", height)
+	}
+	number, ok := utils.SafeCast[uint64](height)
+	if !ok {
+		return nil, fmt.Errorf("EVM-only block height exceeds uint64: %d", height)
+	}
+	timestamp, ok := utils.SafeCast[uint64](req.Header.Time.Unix())
+	if !ok {
+		return nil, fmt.Errorf("EVM-only block timestamp is negative: %s", req.Header.Time)
+	}
+	blockHash := common.BytesToHash(req.Hash)
+	for state := range a.state.Lock() {
+		if state.pending.IsPresent() {
+			return nil, fmt.Errorf("EVM-only block %d finalized before committing the previous block", height)
+		}
+		if height != state.nextHeight {
+			return nil, fmt.Errorf("EVM-only block height %d does not match next height %d", height, state.nextHeight)
+		}
+		result, err := a.executor.ExecuteBlock(ctx, evmonly.BlockRequest{
+			Context: evmonly.BlockContext{
+				Number:      number,
+				Time:        timestamp,
+				GasLimit:    a.gasLimit,
+				ChainID:     new(big.Int).Set(a.chainID),
+				BaseFee:     new(big.Int),
+				BlobBaseFee: new(big.Int),
+				ParentHash:  state.parentHash,
+				BlockHash:   blockHash,
+				PrevRandao:  crypto.Keccak256Hash(binary.BigEndian.AppendUint64(nil, timestamp)),
+			},
+			Txs: req.Txs,
+		})
+		if err != nil {
+			return nil, err
+		}
+		defer result.Release()
+		appHash, err := hashEVMOnlyInMemoryResult(state.appHash, number, blockHash, result)
+		if err != nil {
+			return nil, err
+		}
+		state.pending = utils.Some(evmOnlyInMemoryPending{height: height, appHash: appHash, blockHash: blockHash})
+		return &abci.ResponseFinalizeBlock{
+			AppHash:   append([]byte(nil), appHash[:]...),
+			TxResults: evmOnlyABCIResults(result),
+		}, nil
+	}
+	panic("unreachable")
+}
+
+func (a *evmOnlyInMemoryApplication) Commit(context.Context) (*abci.ResponseCommit, error) {
+	for state := range a.state.Lock() {
+		pending, ok := state.pending.Get()
+		if !ok {
+			return nil, fmt.Errorf("EVM-only Commit called without a finalized block")
+		}
+		state.committedHeight = pending.height
+		state.nextHeight = pending.height + 1
+		state.appHash = pending.appHash
+		state.parentHash = pending.blockHash
+		state.pending = utils.None[evmOnlyInMemoryPending]()
+		return &abci.ResponseCommit{}, nil
+	}
+	panic("unreachable")
+}
+
+func evmOnlyABCIResults(result *evmonly.BlockResult) []*abci.ExecTxResult {
+	txResults := make([]*abci.ExecTxResult, len(result.Txs))
+	for i, tx := range result.Txs {
+		gasUsed := min(tx.GasUsed, math.MaxInt64)
+		txResults[i] = &abci.ExecTxResult{
+			Code:      abci.CodeTypeOK,
+			GasWanted: int64(gasUsed),
+			GasUsed:   int64(gasUsed),
+		}
+	}
+	return txResults
+}
+
+func hashEVMOnlyInMemoryResult(previous common.Hash, height uint64, blockHash common.Hash, result *evmonly.BlockResult) (common.Hash, error) {
+	h := sha256.New()
+	_, _ = h.Write(previous[:])
+	_, _ = h.Write(binary.BigEndian.AppendUint64(nil, height))
+	_, _ = h.Write(blockHash[:])
+	_, _ = h.Write(binary.BigEndian.AppendUint64(nil, result.GasUsed))
+	changesets, err := evmonly.EncodeMemoryStoreChangeSet(result.ChangeSet)
+	if err != nil {
+		return common.Hash{}, err
+	}
+	for _, changeset := range changesets {
+		writeEVMOnlyHashBytes(h, []byte(changeset.Name))
+		for _, pair := range changeset.Changeset.Pairs {
+			writeEVMOnlyHashBytes(h, pair.Key)
+			if pair.Delete {
+				_, _ = h.Write([]byte{1})
+			} else {
+				_, _ = h.Write([]byte{0})
+			}
+			writeEVMOnlyHashBytes(h, pair.Value)
+		}
+	}
+	return common.BytesToHash(h.Sum(nil)), nil
+}
+
+type byteWriter interface {
+	Write([]byte) (int, error)
+}
+
+func writeEVMOnlyHashBytes(w byteWriter, value []byte) {
+	_, _ = w.Write(binary.BigEndian.AppendUint64(nil, uint64(len(value))))
+	_, _ = w.Write(value)
+}
+
+type evmOnlyFundedState struct{}
+
+func (evmOnlyFundedState) AccountExists(common.Address) bool { return true }
+func (evmOnlyFundedState) GetBalance(common.Address) *big.Int {
+	return new(big.Int).Set(evmOnlyInMemoryBaseBalance)
+}
+func (evmOnlyFundedState) GetNonce(common.Address) uint64                   { return 0 }
+func (evmOnlyFundedState) GetCode(common.Address) []byte                    { return nil }
+func (evmOnlyFundedState) GetState(common.Address, common.Hash) common.Hash { return common.Hash{} }
diff --git a/sei-tendermint/internal/p2p/evmonly_inmemory_app_test.go b/sei-tendermint/internal/p2p/evmonly_inmemory_app_test.go
new file mode 100644
index 0000000000..b37028d733
--- /dev/null
+++ b/sei-tendermint/internal/p2p/evmonly_inmemory_app_test.go
@@ -0,0 +1,96 @@
+package p2p
+
+import (
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+
+	abci "github.com/sei-protocol/sei-chain/sei-tendermint/abci/types"
+	"github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/require"
+	tmproto "github.com/sei-protocol/sei-chain/sei-tendermint/proto/tendermint/types"
+)
+
+const evmOnlyTestChainID uint64 = 1337
+
+func signedEVMOnlyTestTx(t *testing.T, chainID uint64, nonce uint64) ([]byte, common.Address) {
+	t.Helper()
+	key, err := crypto.GenerateKey()
+	require.NoError(t, err)
+	recipient := common.HexToAddress("0x1000000000000000000000000000000000000001")
+	tx := ethtypes.NewTx(&ethtypes.LegacyTx{
+		Nonce:    nonce,
+		GasPrice: big.NewInt(evmOnlyInMemoryMinGasPrice),
+		Gas:      21_000,
+		To:       &recipient,
+		Value:    big.NewInt(1),
+	})
+	signed, err := ethtypes.SignTx(tx, ethtypes.LatestSignerForChainID(new(big.Int).SetUint64(chainID)), key)
+	require.NoError(t, err)
+	raw, err := signed.MarshalBinary()
+	require.NoError(t, err)
+	return raw, crypto.PubkeyToAddress(key.PublicKey)
+}
+
+func TestEVMOnlyInMemoryApplicationExecutesRawEthereumBlock(t *testing.T) {
+	app := NewEVMOnlyInMemoryProxy(evmOnlyTestChainID, 30_000_000, 1)
+	raw, sender := signedEVMOnlyTestTx(t, evmOnlyTestChainID, 0)
+	check, err := app.CheckTxSafe(t.Context(), &abci.RequestCheckTxV2{Tx: raw})
+	require.NoError(t, err)
+	require.True(t, check.IsOK())
+	require.True(t, check.IsEVM)
+	require.Equal(t, sender, check.EVMSenderAddress)
+	require.Equal(t, uint64(0), app.EvmNonce(sender))
+
+	response, err := app.FinalizeBlock(t.Context(), &abci.RequestFinalizeBlock{
+		Txs:  [][]byte{raw},
+		Hash: crypto.Keccak256([]byte("block-1")),
+		Header: &tmproto.Header{
+			Height: 1,
+			Time:   time.Unix(1_700_000_001, 0),
+		},
+	})
+	require.NoError(t, err)
+	require.Len(t, response.AppHash, common.HashLength)
+	require.Len(t, response.TxResults, 1)
+	require.Positive(t, response.TxResults[0].GasUsed)
+	_, err = app.Commit(t.Context())
+	require.NoError(t, err)
+	require.Equal(t, int64(1), app.LastBlockHeight())
+	require.Equal(t, uint64(1), app.EvmNonce(sender))
+	require.Equal(t, response.AppHash, app.Info().LastBlockAppHash)
+}
+
+func TestEVMOnlyInMemoryApplicationRejectsWrongChain(t *testing.T) {
+	app := NewEVMOnlyInMemoryProxy(evmOnlyTestChainID, 30_000_000, 1)
+	raw, _ := signedEVMOnlyTestTx(t, evmOnlyTestChainID+1, 0)
+
+	response, err := app.CheckTxSafe(t.Context(), &abci.RequestCheckTxV2{Tx: raw})
+
+	require.NoError(t, err)
+	require.True(t, response.IsErr())
+}
+
+func TestEVMOnlyInMemoryApplicationProducesDeterministicRoot(t *testing.T) {
+	raw, _ := signedEVMOnlyTestTx(t, evmOnlyTestChainID, 0)
+	request := &abci.RequestFinalizeBlock{
+		Txs:  [][]byte{raw},
+		Hash: crypto.Keccak256([]byte("same-block")),
+		Header: &tmproto.Header{
+			Height: 1,
+			Time:   time.Unix(1_700_000_001, 0),
+		},
+	}
+	first := NewEVMOnlyInMemoryProxy(evmOnlyTestChainID, 30_000_000, 1)
+	second := NewEVMOnlyInMemoryProxy(evmOnlyTestChainID, 30_000_000, 1)
+
+	firstResponse, err := first.FinalizeBlock(t.Context(), request)
+	require.NoError(t, err)
+	secondResponse, err := second.FinalizeBlock(t.Context(), request)
+	require.NoError(t, err)
+
+	require.Equal(t, firstResponse.AppHash, secondResponse.AppHash)
+}
diff --git a/sei-tendermint/internal/rpc/core/blocks.go b/sei-tendermint/internal/rpc/core/blocks.go
index b8aa3537af..b09af4ca5e 100644
--- a/sei-tendermint/internal/rpc/core/blocks.go
+++ b/sei-tendermint/internal/rpc/core/blocks.go
@@ -127,7 +127,7 @@ func (env *Environment) Block(ctx context.Context, req *coretypes.RequestBlockIn
 }
 
 // autobahnCheckAndGetHeight resolves a caller-supplied height pointer to a
-// concrete int64 and validates it against the current ABCI head. nil (or
+// concrete int64 and validates it against the GigaRouter execution head. nil (or
 // zero) means "latest". Returns the same error sentinels as env.getHeight
 // (ErrZeroOrNegativeHeight, ErrHeightExceedsChainHead, ErrHeightNotAvailable)
 // so downstream consumers like evmrpc — which translate
@@ -145,7 +145,11 @@ func (env *Environment) Block(ctx context.Context, req *coretypes.RequestBlockIn
 // wired into block execution: switch this and BlockByNumber to read from
 // BlockDB, and source `base` from BlockDB.GetLowestBlockHeight.
 func (env *Environment) autobahnCheckAndGetHeight(heightPtr *int64) (int64, error) {
-	return env.getHeight(env.App.Info().LastBlockHeight, heightPtr)
+	giga, ok := env.gigaRouter().Get()
+	if !ok {
+		panic("autobahnCheckAndGetHeight called without GigaRouter")
+	}
+	return env.getHeight(giga.LastCommittedBlockNumber(), heightPtr)
 }
 
 // BlockByHash gets block by hash.
diff --git a/sei-tendermint/node/setup.go b/sei-tendermint/node/setup.go
index 092f4c3e16..db7f9597ce 100644
--- a/sei-tendermint/node/setup.go
+++ b/sei-tendermint/node/setup.go
@@ -295,6 +295,14 @@ func buildGigaRouter(
 	if err != nil {
 		return nil, nil, err
 	}
+	if fc.EVMOnlyInMemory {
+		maxGas, err := genesisMaxGas(genDoc)
+		if err != nil {
+			return nil, nil, err
+		}
+		logger.Warn("Autobahn EVM-only in-memory execution enabled; state is ephemeral and unsafe for persistent networks")
+		app = p2p.NewEVMOnlyInMemoryProxy(config.AutobahnEVMOnlyInMemoryChainID, maxGas, genDoc.InitialHeight)
+	}
 	if valKey, ok := validatorKey.Get(); ok {
 		_, inCommittee := validatorAddrs[valKey.Public()]
 		switch {