feat: use square size params

app/estimate_square_size.go

@@ -86,7 +86,7 @@ func calculateCompactShareCount(txs []*parsedTx, squareSize int) int {
 // estimateSquareSize uses the provided block data to estimate the square size
 // assuming that all malleated txs follow the non interactive default rules.
 // Returns the estimated square size and the number of shares used.
-func estimateSquareSize(txs []*parsedTx) (uint64, int) {
+func estimateSquareSize(txs []*parsedTx, minSquareSize, maxSquareSize int) (uint64, int) {
 	// get the raw count of shares taken by each type of block data
 	txShares, msgLens := rawShareCount(txs)
 	msgShares := 0
@@ -99,8 +99,8 @@ func estimateSquareSize(txs []*parsedTx) (uint64, int) {
 	squareSize := shares.RoundUpPowerOfTwo(int(math.Ceil(math.Sqrt(float64(txShares + msgShares)))))
 
 	// the starting square size should at least be the minimum
-	if squareSize < appconsts.DefaultMinSquareSize {
-		squareSize = appconsts.DefaultMinSquareSize
+	if squareSize < minSquareSize {
+		squareSize = minSquareSize
 	}
 
 	var fits bool
@@ -113,8 +113,8 @@ func estimateSquareSize(txs []*parsedTx) (uint64, int) {
 		fits, msgShares = shares.FitsInSquare(txShares, squareSize, msgLens...)
 		switch {
 		// stop estimating if we know we can reach the max square size
-		case squareSize >= appconsts.DefaultMaxSquareSize:
-			return appconsts.DefaultMaxSquareSize, txShares + msgShares
+		case squareSize >= maxSquareSize:
+			return uint64(maxSquareSize), txShares + msgShares
 		// return if we've found a square size that fits all of the txs
 		case fits:
 			return uint64(squareSize), txShares + msgShares

app/prepare_proposal.go

@@ -22,7 +22,10 @@ func (app *App) PrepareProposal(req abci.RequestPrepareProposal) abci.ResponsePr
 
 	// estimate the square size. This estimation errors on the side of larger
 	// squares but can only return values within the min and max square size.
-	squareSize, totalSharesUsed := estimateSquareSize(parsedTxs)
+	ctx := app.NewContext(true, core.Header{Height: app.LastBlockHeight()})
+	minSquareSize := app.BlobKeeper.MinSquareSize(ctx)
+	maxSquareSize := app.BlobKeeper.MaxSquareSize(ctx)
+	squareSize, totalSharesUsed := estimateSquareSize(parsedTxs, int(minSquareSize), int(maxSquareSize))
 
 	// the totalSharesUsed can be larger that the max number of shares if we
 	// reach the max square size. In this case, we must prune the deprioritized
@@ -57,7 +60,7 @@ func (app *App) PrepareProposal(req abci.RequestPrepareProposal) abci.ResponsePr
 	}
 
 	// erasure the data square which we use to create the data root.
-	eds, err := da.ExtendShares(squareSize, shares.ToBytes(dataSquare))
+	eds, err := da.ExtendShares(squareSize, shares.ToBytes(dataSquare), uint64(minSquareSize), uint64(maxSquareSize))
 	if err != nil {
 		app.Logger().Error(
 			"failure to erasure the data square while creating a proposal block",

pkg/da/data_availability_header.go

@@ -13,11 +13,6 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
-const (
-	maxExtendedSquareWidth = appconsts.DefaultMaxSquareSize * 2
-	minExtendedSquareWidth = appconsts.DefaultMinSquareSize * 2
-)
-
 // DataAvailabilityHeader (DAHeader) contains the row and column roots of the
 // erasure coded version of the data in Block.Data. The original Block.Data is
 // split into shares and arranged in a square of width squareSize. Then, this
@@ -49,13 +44,13 @@ func NewDataAvailabilityHeader(eds *rsmt2d.ExtendedDataSquare) DataAvailabilityH
 	return dah
 }
 
-func ExtendShares(squareSize uint64, shares [][]byte) (*rsmt2d.ExtendedDataSquare, error) {
+func ExtendShares(squareSize uint64, shares [][]byte, minSquareSize, maxSquareSize uint64) (*rsmt2d.ExtendedDataSquare, error) {
 	// Check that square size is with range
-	if squareSize < appconsts.DefaultMinSquareSize || squareSize > appconsts.DefaultMaxSquareSize {
+	if squareSize < minSquareSize || squareSize > maxSquareSize {
 		return nil, fmt.Errorf(
 			"invalid square size: min %d max %d provided %d",
-			appconsts.DefaultMinSquareSize,
-			appconsts.DefaultMaxSquareSize,
+			minSquareSize,
+			maxSquareSize,
 			squareSize,
 		)
 	}
@@ -115,7 +110,7 @@ func (dah *DataAvailabilityHeader) ToProto() (*daproto.DataAvailabilityHeader, e
 	return dahp, nil
 }
 
-func DataAvailabilityHeaderFromProto(dahp *daproto.DataAvailabilityHeader) (dah *DataAvailabilityHeader, err error) {
+func DataAvailabilityHeaderFromProto(dahp *daproto.DataAvailabilityHeader, minSquareSize, maxSquareSize int) (dah *DataAvailabilityHeader, err error) {
 	if dahp == nil {
 		return nil, errors.New("nil DataAvailabilityHeader")
 	}
@@ -124,11 +119,13 @@ func DataAvailabilityHeaderFromProto(dahp *daproto.DataAvailabilityHeader) (dah
 	dah.RowsRoots = dahp.RowRoots
 	dah.ColumnRoots = dahp.ColumnRoots
 
-	return dah, dah.ValidateBasic()
+	return dah, dah.ValidateBasic(minSquareSize, maxSquareSize)
 }
 
 // ValidateBasic runs stateless checks on the DataAvailabilityHeader.
-func (dah *DataAvailabilityHeader) ValidateBasic() error {
+func (dah *DataAvailabilityHeader) ValidateBasic(minSquareSize, maxSquareSize int) error {
+	maxExtendedSquareWidth := minSquareSize * 2
+	minExtendedSquareWidth := maxSquareSize * 2
 	if dah == nil {
 		return errors.New("nil data availability header is not valid")
 	}
@@ -174,9 +171,9 @@ var tailPaddingShare = append(
 
 // MinDataAvailabilityHeader returns the minimum valid data availability header.
 // It is equal to the data availability header for an empty block
-func MinDataAvailabilityHeader() DataAvailabilityHeader {
+func MinDataAvailabilityHeader(minSqaureSize, maxSqaureSize int) DataAvailabilityHeader {
 	shares := GenerateEmptyShares(appconsts.MinShareCount)
-	eds, err := ExtendShares(appconsts.DefaultMinSquareSize, shares)
+	eds, err := ExtendShares(uint64(minSqaureSize), shares, uint64(minSqaureSize), uint64(maxSqaureSize))
 	if err != nil {
 		panic(err)
 	}

pkg/da/data_availability_header_test.go

@@ -23,13 +23,13 @@ func TestNilDataAvailabilityHeaderHashDoesntCrash(t *testing.T) {
 }
 
 func TestMinDataAvailabilityHeader(t *testing.T) {
-	dah := MinDataAvailabilityHeader()
+	dah := MinDataAvailabilityHeader(appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize)
 	expectedHash := []byte{
 		0x6f, 0x52, 0xda, 0xc1, 0x65, 0x45, 0xe4, 0x57, 0x25, 0xbe, 0x6e, 0xa3, 0x2a, 0xed, 0x55, 0x26,
 		0x6e, 0x45, 0x3, 0x48, 0x0, 0xee, 0xe1, 0xd8, 0x7c, 0x94, 0x28, 0xf4, 0x84, 0x4e, 0xa4, 0x7a,
 	}
 	require.Equal(t, expectedHash, dah.hash)
-	require.NoError(t, dah.ValidateBasic())
+	require.NoError(t, dah.ValidateBasic(appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize))
 	// important note: also see the types.TestEmptyBlockDataAvailabilityHeader test
 	// which ensures that empty block data results in the minimum data availability
 	// header
@@ -66,7 +66,7 @@ func TestNewDataAvailabilityHeader(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			eds, err := ExtendShares(tt.squareSize, tt.shares)
+			eds, err := ExtendShares(tt.squareSize, tt.shares, appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize)
 			require.NoError(t, err)
 			resdah := NewDataAvailabilityHeader(eds)
 			require.Equal(t, tt.squareSize*2, uint64(len(resdah.ColumnRoots)), tt.name)
@@ -101,7 +101,7 @@ func TestExtendShares(t *testing.T) {
 
 	for _, tt := range tests {
 		tt := tt
-		eds, err := ExtendShares(tt.squareSize, tt.shares)
+		eds, err := ExtendShares(tt.squareSize, tt.shares, appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize)
 		if tt.expectedErr {
 			require.NotNil(t, err)
 			continue
@@ -118,14 +118,14 @@ func TestDataAvailabilityHeaderProtoConversion(t *testing.T) {
 	}
 
 	shares := generateShares(appconsts.DefaultMaxSquareSize*appconsts.DefaultMaxSquareSize, 1)
-	eds, err := ExtendShares(appconsts.DefaultMaxSquareSize, shares)
+	eds, err := ExtendShares(appconsts.DefaultMaxSquareSize, shares, appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize)
 	require.NoError(t, err)
 	bigdah := NewDataAvailabilityHeader(eds)
 
 	tests := []test{
 		{
 			name: "min",
-			dah:  MinDataAvailabilityHeader(),
+			dah:  MinDataAvailabilityHeader(appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize),
 		},
 		{
 			name: "max",
@@ -137,7 +137,7 @@ func TestDataAvailabilityHeaderProtoConversion(t *testing.T) {
 		tt := tt
 		pdah, err := tt.dah.ToProto()
 		require.NoError(t, err)
-		resDah, err := DataAvailabilityHeaderFromProto(pdah)
+		resDah, err := DataAvailabilityHeaderFromProto(pdah, appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize)
 		require.NoError(t, err)
 		resDah.Hash() // calc the hash to make the comparisons fair
 		require.Equal(t, tt.dah, *resDah, tt.name)
@@ -153,7 +153,7 @@ func Test_DAHValidateBasic(t *testing.T) {
 	}
 
 	shares := generateShares(appconsts.DefaultMaxSquareSize*appconsts.DefaultMaxSquareSize, 1)
-	eds, err := ExtendShares(appconsts.DefaultMaxSquareSize, shares)
+	eds, err := ExtendShares(appconsts.DefaultMaxSquareSize, shares, appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize)
 	require.NoError(t, err)
 	bigdah := NewDataAvailabilityHeader(eds)
 
@@ -170,16 +170,16 @@ func Test_DAHValidateBasic(t *testing.T) {
 	tooSmallDah.ColumnRoots = [][]byte{bytes.Repeat([]byte{2}, 32)}
 	tooSmallDah.RowsRoots = [][]byte{bytes.Repeat([]byte{2}, 32)}
 	// use a bad hash
-	badHashDah := MinDataAvailabilityHeader()
+	badHashDah := MinDataAvailabilityHeader(appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize)
 	badHashDah.hash = []byte{1, 2, 3, 4}
 	// dah with not equal number of roots
-	mismatchDah := MinDataAvailabilityHeader()
+	mismatchDah := MinDataAvailabilityHeader(appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize)
 	mismatchDah.ColumnRoots = append(mismatchDah.ColumnRoots, bytes.Repeat([]byte{2}, 32))
 
 	tests := []test{
 		{
 			name: "min",
-			dah:  MinDataAvailabilityHeader(),
+			dah:  MinDataAvailabilityHeader(appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize),
 		},
 		{
 			name: "max",
@@ -213,7 +213,7 @@ func Test_DAHValidateBasic(t *testing.T) {
 
 	for _, tt := range tests {
 		tt := tt
-		err := tt.dah.ValidateBasic()
+		err := tt.dah.ValidateBasic(appconsts.DefaultMinSquareSize, appconsts.DefaultMaxSquareSize)
 		if tt.expectErr {
 			require.True(t, strings.Contains(err.Error(), tt.errStr), tt.name)
 			require.Error(t, err)

x/blob/types/payforblob.go

@@ -20,7 +20,6 @@ const (
 	URLMsgWirePayForBlob = "/blob.MsgWirePayForBlob"
 	URLMsgPayForBlob     = "/blob.MsgPayForBlob"
 	ShareSize            = appconsts.ShareSize
-	SquareSize           = appconsts.DefaultMaxSquareSize
 	NamespaceIDSize      = appconsts.NamespaceSize
 )