fix(manager): use block params from consensus param

block/block.go

@@ -72,7 +72,6 @@ func (m *Manager) applyBlock(block *types.Block, commit *types.Commit, blockMeta
 		// Update the state with the new app hash, and store height from the commit.
 		// Every one of those, if happens before commit, prevents us from re-executing the block in case failed during commit.
 		m.Executor.UpdateStateAfterCommit(m.State, responses, appHash, block.Header.Height)
-		m.ValidateConsensusBlockParams()
 	}
 
 	// check if the proposer needs to be changed

block/executor.go

@@ -7,7 +7,6 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	tmcrypto "github.com/tendermint/tendermint/crypto/encoding"
 	tmstate "github.com/tendermint/tendermint/proto/tendermint/state"
-	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 	"github.com/tendermint/tendermint/proxy"
 	tmtypes "github.com/tendermint/tendermint/types"
 	"go.uber.org/multierr"
@@ -16,6 +15,9 @@ import (
 	"github.com/dymensionxyz/dymint/types"
 )
 
+// default minimum block max size allowed. not specific reason to set it to 10K, but we need to avoid no transactions can be included in a block.
+const minBlockMaxBytes = 10000
+
 // Executor creates and applies blocks and maintains state.
 type Executor struct {
 	localAddress          []byte
@@ -60,37 +62,20 @@ func (e *Executor) InitChain(genesis *tmtypes.GenesisDoc, valset []*tmtypes.Vali
 			Power:  validator.VotingPower,
 		})
 	}
-	params := genesis.ConsensusParams
 
 	return e.proxyAppConsensusConn.InitChainSync(abci.RequestInitChain{
-		Time:    genesis.GenesisTime,
-		ChainId: genesis.ChainID,
-		ConsensusParams: &abci.ConsensusParams{
-			Block: &abci.BlockParams{
-				MaxBytes: params.Block.MaxBytes,
-				MaxGas:   params.Block.MaxGas,
-			},
-			Evidence: &tmproto.EvidenceParams{
-				MaxAgeNumBlocks: params.Evidence.MaxAgeNumBlocks,
-				MaxAgeDuration:  params.Evidence.MaxAgeDuration,
-				MaxBytes:        params.Evidence.MaxBytes,
-			},
-			Validator: &tmproto.ValidatorParams{
-				PubKeyTypes: params.Validator.PubKeyTypes,
-			},
-			Version: &tmproto.VersionParams{
-				AppVersion: params.Version.AppVersion,
-			},
-		},
-		Validators:    valUpdates,
-		AppStateBytes: genesis.AppState,
-		InitialHeight: genesis.InitialHeight,
+		Time:            genesis.GenesisTime,
+		ChainId:         genesis.ChainID,
+		ConsensusParams: &abci.ConsensusParams{},
+		Validators:      valUpdates,
+		AppStateBytes:   genesis.AppState,
+		InitialHeight:   genesis.InitialHeight,
 	})
 }
 
 // CreateBlock reaps transactions from mempool and builds a block.
-func (e *Executor) CreateBlock(height uint64, lastCommit *types.Commit, lastHeaderHash, nextSeqHash [32]byte, state *types.State, maxBlockDataSizeBytes uint32) *types.Block {
-	maxBlockDataSizeBytes = min(maxBlockDataSizeBytes, uint32(state.ConsensusParams.Block.MaxBytes))
+func (e *Executor) CreateBlock(height uint64, lastCommit *types.Commit, lastHeaderHash, nextSeqHash [32]byte, state *types.State, maxBlockDataSizeBytes uint64) *types.Block {
+	maxBlockDataSizeBytes = min(maxBlockDataSizeBytes, uint64(max(minBlockMaxBytes, state.ConsensusParams.Block.MaxBytes)))
 	mempoolTxs := e.mempool.ReapMaxBytesMaxGas(int64(maxBlockDataSizeBytes), state.ConsensusParams.Block.MaxGas)
 
 	block := &types.Block{

block/executor_test.go

@@ -50,7 +50,7 @@ func TestCreateBlock(t *testing.T) {
 	executor, err := block.NewExecutor([]byte("test address"), "test", mpool, proxy.NewAppConns(clientCreator), nil, logger)
 	assert.NoError(err)
 
-	maxBytes := uint32(100)
+	maxBytes := uint64(100)
 
 	// Create a valid proposer for the block
 	proposerKey := ed25519.GenPrivKey()
@@ -165,7 +165,7 @@ func TestApplyBlock(t *testing.T) {
 	state.Sequencers.SetProposer(types.NewSequencerFromValidator(*tmtypes.NewValidator(tmPubKey, 1)))
 	state.InitialHeight = 1
 	state.SetHeight(0)
-	maxBytes := uint32(1000)
+	maxBytes := uint64(10000)
 	state.ConsensusParams.Block.MaxBytes = int64(maxBytes)
 	state.ConsensusParams.Block.MaxGas = 100000
 	state.RollappParams.Da = "mock"
@@ -207,7 +207,7 @@ func TestApplyBlock(t *testing.T) {
 	require.NoError(mpool.CheckTx([]byte{0, 1, 2, 3, 4}, func(r *abci.Response) {}, mempool.TxInfo{}))
 	require.NoError(mpool.CheckTx([]byte{5, 6, 7, 8, 9}, func(r *abci.Response) {}, mempool.TxInfo{}))
 	require.NoError(mpool.CheckTx([]byte{1, 2, 3, 4, 5}, func(r *abci.Response) {}, mempool.TxInfo{}))
-	require.NoError(mpool.CheckTx(make([]byte, 90), func(r *abci.Response) {}, mempool.TxInfo{}))
+	require.NoError(mpool.CheckTx(make([]byte, 9990), func(r *abci.Response) {}, mempool.TxInfo{}))
 	block = executor.CreateBlock(2, commit, [32]byte{}, [32]byte(state.Sequencers.ProposerHash()), state, maxBytes)
 	require.NotNil(block)
 	assert.Equal(uint64(2), block.Header.Height)

block/initchain.go

@@ -23,7 +23,6 @@ func (m *Manager) RunInitChain(ctx context.Context) error {
 	}
 	// update the state with only the consensus pubkey
 	m.Executor.UpdateStateAfterInitChain(m.State, res)
-	m.ValidateConsensusBlockParams()
 	m.Executor.UpdateMempoolAfterInitChain(m.State)
 	if _, err := m.Store.SaveState(m.State, nil); err != nil {
 		return err

block/manager.go

@@ -33,9 +33,6 @@ import (
 	"github.com/dymensionxyz/dymint/types"
 )
 
-// default minimum block max size allowed. not specific reason to set it to 10K, but we need to avoid no transactions can be included in a block.
-const minBlockMaxBytes = 10000
-
 // Manager is responsible for aggregating transactions into blocks.
 type Manager struct {
 	logger types.Logger
@@ -327,14 +324,3 @@ func (m *Manager) setDA(daconfig string, dalcKV store.KV, logger log.Logger) err
 	m.Retriever = retriever
 	return nil
 }
-
-func (m *Manager) ValidateConsensusBlockParams() {
-	if m.State.ConsensusParams.Block.MaxBytes < minBlockMaxBytes {
-		m.logger.Info("Block max bytes in consensus params lower than minimum accepted in consensus params. Using minimum accepted as max block bytes.", "block_max_bytes", m.State.ConsensusParams.Block.MaxBytes, "min_max_bytes", minBlockMaxBytes)
-		m.State.ConsensusParams.Block.MaxBytes = minBlockMaxBytes
-	}
-	if m.State.ConsensusParams.Block.MaxBytes > int64(m.Conf.BatchSubmitBytes) {
-		m.logger.Info("Block max bytes in consensus params higher than DA batch size. Using DA batch size as max block bytes.", "block_max_bytes", m.State.ConsensusParams.Block.MaxBytes, "DA_batch_size", m.Conf.BatchSubmitBytes)
-		m.State.ConsensusParams.Block.MaxBytes = minBlockMaxBytes
-	}
-}

block/produce.go

@@ -148,7 +148,7 @@ func (m *Manager) produceBlock(allowEmpty bool, nextProposerHash *[32]byte) (*ty
 		return nil, nil, fmt.Errorf("load block: height: %d: %w: %w", newHeight, err, ErrNonRecoverable)
 	}
 
-	maxBlockDataSize := uint32(float64(m.Conf.BatchSubmitBytes) * types.MaxBlockSizeAdjustment)
+	maxBlockDataSize := uint64(float64(m.Conf.BatchSubmitBytes) * types.MaxBlockSizeAdjustment)
 	proposerHashForBlock := [32]byte(m.State.Sequencers.ProposerHash())
 	// if nextProposerHash is set, we create a last block
 	if nextProposerHash != nil {

block/state.go

@@ -90,7 +90,6 @@ func (m *Manager) UpdateStateFromApp() error {
 
 	// update the state with the app hashes created on the app commit
 	m.Executor.UpdateStateAfterCommit(m.State, resp, proxyAppInfo.LastBlockAppHash, appHeight)
-	m.ValidateConsensusBlockParams()
 
 	return nil
 }
@@ -108,20 +107,6 @@ func (e *Executor) UpdateStateAfterInitChain(s *types.State, res *abci.ResponseI
 			s.ConsensusParams.Block.MaxBytes = params.Block.MaxBytes
 			s.ConsensusParams.Block.MaxGas = params.Block.MaxGas
 		}
-		if params.Evidence != nil {
-			s.ConsensusParams.Evidence.MaxAgeNumBlocks = params.Evidence.MaxAgeNumBlocks
-			s.ConsensusParams.Evidence.MaxAgeDuration = params.Evidence.MaxAgeDuration
-			s.ConsensusParams.Evidence.MaxBytes = params.Evidence.MaxBytes
-		}
-		if params.Validator != nil {
-			// Copy params.Validator.PubkeyTypes, and set result's value to the copy.
-			// This avoids having to initialize the slice to 0 values, and then write to it again.
-			s.ConsensusParams.Validator.PubKeyTypes = append([]string{}, params.Validator.PubKeyTypes...)
-		}
-		if params.Version != nil {
-			s.ConsensusParams.Version.AppVersion = params.Version.AppVersion
-		}
-		s.Version.Consensus.App = s.ConsensusParams.Version.AppVersion
 	}
 	// We update the last results hash with the empty hash, to conform with RFC-6962.
 	copy(s.LastResultsHash[:], merkle.HashFromByteSlices(nil))

p2p/validator_test.go

@@ -129,7 +129,7 @@ func TestValidator_BlockValidator(t *testing.T) {
 			assert.NoError(t, err)
 
 			// Create state
-			maxBytes := uint32(100)
+			maxBytes := uint64(100)
 			state := &types.State{}
 			state.Sequencers.SetProposer(types.NewSequencerFromValidator(*tmtypes.NewValidator(proposerKey.PubKey(), 1)))
 			state.ConsensusParams.Block.MaxGas = 100000