Propogate on chain consensus params to tendermint params

.github/workflows/integration-test.yml

@@ -266,43 +266,6 @@ jobs:
               "./integration_test/contracts/verify_flatkv_partial_loss_fails_loudly.sh",
             ],
           },
-          {
-            # FlatKV EVM migrate cluster coverage.
-            #
-            # The cluster boots with GIGA_MIGRATE_FROM_MEMIAVL=true so
-            # every validator starts in sc-write-mode = memiavl_only,
-            # i.e. v0 (FlatKV not yet allocated). This is the inverse of
-            # the FlatKV Integration row above (which boots in
-            # test_only_dual_write) and is what makes the migration
-            # script's pre-flip check meaningful: if the matrix env ever
-            # silently lands the cluster in any mode other than
-            # memiavl_only, the script will fail loudly at the pre-flip
-            # grep instead of "succeeding" with a no-op migration.
-            #
-            # Steps:
-            #   1  Deposit an EVM fixture while in v0 so the migration
-            #      has real account+code+storage to drain. The fixture
-            #      writes roughly 4000 storage keys by default so the
-            #      migration spans multiple batches instead of trivially
-            #      completing against an empty or smoke-sized tree.
-            #   2  Coordinated stop -> sed sc-write-mode -> restart on
-            #      all 4 validators, then poll seidb migrate-evm-status
-            #      until every validator reports completion. Cross-
-            #      validator FlatKV digest agreement is asserted at a
-            #      shared post-migration height; any non-determinism in
-            #      the batch copier would surface here as a digest
-            #      mismatch.
-            #   3  Re-run the fixture round-trip check against the
-            #      now-FlatKV-backed EVM state, confirming pre-migration
-            #      data survives the migration intact (read transparency).
-            name: "FlatKV EVM Migrate",
-            env: "GIGA_MIGRATE_FROM_MEMIAVL=true",
-            scripts: [
-              "docker exec sei-node-0 integration_test/contracts/deploy_flatkv_evm_fixture.sh",
-              "./integration_test/contracts/verify_flatkv_evm_migrate.sh",
-              "docker exec sei-node-0 integration_test/contracts/verify_flatkv_evm_store.sh",
-            ],
-          },
           {
             # Post-migration FlatKV-only state-sync coverage.
             #

app/app.go

@@ -1393,10 +1393,11 @@ func (app *App) FinalizeBlocker(ctx sdk.Context, req *abci.RequestFinalizeBlock)
 			if app.EvmKeeper.EthReplayConfig.Enabled || app.EvmKeeper.EthBlockTestConfig.Enabled {
 				return &abci.ResponseFinalizeBlock{}, nil
 			}
+			consensusParamUpdates := app.GetConsensusParamsForStateToCommit()
 			cms := app.WriteState()
 			app.LightInvarianceChecks(ctx.Context(), cms, app.lightInvarianceConfig)
 			appHash := app.GetWorkingHash()
-			resp := app.getFinalizeBlockResponse(appHash, events, txRes, endBlockResp)
+			resp := app.getFinalizeBlockResponse(appHash, events, txRes, endBlockResp, consensusParamUpdates)
 			if hasHeadNotifier {
 				headNotifier.Stash(req, &resp)
 			}
@@ -1423,10 +1424,11 @@ func (app *App) FinalizeBlocker(ctx sdk.Context, req *abci.RequestFinalizeBlock)
 	if app.EvmKeeper.EthReplayConfig.Enabled || app.EvmKeeper.EthBlockTestConfig.Enabled {
 		return &abci.ResponseFinalizeBlock{}, nil
 	}
+	consensusParamUpdates := app.GetConsensusParamsForStateToCommit()
 	cms := app.WriteState()
 	app.LightInvarianceChecks(ctx.Context(), cms, app.lightInvarianceConfig)
 	appHash := app.GetWorkingHash()
-	resp := app.getFinalizeBlockResponse(appHash, events, txResults, endBlockResp)
+	resp := app.getFinalizeBlockResponse(appHash, events, txResults, endBlockResp, consensusParamUpdates)
 	if hasHeadNotifier {
 		headNotifier.Stash(req, &resp)
 	}
@@ -2442,7 +2444,13 @@ func (app *App) DecodeTransactionsConcurrently(ctx sdk.Context, txs [][]byte) []
 	return typedTxs
 }
 
-func (app *App) getFinalizeBlockResponse(appHash []byte, events []abci.Event, txResults []*abci.ExecTxResult, endBlockResp abci.ResponseEndBlock) abci.ResponseFinalizeBlock {
+func (app *App) getFinalizeBlockResponse(
+	appHash []byte,
+	events []abci.Event,
+	txResults []*abci.ExecTxResult,
+	endBlockResp abci.ResponseEndBlock,
+	consensusParamUpdates *tmproto.ConsensusParams,
+) abci.ResponseFinalizeBlock {
 	if app.EvmKeeper.EthReplayConfig.Enabled || app.EvmKeeper.EthBlockTestConfig.Enabled {
 		return abci.ResponseFinalizeBlock{}
 	}
@@ -2455,27 +2463,74 @@ func (app *App) getFinalizeBlockResponse(appHash []byte, events []abci.Event, tx
 				Power:  v.Power,
 			}
 		}),
-		ConsensusParamUpdates: &tmproto.ConsensusParams{
-			Block: &tmproto.BlockParams{
-				MaxBytes:      endBlockResp.ConsensusParamUpdates.Block.MaxBytes,
-				MaxGas:        endBlockResp.ConsensusParamUpdates.Block.MaxGas,
-				MinTxsInBlock: endBlockResp.ConsensusParamUpdates.Block.MinTxsInBlock,
-				MaxGasWanted:  endBlockResp.ConsensusParamUpdates.Block.MaxGasWanted,
-			},
-			Evidence: &tmproto.EvidenceParams{
-				MaxAgeNumBlocks: endBlockResp.ConsensusParamUpdates.Evidence.MaxAgeNumBlocks,
-				MaxAgeDuration:  endBlockResp.ConsensusParamUpdates.Evidence.MaxAgeDuration,
-				MaxBytes:        endBlockResp.ConsensusParamUpdates.Evidence.MaxBytes,
-			},
-			Validator: &tmproto.ValidatorParams{
-				PubKeyTypes: endBlockResp.ConsensusParamUpdates.Validator.PubKeyTypes,
-			},
-			Version: &tmproto.VersionParams{
-				AppVersion: endBlockResp.ConsensusParamUpdates.Version.AppVersion,
-			},
-		},
-		AppHash: appHash,
+		ConsensusParamUpdates: cloneConsensusParams(consensusParamUpdates),
+		AppHash:               appHash,
+	}
+}
+
+func cloneConsensusParams(params *tmproto.ConsensusParams) *tmproto.ConsensusParams {
+	if params == nil {
+		return nil
+	}
+
+	cp := &tmproto.ConsensusParams{}
+	if params.Block != nil {
+		cp.Block = &tmproto.BlockParams{
+			MaxBytes:      params.Block.MaxBytes,
+			MaxGas:        params.Block.MaxGas,
+			MinTxsInBlock: params.Block.MinTxsInBlock,
+			MaxGasWanted:  params.Block.MaxGasWanted,
+		}
+	}
+	if params.Evidence != nil {
+		cp.Evidence = &tmproto.EvidenceParams{
+			MaxAgeNumBlocks: params.Evidence.MaxAgeNumBlocks,
+			MaxAgeDuration:  params.Evidence.MaxAgeDuration,
+			MaxBytes:        params.Evidence.MaxBytes,
+		}
+	}
+	if params.Validator != nil {
+		cp.Validator = &tmproto.ValidatorParams{
+			PubKeyTypes: append([]string(nil), params.Validator.PubKeyTypes...),
+		}
+	}
+	if params.Version != nil {
+		cp.Version = &tmproto.VersionParams{
+			AppVersion: params.Version.AppVersion,
+		}
+	}
+	if params.Synchrony != nil {
+		cp.Synchrony = &tmproto.SynchronyParams{
+			Precision:    cloneDuration(params.Synchrony.Precision),
+			MessageDelay: cloneDuration(params.Synchrony.MessageDelay),
+		}
+	}
+	if params.Timeout != nil {
+		cp.Timeout = &tmproto.TimeoutParams{
+			Propose:             cloneDuration(params.Timeout.Propose),
+			ProposeDelta:        cloneDuration(params.Timeout.ProposeDelta),
+			Vote:                cloneDuration(params.Timeout.Vote),
+			VoteDelta:           cloneDuration(params.Timeout.VoteDelta),
+			Commit:              cloneDuration(params.Timeout.Commit),
+			BypassCommitTimeout: params.Timeout.BypassCommitTimeout,
+		}
+	}
+	if params.Abci != nil {
+		cp.Abci = &tmproto.ABCIParams{
+			VoteExtensionsEnableHeight: params.Abci.VoteExtensionsEnableHeight,
+			RecheckTx:                  params.Abci.RecheckTx,
+		}
+	}
+
+	return cp
+}
+
+func cloneDuration(duration *time.Duration) *time.Duration {
+	if duration == nil {
+		return nil
 	}
+	cloned := *duration
+	return &cloned
 }
 
 // LoadHeight loads a particular height

app/consensus_params_test.go

@@ -0,0 +1,73 @@
+package app
+
+import (
+	"testing"
+	"time"
+
+	"github.com/sei-protocol/sei-chain/sei-tendermint/abci/types"
+	tmproto "github.com/sei-protocol/sei-chain/sei-tendermint/proto/tendermint/types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetFinalizeBlockResponsePropagatesFullConsensusParams(t *testing.T) {
+	propose := 300 * time.Millisecond
+	proposeDelta := 50 * time.Millisecond
+	vote := 50 * time.Millisecond
+	voteDelta := 50 * time.Millisecond
+	commit := 200 * time.Millisecond
+	precision := 505 * time.Millisecond
+	messageDelay := 12 * time.Second
+
+	consensusParamUpdates := &tmproto.ConsensusParams{
+		Block: &tmproto.BlockParams{
+			MaxBytes:      22020096,
+			MaxGas:        12500000,
+			MinTxsInBlock: 0,
+			MaxGasWanted:  50000000,
+		},
+		Evidence: &tmproto.EvidenceParams{
+			MaxAgeNumBlocks: 100000,
+			MaxAgeDuration:  48 * time.Hour,
+			MaxBytes:        1048576,
+		},
+		Validator: &tmproto.ValidatorParams{
+			PubKeyTypes: []string{"ed25519"},
+		},
+		Version: &tmproto.VersionParams{
+			AppVersion: 1,
+		},
+		Synchrony: &tmproto.SynchronyParams{
+			Precision:    &precision,
+			MessageDelay: &messageDelay,
+		},
+		Timeout: &tmproto.TimeoutParams{
+			Propose:             &propose,
+			ProposeDelta:        &proposeDelta,
+			Vote:                &vote,
+			VoteDelta:           &voteDelta,
+			Commit:              &commit,
+			BypassCommitTimeout: false,
+		},
+		Abci: &tmproto.ABCIParams{
+			VoteExtensionsEnableHeight: 123,
+			RecheckTx:                  true,
+		},
+	}
+
+	app := &App{}
+	resp := app.getFinalizeBlockResponse(
+		[]byte("hash"),
+		nil,
+		nil,
+		types.ResponseEndBlock{},
+		consensusParamUpdates,
+	)
+
+	require.Equal(t, consensusParamUpdates.Block, resp.ConsensusParamUpdates.Block)
+	require.Equal(t, consensusParamUpdates.Evidence, resp.ConsensusParamUpdates.Evidence)
+	require.Equal(t, consensusParamUpdates.Validator, resp.ConsensusParamUpdates.Validator)
+	require.Equal(t, consensusParamUpdates.Version, resp.ConsensusParamUpdates.Version)
+	require.Equal(t, consensusParamUpdates.Synchrony, resp.ConsensusParamUpdates.Synchrony)
+	require.Equal(t, consensusParamUpdates.Timeout, resp.ConsensusParamUpdates.Timeout)
+	require.Equal(t, consensusParamUpdates.Abci, resp.ConsensusParamUpdates.Abci)
+}

sei-cosmos/baseapp/baseapp.go

@@ -697,6 +697,13 @@ func (app *BaseApp) GetConsensusParams(ctx sdk.Context) *tmproto.ConsensusParams
 	return cp
 }
 
+func (app *BaseApp) GetConsensusParamsForStateToCommit() *tmproto.ConsensusParams {
+	if app.stateToCommit == nil {
+		return nil
+	}
+	return app.GetConsensusParams(app.stateToCommit.Context())
+}
+
 // AddRunTxRecoveryHandler adds custom app.runTx method panic handlers.
 func (app *BaseApp) AddRunTxRecoveryHandler(handlers ...RecoveryHandler) {
 	for _, h := range handlers {