(consensus/params): Set default value of BlobParams.maxBytes to 0 (#19)

* Set default value of blob params to 0

* Added maxBytes param update to e2e

* Update ci.toml with proper blob_max_bytes value and fix check

* fixed edge case when blobs are disabled, lowered the height they are activated at

* Minor fixes to address initial comments

* BlobMaxBytes update logic is the same as VE

* Removed printf

* Moved BlobMaxBytes var close to BlobMaxBytesUpdateHeight

* Do not use blob in UTs

* Fix UT to use blobs and set maxBlobBytes to 800kb

* Fix typo

* Applied review comments

* Fix UTs

* Update comment

Co-authored-by: Sergio Mena <[email protected]>

* Update comment

Co-authored-by: Sergio Mena <[email protected]>

---------

Co-authored-by: Sergio Mena <[email protected]>

Author: jmalicevic

consensus/byzantine_test.go

@@ -353,6 +353,7 @@ func TestByzantineConflictingProposalsWithPartition(t *testing.T) {
 		require.NoError(t, err)
 
 		conR := NewReactor(css[i], true) // so we don't start the consensus states
+		conR.conS.state.ConsensusParams.Blob.MaxBytes = types.MaxBlobSizeBytes
 		conR.SetLogger(logger.With("validator", i))
 		conR.SetEventBus(eventBus)
 

consensus/common_test.go

@@ -513,13 +513,13 @@ func loadPrivValidator(config *cfg.Config) *privval.FilePV {
 }
 
 func randState(nValidators int) (*State, []*validatorStub) {
-	return randStateWithApp(nValidators, kvstore.NewInMemoryApplication())
+	return randStateWithApp(nValidators, kvstore.NewInMemoryApplication(), false)
 }
 
 func randStateWithBlob(nValidators int) (*State, []*validatorStub) {
 	app := kvstore.NewInMemoryApplication()
 	app.SetGenerateBlobs()
-	return randStateWithApp(nValidators, app)
+	return randStateWithApp(nValidators, app, true)
 }
 
 func randStateWithAppWithHeight(
@@ -531,8 +531,11 @@ func randStateWithAppWithHeight(
 	c.ABCI.VoteExtensionsEnableHeight = height
 	return randStateWithAppImpl(nValidators, app, c)
 }
-func randStateWithApp(nValidators int, app abci.Application) (*State, []*validatorStub) {
+func randStateWithApp(nValidators int, app abci.Application, blob bool) (*State, []*validatorStub) {
 	c := test.ConsensusParams()
+	if blob {
+		c.Blob.MaxBytes = 100
+	}
 	return randStateWithAppImpl(nValidators, app, c)
 }
 
@@ -877,6 +880,7 @@ func randConsensusNetWithPeers(
 	appFunc func(string) abci.Application,
 ) ([]*State, *types.GenesisDoc, *cfg.Config, cleanupFunc) {
 	c := test.ConsensusParams()
+	c.Blob.MaxBytes = 100
 	genDoc, privVals := randGenesisDoc(nValidators, false, testMinPower, c)
 	css := make([]*State, nPeers)
 	logger := consensusLogger()

consensus/reactor_test.go

@@ -421,8 +421,8 @@ func TestReactorRecordsVotesAndBlockPartsAndBlobParts(t *testing.T) {
 	n := 4
 
 	css, _, _, cleanup := randConsensusNetWithPeers(t, n, n, "consensus_reactor_test", newMockTickerFunc(true), newPersistentKVStoreWithPathAndBlob)
-
 	defer cleanup()
+
 	reactors, blocksSubs, eventBuses := startConsensusNet(t, css, n)
 	defer stopConsensusNet(log.TestingLogger(), reactors, eventBuses)
 

consensus/state_test.go

@@ -1655,7 +1655,7 @@ func TestProcessProposalAccept(t *testing.T) {
 			}
 			m.On("ProcessProposal", mock.Anything, mock.Anything).Return(&abci.ResponseProcessProposal{Status: status}, nil)
 			m.On("PrepareProposal", mock.Anything, mock.Anything).Return(&abci.ResponsePrepareProposal{}, nil).Maybe()
-			cs1, _ := randStateWithApp(4, m)
+			cs1, _ := randStateWithApp(4, m, false)
 			height, round := cs1.Height, cs1.Round
 
 			proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
@@ -1796,7 +1796,7 @@ func TestVerifyVoteExtensionNotCalledOnAbsentPrecommit(t *testing.T) {
 	}, nil)
 	m.On("FinalizeBlock", mock.Anything, mock.Anything).Return(&abci.ResponseFinalizeBlock{}, nil).Maybe()
 	m.On("Commit", mock.Anything, mock.Anything).Return(&abci.ResponseCommit{}, nil).Maybe()
-	cs1, vss := randStateWithApp(4, m)
+	cs1, vss := randStateWithApp(4, m, false)
 	height, round := cs1.Height, cs1.Round
 	cs1.state.ConsensusParams.ABCI.VoteExtensionsEnableHeight = cs1.Height
 
@@ -1890,7 +1890,7 @@ func TestPrepareProposalReceivesVoteExtensions(t *testing.T) {
 	m.On("Commit", mock.Anything, mock.Anything).Return(&abci.ResponseCommit{}, nil).Maybe()
 	m.On("FinalizeBlock", mock.Anything, mock.Anything).Return(&abci.ResponseFinalizeBlock{}, nil)
 
-	cs1, vss := randStateWithApp(4, m)
+	cs1, vss := randStateWithApp(4, m, false)
 	height, round := cs1.Height, cs1.Round
 
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
@@ -1994,7 +1994,7 @@ func TestFinalizeBlockCalled(t *testing.T) {
 			m.On("FinalizeBlock", mock.Anything, mock.Anything).Return(r, nil).Maybe()
 			m.On("Commit", mock.Anything, mock.Anything).Return(&abci.ResponseCommit{}, nil).Maybe()
 
-			cs1, vss := randStateWithApp(4, m)
+			cs1, vss := randStateWithApp(4, m, false)
 			height, round := cs1.Height, cs1.Round
 
 			proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)

test/e2e/app/app.go

@@ -24,6 +24,7 @@ import (
 	"github.com/cometbft/cometbft/libs/protoio"
 	cryptoproto "github.com/cometbft/cometbft/proto/tendermint/crypto"
 	cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
+
 	cmttypes "github.com/cometbft/cometbft/types"
 	"github.com/cometbft/cometbft/version"
 )
@@ -36,6 +37,7 @@ const (
 	suffixChainID       string = "ChainID"
 	suffixVoteExtHeight string = "VoteExtensionsHeight"
 	suffixInitialHeight string = "InitialHeight"
+	suffixBlobMaxBytes  string = "BlobMaxBytes"
 )
 
 // Application is an ABCI application for use by end-to-end tests. It is a
@@ -111,6 +113,16 @@ type Config struct {
 	// -1 denotes it is set at genesis.
 	// 0 denotes it is set at InitChain.
 	VoteExtensionsUpdateHeight int64 `toml:"vote_extensions_update_height"`
+
+	// BlobMaxBytesUpdateHeight configures the height at which the
+	// blob max bytes consensus parameters are updated
+	// -1 means the max_bytes value is set at genesis
+	// 0 means the max_bytes value is set at InitChain
+	// >0 means the max_bytes value is set at the given height
+	BlobMaxBytesUpdateHeight int64 `toml:"blob_max_bytes_update_height"`
+
+	// BlobMaxBytes is the value of max bytes for blobs
+	BlobMaxBytes int64 `toml:"blob_max_bytes"`
 }
 
 func DefaultConfig(dir string) *Config {
@@ -123,14 +135,15 @@ func DefaultConfig(dir string) *Config {
 
 // blobOracle can tell you the expected blob on a specific height.
 // It can be used to add blobs to proposals or simulate network peer responses.
-// Blob properties: height modulo 4
+// Blob properties: height modulo 5
 // 0 - no blob
 // 1 - blob is exactly 8 bytes long and contains the height truncated into a byte 8 times
 // 2 - blob is empty ([]byte{})
 // 3 - blob is variable length string that contains "BLOBXXX" where XXX is height multiplied by 0x80 in hex
 // 4 - blob is the size of MaxBlobSizeBytes and contains height truncated into two bytes repeated.
 func blobOracle(height int64) ([]byte, bool) {
-	switch height % 4 {
+
+	switch height % 5 {
 	case 1:
 		truncatedHeight := byte(height % 0x100)
 		data := bytes.Repeat([]byte{truncatedHeight}, 8)
@@ -141,7 +154,7 @@ func blobOracle(height int64) ([]byte, bool) {
 		return []byte(fmt.Sprintf("BLOB%x", height*0x80)), true
 	case 4:
 		truncatedHeight := byte(height % 0x10000)
-		data := bytes.Repeat([]byte{truncatedHeight}, cmttypes.MaxBlobSizeBytes/4)
+		data := bytes.Repeat([]byte{truncatedHeight}, cmttypes.MaxBlobSizeBytes)
 		return data, true
 	}
 	return nil, false
@@ -204,6 +217,26 @@ func (app *Application) Info(context.Context, *abci.RequestInfo) (*abci.Response
 	}, nil
 }
 
+// Expected to be called with params set
+func (app *Application) updateBlobMaxBytes(currentHeight int64, params *cmtproto.ConsensusParams) *cmtproto.ConsensusParams {
+
+	if app.cfg.BlobMaxBytesUpdateHeight == currentHeight {
+		app.logger.Info("updating blob max bytes on the fly",
+			"current_height", currentHeight,
+			"blob_max_bytes_update_height", app.cfg.BlobMaxBytesUpdateHeight)
+		if params == nil {
+			params = &cmtproto.ConsensusParams{}
+		}
+		params.Blob = &cmtproto.BlobParams{
+			MaxBytes: app.cfg.BlobMaxBytes,
+		}
+
+		app.logger.Info("updating blob max bytes in app_state", "height", app.cfg.BlobMaxBytes)
+		app.state.Set(prefixReservedKey+suffixBlobMaxBytes, strconv.FormatInt(app.cfg.BlobMaxBytes, 10))
+	}
+	return params
+}
+
 func (app *Application) updateVoteExtensionEnableHeight(currentHeight int64) *cmtproto.ConsensusParams {
 	var params *cmtproto.ConsensusParams
 	if app.cfg.VoteExtensionsUpdateHeight == currentHeight {
@@ -224,6 +257,7 @@ func (app *Application) updateVoteExtensionEnableHeight(currentHeight int64) *cm
 // Info implements ABCI.
 func (app *Application) InitChain(_ context.Context, req *abci.RequestInitChain) (*abci.ResponseInitChain, error) {
 	var err error
+
 	app.state.initialHeight = uint64(req.InitialHeight)
 	if len(req.AppStateBytes) > 0 {
 		err = app.state.Import(0, req.AppStateBytes)
@@ -237,6 +271,7 @@ func (app *Application) InitChain(_ context.Context, req *abci.RequestInitChain)
 	app.state.Set(prefixReservedKey+suffixVoteExtHeight, strconv.FormatInt(req.ConsensusParams.Abci.VoteExtensionsEnableHeight, 10))
 	app.logger.Info("setting initial height in app_state", "initial_height", req.InitialHeight)
 	app.state.Set(prefixReservedKey+suffixInitialHeight, strconv.FormatInt(req.InitialHeight, 10))
+	app.state.Set(prefixReservedKey+suffixBlobMaxBytes, strconv.FormatInt(req.ConsensusParams.Blob.MaxBytes, 10))
 	// Get validators from genesis
 	if req.Validators != nil {
 		for _, val := range req.Validators {
@@ -249,6 +284,8 @@ func (app *Application) InitChain(_ context.Context, req *abci.RequestInitChain)
 
 	params := app.updateVoteExtensionEnableHeight(0)
 
+	params = app.updateBlobMaxBytes(0, params)
+
 	resp := &abci.ResponseInitChain{
 		ConsensusParams: params,
 		AppHash:         app.state.GetHash(),
@@ -281,6 +318,10 @@ func (app *Application) CheckTx(_ context.Context, req *abci.RequestCheckTx) (*a
 // It returns a boolean indicating if a blob exists (either retrieved from the simaulted network or from the
 // local cache) and the blob itself.
 func (app *Application) GetBlob(height int64) ([]byte, bool, error) {
+	if !app.checkBlobEnabled("getBlob") {
+		// Blob max bytes is 0 so we cannot send a blob
+		return nil, false, nil
+	}
 	// First check the local cache
 	if blob, found := app.blobCache[height]; found {
 		if !isBlob(blob) {
@@ -317,18 +358,20 @@ func (app *Application) FinalizeBlock(_ context.Context, req *abci.RequestFinali
 	}
 
 	// Verify blob.
-	blob, exists, err := app.GetBlob(req.Height)
-	if err != nil {
-		return nil, fmt.Errorf("could not fetch blob for height %d, %s", req.Height, err.Error())
-	}
-	if exists && !VerifyBlob(req.Height, blob) {
-		return nil, fmt.Errorf("blob verification failed for height %d", req.Height)
-	}
+	if app.checkBlobEnabled("FinalizeBlock") {
+		blob, exists, err := app.GetBlob(req.Height)
+		if err != nil {
+			return nil, fmt.Errorf("could not fetch blob for height %d, %s", req.Height, err.Error())
+		}
+		if exists && !VerifyBlob(req.Height, blob) {
+			return nil, fmt.Errorf("blob verification failed for height %d", req.Height)
+		}
 
-	// This is a short-term cache so we delete the entry after we received it.
-	delete(app.blobCache, req.Height)
-	if len(app.blobCache) != 0 {
-		app.logger.Error("blob cache should be empty", "size", len(app.blobCache))
+		// This is a short-term cache so we delete the entry after we received it.
+		delete(app.blobCache, req.Height)
+		if len(app.blobCache) != 0 {
+			app.logger.Error("blob cache should be empty", "size", len(app.blobCache))
+		}
 	}
 
 	for _, ev := range req.Misbehavior {
@@ -348,6 +391,8 @@ func (app *Application) FinalizeBlock(_ context.Context, req *abci.RequestFinali
 
 	params := app.updateVoteExtensionEnableHeight(req.Height)
 
+	params = app.updateBlobMaxBytes(req.Height, params)
+
 	if app.cfg.FinalizeBlockDelay != 0 {
 		time.Sleep(app.cfg.FinalizeBlockDelay)
 	}
@@ -527,17 +572,23 @@ func (app *Application) PrepareProposal(
 		// Coherence: No need to call parseTx, as the check is stateless and has been performed by CheckTx
 		txs = append(txs, tx)
 	}
+	var blob []byte
+	var exists bool
 	// Generate blob for the current height.
-	blob, exists := CreateBlob(req.Height)
-
+	if app.checkBlobEnabled("prepare_proposal") {
+		blob, exists = CreateBlob(req.Height)
+		if len(blob) != 0 {
+			app.logger.Debug("Received blob", "Blob: ", blob[min(len(blob)-1, 10)])
+		}
+	}
 	if app.cfg.PrepareProposalDelay != 0 {
 		time.Sleep(app.cfg.PrepareProposalDelay)
 	}
 
 	if !exists {
 		return &abci.ResponsePrepareProposal{Txs: txs}, nil
 	}
-	fmt.Println("BLOB_1: ", blob)
+
 	return &abci.ResponsePrepareProposal{Txs: txs, Blob: blob}, nil
 }
 
@@ -548,23 +599,28 @@ func (app *Application) PrepareProposal(
 func (app *Application) ProcessProposal(_ context.Context, req *abci.RequestProcessProposal) (*abci.ResponseProcessProposal, error) {
 	r := &abci.Request{Value: &abci.Request_ProcessProposal{ProcessProposal: &abci.RequestProcessProposal{}}}
 	app.logger.Info("ABCIRequest", "request", r)
+	if app.checkBlobEnabled("ProcessProposal") {
 
-	fmt.Println("BLOB: ", req.Blob)
-
-	if !VerifyBlob(req.Height, req.Blob) {
-		app.logger.Error("invalid blob, rejecting proposal", "received height", req.Height, "received", req.Blob)
-		return &abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_REJECT}, nil
-	}
-	// Blob verification
-	if len(req.Blob) != 0 {
-		// Proposal will be accepted by us and blob exists and valid, so we store it in the cache.
-		app.blobCache[req.Height] = req.Blob
+		if !VerifyBlob(req.Height, req.Blob) {
+			app.logger.Error("invalid blob, rejecting proposal", "received height", req.Height, "received", req.Blob)
+			return &abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_REJECT}, nil
+		}
+		// Blob verification
+		if len(req.Blob) != 0 {
+			app.logger.Debug("Received blob", "Blob: ", req.Blob[min(len(req.Blob)-1, 10)])
+			// Proposal will be accepted by us and blob exists and valid, so we store it in the cache.
+			app.blobCache[req.Height] = req.Blob
+		} else {
+			// Proposal will be accepted by us and there is no blob.
+			// We make a note of it in the cache so we can inform FinalizeBlock. A real application will have better methods for this.
+			app.blobCache[req.Height] = noBlobBytes()
+		}
 	} else {
-		// Proposal will be accepted by us and there is no blob.
-		// We make a note of it in the cache so we can inform FinalizeBlock. A real application will have better methods for this.
-		app.blobCache[req.Height] = noBlobBytes()
+		if len(req.Blob) != 0 {
+			app.logger.Error("received a blob when blobs are disabled, rejecting proposal", "received height", req.Height, "received", req.Blob)
+			return &abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_REJECT}, nil
+		}
 	}
-
 	_, areExtensionsEnabled := app.checkHeightAndExtensions(true, req.Height, "ProcessProposal")
 
 	for _, tx := range req.Txs {
@@ -686,6 +742,21 @@ func (app *Application) getAppHeight() int64 {
 	return appHeight + 1
 }
 
+func (app *Application) checkBlobEnabled(callsite string) bool {
+	blobMaxBytesStr := app.state.Get(prefixReservedKey + suffixBlobMaxBytes)
+	if len(blobMaxBytesStr) == 0 {
+		panic("blob max bytes not set in database")
+	}
+	blobMaxBytes, err := strconv.ParseInt(blobMaxBytesStr, 10, 64)
+	if err != nil {
+		panic(fmt.Errorf("malformed blob max bytes %q in database", blobMaxBytesStr))
+	}
+	if blobMaxBytes == 0 {
+		return false
+	}
+	return true
+}
+
 func (app *Application) checkHeightAndExtensions(isPrepareProcessProposal bool, height int64, callsite string) (int64, bool) {
 	appHeight := app.getAppHeight()
 	if height != appHeight {

test/e2e/generator/generate.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/Masterminds/semver/v3"
 	e2e "github.com/cometbft/cometbft/test/e2e/pkg"
+	"github.com/cometbft/cometbft/types"
 	"github.com/cometbft/cometbft/version"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing/object"
@@ -62,6 +63,8 @@ var (
 	voteExtensionUpdateHeight = uniformChoice{int64(-1), int64(0), int64(1)} // -1: genesis, 0: InitChain, 1: (use offset)
 	voteExtensionEnabled      = weightedChoice{true: 3, false: 1}
 	voteExtensionHeightOffset = uniformChoice{int64(0), int64(10), int64(100)}
+	blobMaxBytesUpdateHeight  = uniformChoice{int64(-1), int64(0), int64(1)}
+	blobHeightOffset          = uniformChoice{int64(0), int64(10), int64(100)}
 )
 
 type generateConfig struct {
@@ -157,6 +160,16 @@ func generateTestnet(r *rand.Rand, opt map[string]interface{}, upgradeVersion st
 		manifest.VoteExtensionsEnableHeight = baseHeight + voteExtensionHeightOffset.Choose(r).(int64)
 	}
 
+	manifest.BlobMaxBytesUpdateHeight = blobMaxBytesUpdateHeight.Choose(r).(int64)
+
+	if manifest.BlobMaxBytesUpdateHeight == 1 {
+		manifest.BlobMaxBytesUpdateHeight = manifest.InitialHeight + blobHeightOffset.Choose(r).(int64)
+		manifest.BlobMaxBytes = types.MaxBlobSizeBytes
+	}
+
+	if manifest.BlobMaxBytesUpdateHeight == 0 {
+		manifest.BlobMaxBytes = types.MaxBlobSizeBytes
+	}
 	var numSeeds, numValidators, numFulls, numLightClients int
 	switch opt["topology"].(string) {
 	case "single":

test/e2e/networks/ci.toml

@@ -5,6 +5,8 @@ ipv6 = true
 initial_height = 1000
 vote_extensions_update_height = -1
 vote_extensions_enable_height = 1000
+blob_max_bytes_update_height = 1000
+blob_max_bytes = 819200
 evidence = 5
 initial_state = { initial01 = "a", initial02 = "b", initial03 = "c" }
 prepare_proposal_delay = "100ms"