feat!: pack squares densely by implementing ADR013

pkg/appconsts/appconsts.go

@@ -72,16 +72,11 @@ const (
 	// data square.
 	MinShareCount = DefaultMinSquareSize * DefaultMinSquareSize
 
-	// SubtreeRootThreshold dictates the threashold for increasing the sub
-	// tree root height for blobs. If the number of subtree roots used to create
-	// a share commitment surpasses this threshold, then the height is
-	// increased. The rationale for this value is described in more detail in
-	// ADR013 (./docs/architecture/adr-013). Note that this value should not
-	// drop below the max square size. That could result in the caculating a sub
-	// tree width for a blob that is larger than whatever the actual suquare
-	// size for that block. Having a value that is larger than the square is
-	// simply wasteful in that the proofs for large blobs are unnecessarily
-	// large.
+	// SubtreeRootThreshold works as a target value for the number of subtree roots in the
+	// share commitment. If a blob contains more shares than this number, than the height
+	// of the subtree roots will gradually increases to so that the amount remains within that limit.
+	// The rationale for this value is described in more detail in ADR013
+	// (./docs/architecture/adr-013).
 	// ADR013 https://github.com/celestiaorg/celestia-app/blob/e905143e8fe138ce6085ae9a5c1af950a2d87638/docs/architecture/adr-013-non-interactive-default-rules-for-zero-padding.md //nolint: lll
 	SubtreeRootThreshold = DefaultMaxSquareSize
 

pkg/inclusion/paths.go

@@ -29,11 +29,11 @@ func calculateCommitmentPaths(squareSize, start, blobShareLen int) []path {
 			end = normalizedEndIndex
 		}
 
-		// subTreeRootMaxHeight is the maximum height of a subtree root that was
+		// subTreeRootMaxDepth is the maximum depth of a subtree root that was
 		// used to generate the commitment. The height is based on the
 		// SubtreeRootThreshold. See ADR-013 for more details.
-		subTreeRootMaxHeight := int(math.Log2(float64(shares.SubTreeWidth(blobShareLen))))
-		minDepth := maxDepth - subTreeRootMaxHeight
+		subTreeRootMaxDepth := int(math.Log2(float64(shares.SubTreeWidth(blobShareLen))))
+		minDepth := maxDepth - subTreeRootMaxDepth
 		coords := calculateSubTreeRootCoordinates(maxDepth, minDepth, start, end)
 		for _, c := range coords {
 			paths = append(paths, path{

pkg/shares/non_interactive_defaults.go

@@ -92,7 +92,7 @@ func BlobMinSquareSize(shareCount int) int {
 	return RoundUpPowerOfTwo(int(math.Ceil(math.Sqrt(float64(shareCount)))))
 }
 
-// SubTreeWidth determines the number of leaves per subtree in the share
+// SubTreeWidth determines the maximum number of leaves per subtree in the share
 // commitment over a given blob. The input should be the total number of shares
 // used by that blob. The reasoning behind this algorithm is discussed in depth
 // in ADR013
@@ -113,11 +113,7 @@ func SubTreeWidth(shareCount int) int {
 
 	// use the minimum of the subtree width and the min square size, this
 	// gurarantees that a valid value is returned
-	s = min(s, BlobMinSquareSize(shareCount))
-
-	// using a value below the min square size is wasteful, see ADR013 for more
-	// details
-	return max(s, appconsts.DefaultMinSquareSize)
+	return min(s, BlobMinSquareSize(shareCount))
 }
 
 func min[T constraints.Integer](i, j T) T {
@@ -127,13 +123,6 @@ func min[T constraints.Integer](i, j T) T {
 	return j
 }
 
-func max[T constraints.Integer](i, j T) T {
-	if i > j {
-		return i
-	}
-	return j
-}
-
 // isStartOfRow returns true if cursor is at the start of a row
 func isStartOfRow(cursor, squareSize int) bool {
 	return cursor == 0 || cursor%squareSize == 0

pkg/shares/non_interactive_defaults_test.go

@@ -369,7 +369,7 @@ func Test_roundUpBy(t *testing.T) {
 	}
 }
 
-func TestMinSquareSize(t *testing.T) {
+func TestBlobMinSquareSize(t *testing.T) {
 	type testCase struct {
 		shareCount int
 		want       int
@@ -475,7 +475,6 @@ func TestSubTreeWidth(t *testing.T) {
 		t.Run(fmt.Sprintf("shareCount %d", tc.shareCount), func(t *testing.T) {
 			got := SubTreeWidth(tc.shareCount)
 			assert.Equal(t, tc.want, got, i)
-			assert.GreaterOrEqual(t, got, appconsts.DefaultMinSquareSize)
 		})
 	}
 }