diff --git a/app/app.go b/app/app.go index 28957a6037..ed9d8564be 100644 --- a/app/app.go +++ b/app/app.go @@ -30,6 +30,7 @@ import ( servertypes "github.com/cosmos/cosmos-sdk/server/types" storetypes "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" genesistypes "github.com/cosmos/cosmos-sdk/types/genesis" "github.com/cosmos/cosmos-sdk/types/module" "github.com/cosmos/cosmos-sdk/types/occ" @@ -93,6 +94,7 @@ import ( ethrpc "github.com/ethereum/go-ethereum/rpc" "github.com/sei-protocol/sei-chain/giga/deps/tasks" + "github.com/gogo/protobuf/proto" "github.com/gorilla/mux" "github.com/rakyll/statik/fs" "github.com/sei-protocol/sei-chain/app/antedecorators" @@ -105,6 +107,8 @@ import ( gigaexecutor "github.com/sei-protocol/sei-chain/giga/executor" gigaconfig "github.com/sei-protocol/sei-chain/giga/executor/config" gigalib "github.com/sei-protocol/sei-chain/giga/executor/lib" + 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" ssconfig "github.com/sei-protocol/sei-chain/sei-db/config" @@ -1327,7 +1331,7 @@ 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 { +func (app *App) ProcessTxsSynchronousV2(ctx sdk.Context, txs [][]byte, typedTxs []sdk.Tx, absoluteTxIndices []int) []*abci.ExecTxResult { defer metrics.BlockProcessLatency(time.Now(), metrics.SYNCHRONOUS) txResults := []*abci.ExecTxResult{} @@ -1340,6 +1344,43 @@ func (app *App) ProcessBlockSynchronous(ctx sdk.Context, txs [][]byte, typedTxs return txResults } +func (app *App) ProcessTxsSynchronousGiga(ctx sdk.Context, txs [][]byte, typedTxs []sdk.Tx, absoluteTxIndices []int) []*abci.ExecTxResult { + defer metrics.BlockProcessLatency(time.Now(), metrics.SYNCHRONOUS) + + txResults := make([]*abci.ExecTxResult, len(txs)) + for i, tx := range txs { + ctx = ctx.WithTxIndex(absoluteTxIndices[i]) + 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, 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 +} + type ChannelResult struct { txIndex int result *abci.ExecTxResult @@ -1382,12 +1423,16 @@ 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.GigaExecutorEnabled { + results := app.ProcessTxsSynchronousGiga(ctx, txs, typedTxs, absoluteTxIndices) + return results, ctx + } else if !ctx.IsOCCEnabled() { + results := app.ProcessTxsSynchronousV2(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) { @@ -1446,6 +1491,7 @@ func (app *App) ProcessTXsWithOCC(ctx sdk.Context, txs [][]byte, typedTxs []sdk. Codespace: r.Response.Codespace, EvmTxInfo: r.Response.EvmTxInfo, }) + } return execResults, ctx @@ -1481,12 +1527,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.GigaExecutorEnabled { - if app.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.GigaExecutorEnabled && app.GigaOCCEnabled { + return app.ProcessBlockWithGigaExecutorOCC(ctx, txs, req, lastCommit, simulate) } ctx = ctx.WithIsOCCEnabled(app.OccEnabled()) @@ -1549,6 +1592,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() { @@ -1599,23 +1643,26 @@ 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 } evmTxs[i] = evmMsg // Execute EVM transaction through giga executor - result, execErr := app.executeEVMTxWithGigaExecutor(ctx, i, evmMsg) + result, execErr := app.executeEVMTxWithGigaExecutor(ctx, 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 } @@ -1643,7 +1690,7 @@ func (app *App) ProcessBlockWithGigaExecutor(ctx sdk.Context, txs [][]byte, req // executeEVMTxWithGigaExecutor executes a single EVM transaction using the giga executor. // The sender address is recovered directly from the transaction signature - no Cosmos SDK ante handlers needed. -func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, txIndex int, msg *evmtypes.MsgEVMTransaction) (*abci.ExecTxResult, error) { +func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, msg *evmtypes.MsgEVMTransaction) (*abci.ExecTxResult, error) { // Get the Ethereum transaction from the message ethTx, txData := msg.AsTransaction() if ethTx == nil || txData == nil { @@ -1674,7 +1721,6 @@ func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, txIndex int, msg * // Prepare context for EVM transaction (set infinite gas meter like original flow) ctx = ctx.WithGasMeter(sdk.NewInfiniteGasMeterWithMultiplier(ctx)) - ctx = ctx.WithTxIndex(txIndex) // Create state DB for this transaction stateDB := gigaevmstate.NewDBImpl(ctx, &app.GigaEvmKeeper, false) @@ -1696,8 +1742,8 @@ func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, txIndex int, msg * 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.GigaEvmKeeper.EvmoneVM, *blockCtx, stateDB, cfg, vm.Config{}, app.GigaEvmKeeper.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.GigaEvmKeeper.GetBaseFee(ctx), &gp) @@ -1708,6 +1754,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 { @@ -1755,20 +1807,55 @@ func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, txIndex int, msg * // Determine result code based on VM error code := uint32(0) if execResult.Err != nil { - code = 1 + code = sdkerrors.ErrEVMVMError.ABCICode() + } + + // GasWanted should be set to the transaction's gas limit to match standard executor behavior. + // This is critical for LastResultsHash computation which uses Code, Data, GasWanted, and GasUsed. + gasWanted := int64(ethTx.Gas()) //nolint:gosec // G115: safe, Gas() won't exceed int64 max + gasUsed := int64(execResult.UsedGas) //nolint:gosec // G115: safe, UsedGas won't exceed int64 max + + // Build Data field to match standard executor format. + // Standard path wraps MsgEVMTransactionResponse in TxMsgData. + // This is critical for LastResultsHash to match. + evmResponse := &evmtypes.MsgEVMTransactionResponse{ + GasUsed: execResult.UsedGas, + VmError: vmError, + ReturnData: execResult.ReturnData, + Hash: ethTx.Hash().Hex(), + Logs: evmtypes.NewLogsFromEth(stateDB.GetAllLogs()), + } + evmResponseBytes, marshalErr := evmResponse.Marshal() + if marshalErr != nil { + return &abci.ExecTxResult{ + Code: 1, + Log: fmt.Sprintf("failed to marshal evm response: %v", marshalErr), + }, nil } - // Serialize receipt to include in response Data field. - // In OCC mode, transient store writes are lost because the CacheMultiStore - // isn't committed, so we pass the receipt through the response for later processing. - receiptBytes, _ := receipt.Marshal() + // Wrap in TxMsgData like the standard path does + txMsgData := &sdk.TxMsgData{ + Data: []*sdk.MsgData{ + { + MsgType: sdk.MsgTypeURL(msg), + Data: evmResponseBytes, + }, + }, + } + txMsgDataBytes, txMarshalErr := proto.Marshal(txMsgData) + if txMarshalErr != nil { + return &abci.ExecTxResult{ + Code: 1, + Log: fmt.Sprintf("failed to marshal tx msg data: %v", txMarshalErr), + }, nil + } - //nolint:gosec // G115: safe, UsedGas won't exceed int64 max return &abci.ExecTxResult{ - Code: code, - Data: receiptBytes, - GasUsed: int64(execResult.UsedGas), - Log: vmError, + Code: code, + Data: txMsgDataBytes, + GasWanted: gasWanted, + GasUsed: gasUsed, + Log: vmError, EvmTxInfo: &abci.EvmTxInfo{ TxHash: ethTx.Hash().Hex(), VmError: vmError, @@ -1864,19 +1951,22 @@ func (app *App) ProcessBlockWithGigaExecutorOCC(ctx sdk.Context, txs [][]byte, r evmTotalGasUsed += resp.GasUsed // Restore transient store data using main context - if resp.Code == 0 && len(resp.Data) > 0 && evmTxs[idx] != nil { - receipt := &evmtypes.Receipt{} - if err := receipt.Unmarshal(resp.Data); err == nil { - ethTx, _ := evmTxs[idx].AsTransaction() - if ethTx != nil { - txHash := ethTx.Hash() - // Write receipt to transient store using main context - _ = app.EvmKeeper.SetTransientReceipt(ctx.WithTxIndex(idx), txHash, receipt) - // Write deferred info using main context - bloom := ethtypes.Bloom{} - bloom.SetBytes(receipt.LogsBloom) - app.EvmKeeper.AppendToEvmTxDeferredInfo(ctx.WithTxIndex(idx), bloom, txHash, sdk.ZeroInt()) + // In OCC mode, the Data field contains TxMsgData (standard format) for correct LastResultsHash. + // We need to extract the receipt info from the response or reconstruct it. + if resp.Code == 0 && evmTxs[idx] != nil { + ethTx, _ := evmTxs[idx].AsTransaction() + if ethTx != nil { + txHash := ethTx.Hash() + // In OCC mode, the receipt was written during execution but may have been lost. + // We can reconstruct minimal receipt info from the response for deferred processing. + // The full receipt details would need to be fetched from transient store if it exists. + bloom := ethtypes.Bloom{} + // Try to get receipt from transient store (may exist if execution succeeded) + existingReceipt, receiptErr := app.EvmKeeper.GetTransientReceipt(ctx.WithTxIndex(idx), txHash, uint64(idx)) //nolint:gosec // G115: idx is a valid tx index, always non-negative + if receiptErr == nil && existingReceipt != nil { + bloom.SetBytes(existingReceipt.LogsBloom) } + app.EvmKeeper.AppendToEvmTxDeferredInfo(ctx.WithTxIndex(idx), bloom, txHash, sdk.ZeroInt()) } } } @@ -1925,8 +2015,14 @@ func (app *App) gigaDeliverTx(ctx sdk.Context, req abci.RequestDeliverTxV2, tx s return abci.ResponseDeliverTx{Code: 1, Log: "not an EVM transaction"} } - result, err := app.executeEVMTxWithGigaExecutor(ctx, ctx.TxIndex(), evmMsg) + result, err := app.executeEVMTxWithGigaExecutor(ctx, 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)} } diff --git a/giga/executor/precompiles/failfast.go b/giga/executor/precompiles/failfast.go index c0b2e67a87..121e4408cb 100644 --- a/giga/executor/precompiles/failfast.go +++ b/giga/executor/precompiles/failfast.go @@ -1,7 +1,6 @@ package precompiles import ( - "errors" "math/big" "github.com/ethereum/go-ethereum/common" @@ -38,7 +37,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{} diff --git a/giga/executor/utils/errors.go b/giga/executor/utils/errors.go index 18c057776e..cceda092f2 100644 --- a/giga/executor/utils/errors.go +++ b/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 } diff --git a/giga/tests/giga_test.go b/giga/tests/giga_test.go index 12c0590379..b89cb9f83f 100644 --- a/giga/tests/giga_test.go +++ b/giga/tests/giga_test.go @@ -1,6 +1,8 @@ package giga_test import ( + "bytes" + "fmt" "math/big" "testing" "time" @@ -17,6 +19,7 @@ import ( "github.com/sei-protocol/sei-chain/x/evm/types/ethtx" "github.com/stretchr/testify/require" abci "github.com/tendermint/tendermint/abci/types" + "github.com/tendermint/tendermint/crypto/merkle" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" ) @@ -206,6 +209,86 @@ func RunBlock(t testing.TB, tCtx *GigaTestContext, txs [][]byte) ([]abci.Event, return events, results, err } +// ComputeLastResultsHash computes the LastResultsHash from tx results +// This uses the same logic as tendermint: only Code, Data, GasWanted, GasUsed are included +func ComputeLastResultsHash(results []*abci.ExecTxResult) ([]byte, error) { + rs, err := abci.MarshalTxResults(results) + if err != nil { + return nil, err + } + return merkle.HashFromByteSlices(rs), nil +} + +// CompareLastResultsHash compares the LastResultsHash between two result sets +// This is the critical comparison for consensus - if hashes differ, nodes will fork +func CompareLastResultsHash(t *testing.T, testName string, expected, actual []*abci.ExecTxResult) { + expectedHash, err := ComputeLastResultsHash(expected) + require.NoError(t, err, "%s: failed to compute expected LastResultsHash", testName) + + actualHash, err := ComputeLastResultsHash(actual) + require.NoError(t, err, "%s: failed to compute actual LastResultsHash", testName) + + if !bytes.Equal(expectedHash, actualHash) { + // Log detailed info about each tx result's deterministic fields + t.Logf("%s: LastResultsHash MISMATCH!", testName) + t.Logf(" Expected hash: %X", expectedHash) + t.Logf(" Actual hash: %X", actualHash) + + // Log per-tx deterministic fields to help debug + maxLen := len(expected) + if len(actual) > maxLen { + maxLen = len(actual) + } + for i := 0; i < maxLen; i++ { + var expInfo, actInfo string + if i < len(expected) { + expInfo = fmt.Sprintf("Code=%d GasWanted=%d GasUsed=%d DataLen=%d", + expected[i].Code, expected[i].GasWanted, expected[i].GasUsed, len(expected[i].Data)) + } else { + expInfo = "(missing)" + } + if i < len(actual) { + actInfo = fmt.Sprintf("Code=%d GasWanted=%d GasUsed=%d DataLen=%d", + actual[i].Code, actual[i].GasWanted, actual[i].GasUsed, len(actual[i].Data)) + } else { + actInfo = "(missing)" + } + + // Check if this tx differs + differs := "" + if i < len(expected) && i < len(actual) { + if expected[i].Code != actual[i].Code || + expected[i].GasWanted != actual[i].GasWanted || + expected[i].GasUsed != actual[i].GasUsed || + !bytes.Equal(expected[i].Data, actual[i].Data) { + differs = " <-- DIFFERS" + } + } + t.Logf(" tx[%d] expected: %s", i, expInfo) + t.Logf(" tx[%d] actual: %s%s", i, actInfo, differs) + } + } + + require.True(t, bytes.Equal(expectedHash, actualHash), + "%s: LastResultsHash mismatch - expected %X, got %X", testName, expectedHash, actualHash) +} + +// CompareDeterministicFields compares the 4 deterministic fields that go into LastResultsHash +func CompareDeterministicFields(t *testing.T, testName string, expected, actual []*abci.ExecTxResult) { + require.Equal(t, len(expected), len(actual), "%s: result count mismatch", testName) + + for i := range expected { + require.Equal(t, expected[i].Code, actual[i].Code, + "%s: tx[%d] Code mismatch (expected %d, got %d)", testName, i, expected[i].Code, actual[i].Code) + require.Equal(t, expected[i].GasWanted, actual[i].GasWanted, + "%s: tx[%d] GasWanted mismatch (expected %d, got %d)", testName, i, expected[i].GasWanted, actual[i].GasWanted) + require.Equal(t, expected[i].GasUsed, actual[i].GasUsed, + "%s: tx[%d] GasUsed mismatch (expected %d, got %d)", testName, i, expected[i].GasUsed, actual[i].GasUsed) + require.True(t, bytes.Equal(expected[i].Data, actual[i].Data), + "%s: tx[%d] Data mismatch (expected len=%d, got len=%d)", testName, i, len(expected[i].Data), len(actual[i].Data)) + } +} + // CompareResults compares execution results between two runs func CompareResults(t *testing.T, testName string, expected, actual []*abci.ExecTxResult) { compareResultsWithOptions(t, testName, expected, actual, true) @@ -810,3 +893,217 @@ func TestAllModes_ContractExecution(t *testing.T) { t.Logf("Contract deployment and calls produced identical results across all three executor modes") } + +// ============================================================================ +// LastResultsHash Consistency Tests +// These tests verify that the deterministic fields (Code, Data, GasWanted, GasUsed) +// that go into LastResultsHash are identical between executor modes. +// This is critical for consensus - mismatches cause chain forks. +// ============================================================================ + +// TestLastResultsHash_GigaVsGeth_SimpleTransfer verifies LastResultsHash matches for simple transfers +func TestLastResultsHash_GigaVsGeth_SimpleTransfer(t *testing.T) { + blockTime := time.Now() + accts := utils.NewTestAccounts(5) + txCount := 5 + + transfers := GenerateNonConflictingTransfers(txCount) + + // Run with Geth (baseline) + gethCtx := NewGigaTestContext(t, accts, blockTime, 1, ModeV2withOCC) + gethTxs := CreateEVMTransferTxs(t, gethCtx, transfers) + _, gethResults, gethErr := RunBlock(t, gethCtx, gethTxs) + require.NoError(t, gethErr, "Geth execution failed") + + // Run with Giga Sequential + gigaCtx := NewGigaTestContext(t, accts, blockTime, 1, ModeGigaSequential) + gigaTxs := CreateEVMTransferTxs(t, gigaCtx, transfers) + _, gigaResults, gigaErr := RunBlock(t, gigaCtx, gigaTxs) + require.NoError(t, gigaErr, "Giga execution failed") + + // Verify all transactions succeeded + for i, result := range gethResults { + require.Equal(t, uint32(0), result.Code, "Geth tx[%d] failed: %s", i, result.Log) + } + for i, result := range gigaResults { + require.Equal(t, uint32(0), result.Code, "Giga tx[%d] failed: %s", i, result.Log) + } + + // Compare LastResultsHash - this is the critical consensus check + CompareLastResultsHash(t, "LastResultsHash_GigaVsGeth_SimpleTransfer", gethResults, gigaResults) + + // Also compare individual deterministic fields for detailed debugging + CompareDeterministicFields(t, "DeterministicFields_GigaVsGeth_SimpleTransfer", gethResults, gigaResults) + + gethHash, _ := ComputeLastResultsHash(gethResults) + gigaHash, _ := ComputeLastResultsHash(gigaResults) + t.Logf("LastResultsHash verified identical: %X", gethHash) + t.Logf("Geth hash: %X", gethHash) + t.Logf("Giga hash: %X", gigaHash) +} + +// TestLastResultsHash_GigaVsGeth_ContractDeploy verifies LastResultsHash for contract deployment +func TestLastResultsHash_GigaVsGeth_ContractDeploy(t *testing.T) { + blockTime := time.Now() + accts := utils.NewTestAccounts(5) + + deployer := utils.NewSigner() + + // Run with Geth + gethCtx := NewGigaTestContext(t, accts, blockTime, 1, ModeV2withOCC) + gethTxs := CreateContractDeployTxs(t, gethCtx, []EVMContractDeploy{ + {Signer: deployer, Bytecode: simpleStorageBytecode, Nonce: 0}, + }) + _, gethResults, gethErr := RunBlock(t, gethCtx, gethTxs) + require.NoError(t, gethErr) + require.Equal(t, uint32(0), gethResults[0].Code, "Geth deploy failed: %s", gethResults[0].Log) + + // Run with Giga + gigaCtx := NewGigaTestContext(t, accts, blockTime, 1, ModeGigaSequential) + gigaTxs := CreateContractDeployTxs(t, gigaCtx, []EVMContractDeploy{ + {Signer: deployer, Bytecode: simpleStorageBytecode, Nonce: 0}, + }) + _, gigaResults, gigaErr := RunBlock(t, gigaCtx, gigaTxs) + require.NoError(t, gigaErr) + require.Equal(t, uint32(0), gigaResults[0].Code, "Giga deploy failed: %s", gigaResults[0].Log) + + // Compare LastResultsHash + CompareLastResultsHash(t, "LastResultsHash_GigaVsGeth_ContractDeploy", gethResults, gigaResults) + + gethHash, _ := ComputeLastResultsHash(gethResults) + t.Logf("Contract deploy LastResultsHash verified identical: %X", gethHash) +} + +// TestLastResultsHash_GigaVsGeth_ContractCall verifies LastResultsHash for contract calls +func TestLastResultsHash_GigaVsGeth_ContractCall(t *testing.T) { + blockTime := time.Now() + accts := utils.NewTestAccounts(5) + + deployer := utils.NewSigner() + caller := utils.NewSigner() + contractAddr := crypto.CreateAddress(deployer.EvmAddress, 0) + + // Run with Geth: deploy + call + gethCtx := NewGigaTestContext(t, accts, blockTime, 1, ModeV2withOCC) + gethDeployTxs := CreateContractDeployTxs(t, gethCtx, []EVMContractDeploy{ + {Signer: deployer, Bytecode: simpleStorageBytecode, Nonce: 0}, + }) + gethCallTxs := CreateContractCallTxs(t, gethCtx, []EVMContractCall{ + {Signer: caller, Contract: contractAddr, Data: encodeSetCall(big.NewInt(42)), Nonce: 0}, + }) + allGethTxs := append(gethDeployTxs, gethCallTxs...) + _, gethResults, gethErr := RunBlock(t, gethCtx, allGethTxs) + require.NoError(t, gethErr) + require.Equal(t, uint32(0), gethResults[0].Code, "Geth deploy failed: %s", gethResults[0].Log) + require.Equal(t, uint32(0), gethResults[1].Code, "Geth call failed: %s", gethResults[1].Log) + + // Run with Giga: deploy + call + gigaCtx := NewGigaTestContext(t, accts, blockTime, 1, ModeGigaSequential) + gigaDeployTxs := CreateContractDeployTxs(t, gigaCtx, []EVMContractDeploy{ + {Signer: deployer, Bytecode: simpleStorageBytecode, Nonce: 0}, + }) + gigaCallTxs := CreateContractCallTxs(t, gigaCtx, []EVMContractCall{ + {Signer: caller, Contract: contractAddr, Data: encodeSetCall(big.NewInt(42)), Nonce: 0}, + }) + allGigaTxs := append(gigaDeployTxs, gigaCallTxs...) + _, gigaResults, gigaErr := RunBlock(t, gigaCtx, allGigaTxs) + require.NoError(t, gigaErr) + require.Equal(t, uint32(0), gigaResults[0].Code, "Giga deploy failed: %s", gigaResults[0].Log) + require.Equal(t, uint32(0), gigaResults[1].Code, "Giga call failed: %s", gigaResults[1].Log) + + // Compare LastResultsHash + CompareLastResultsHash(t, "LastResultsHash_GigaVsGeth_ContractCall", gethResults, gigaResults) + + gethHash, _ := ComputeLastResultsHash(gethResults) + t.Logf("Contract call LastResultsHash verified identical: %X", gethHash) +} + +// TestLastResultsHash_AllModes verifies LastResultsHash is identical across all executor modes +func TestLastResultsHash_AllModes(t *testing.T) { + blockTime := time.Now() + accts := utils.NewTestAccounts(5) + txCount := 10 + workers := 4 + + transfers := GenerateNonConflictingTransfers(txCount) + + // Geth with OCC (standard production path) + gethCtx := NewGigaTestContext(t, accts, blockTime, workers, ModeV2withOCC) + gethTxs := CreateEVMTransferTxs(t, gethCtx, transfers) + _, gethResults, err := RunBlock(t, gethCtx, gethTxs) + require.NoError(t, err) + + // Giga Sequential + gigaSeqCtx := NewGigaTestContext(t, accts, blockTime, 1, ModeGigaSequential) + gigaSeqTxs := CreateEVMTransferTxs(t, gigaSeqCtx, transfers) + _, gigaSeqResults, err := RunBlock(t, gigaSeqCtx, gigaSeqTxs) + require.NoError(t, err) + + // Giga OCC + gigaOCCCtx := NewGigaTestContext(t, accts, blockTime, workers, ModeGigaOCC) + gigaOCCTxs := CreateEVMTransferTxs(t, gigaOCCCtx, transfers) + _, gigaOCCResults, err := RunBlock(t, gigaOCCCtx, gigaOCCTxs) + require.NoError(t, err) + + // Verify all transactions succeeded + for i := range gethResults { + require.Equal(t, uint32(0), gethResults[i].Code, "Geth tx[%d] failed", i) + require.Equal(t, uint32(0), gigaSeqResults[i].Code, "GigaSeq tx[%d] failed", i) + require.Equal(t, uint32(0), gigaOCCResults[i].Code, "GigaOCC tx[%d] failed", i) + } + + // Compare LastResultsHash across all modes + CompareLastResultsHash(t, "Geth vs GigaSequential", gethResults, gigaSeqResults) + CompareLastResultsHash(t, "GigaSequential vs GigaOCC", gigaSeqResults, gigaOCCResults) + CompareLastResultsHash(t, "Geth vs GigaOCC", gethResults, gigaOCCResults) + + gethHash, _ := ComputeLastResultsHash(gethResults) + gigaSeqHash, _ := ComputeLastResultsHash(gigaSeqResults) + gigaOCCHash, _ := ComputeLastResultsHash(gigaOCCResults) + + t.Logf("LastResultsHash verified identical across all 3 executor modes:") + t.Logf(" Geth+OCC: %X", gethHash) + t.Logf(" Giga Sequential: %X", gigaSeqHash) + t.Logf(" Giga+OCC: %X", gigaOCCHash) +} + +// TestLastResultsHash_DeterministicFieldsLogged logs the deterministic fields for manual inspection +// This is useful for debugging when hashes don't match +func TestLastResultsHash_DeterministicFieldsLogged(t *testing.T) { + blockTime := time.Now() + accts := utils.NewTestAccounts(5) + + // Single simple transfer for easy inspection + transfers := GenerateNonConflictingTransfers(1) + + // Run with Geth + gethCtx := NewGigaTestContext(t, accts, blockTime, 1, ModeV2withOCC) + gethTxs := CreateEVMTransferTxs(t, gethCtx, transfers) + _, gethResults, _ := RunBlock(t, gethCtx, gethTxs) + + // Run with Giga + gigaCtx := NewGigaTestContext(t, accts, blockTime, 1, ModeGigaSequential) + gigaTxs := CreateEVMTransferTxs(t, gigaCtx, transfers) + _, gigaResults, _ := RunBlock(t, gigaCtx, gigaTxs) + + // Log the deterministic fields for inspection + t.Log("=== Geth Result ===") + for i, r := range gethResults { + t.Logf("tx[%d]: Code=%d GasWanted=%d GasUsed=%d DataLen=%d Data=%X", + i, r.Code, r.GasWanted, r.GasUsed, len(r.Data), r.Data) + } + + t.Log("=== Giga Result ===") + for i, r := range gigaResults { + t.Logf("tx[%d]: Code=%d GasWanted=%d GasUsed=%d DataLen=%d Data=%X", + i, r.Code, r.GasWanted, r.GasUsed, len(r.Data), r.Data) + } + + gethHash, _ := ComputeLastResultsHash(gethResults) + gigaHash, _ := ComputeLastResultsHash(gigaResults) + t.Logf("Geth LastResultsHash: %X", gethHash) + t.Logf("Giga LastResultsHash: %X", gigaHash) + + // Still verify they match + CompareLastResultsHash(t, "DeterministicFieldsLogged", gethResults, gigaResults) +} diff --git a/go.mod b/go.mod index a78cc97314..993d78468c 100644 --- a/go.mod +++ b/go.mod @@ -361,7 +361,7 @@ replace ( github.com/btcsuite/btcd => github.com/btcsuite/btcd v0.23.2 github.com/confio/ics23/go => github.com/cosmos/cosmos-sdk/ics23/go v0.8.0 github.com/cosmos/cosmos-sdk => ./sei-cosmos - github.com/ethereum/go-ethereum => github.com/sei-protocol/go-ethereum v1.15.7-sei-15 + github.com/ethereum/go-ethereum => github.com/sei-protocol/go-ethereum v1.15.7-sei-16 github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1 // Latest goleveldb is broken, we have to stick to this version github.com/syndtr/goleveldb => github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 diff --git a/go.sum b/go.sum index a01d843507..c3efbc3b9d 100644 --- a/go.sum +++ b/go.sum @@ -1943,8 +1943,8 @@ github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg github.com/securego/gosec/v2 v2.13.1 h1:7mU32qn2dyC81MH9L2kefnQyRMUarfDER3iQyMHcjYM= github.com/securego/gosec/v2 v2.13.1/go.mod h1:EO1sImBMBWFjOTFzMWfTRrZW6M15gm60ljzrmy/wtHo= github.com/segmentio/fasthash v1.0.3/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY= -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.7-sei-16 h1:MUvhmn5acNwS/9smQ19gdl6Qh3cNjukTQzz4u8GiUHs= +github.com/sei-protocol/go-ethereum v1.15.7-sei-16/go.mod h1:+S9k+jFzlyVTNcYGvqFhzN/SFhI6vA+aOY4T5tLSPL0= 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-load v0.0.0-20251007135253-78fbdc141082 h1:f2sY8OcN60UL1/6POx+HDMZ4w04FTZtSScnrFSnGZHg= diff --git a/go.work.sum b/go.work.sum index 2aaacdf66c..23e7ca331b 100644 --- a/go.work.sum +++ b/go.work.sum @@ -61,7 +61,6 @@ cloud.google.com/go/gkebackup v1.6.2/go.mod h1:WsTSWqKJkGan1pkp5dS30oxb+Eaa6cLvx cloud.google.com/go/gkeconnect v0.12.0/go.mod h1:zn37LsFiNZxPN4iO7YbUk8l/E14pAJ7KxpoXoxt7Ly0= cloud.google.com/go/gkehub v0.15.2/go.mod h1:8YziTOpwbM8LM3r9cHaOMy2rNgJHXZCrrmGgcau9zbQ= cloud.google.com/go/gkemulticloud v1.4.1/go.mod h1:KRvPYcx53bztNwNInrezdfNF+wwUom8Y3FuJBwhvFpQ= -cloud.google.com/go/grafeas v0.3.11/go.mod h1:dcQyG2+T4tBgG0MvJAh7g2wl/xHV2w+RZIqivwuLjNg= cloud.google.com/go/gsuiteaddons v1.7.2/go.mod h1:GD32J2rN/4APilqZw4JKmwV84+jowYYMkEVwQEYuAWc= cloud.google.com/go/iam v1.2.2/go.mod h1:0Ys8ccaZHdI1dEUilwzqng/6ps2YB6vRsjIe00/+6JY= cloud.google.com/go/iap v1.10.2/go.mod h1:cClgtI09VIfazEK6VMJr6bX8KQfuQ/D3xqX+d0wrUlI= @@ -124,123 +123,50 @@ cloud.google.com/go/vpcaccess v1.8.2/go.mod h1:4yvYKNjlNjvk/ffgZ0PuEhpzNJb8HybSM cloud.google.com/go/webrisk v1.10.2/go.mod h1:c0ODT2+CuKCYjaeHO7b0ni4CUrJ95ScP5UFl9061Qq8= cloud.google.com/go/websecurityscanner v1.7.2/go.mod h1:728wF9yz2VCErfBaACA5px2XSYHQgkK812NmHcUsDXA= cloud.google.com/go/workflows v1.13.2/go.mod h1:l5Wj2Eibqba4BsADIRzPLaevLmIuYF2W+wfFBkRG3vU= -crawshaw.io/sqlite v0.3.3-0.20220618202545-d1964889ea3c/go.mod h1:igAO5JulrQ1DbdZdtVq48mnZUBAPOeFzer7VhDWNtW4= github.com/BurntSushi/toml v0.4.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= github.com/BurntSushi/toml v1.2.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= -github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp v1.5.0/go.mod h1:dppbR7CwXD4pgtV9t3wD1812RaLDcBjtblcDF5f1vI0= github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.25.0/go.mod h1:obipzmGjfSjam60XLwGfqUkJsfiheAl+TUjG+4yzyPM= github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.48.1/go.mod h1:jyqM3eLpJ3IbIFDTKVz2rF9T/xWGW0rIriGwnz8l9Tk= -github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0.48.1/go.mod h1:0wEl7vrAD8mehJyohS9HZy+WyEOaQO2mJx86Cvh93kM= github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.48.1/go.mod h1:viRWSEhtMZqz1rhwmOVKkWl6SwmVowfL9O2YR5gI2PE= -github.com/RoaringBitmap/roaring v1.2.2/go.mod h1:plvDsJQpxOC5bw8LRteu/MLWHsHez/3y6cubLI4/1yE= -github.com/VictoriaMetrics/metrics v1.23.1/go.mod h1:rAr/llLpEnAdTehiNlUxKgnjcOuROSzpw0GvjpEbvFc= -github.com/ajwerner/btree v0.0.0-20211221152037-f427b3e689c0/go.mod h1:q37NoqncT41qKc048STsifIt69LfUJ8SrWWcz/yam5k= -github.com/alecthomas/atomic v0.1.0-alpha2/go.mod h1:zD6QGEyw49HIq19caJDc2NMXAy8rNi9ROrxtMXATfyI= github.com/alecthomas/kingpin/v2 v2.4.0/go.mod h1:0gyi0zQnjuFk8xrkNKamJoyUo382HRL7ATRpFZCw6tE= github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137/go.mod h1:OMCwj8VM1Kc9e19TLln2VL61YJF0x1XFtfdL4JdbSyE= -github.com/anacrolix/chansync v0.3.0/go.mod h1:DZsatdsdXxD0WiwcGl0nJVwyjCKMDv+knl1q2iBjA2k= -github.com/anacrolix/dht/v2 v2.19.2-0.20221121215055-066ad8494444/go.mod h1:MctKM1HS5YYDb3F30NGJxLE+QPuqWoT5ReW/4jt8xew= -github.com/anacrolix/envpprof v1.2.1/go.mod h1:My7T5oSqVfEn4MD4Meczkw/f5lSIndGAKu/0SM/rkf4= -github.com/anacrolix/generics v0.0.0-20220618083756-f99e35403a60/go.mod h1:ff2rHB/joTV03aMSSn/AZNnaIpUw0h3njetGsaXcMy8= -github.com/anacrolix/go-libutp v1.2.0/go.mod h1:RrJ3KcaDcf9Jqp33YL5V/5CBEc6xMc7aJL8wXfuWL50= -github.com/anacrolix/log v0.13.2-0.20221123232138-02e2764801c3/go.mod h1:MD4fn2pYcyhUAQg9SxoGOpTnV/VIdiKVYKZdCbDC97k= -github.com/anacrolix/missinggo v1.3.0/go.mod h1:bqHm8cE8xr+15uVfMG3BFui/TxyB6//H5fwlq/TeqMc= -github.com/anacrolix/missinggo/perf v1.0.0/go.mod h1:ljAFWkBuzkO12MQclXzZrosP5urunoLS0Cbvb4V0uMQ= -github.com/anacrolix/missinggo/v2 v2.7.0/go.mod h1:2IZIvmRTizALNYFYXsPR7ofXPzJgyBpKZ4kMqMEICkI= -github.com/anacrolix/mmsg v1.0.0/go.mod h1:x8kRaJY/dCrY9Al0PEcj1mb/uFHwP6GCJ9fLl4thEPc= -github.com/anacrolix/multiless v0.3.0/go.mod h1:TrCLEZfIDbMVfLoQt5tOoiBS/uq4y8+ojuEVVvTNPX4= -github.com/anacrolix/stm v0.4.0/go.mod h1:GCkwqWoAsP7RfLW+jw+Z0ovrt2OO7wRzcTtFYMYY5t8= -github.com/anacrolix/sync v0.4.0/go.mod h1:BbecHL6jDSExojhNtgTFSBcdGerzNc64tz3DCOj/I0g= -github.com/anacrolix/torrent v1.48.0/go.mod h1:3UtkJ8BnxXDRwvk+eT+uwiZalfFJ8YzAhvxe4QRPSJI= -github.com/anacrolix/upnp v0.1.3-0.20220123035249-922794e51c96/go.mod h1:Wa6n8cYIdaG35x15aH3Zy6d03f7P728QfdcDeD/IEOs= -github.com/anacrolix/utp v0.1.0/go.mod h1:MDwc+vsGEq7RMw6lr2GKOEqjWny5hO5OZXRVNaBJ2Dk= github.com/andybalholm/brotli v1.0.2/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y= github.com/andybalholm/brotli v1.0.3/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig= -github.com/apache/arrow/go/v15 v15.0.2/go.mod h1:DGXsR3ajT524njufqf95822i+KTh+yea1jass9YXgjA= -github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.8.1/go.mod h1:CM+19rL1+4dFWnOQKwDc7H1KwXTz+h61oUSHyhV0b3o= -github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg= github.com/bazelbuild/rules_go v0.49.0/go.mod h1:Dhcz716Kqg1RHNWos+N6MlXNkjNP2EwZQ0LukRKJfMs= -github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8/go.mod h1:spo1JLcs67NmW1aVLEgtA8Yy1elc+X8y5SRW1sFW4Og= -github.com/c2h5oh/datasize v0.0.0-20220606134207-859f65c6625b/go.mod h1:S/7n9copUssQ56c7aAgHqftWO4LTf4xY6CGWt8Bc+3M= -github.com/casbin/casbin/v2 v2.37.0/go.mod h1:vByNa/Fchek0KZUgG5wEsl7iFsiviAYKRtgrQfcJqHg= -github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw= -github.com/clbanning/mxj v1.8.4/go.mod h1:BVjHeAH+rl9rs6f+QIpeRl0tfu10SXn1pUSa5PVGJng= github.com/cncf/xds/go v0.0.0-20211130200136-a8f946100490/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20240423153145-555b57ec207b/go.mod h1:W+zGtBO5Y1IgJhy4+A9GOqVhqLpfZi+vwmdNXUehLA8= github.com/cncf/xds/go v0.0.0-20240905190251-b4127c9b8d78/go.mod h1:W+zGtBO5Y1IgJhy4+A9GOqVhqLpfZi+vwmdNXUehLA8= -github.com/consensys/bavard v0.1.31-0.20250406004941-2db259e4b582/go.mod h1:k/zVjHHC4B+PQy1Pg7fgvG3ALicQw540Crag8qx+dZs= github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk= -github.com/crate-crypto/go-eth-kzg v1.3.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI= -github.com/creachadair/command v0.0.0-20220426235536-a748effdf6a1/go.mod h1:bAM+qFQb/KwWyCc9MLC4U1jvn3XyakqP5QRkds5T6cY= -github.com/edsrzf/mmap-go v1.1.0/go.mod h1:19H/e8pUPLicwkyNgOykDXkJ9F0MHE+Z52B8EIth78Q= github.com/envoyproxy/go-control-plane v0.10.1/go.mod h1:AY7fTTXNdv/aJ2O5jwpxAPOWUZ7hQAEvzN5Pf27BkQQ= github.com/envoyproxy/go-control-plane v0.13.1/go.mod h1:X45hY0mufo6Fd0KW3rqsGvQMw58jvjymeCzBU3mWyHw= github.com/envoyproxy/protoc-gen-validate v0.6.2/go.mod h1:2t7qjJNvHPx8IjnBOzl9E9/baC+qXE/TeeyBRzgJDws= github.com/envoyproxy/protoc-gen-validate v1.0.4/go.mod h1:qys6tmnRsYrQqIhm2bvKZH4Blx/1gTIZ2UKVY1M+Yew= github.com/envoyproxy/protoc-gen-validate v1.1.0/go.mod h1:sXRDRVmzEbkM7CVcM06s9shE/m23dg3wzjl0UWqJ2q4= -github.com/ethereum/c-kzg-4844/v2 v2.1.1/go.mod h1:TC48kOKjJKPbN7C++qIgt0TJzZ70QznYR7Ob+WXl57E= github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= -github.com/go-zookeeper/zk v1.0.2/go.mod h1:nOB03cncLtlp4t+UAkGSV+9beXP/akpekBwL+UX1Qcw= github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= github.com/google/btree v1.0.1/go.mod h1:xXMiIv4Fb/0kKde4SpL7qlzvu5cMJDRkFDxJfI9uaxA= -github.com/google/go-pkcs11 v0.3.0/go.mod h1:6eQoGcuNJpa7jnd5pMGdkSaQpNDYvPlXWMcjXXThLlY= -github.com/google/martian/v3 v3.3.3/go.mod h1:iEPrYcgCF7jA9OtScMFQyAlZZ4YXTKEtJ1E6RWzmBA0= github.com/google/s2a-go v0.1.8/go.mod h1:6iNWHTpQ+nfNRN5E00MSdfDwVesa8hhS32PhPO8deJA= -github.com/googleapis/cloud-bigtable-clients-test v0.0.2/go.mod h1:mk3CrkrouRgtnhID6UZQDK3DrFFa7cYCAJcEmNsHYrY= github.com/googleapis/enterprise-certificate-proxy v0.3.4/go.mod h1:YKe7cfqYXjKGpGvmSg28/fFvhNzinZQm8DGnaburhGA= github.com/googleapis/gax-go/v2 v2.14.1/go.mod h1:Hb/NubMaVM88SrNkvl8X/o8XWwDJEPqouaLeN2IUxoA= github.com/gookit/color v1.5.1/go.mod h1:wZFzea4X8qN6vHOSP2apMb4/+w/orMznEzYsIHPaqKM= github.com/gostaticanalysis/analysisutil v0.4.1/go.mod h1:18U/DLpRgIUd459wGxVHE0fRgmo1UgHDcbw7F5idXu0= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0/go.mod h1:YN5jB8ie0yfIUg6VvR9Kz84aCaG7AsGZnLjhHbUqwPg= github.com/hashicorp/consul/api v1.11.0/go.mod h1:XjsvQN+RJGWI2TWy1/kqaE16HrR2J/FWgkYjdZQsX9M= github.com/hashicorp/go-hclog v1.0.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= github.com/hashicorp/mdns v1.0.1/go.mod h1:4gW7WsVCke5TE7EPeYliwHlRUyBtfCwuFwuMg2DmyNY= github.com/hashicorp/memberlist v0.2.2/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE= github.com/hashicorp/serf v0.9.5/go.mod h1:UWDWwZeL5cuWDJdl0C6wrvrUwEqtQ4ZKBKKENpqIUyk= -github.com/huandu/xstrings v1.3.2/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= -github.com/hudl/fargo v1.4.0/go.mod h1:9Ai6uvFy5fQNq6VPKtg+Ceq1+eTY4nKUlR2JElEOcDo= github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/inconshreveable/mousetrap v1.0.1/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/josharian/txtarfs v0.0.0-20210218200122-0702f000015a/go.mod h1:izVPOvVRsHiKkeGCT6tYBNWyDVuzj9wAaBb5R9qamfw= github.com/klauspost/compress v1.13.4/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg= github.com/klauspost/compress v1.13.5/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk= -github.com/ledgerwatch/interfaces v0.0.0-20230210062155-539b8171d9f0/go.mod h1:ugQv1QllJzBny3cKZKxUrSnykkjkBgm27eQM6dnGAcc= -github.com/ledgerwatch/log/v3 v3.7.0/go.mod h1:J2Jl6zV/58LeA6LTaVVnCGyf1/cYYSEOOLHY4ZN8S2A= -github.com/ledgerwatch/secp256k1 v1.0.0/go.mod h1:SPmqJFciiF/Q0mPt2jVs2dTr/1TZBTIA+kPMmKgBAak= -github.com/ledgerwatch/trackerslist v1.0.0/go.mod h1:pCC+eEw8izNcnBBiSwvIq8kKsxDLInAafSW275jqFrg= -github.com/lispad/go-generics-tools v1.1.0/go.mod h1:2csd1EJljo/gy5qG4khXol7ivCPptNjG5Uv2X8MgK84= github.com/lyft/protoc-gen-star v0.5.3/go.mod h1:V0xaHgaf5oCCqmcxYcWiDfTiKsZsRc87/1qhoTACD8w= github.com/lyft/protoc-gen-star/v2 v2.0.4-0.20230330145011-496ad1ac90a4/go.mod h1:amey7yeodaJhXSbf/TlLvWiqQfLOSpEk//mLlc+axEk= -github.com/magefile/mage v1.14.0/go.mod h1:z5UZb/iS3GoOSn0JgWuiw7dxlurVYTu+/jHXqQg881A= -github.com/matryer/moq v0.3.0/go.mod h1:RJ75ZZZD71hejp39j4crZLsEDszGk6iH4v4YsWFKH4s= github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= -github.com/miekg/dns v1.1.43/go.mod h1:+evo5L0630/F6ca/Z9+GAqzhjGyn8/c+TBaOyfEl0V4= github.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg= -github.com/mschoch/smat v0.2.0/go.mod h1:kc9mz7DoBKqDyiRL7VZN8KvXQMWeTaVnttLRXOlotKw= -github.com/oklog/ulid/v2 v2.0.2/go.mod h1:mtBL0Qe/0HAx6/a4Z30qxVIAL1eQDweXq5lxOEiwQ68= github.com/onsi/gomega v1.20.0/go.mod h1:DtrZpjmvpn2mPm4YWQa0/ALMDj9v4YxLgojwPeREyVo= -github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= -github.com/openzipkin/zipkin-go v0.2.5/go.mod h1:KpXfKdgRDnnhsxw4pNIH9Md5lyFqKUa4YDFlwRYAMyE= -github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58/go.mod h1:DXv8WO4yhMYhSNPKjeNKa5WY9YCIEBRbNzFFPJbWO6Y= -github.com/performancecopilot/speed/v4 v4.0.0/go.mod h1:qxrSyuDGrTOWfV+uKRFhfxw6h/4HXRGUiZiufxo49BM= -github.com/pierrec/lz4/v4 v4.1.18/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= -github.com/pion/datachannel v1.5.2/go.mod h1:FTGQWaHrdCwIJ1rw6xBIfZVkslikjShim5yr05XFuCQ= -github.com/pion/ice/v2 v2.2.6/go.mod h1:SWuHiOGP17lGromHTFadUe1EuPgFh/oCU6FCMZHooVE= -github.com/pion/interceptor v0.1.11/go.mod h1:tbtKjZY14awXd7Bq0mmWvgtHB5MDaRN7HV3OZ/uy7s8= -github.com/pion/mdns v0.0.5/go.mod h1:UgssrvdD3mxpi8tMxAXbsppL3vJ4Jipw1mTCW+al01g= -github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8= -github.com/pion/rtcp v1.2.9/go.mod h1:qVPhiCzAm4D/rxb6XzKeyZiQK69yJpbUDJSF7TgrqNo= -github.com/pion/rtp v1.7.13/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko= -github.com/pion/sctp v1.8.2/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s= -github.com/pion/sdp/v3 v3.0.5/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw= -github.com/pion/srtp/v2 v2.0.9/go.mod h1:5TtM9yw6lsH0ppNCehB/EjEUli7VkUgKSPJqWVqbhQ4= github.com/pion/stun v0.3.5 h1:uLUCBCkQby4S1cf6CGuR9QrVOKcvUwFeemaC865QHDg= -github.com/pion/stun v0.3.5/go.mod h1:gDMim+47EeEtfWogA37n6qXZS88L5V6LqFcf+DZA2UA= github.com/pion/transport v0.13.1 h1:/UH5yLeQtwm2VZIPjxwnNFxjS4DFhyLfS4GlfuKUzfA= -github.com/pion/transport v0.13.1/go.mod h1:EBxbqzyv+ZrmDb82XswEE0BjfQFtuw1Nu6sjnjWCsGg= -github.com/pion/turn/v2 v2.0.8/go.mod h1:+y7xl719J8bAEVpSXBXvTxStjJv3hbz9YFflvkpcGPw= -github.com/pion/udp v0.1.1/go.mod h1:6AFo+CMdKQm7UiA0eUPA8/eVCTx8jBIITLZHc9DWX5M= -github.com/pion/webrtc/v3 v3.1.42/go.mod h1:ffD9DulDrPxyWvDPUIPAOSAWx9GUlOExiJPf7cCcMLA= github.com/pkg/sftp v1.13.7/go.mod h1:KMKI0t3T6hfA+lTR/ssZdunHo+uwq7ghoN09/FSu3DY= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/prometheus/client_golang v1.20.4/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE= @@ -248,46 +174,32 @@ github.com/prometheus/client_model v0.6.0/go.mod h1:NTQHnmxFpouOD0DpvP4XujX3CdOA github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is= github.com/quasilyte/go-ruleguard/dsl v0.3.22/go.mod h1:KeCP03KrjuSO0H1kTuZQCWlQPulDV6YMIXmpQss17rU= -github.com/remyoudompheng/go-dbus v0.0.0-20121104212943-b7232d34b1d5/go.mod h1:+u151txRmLpwxBmpYn9z3d1sdJdjRPQpsXuYeY9jNls= -github.com/remyoudompheng/go-liblzma v0.0.0-20190506200333-81bf2d431b96/go.mod h1:90HvCY7+oHHUKkbeMCiHt1WuFR2/hPJ9QrljDG+v6ls= -github.com/remyoudompheng/go-misc v0.0.0-20190427085024-2d6ac652a50e/go.mod h1:80FQABjoFzZ2M5uEa6FUaJYEmqU2UOKojlFVak1UAwI= github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= -github.com/rs/dnscache v0.0.0-20211102005908-e0241e321417/go.mod h1:qe5TWALJ8/a1Lqznoc5BDHpYX/8HU60Hm2AwRmqzxqA= github.com/russross/blackfriday v1.5.2 h1:HyvC0ARfnZBqnXwABFeSZHpKvJHJJfPz81GNueLj0oo= github.com/sagikazarmark/crypt v0.3.0/go.mod h1:uD/D+6UF4SrIR1uGEv7bBNkNqLGqUr43MRiaGWX1Nig= -github.com/sagikazarmark/crypt v0.6.0/go.mod h1:U8+INwJo3nBv1m6A/8OBXAq7Jnpspk5AxSgDyEQcea8= +github.com/sei-protocol/go-ethereum v1.15.7-sei-16 h1:MUvhmn5acNwS/9smQ19gdl6Qh3cNjukTQzz4u8GiUHs= +github.com/sei-protocol/go-ethereum v1.15.7-sei-16/go.mod h1:+S9k+jFzlyVTNcYGvqFhzN/SFhI6vA+aOY4T5tLSPL0= github.com/shirou/gopsutil/v3 v3.22.9/go.mod h1:bBYl1kjgEJpWpxeHmLI+dVHWtyAwfcmSBLDsp2TNT8A= github.com/spf13/afero v1.10.0/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ= github.com/spf13/cobra v1.3.0/go.mod h1:BrRVncBjOJa/eUcVVm9CE+oC6as8k+VYr4NY7WCi9V4= github.com/spf13/cobra v1.6.0/go.mod h1:IOw/AERYS7UzyrGinqmz6HLUo219MORXGxhbaJUqzrY= github.com/spf13/viper v1.10.0/go.mod h1:SoyBPwAtKDzypXNDFKN5kzH7ppppbGZtls1UpIy5AsM= -github.com/streadway/amqp v1.0.0/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= -github.com/streadway/handy v0.0.0-20200128134331-0f66f006fb2e/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI= github.com/stretchr/testify v1.7.5/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/subosito/gotenv v1.4.1/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0= github.com/tklauser/go-sysconf v0.3.10/go.mod h1:C8XykCvCb+Gn0oNCWPIlcb0RuglQTYaQ2hGm7jmxEFk= github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hMwiKKqXCQ= -github.com/torquem-ch/mdbx-go v0.27.5/go.mod h1:T2fsoJDVppxfAPTLd1svUgH1kpPmeXdPESmroSHcL1E= github.com/urfave/cli v1.22.1 h1:+mkCCcOFKPnCmVYVcURKps1Xe+3zP90gSYGNfRkjoIY= github.com/valyala/fasthttp v1.30.0/go.mod h1:2rsYD01CKFrjjsvFxx75KlEUNpWNBY9JWD3K/7o2Cus= -github.com/valyala/fastrand v1.1.0/go.mod h1:HWqCzkrkg6QXT8V2EXWvXCoow7vLwOFN002oeRzjapQ= -github.com/valyala/histogram v1.2.0/go.mod h1:Hb4kBwb4UxsaNbbbh+RRz8ZR6pdodR57tzWUS3BUzXY= github.com/valyala/quicktemplate v1.7.0/go.mod h1:sqKJnoaOF88V07vkO+9FL8fb9uZg/VPSJnLYn+LmLk8= github.com/xhit/go-str2duration/v2 v2.1.0/go.mod h1:ohY8p+0f07DiV6Em5LKB0s2YpLtXVyJfNt1+BlmyAsU= -go.einride.tech/aip v0.68.0/go.mod h1:7y9FF8VtPWqpxuAxl0KQWqaULxW4zFIesD6zF5RIHHg= go.etcd.io/etcd/api/v3 v3.5.1/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= -go.etcd.io/etcd/api/v3 v3.5.4/go.mod h1:5GB2vv4A4AOn3yk7MftYGHkUfGtDHnEraIjym4dYz5A= go.etcd.io/etcd/client/pkg/v3 v3.5.1/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= -go.etcd.io/etcd/client/pkg/v3 v3.5.4/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= go.etcd.io/etcd/client/v2 v2.305.1/go.mod h1:pMEacxZW7o8pg4CrFE7pquyCJJzZvkvdD2RibOCCCGs= -go.etcd.io/etcd/client/v2 v2.305.4/go.mod h1:Ud+VUwIi9/uQHOMA+4ekToJ12lTxlv0zB/+DHwTGEbU= -go.etcd.io/etcd/client/v3 v3.5.4/go.mod h1:ZaRkVgBZC+L+dLCjTcF1hRXpgZXQPOvnA/Ak/gq3kiY= go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= go.opentelemetry.io/contrib/detectors/gcp v1.29.0/go.mod h1:GW2aWZNwR2ZxDLdv8OyC2G8zkRoQBuURgV7RPQgcPoU= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0/go.mod h1:B9yO6b04uB80CzjedvewuqDhxJxi11s7/GtiGa8bAjI= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0/go.mod h1:L7UH0GbB0p47T4Rri3uHjbpCFYrVrwc1I25QhNPiGK8= go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8= -go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.29.0/go.mod h1:BLbf7zbNIONBLPwvFnwNHGj4zge8uTCM/UPIVW1Mq2I= go.opentelemetry.io/otel/metric v1.29.0/go.mod h1:auu/QWieFVWx+DmQOUMgj0F8LHWdgalxXqvp7BII/W8= go.opentelemetry.io/otel/sdk v1.29.0/go.mod h1:pM8Dx5WKnvxLCb+8lG1PRNIDxu9g9b9g59Qr7hfAAok= go.opentelemetry.io/otel/sdk/metric v1.29.0/go.mod h1:6zZLdCl2fkauYoZIOn/soQIDSWFmNSRcICarHfuhNJQ= @@ -328,20 +240,17 @@ golang.org/x/tools v0.26.0/go.mod h1:TPVVj70c7JJ3WCazhD8OdXcZg/og+b9+tH/KxylGwH0 golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= google.golang.org/api v0.62.0/go.mod h1:dKmwPCydfsad4qCH08MSdgWjfHOyfpd4VtDGgRFdavw= google.golang.org/api v0.215.0/go.mod h1:fta3CVtuJYOEdugLNWm6WodzOS8KdFckABwN4I40hzY= -google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= google.golang.org/genproto v0.0.0-20211129164237-f09f9a12af12/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20211203200212-54befc351ae9/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto/googleapis/api v0.0.0-20230822172742-b8732ec3820d/go.mod h1:KjSP20unUpOx5kyQUFa7k4OJg0qeJ7DEZflGDu2p6Bk= google.golang.org/genproto/googleapis/api v0.0.0-20240528184218-531527333157/go.mod h1:99sLkeliLXfdj2J75X3Ho+rrVCaJze0uwN7zDDkjPVU= google.golang.org/genproto/googleapis/api v0.0.0-20240826202546-f6391c0de4c7/go.mod h1:OCdP9MfskevB/rbYvHTsXTtKC+3bHWajPdoKgjcYkfo= google.golang.org/genproto/googleapis/api v0.0.0-20241113202542-65e8d215514f/go.mod h1:Yo94eF2nj7igQt+TiJ49KxjIH8ndLYPZMIRSiRcEbg0= -google.golang.org/genproto/googleapis/bytestream v0.0.0-20241223144023-3abc09e42ca8/go.mod h1:bLYPejkLzwgJuAHlIk1gdPOlx9CUYXLZi2rZxL/ursM= google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY= google.golang.org/genproto/googleapis/rpc v0.0.0-20240528184218-531527333157/go.mod h1:EfXuqaE1J41VCDicxHzUDm+8rk+7ZdXzHV0IhO/I6s0= google.golang.org/genproto/googleapis/rpc v0.0.0-20240826202546-f6391c0de4c7/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= google.golang.org/genproto/googleapis/rpc v0.0.0-20241113202542-65e8d215514f/go.mod h1:GX3210XPVPUjJbTUbvwI8f2IpZDMZuPJWDzDuebbviI= google.golang.org/genproto/googleapis/rpc v0.0.0-20241206012308-a4fef0638583/go.mod h1:5uTbfoYQed2U9p3KIj2/Zzm02PYhndfdmML0qC3q3FU= -google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.3.0/go.mod h1:Dk1tviKTvMCz5tvh7t+fh94dhmQVHuCt2OzJB3CTW9Y= google.golang.org/protobuf v1.35.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= google.golang.org/protobuf v1.36.0/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= diff --git a/sei-cosmos/go.mod b/sei-cosmos/go.mod index a3862da765..8abb7b4e80 100644 --- a/sei-cosmos/go.mod +++ b/sei-cosmos/go.mod @@ -220,7 +220,7 @@ replace ( github.com/99designs/keyring => github.com/cosmos/keyring v1.1.7-0.20210622111912-ef00f8ac3d76 github.com/btcsuite/btcd => github.com/btcsuite/btcd v0.23.2 github.com/confio/ics23/go => github.com/cosmos/cosmos-sdk/ics23/go v0.8.0 - github.com/ethereum/go-ethereum => github.com/sei-protocol/go-ethereum v1.15.7-sei-15 + github.com/ethereum/go-ethereum => github.com/sei-protocol/go-ethereum v1.15.7-sei-16 // Fix upstream GHSA-h395-qcrw-5vmq vulnerability. // TODO Remove it: https://github.com/cosmos/cosmos-sdk/issues/10409 github.com/gin-gonic/gin => github.com/gin-gonic/gin v1.7.0 diff --git a/sei-cosmos/go.sum b/sei-cosmos/go.sum index 2e4740850f..b07b9b4090 100644 --- a/sei-cosmos/go.sum +++ b/sei-cosmos/go.sum @@ -1709,8 +1709,8 @@ github.com/sasha-s/go-deadlock v0.3.1/go.mod h1:F73l+cr82YSh10GxyRI6qZiCgK64VaZj github.com/schollz/closestmatch v2.1.0+incompatible/go.mod h1:RtP1ddjLong6gTkbtmuhtR2uUrrJOpYzYRvbcPAid+g= github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= github.com/segmentio/fasthash v1.0.3/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY= -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.7-sei-16 h1:MUvhmn5acNwS/9smQ19gdl6Qh3cNjukTQzz4u8GiUHs= +github.com/sei-protocol/go-ethereum v1.15.7-sei-16/go.mod h1:+S9k+jFzlyVTNcYGvqFhzN/SFhI6vA+aOY4T5tLSPL0= 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-load v0.0.0-20251007135253-78fbdc141082 h1:f2sY8OcN60UL1/6POx+HDMZ4w04FTZtSScnrFSnGZHg= diff --git a/sei-tendermint/internal/state/execution.go b/sei-tendermint/internal/state/execution.go index a030a94977..2cc851e65f 100644 --- a/sei-tendermint/internal/state/execution.go +++ b/sei-tendermint/internal/state/execution.go @@ -214,6 +214,18 @@ func (blockExec *BlockExecutor) ValidateBlock(ctx context.Context, state State, err := validateBlock(state, block) if err != nil { + // Check if this is a LastResultsHash mismatch and log detailed info + if !bytes.Equal(block.LastResultsHash, state.LastResultsHash) { + blockExec.logger.Error("LastResultsHash mismatch detected", + "height", block.Height, + "expectedHash", fmt.Sprintf("%X", state.LastResultsHash), + "gotHash", fmt.Sprintf("%X", block.LastResultsHash), + "blockHash", fmt.Sprintf("%X", block.Hash()), + "lastBlockHeight", state.LastBlockHeight, + "lastBlockID", state.LastBlockID.String(), + "numTxs", len(block.Txs), + ) + } return fmt.Errorf("validateBlock(): %w", err) } @@ -342,6 +354,31 @@ func (blockExec *BlockExecutor) ApplyBlock( return state, fmt.Errorf("marshaling TxResults: %w", err) } h := merkle.HashFromByteSlices(rs) + + // Log LastResultsHash computation details for debugging consensus issues + if len(fBlockRes.TxResults) > 0 { + blockExec.logger.Info("LastResultsHash computed", + "height", block.Height, + "hash", fmt.Sprintf("%X", h), + "txCount", len(fBlockRes.TxResults), + ) + // Log per-tx deterministic fields (Code, Data, GasWanted, GasUsed) for debugging + for i, txRes := range fBlockRes.TxResults { + dataLen := 0 + if txRes.Data != nil { + dataLen = len(txRes.Data) + } + blockExec.logger.Debug("TxResult for LastResultsHash", + "height", block.Height, + "txIndex", i, + "code", txRes.Code, + "gasWanted", txRes.GasWanted, + "gasUsed", txRes.GasUsed, + "dataLen", dataLen, + ) + } + } + state, err = state.Update(blockID, &block.Header, h, fBlockRes.ConsensusParamUpdates, validatorUpdates) if err != nil { return state, fmt.Errorf("commit failed for application: %w", err)