fix(manager): use block params from consensus param

block/executor.go

@@ -16,6 +16,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,6 +63,7 @@ func (e *Executor) InitChain(genesis *tmtypes.GenesisDoc, valset []*tmtypes.Vali
 			Power:  validator.VotingPower,
 		})
 	}
+
 	params := genesis.ConsensusParams
 
 	return e.proxyAppConsensusConn.InitChainSync(abci.RequestInitChain{
@@ -81,19 +85,16 @@ func (e *Executor) InitChain(genesis *tmtypes.GenesisDoc, valset []*tmtypes.Vali
 			Version: &tmproto.VersionParams{
 				AppVersion: params.Version.AppVersion,
 			},
-		},
-		Validators:    valUpdates,
+		}, 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 uint64) *types.Block {
-	if state.ConsensusParams.Blockmaxsize > 0 {
-		maxBlockDataSizeBytes = min(maxBlockDataSizeBytes, uint64(state.ConsensusParams.Blockmaxsize))
-	}
-	mempoolTxs := e.mempool.ReapMaxBytesMaxGas(int64(maxBlockDataSizeBytes), state.ConsensusParams.Blockmaxgas)
+	maxBlockDataSizeBytes = min(maxBlockDataSizeBytes, uint64(max(minBlockMaxBytes, state.ConsensusParams.Block.MaxBytes)))
+	mempoolTxs := e.mempool.ReapMaxBytesMaxGas(int64(maxBlockDataSizeBytes), state.ConsensusParams.Block.MaxGas)
 
 	block := &types.Block{
 		Header: types.Header{
@@ -160,8 +161,8 @@ func (e *Executor) commit(state *types.State, block *types.Block, deliverTxs []*
 		return nil, 0, err
 	}
 
-	maxBytes := state.ConsensusParams.Blockmaxsize
-	maxGas := state.ConsensusParams.Blockmaxgas
+	maxBytes := state.ConsensusParams.Block.MaxBytes
+	maxGas := state.ConsensusParams.Block.MaxGas
 	err = e.mempool.Update(int64(block.Header.Height), fromDymintTxs(block.Data.Txs), deliverTxs)
 	if err != nil {
 		return nil, 0, err

block/executor_test.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/dymensionxyz/dymint/block"
-	"github.com/dymensionxyz/dymint/types/pb/dymint"
 
 	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
@@ -61,11 +60,8 @@ func TestCreateBlock(t *testing.T) {
 	// Init state
 	state := &types.State{}
 	state.Sequencers.SetProposer(types.NewSequencerFromValidator(*tmtypes.NewValidator(tmPubKey, 1)))
-	state.ConsensusParams = dymint.RollappConsensusParams{
-		Blockmaxsize: int64(maxBytes),
-		Blockmaxgas:  100000,
-	}
-
+	state.ConsensusParams.Block.MaxBytes = int64(maxBytes)
+	state.ConsensusParams.Block.MaxGas = 100000
 	// empty block
 	block := executor.CreateBlock(1, &types.Commit{}, [32]byte{}, [32]byte(state.Sequencers.ProposerHash()[:]), state, maxBytes)
 	require.NotNil(block)
@@ -103,11 +99,13 @@ func TestApplyBlock(t *testing.T) {
 	app.On("DeliverTx", mock.Anything).Return(abci.ResponseDeliverTx{})
 	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{
 		RollappConsensusParamUpdates: &abci.RollappConsensusParams{
-			Da:     "celestia",
-			Commit: "abcde",
+			Da:      "celestia",
+			Version: "abcde",
+		},
+		ConsensusParamUpdates: &abci.ConsensusParams{
 			Block: &abci.BlockParams{
-				MaxBytes: 100,
 				MaxGas:   100,
+				MaxBytes: 100,
 			},
 		},
 	})
@@ -167,13 +165,10 @@ func TestApplyBlock(t *testing.T) {
 	state.Sequencers.SetProposer(types.NewSequencerFromValidator(*tmtypes.NewValidator(tmPubKey, 1)))
 	state.InitialHeight = 1
 	state.SetHeight(0)
-	maxBytes := uint64(1000)
-	state.ConsensusParams = dymint.RollappConsensusParams{
-		Blockmaxgas:  100000,
-		Blockmaxsize: int64(maxBytes),
-		Da:           "mock",
-		Commit:       "",
-	}
+	maxBytes := uint64(10000)
+	state.ConsensusParams.Block.MaxBytes = int64(maxBytes)
+	state.ConsensusParams.Block.MaxGas = 100000
+	state.RollappParams.Da = "mock"
 
 	// Create first block with one Tx from mempool
 	_ = mpool.CheckTx([]byte{1, 2, 3, 4}, func(r *abci.Response) {}, mempool.TxInfo{})
@@ -212,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)
@@ -258,10 +253,10 @@ func TestApplyBlock(t *testing.T) {
 	assert.Equal(uint64(2), state.Height())
 
 	// check rollapp params update
-	assert.Equal(state.ConsensusParams.Da, "celestia")
-	assert.Equal(state.ConsensusParams.Commit, "abcde")
-	assert.Equal(state.ConsensusParams.Blockmaxsize, int64(100))
-	assert.Equal(state.ConsensusParams.Blockmaxgas, int64(100))
+	assert.Equal(state.RollappParams.Da, "celestia")
+	assert.Equal(state.RollappParams.Version, "abcde")
+	assert.Equal(state.ConsensusParams.Block.MaxBytes, int64(100))
+	assert.Equal(state.ConsensusParams.Block.MaxGas, int64(100))
 
 	// wait for at least 4 Tx events, for up to 3 second.
 	// 3 seconds is a fail-scenario only

block/initchain.go

@@ -27,6 +27,5 @@ func (m *Manager) RunInitChain(ctx context.Context) error {
 	if _, err := m.Store.SaveState(m.State, nil); err != nil {
 		return err
 	}
-
 	return nil
 }

block/manager.go

@@ -289,28 +289,24 @@ func (m *Manager) UpdateTargetHeight(h uint64) {
 
 // ValidateConfigWithRollappParams checks the configuration params are consistent with the params in the dymint state (e.g. DA and version)
 func (m *Manager) ValidateConfigWithRollappParams() error {
-	if version.Commit != m.State.ConsensusParams.Commit {
-		return fmt.Errorf("binary version mismatch. rollapp param: %s binary used:%s", version.Commit, m.State.ConsensusParams.Commit)
+	if version.Commit != m.State.RollappParams.Version {
+		return fmt.Errorf("binary version mismatch. rollapp param: %s binary used:%s", m.State.RollappParams.Version, version.Commit)
 	}
 
-	if da.Client(m.State.ConsensusParams.Da) != m.DAClient.GetClientType() {
-		return fmt.Errorf("da client mismatch. rollapp param: %s da configured: %s", m.DAClient.GetClientType(), m.State.ConsensusParams.Da)
+	if da.Client(m.State.RollappParams.Da) != m.DAClient.GetClientType() {
+		return fmt.Errorf("da client mismatch. rollapp param: %s da configured: %s", m.State.RollappParams.Da, m.DAClient.GetClientType())
 	}
 
 	if m.Conf.BatchSubmitBytes > uint64(m.DAClient.GetMaxBlobSizeBytes()) {
-		return fmt.Errorf("batch size above limit %d: DA %s", m.DAClient.GetMaxBlobSizeBytes(), m.DAClient.GetClientType())
-	}
-
-	if m.State.ConsensusParams.Blockmaxsize > int64(m.DAClient.GetMaxBlobSizeBytes()) {
-		return fmt.Errorf("max block size above limit: %d: DA: %s", int64(m.DAClient.GetMaxBlobSizeBytes()), m.DAClient.GetClientType())
+		return fmt.Errorf("batch size above limit: batch size: %d limit: %d: DA %s", m.Conf.BatchSubmitBytes, m.DAClient.GetMaxBlobSizeBytes(), m.DAClient.GetClientType())
 	}
 
 	return nil
 }
 
 // setDA initializes DA client in blockmanager according to DA type set in genesis or stored in state
 func (m *Manager) setDA(daconfig string, dalcKV store.KV, logger log.Logger) error {
-	daLayer := m.State.ConsensusParams.Da
+	daLayer := m.State.RollappParams.Da
 	dalc := registry.GetClient(daLayer)
 	if dalc == nil {
 		return fmt.Errorf("get data availability client named '%s'", daLayer)

block/manager_test.go

@@ -128,14 +128,18 @@ func TestInitialState(t *testing.T) {
 func TestProduceOnlyAfterSynced(t *testing.T) {
 	// Init app
 	app := testutil.GetAppMock(testutil.EndBlock)
-	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{RollappConsensusParamUpdates: &abci.RollappConsensusParams{
-		Da:     "mock",
-		Commit: version.Commit,
-		Block: &abci.BlockParams{
-			MaxBytes: 500000,
-			MaxGas:   40000000,
+	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{
+		RollappConsensusParamUpdates: &abci.RollappConsensusParams{
+			Da:      "mock",
+			Version: version.Commit,
 		},
-	}})
+		ConsensusParamUpdates: &abci.ConsensusParams{
+			Block: &abci.BlockParams{
+				MaxGas:   40000000,
+				MaxBytes: 500000,
+			},
+		},
+	})
 	// Create proxy app
 	clientCreator := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(clientCreator)
@@ -207,14 +211,18 @@ func TestProduceNewBlock(t *testing.T) {
 	app := testutil.GetAppMock(testutil.Commit, testutil.EndBlock)
 	commitHash := [32]byte{1}
 	app.On("Commit", mock.Anything).Return(abci.ResponseCommit{Data: commitHash[:]})
-	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{RollappConsensusParamUpdates: &abci.RollappConsensusParams{
-		Da:     "mock",
-		Commit: version.Commit,
-		Block: &abci.BlockParams{
-			MaxBytes: 500000,
-			MaxGas:   40000000,
+	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{
+		RollappConsensusParamUpdates: &abci.RollappConsensusParams{
+			Da:      "mock",
+			Version: version.Commit,
+		},
+		ConsensusParamUpdates: &abci.ConsensusParams{
+			Block: &abci.BlockParams{
+				MaxGas:   40000000,
+				MaxBytes: 500000,
+			},
 		},
-	}})
+	})
 	// Create proxy app
 	clientCreator := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(clientCreator)
@@ -236,14 +244,18 @@ func TestProducePendingBlock(t *testing.T) {
 	app := testutil.GetAppMock(testutil.Commit, testutil.EndBlock)
 	commitHash := [32]byte{1}
 	app.On("Commit", mock.Anything).Return(abci.ResponseCommit{Data: commitHash[:]})
-	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{RollappConsensusParamUpdates: &abci.RollappConsensusParams{
-		Da:     "mock",
-		Commit: version.Commit,
-		Block: &abci.BlockParams{
-			MaxBytes: 500000,
-			MaxGas:   40000000,
+	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{
+		RollappConsensusParamUpdates: &abci.RollappConsensusParams{
+			Da:      "mock",
+			Version: version.Commit,
 		},
-	}})
+		ConsensusParamUpdates: &abci.ConsensusParams{
+			Block: &abci.BlockParams{
+				MaxGas:   40000000,
+				MaxBytes: 500000,
+			},
+		},
+	})
 	// Create proxy app
 	clientCreator := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(clientCreator)
@@ -346,14 +358,18 @@ func TestProduceBlockFailAfterCommit(t *testing.T) {
 				LastBlockHeight:  tc.LastAppBlockHeight,
 				LastBlockAppHash: tc.LastAppCommitHash[:],
 			})
-			app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{RollappConsensusParamUpdates: &abci.RollappConsensusParams{
-				Da:     "mock",
-				Commit: version.Commit,
-				Block: &abci.BlockParams{
-					MaxBytes: 500000,
-					MaxGas:   40000000,
+			app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{
+				RollappConsensusParamUpdates: &abci.RollappConsensusParams{
+					Da:      "mock",
+					Version: version.Commit,
+				},
+				ConsensusParamUpdates: &abci.ConsensusParams{
+					Block: &abci.BlockParams{
+						MaxGas:   40000000,
+						MaxBytes: 500000,
+					},
 				},
-			}})
+			})
 			mockStore.ShouldFailUpdateStateWithBatch = tc.shoudFailOnSaveState
 			_, _, _ = manager.ProduceApplyGossipBlock(context.Background(), true)
 			storeState, err := manager.Store.LoadState()
@@ -374,14 +390,18 @@ func TestCreateNextDABatchWithBytesLimit(t *testing.T) {
 	assert := assert.New(t)
 	require := require.New(t)
 	app := testutil.GetAppMock(testutil.EndBlock)
-	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{RollappConsensusParamUpdates: &abci.RollappConsensusParams{
-		Da:     "mock",
-		Commit: version.Commit,
-		Block: &abci.BlockParams{
-			MaxBytes: 500000,
-			MaxGas:   40000000,
+	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{
+		RollappConsensusParamUpdates: &abci.RollappConsensusParams{
+			Da:      "mock",
+			Version: version.Commit,
+		},
+		ConsensusParamUpdates: &abci.ConsensusParams{
+			Block: &abci.BlockParams{
+				MaxGas:   40000000,
+				MaxBytes: 500000,
+			},
 		},
-	}})
+	})
 	// Create proxy app
 	clientCreator := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(clientCreator)
@@ -452,14 +472,18 @@ func TestDAFetch(t *testing.T) {
 	require := require.New(t)
 	// Setup app
 	app := testutil.GetAppMock(testutil.Info, testutil.Commit, testutil.EndBlock)
-	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{RollappConsensusParamUpdates: &abci.RollappConsensusParams{
-		Da:     "mock",
-		Commit: version.Commit,
-		Block: &abci.BlockParams{
-			MaxBytes: 500000,
-			MaxGas:   40000000,
+	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{
+		RollappConsensusParamUpdates: &abci.RollappConsensusParams{
+			Da:      "mock",
+			Version: version.Commit,
+		},
+		ConsensusParamUpdates: &abci.ConsensusParams{
+			Block: &abci.BlockParams{
+				MaxGas:   40000000,
+				MaxBytes: 500000,
+			},
 		},
-	}})
+	})
 	// Create proxy app
 	clientCreator := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(clientCreator)

block/production_test.go

@@ -37,14 +37,18 @@ func TestCreateEmptyBlocksEnableDisable(t *testing.T) {
 	assert := assert.New(t)
 	require := require.New(t)
 	app := testutil.GetAppMock(testutil.EndBlock)
-	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{RollappConsensusParamUpdates: &abci.RollappConsensusParams{
-		Da:     "mock",
-		Commit: version.Commit,
-		Block: &abci.BlockParams{
-			MaxBytes: 500000,
-			MaxGas:   40000000,
+	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{
+		RollappConsensusParamUpdates: &abci.RollappConsensusParams{
+			Da:      "mock",
+			Version: version.Commit,
 		},
-	}})
+		ConsensusParamUpdates: &abci.ConsensusParams{
+			Block: &abci.BlockParams{
+				MaxGas:   40000000,
+				MaxBytes: 500000,
+			},
+		},
+	})
 	// Create proxy app
 	clientCreator := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(clientCreator)
@@ -197,14 +201,18 @@ func TestStopBlockProduction(t *testing.T) {
 	require := require.New(t)
 
 	app := testutil.GetAppMock(testutil.EndBlock)
-	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{RollappConsensusParamUpdates: &abci.RollappConsensusParams{
-		Da:     "mock",
-		Commit: version.Commit,
-		Block: &abci.BlockParams{
-			MaxBytes: 500000,
-			MaxGas:   40000000,
+	app.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{
+		RollappConsensusParamUpdates: &abci.RollappConsensusParams{
+			Da:      "mock",
+			Version: version.Commit,
+		},
+		ConsensusParamUpdates: &abci.ConsensusParams{
+			Block: &abci.BlockParams{
+				MaxGas:   40000000,
+				MaxBytes: 500000,
+			},
 		},
-	}})
+	})
 	// Create proxy app
 	clientCreator := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(clientCreator)