feat: Giga: support synchronous giga execution of blocks

Author: arajasek

app/app.go

@@ -104,6 +104,9 @@ import (
 	evmrpcconfig "github.com/sei-protocol/sei-chain/evmrpc/config"
 	gigaexecutor "github.com/sei-protocol/sei-chain/giga/executor"
 	gigaconfig "github.com/sei-protocol/sei-chain/giga/executor/config"
+
+	gigaprecompiles "github.com/sei-protocol/sei-chain/giga/executor/precompiles"
+	gigautils "github.com/sei-protocol/sei-chain/giga/executor/utils"
 	"github.com/sei-protocol/sei-chain/precompiles"
 	putils "github.com/sei-protocol/sei-chain/precompiles/utils"
 	"github.com/sei-protocol/sei-chain/sei-db/state_db/ss"
@@ -1311,13 +1314,37 @@ func (app *App) DeliverTxWithResult(ctx sdk.Context, tx []byte, typedTx sdk.Tx)
 func (app *App) ProcessBlockSynchronous(ctx sdk.Context, txs [][]byte, typedTxs []sdk.Tx, absoluteTxIndices []int) []*abci.ExecTxResult {
 	defer metrics.BlockProcessLatency(time.Now(), metrics.SYNCHRONOUS)
 
-	txResults := []*abci.ExecTxResult{}
+	txResults := make([]*abci.ExecTxResult, len(txs))
 	for i, tx := range txs {
 		ctx = ctx.WithTxIndex(absoluteTxIndices[i])
-		res := app.DeliverTxWithResult(ctx, tx, typedTxs[i])
-		txResults = append(txResults, res)
+		evmMsg := app.GetEVMMsg(typedTxs[i])
+		// If not an EVM tx, fall back to v2 processing
+		if evmMsg == nil {
+			result := app.DeliverTxWithResult(ctx, tx, typedTxs[i])
+			txResults[i] = result
+			continue
+		}
+
+		// Execute EVM transaction through giga executor
+		result, execErr := app.executeEVMTxWithGigaExecutor(ctx, i, evmMsg)
+		if execErr != nil {
+			// Check if this is a fail-fast error (Cosmos precompile interop detected)
+			if gigautils.ShouldExecutionAbort(execErr) {
+				res := app.DeliverTxWithResult(ctx, tx, typedTxs[i])
+				txResults[i] = res
+				continue
+			}
+			txResults[i] = &abci.ExecTxResult{
+				Code: 1,
+				Log:  fmt.Sprintf("[BUG] giga executor error: %v", execErr),
+			}
+			continue
+		}
+
+		txResults[i] = result
 		metrics.IncrTxProcessTypeCounter(metrics.SYNCHRONOUS)
 	}
+	
 	return txResults
 }
 
@@ -1363,12 +1390,13 @@ func (app *App) PartitionPrioritizedTxs(_ sdk.Context, txs [][]byte, typedTxs []
 
 // ExecuteTxsConcurrently calls the appropriate function for processing transacitons
 func (app *App) ExecuteTxsConcurrently(ctx sdk.Context, txs [][]byte, typedTxs []sdk.Tx, absoluteTxIndices []int) ([]*abci.ExecTxResult, sdk.Context) {
-	// TODO after OCC release, remove this check and call ProcessTXsWithOCC directly
-	if ctx.IsOCCEnabled() {
-		return app.ProcessTXsWithOCC(ctx, txs, typedTxs, absoluteTxIndices)
+	// Giga only supports synchronous execution for now
+	if app.EvmKeeper.GigaExecutorEnabled || !ctx.IsOCCEnabled() {
+		results := app.ProcessBlockSynchronous(ctx, txs, typedTxs, absoluteTxIndices)
+		return results, ctx
 	}
-	results := app.ProcessBlockSynchronous(ctx, txs, typedTxs, absoluteTxIndices)
-	return results, ctx
+
+	return app.ProcessTXsWithOCC(ctx, txs, typedTxs, absoluteTxIndices)
 }
 
 func (app *App) GetDeliverTxEntry(ctx sdk.Context, txIndex int, absoluateIndex int, bz []byte, tx sdk.Tx) (res *sdk.DeliverTxEntry) {
@@ -1462,12 +1490,9 @@ 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 {
-			return app.ProcessBlockWithGigaExecutorOCC(ctx, txs, req, lastCommit, simulate)
-		}
-		return app.ProcessBlockWithGigaExecutor(ctx, txs, req, lastCommit, simulate)
+	// TODO: for now Giga OCC calls ProcessBlockWithGigaExecutorOCC, WIP
+	if app.EvmKeeper.GigaExecutorEnabled && app.EvmKeeper.GigaOCCEnabled {
+		return app.ProcessBlockWithGigaExecutorOCC(ctx, txs, req, lastCommit, simulate)
 	}
 
 	ctx = ctx.WithIsOCCEnabled(app.OccEnabled())
@@ -1530,6 +1555,7 @@ func (app *App) ProcessBlock(ctx sdk.Context, txs [][]byte, req BlockProcessRequ
 // ProcessBlockWithGigaExecutor executes block transactions using the Giga executor,
 // bypassing the standard Cosmos SDK transaction processing flow.
 // This is an experimental path for improved EVM throughput.
+// NOTE: This is not currently used in the codebase, but might be in the future.
 func (app *App) ProcessBlockWithGigaExecutor(ctx sdk.Context, txs [][]byte, req BlockProcessRequest, lastCommit abci.CommitInfo, simulate bool) (events []abci.Event, txResults []*abci.ExecTxResult, endBlockResp abci.ResponseEndBlock, err error) {
 	// Panic recovery like original ProcessBlock
 	defer func() {
@@ -1580,12 +1606,9 @@ func (app *App) ProcessBlockWithGigaExecutor(ctx sdk.Context, txs [][]byte, req
 		// Check if this is an EVM transaction
 		evmMsg := app.GetEVMMsg(decodedTx)
 		if evmMsg == nil {
-			// Non-EVM transaction - for now, fall back to standard processing
-			// TODO: Handle or reject non-EVM txs in giga mode
-			txResults[i] = &abci.ExecTxResult{
-				Code: 1,
-				Log:  "non-EVM transactions not supported in giga executor mode",
-			}
+			res := app.DeliverTxWithResult(ctx, txBytes, decodedTx)
+			// Non-EVM transaction - fall back to standard processing
+			txResults[i] = res
 			continue
 		}
 
@@ -1594,9 +1617,15 @@ func (app *App) ProcessBlockWithGigaExecutor(ctx sdk.Context, txs [][]byte, req
 		// Execute EVM transaction through giga executor
 		result, execErr := app.executeEVMTxWithGigaExecutor(ctx, i, evmMsg)
 		if execErr != nil {
+			// Check if this is a fail-fast error (Cosmos precompile interop detected)
+			if gigautils.ShouldExecutionAbort(execErr) {
+				res := app.DeliverTxWithResult(ctx, txBytes, decodedTx)
+				txResults[i] = res
+				continue
+			}
 			txResults[i] = &abci.ExecTxResult{
 				Code: 1,
-				Log:  fmt.Sprintf("giga executor error: %v", execErr),
+				Log:  fmt.Sprintf("[BUG] giga executor error: %v", execErr),
 			}
 			continue
 		}
@@ -1676,8 +1705,8 @@ func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, txIndex int, msg *
 	sstore := app.EvmKeeper.GetParams(ctx).SeiSstoreSetGasEip2200
 	cfg := evmtypes.DefaultChainConfig().EthereumConfigWithSstore(app.EvmKeeper.ChainID(ctx), &sstore)
 
-	// Create Giga executor VM (wraps evmone)
-	gigaExecutor := gigaexecutor.NewEvmoneExecutor(*blockCtx, stateDB, cfg, vm.Config{}, app.EvmKeeper.CustomPrecompiles(ctx))
+	// Create Giga executor VM
+	gigaExecutor := gigaexecutor.NewGethExecutor(*blockCtx, stateDB, cfg, vm.Config{}, gigaprecompiles.AllCustomPrecompilesFailFast)
 
 	// Execute the transaction through giga VM
 	execResult, execErr := gigaExecutor.ExecuteTransaction(ethTx, sender, app.EvmKeeper.GetBaseFee(ctx), &gp)
@@ -1688,6 +1717,12 @@ func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, txIndex int, msg *
 		}, nil
 	}
 
+	// Check if the execution hit a fail-fast precompile (Cosmos interop detected)
+	// Return the error to the caller so it can handle accordingly (e.g., fallback to standard execution)
+	if execResult.Err != nil && gigautils.ShouldExecutionAbort(execResult.Err) {
+		return nil, execResult.Err
+	}
+
 	// Finalize state changes
 	_, ferr := stateDB.Finalize()
 	if ferr != nil {
@@ -1905,6 +1940,12 @@ func (app *App) gigaDeliverTx(ctx sdk.Context, req abci.RequestDeliverTxV2, tx s
 
 	result, err := app.executeEVMTxWithGigaExecutor(ctx, ctx.TxIndex(), evmMsg)
 	if err != nil {
+		// Check if this is a fail-fast error (Cosmos precompile interop detected)
+		if gigautils.ShouldExecutionAbort(err) {
+			// Transaction requires Cosmos interop - not supported in giga mode
+			// TODO: implement fallback to standard execution path
+			return abci.ResponseDeliverTx{Code: 1, Log: fmt.Sprintf("giga executor: cosmos interop not supported: %v", err)}
+		}
 		return abci.ResponseDeliverTx{Code: 1, Log: fmt.Sprintf("giga executor error: %v", err)}
 	}
 

giga/executor/precompiles/failfast.go

@@ -1,7 +1,7 @@
 package precompiles
 
 import (
-	"errors"
+	"fmt"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -38,7 +38,24 @@ var FailFastPrecompileAddresses = []common.Address{
 	common.HexToAddress(p256.P256VerifyAddress),
 }
 
-var ErrInvalidPrecompileCall = errors.New("invalid precompile call")
+// InvalidPrecompileCallError is an error type that implements vm.AbortError,
+// signaling that execution should abort and this error should propagate
+// through the entire call stack.
+type InvalidPrecompileCallError struct{}
+
+func (e *InvalidPrecompileCallError) Error() string {
+	return "invalid precompile call"
+}
+
+// IsAbortError implements vm.AbortError interface, signaling that this error
+// should propagate through the EVM call stack instead of being swallowed.
+func (e *InvalidPrecompileCallError) IsAbortError() bool {
+	return true
+}
+
+// ErrInvalidPrecompileCall is the singleton error instance for invalid precompile calls.
+// It implements vm.AbortError to ensure it propagates through the call stack.
+var ErrInvalidPrecompileCall error = &InvalidPrecompileCallError{}
 
 type FailFastPrecompile struct{}
 
@@ -49,6 +66,7 @@ func (p *FailFastPrecompile) RequiredGas(input []byte) uint64 {
 }
 
 func (p *FailFastPrecompile) Run(evm *vm.EVM, caller common.Address, callingContract common.Address, input []byte, value *big.Int, readOnly bool, isFromDelegateCall bool, hooks *tracing.Hooks) ([]byte, error) {
+	fmt.Println("FAILFAST PRECOMPILE CALLED: 52")
 	return nil, ErrInvalidPrecompileCall
 }
 

giga/executor/utils/errors.go

@@ -1,11 +1,17 @@
 package utils
 
 import (
-	"errors"
-
-	"github.com/sei-protocol/sei-chain/giga/executor/precompiles"
+	"github.com/ethereum/go-ethereum/core/vm"
 )
 
+// ShouldExecutionAbort checks if the given error is an AbortError that should
+// cause Giga execution to abort and fall back to standard execution.
 func ShouldExecutionAbort(err error) bool {
-	return errors.Is(err, precompiles.ErrInvalidPrecompileCall)
+	if err == nil {
+		return false
+	}
+	if abortErr, ok := err.(vm.AbortError); ok {
+		return abortErr.IsAbortError()
+	}
+	return false
 }

go.work

@@ -5,3 +5,5 @@ use (
 	./sei-cosmos
 	./sei-tendermint
 )
+
+replace github.com/ethereum/go-ethereum => github.com/sei-protocol/go-ethereum v1.15.8-wip

go.work.sum

@@ -803,8 +803,8 @@ github.com/schollz/closestmatch v2.1.0+incompatible h1:Uel2GXEpJqOWBrlyI+oY9LTiy
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 h1:nn5Wsu0esKSJiIVhscUtVbo7ada43DJhG55ua/hjS5I=
 github.com/seccomp/libseccomp-golang v0.9.1 h1:NJjM5DNFOs0s3kYE1WUOr6G8V97sdt46rlXTMfXGWBo=
 github.com/segmentio/fasthash v1.0.3 h1:EI9+KE1EwvMLBWwjpRDc+fEM+prwxDYbslddQGtrmhM=
-github.com/sei-protocol/go-ethereum v1.15.7-sei-15 h1:cK2ZiNo9oWO4LeyRlZYZMILspPq0yoHIJdjLviAxtXE=
-github.com/sei-protocol/go-ethereum v1.15.7-sei-15/go.mod h1:+S9k+jFzlyVTNcYGvqFhzN/SFhI6vA+aOY4T5tLSPL0=
+github.com/sei-protocol/go-ethereum v1.15.8-wip h1:isUcMF8DkzsrCoYIxlMKAw7bR5rmzJqwWurunv/t/kI=
+github.com/sei-protocol/go-ethereum v1.15.8-wip/go.mod h1:+S9k+jFzlyVTNcYGvqFhzN/SFhI6vA+aOY4T5tLSPL0=
 github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
 github.com/shirou/gopsutil/v3 v3.22.9/go.mod h1:bBYl1kjgEJpWpxeHmLI+dVHWtyAwfcmSBLDsp2TNT8A=
 github.com/shirou/gopsutil/v3 v3.23.2 h1:PAWSuiAszn7IhPMBtXsbSCafej7PqUOvY6YywlQUExU=