Add ConsensusParams updates handling logic (#1367) (#1420)

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.
-->

Duplicate of #1367
Reference to corresponding [cometBFT
code](https://github.com/cometbft/cometbft/blob/6c1deb50b146bf8d27a65fbce8dbba89052dd607/internal/state/execution.go#L615).

Removes validator updates code as well that is now unnecessary due to
switch to single sequencer.

<!--
Please provide an explanation of the PR, including the appropriate
context,
background, goal, and rationale. If there is an issue with this
information,
please provide a tl;dr and link the issue.
-->

<!--
Please complete the checklist to ensure that the PR is ready to be
reviewed.

IMPORTANT:
PRs should be left in Draft until the below checklist is completed. -->

- [x] New and updated code has appropriate documentation
- [x] New and updated code has new and/or updated testing
- [x] Required CI checks are passing
- [ ] Visual proof for any user facing features like CLI or
documentation updates
- [x] Linked issues closed with keywords

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.
-->

## Overview

<!-- 
Please provide an explanation of the PR, including the appropriate
context,
background, goal, and rationale. If there is an issue with this
information,
please provide a tl;dr and link the issue. 
-->

## Checklist

<!-- 
Please complete the checklist to ensure that the PR is ready to be
reviewed.

IMPORTANT:
PRs should be left in Draft until the below checklist is completed.
-->

- [ ] New and updated code has appropriate documentation
- [ ] New and updated code has new and/or updated testing
- [ ] Required CI checks are passing
- [ ] Visual proof for any user facing features like CLI or
documentation updates
- [ ] Linked issues closed with keywords


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

- **New Features**
- Search bar implemented, enhancing the user interface for better
navigation and search capabilities.
- **Improvements**
- Updated consensus parameter retrieval for improved consistency and
reliability.
- Refined state update process to better handle consensus parameter
updates.
- **Bug Fixes**
- Adjusted range checking logic to ensure accurate query bounds
validation.
- **Tests**
- Added new tests to ensure consensus parameters are validated and
updated correctly.
- **Documentation**
- Updated comments to clarify the purpose of key functions and
processes.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: Manav-Aggarwal

node/full_client.go

@@ -376,11 +376,12 @@ func (c *FullClient) ConsensusState(ctx context.Context) (*ctypes.ResultConsensu
 }
 
 // ConsensusParams returns consensus params at given height.
-//
-// Currently, consensus params changes are not supported and this method returns params as defined in genesis.
 func (c *FullClient) ConsensusParams(ctx context.Context, height *int64) (*ctypes.ResultConsensusParams, error) {
-	// TODO(tzdybal): implement consensus params handling: https://github.com/rollkit/rollkit/issues/291
-	params := c.node.GetGenesis().ConsensusParams
+	state, err := c.node.Store.GetState()
+	if err != nil {
+		return nil, err
+	}
+	params := state.ConsensusParams
 	return &ctypes.ResultConsensusParams{
 		BlockHeight: int64(c.normalizeHeight(height)),
 		ConsensusParams: cmtypes.ConsensusParams{

state/executor.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	abci "github.com/cometbft/cometbft/abci/types"
-	cryptoenc "github.com/cometbft/cometbft/crypto/encoding"
 	cmbytes "github.com/cometbft/cometbft/libs/bytes"
 	cmproto "github.com/cometbft/cometbft/proto/tendermint/types"
 	"github.com/cometbft/cometbft/proxy"
@@ -167,7 +166,7 @@ func (e *BlockExecutor) CreateBlock(height uint64, lastCommit *types.Commit, las
 	return block, nil
 }
 
-// ProcessProposal processes the proposal.
+// ProcessProposal calls the corresponding ABCI method on the app.
 func (e *BlockExecutor) ProcessProposal(
 	block *types.Block,
 	state types.State,
@@ -215,29 +214,15 @@ func (e *BlockExecutor) ApplyBlock(ctx context.Context, state types.State, block
 		return types.State{}, nil, err
 	}
 
-	abciValUpdates := resp.ValidatorUpdates
-
-	err = validateValidatorUpdates(abciValUpdates, state.ConsensusParams.Validator)
+	state, err = e.updateState(state, block, resp)
 	if err != nil {
-		return state, nil, fmt.Errorf("error in validator updates: %v", err)
+		return types.State{}, nil, err
 	}
 
-	validatorUpdates, err := cmtypes.PB2TM.ValidatorUpdates(abciValUpdates)
-	if err != nil {
-		return state, nil, err
-	}
-	if len(validatorUpdates) > 0 {
-		e.logger.Debug("updates to validators", "updates", cmtypes.ValidatorListString(validatorUpdates))
-	}
 	if state.ConsensusParams.Block.MaxBytes == 0 {
 		e.logger.Error("maxBytes=0", "state.ConsensusParams.Block", state.ConsensusParams.Block, "block", block)
 	}
 
-	state, err = e.updateState(state, block, resp, validatorUpdates)
-	if err != nil {
-		return types.State{}, nil, err
-	}
-
 	return state, resp, nil
 }
 
@@ -255,12 +240,36 @@ func (e *BlockExecutor) Commit(ctx context.Context, state types.State, block *ty
 	return appHash, retainHeight, nil
 }
 
-func (e *BlockExecutor) updateState(state types.State, block *types.Block, finalizeBlockResponse *abci.ResponseFinalizeBlock, validatorUpdates []*cmtypes.Validator) (types.State, error) {
+// updateConsensusParams updates the consensus parameters based on the provided updates.
+func (e *BlockExecutor) updateConsensusParams(height uint64, params cmtypes.ConsensusParams, consensusParamUpdates *cmproto.ConsensusParams) (cmproto.ConsensusParams, uint64, error) {
+	nextParams := params.Update(consensusParamUpdates)
+	if err := types.ConsensusParamsValidateBasic(nextParams); err != nil {
+		return cmproto.ConsensusParams{}, 0, fmt.Errorf("validating new consensus params: %w", err)
+	}
+	if err := nextParams.ValidateUpdate(consensusParamUpdates, int64(height)); err != nil {
+		return cmproto.ConsensusParams{}, 0, fmt.Errorf("updating consensus params: %w", err)
+	}
+	return nextParams.ToProto(), nextParams.Version.App, nil
+}
+
+func (e *BlockExecutor) updateState(state types.State, block *types.Block, finalizeBlockResponse *abci.ResponseFinalizeBlock) (types.State, error) {
+	height := block.Height()
+	if finalizeBlockResponse.ConsensusParamUpdates != nil {
+		nextParamsProto, appVersion, err := e.updateConsensusParams(height, types.ConsensusParamsFromProto(state.ConsensusParams), finalizeBlockResponse.ConsensusParamUpdates)
+		if err != nil {
+			return state, err
+		}
+		// Change results from this height but only applies to the next height.
+		state.LastHeightConsensusParamsChanged = height + 1
+		state.Version.Consensus.App = appVersion
+		state.ConsensusParams = nextParamsProto
+	}
+
 	s := types.State{
 		Version:         state.Version,
 		ChainID:         state.ChainID,
 		InitialHeight:   state.InitialHeight,
-		LastBlockHeight: block.Height(),
+		LastBlockHeight: height,
 		LastBlockTime:   block.Time(),
 		LastBlockID: cmtypes.BlockID{
 			Hash: cmbytes.HexBytes(block.Hash()),
@@ -456,27 +465,3 @@ func fromRollkitTxs(rollkitTxs types.Txs) cmtypes.Txs {
 	}
 	return txs
 }
-
-func validateValidatorUpdates(abciUpdates []abci.ValidatorUpdate, params *cmproto.ValidatorParams) error {
-	for _, valUpdate := range abciUpdates {
-		if valUpdate.GetPower() < 0 {
-			return fmt.Errorf("voting power can't be negative %v", valUpdate)
-		} else if valUpdate.GetPower() == 0 {
-			// continue, since this is deleting the validator, and thus there is no
-			// pubkey to check
-			continue
-		}
-
-		// Check if validator's pubkey matches an ABCI type in the consensus params
-		pk, err := cryptoenc.PubKeyFromProto(valUpdate.PubKey)
-		if err != nil {
-			return err
-		}
-
-		if !cmtypes.IsValidPubkeyType(cmtypes.ValidatorParams{PubKeyTypes: params.PubKeyTypes}, pk.Type()) {
-			return fmt.Errorf("validator %v is using pubkey %s, which is unsupported for consensus",
-				valUpdate, pk.Type())
-		}
-	}
-	return nil
-}

state/executor_test.go

@@ -247,3 +247,67 @@ func doTestApplyBlock(t *testing.T) {
 func TestApplyBlockWithFraudProofsDisabled(t *testing.T) {
 	doTestApplyBlock(t)
 }
+
+func TestUpdateStateConsensusParams(t *testing.T) {
+	logger := log.TestingLogger()
+	app := &mocks.Application{}
+	client, err := proxy.NewLocalClientCreator(app).NewABCIClient()
+	require.NoError(t, err)
+	require.NotNil(t, client)
+
+	chainID := "test"
+
+	mpool := mempool.NewCListMempool(cfg.DefaultMempoolConfig(), proxy.NewAppConnMempool(client, proxy.NopMetrics()), 0)
+	eventBus := cmtypes.NewEventBus()
+	require.NoError(t, eventBus.Start())
+	executor := NewBlockExecutor([]byte("test address"), chainID, mpool, proxy.NewAppConnConsensus(client, proxy.NopMetrics()), eventBus, logger)
+
+	state := types.State{
+		ConsensusParams: cmproto.ConsensusParams{
+			Block: &cmproto.BlockParams{
+				MaxBytes: 100,
+				MaxGas:   100000,
+			},
+			Validator: &cmproto.ValidatorParams{
+				PubKeyTypes: []string{cmtypes.ABCIPubKeyTypeEd25519},
+			},
+			Version: &cmproto.VersionParams{
+				App: 1,
+			},
+			Abci: &cmproto.ABCIParams{},
+		},
+	}
+
+	block := types.GetRandomBlock(1234, 2)
+
+	txResults := make([]*abci.ExecTxResult, len(block.Data.Txs))
+	for idx := range block.Data.Txs {
+		txResults[idx] = &abci.ExecTxResult{
+			Code: abci.CodeTypeOK,
+		}
+	}
+
+	resp := &abci.ResponseFinalizeBlock{
+		ConsensusParamUpdates: &cmproto.ConsensusParams{
+			Block: &cmproto.BlockParams{
+				MaxBytes: 200,
+				MaxGas:   200000,
+			},
+			Validator: &cmproto.ValidatorParams{
+				PubKeyTypes: []string{cmtypes.ABCIPubKeyTypeEd25519},
+			},
+			Version: &cmproto.VersionParams{
+				App: 2,
+			},
+		},
+		TxResults: txResults,
+	}
+
+	updatedState, err := executor.updateState(state, block, resp)
+	require.NoError(t, err)
+
+	assert.Equal(t, uint64(1235), updatedState.LastHeightConsensusParamsChanged)
+	assert.Equal(t, int64(200), updatedState.ConsensusParams.Block.MaxBytes)
+	assert.Equal(t, int64(200000), updatedState.ConsensusParams.Block.MaxGas)
+	assert.Equal(t, uint64(2), updatedState.ConsensusParams.Version.App)
+}

state/indexer_utils.go

@@ -43,7 +43,7 @@ func compareInt(op1 *big.Int, op2 interface{}) (int, bool, error) {
 	}
 }
 
-// CheckBounds checks if the value of the event is within the bounds of the query.
+// CheckBounds checks if the given value falls within the specified query range.
 func CheckBounds(ranges indexer.QueryRange, v interface{}) (bool, error) {
 	// These functions fetch the lower and upper bounds of the query
 	// It is expected that for x > 5, the value of lowerBound is 6.

types/params.go

@@ -0,0 +1,49 @@
+package types
+
+import (
+	"errors"
+	"fmt"
+
+	cmtypes "github.com/cometbft/cometbft/types"
+)
+
+// ConsensusParamsValidateBasic validates the ConsensusParams to ensure all values are within their
+// allowed limits, and returns an error if they are not.
+func ConsensusParamsValidateBasic(params cmtypes.ConsensusParams) error {
+	if params.Block.MaxBytes == 0 {
+		return fmt.Errorf("block.MaxBytes cannot be 0")
+	}
+	if params.Block.MaxBytes < -1 {
+		return fmt.Errorf("block.MaxBytes must be -1 or greater than 0. Got %d",
+
+			params.Block.MaxBytes)
+	}
+	if params.Block.MaxBytes > cmtypes.MaxBlockSizeBytes {
+		return fmt.Errorf("block.MaxBytes is too big. %d > %d",
+			params.Block.MaxBytes, cmtypes.MaxBlockSizeBytes)
+	}
+
+	if params.Block.MaxGas < -1 {
+		return fmt.Errorf("block.MaxGas must be greater or equal to -1. Got %d",
+			params.Block.MaxGas)
+	}
+
+	if params.ABCI.VoteExtensionsEnableHeight < 0 {
+		return fmt.Errorf("ABCI.VoteExtensionsEnableHeight cannot be negative. Got: %d", params.ABCI.VoteExtensionsEnableHeight)
+	}
+
+	if len(params.Validator.PubKeyTypes) == 0 {
+		return errors.New("len(Validator.PubKeyTypes) must be greater than 0")
+	}
+
+	// Check if keyType is a known ABCIPubKeyType
+	for i := 0; i < len(params.Validator.PubKeyTypes); i++ {
+		keyType := params.Validator.PubKeyTypes[i]
+		if _, ok := cmtypes.ABCIPubKeyTypesToNames[keyType]; !ok {
+			return fmt.Errorf("params.Validator.PubKeyTypes[%d], %s, is an unknown pubkey type",
+				i, keyType)
+		}
+	}
+
+	return nil
+}

types/params_test.go

@@ -0,0 +1,43 @@
+package types
+
+import (
+	"testing"
+
+	cmtypes "github.com/cometbft/cometbft/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConsensusParamsValidateBasic(t *testing.T) {
+	testCases := []struct {
+		name    string
+		prepare func() cmtypes.ConsensusParams // Function to prepare the test case
+		err     error
+	}{
+		// 1. Test valid params
+		{
+			name: "valid params",
+			prepare: func() cmtypes.ConsensusParams {
+				return cmtypes.ConsensusParams{
+					Block: cmtypes.BlockParams{
+						MaxBytes: 12345,
+						MaxGas:   6543234,
+					},
+					Validator: cmtypes.ValidatorParams{
+						PubKeyTypes: []string{cmtypes.ABCIPubKeyTypeEd25519},
+					},
+					Version: cmtypes.VersionParams{
+						App: 42,
+					},
+				}
+			},
+			err: nil,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			err := ConsensusParamsValidateBasic(tc.prepare())
+			assert.ErrorIs(t, err, tc.err)
+		})
+	}
+}

types/serialization.go

@@ -1,6 +1,7 @@
 package types
 
 import (
+	cmproto "github.com/cometbft/cometbft/proto/tendermint/types"
 	"github.com/cometbft/cometbft/types"
 
 	pb "github.com/rollkit/rollkit/types/pb/rollkit"
@@ -335,3 +336,23 @@ func byteSlicesToSignatures(bytes [][]byte) []Signature {
 	}
 	return sigs
 }
+
+// ConsensusParamsFromProto converts protobuf consensus parameters to consensus parameters
+func ConsensusParamsFromProto(pbParams cmproto.ConsensusParams) types.ConsensusParams {
+	c := types.ConsensusParams{
+		Block: types.BlockParams{
+			MaxBytes: pbParams.Block.MaxBytes,
+			MaxGas:   pbParams.Block.MaxGas,
+		},
+		Validator: types.ValidatorParams{
+			PubKeyTypes: pbParams.Validator.PubKeyTypes,
+		},
+		Version: types.VersionParams{
+			App: pbParams.Version.App,
+		},
+	}
+	if pbParams.Abci != nil {
+		c.ABCI.VoteExtensionsEnableHeight = pbParams.Abci.GetVoteExtensionsEnableHeight()
+	}
+	return c
+}

types/serialization_test.go

@@ -236,3 +236,28 @@ func TestSignaturesRoundtrip(t *testing.T) {
 		assert.Equal(t, newSigs[i], sigs[i])
 	}
 }
+
+func TestConsensusParamsFromProto(t *testing.T) {
+	// Prepare test case
+	pbParams := cmproto.ConsensusParams{
+		Block: &cmproto.BlockParams{
+			MaxBytes: 12345,
+			MaxGas:   67890,
+		},
+		Validator: &cmproto.ValidatorParams{
+			PubKeyTypes: []string{cmtypes.ABCIPubKeyTypeEd25519},
+		},
+		Version: &cmproto.VersionParams{
+			App: 42,
+		},
+	}
+
+	// Call the function to be tested
+	params := ConsensusParamsFromProto(pbParams)
+
+	// Check the results
+	assert.Equal(t, int64(12345), params.Block.MaxBytes)
+	assert.Equal(t, int64(67890), params.Block.MaxGas)
+	assert.Equal(t, uint64(42), params.Version.App)
+	assert.Equal(t, []string{cmtypes.ABCIPubKeyTypeEd25519}, params.Validator.PubKeyTypes)
+}