chore: internalize unneeded go apis (#92)

This PR does an initial pass of the `share` repo and internalizes things
like test methods or the `Builder` struct that should not be public.

---------

Co-authored-by: Rootul P <[email protected]>

README.md

@@ -7,7 +7,6 @@
 Package   | Description
 ----------|---------------------------------------------------------------------------------------------------------------------
 inclusion | Package inclusion contains functions to generate the blob share commitment from a given blob.
-merkle    | Package merkle computes a deterministic minimal height Merkle tree hash.
 share    | Package share contains the Share data structure.
 square    | Package square implements the logic to construct the original data square based on a list of transactions.
 

inclusion/blob_share_commitment_rules.go

@@ -1,9 +1,9 @@
 package inclusion
 
 import (
+	"fmt"
 	"math"
 
-	"github.com/celestiaorg/go-square/share"
 	"golang.org/x/exp/constraints"
 )
 
@@ -48,10 +48,31 @@ func RoundUpByMultipleOf(cursor, v int) int {
 	return ((cursor / v) + 1) * v
 }
 
+// RoundUpPowerOfTwo returns the next power of two greater than or equal to input.
+func RoundUpPowerOfTwo[I constraints.Integer](input I) I {
+	var result I = 1
+	for result < input {
+		result <<= 1
+	}
+	return result
+}
+
+// RoundDownPowerOfTwo returns the next power of two less than or equal to input.
+func RoundDownPowerOfTwo[I constraints.Integer](input I) (I, error) {
+	if input <= 0 {
+		return 0, fmt.Errorf("input %v must be positive", input)
+	}
+	roundedUp := RoundUpPowerOfTwo(input)
+	if roundedUp == input {
+		return roundedUp, nil
+	}
+	return roundedUp / 2, nil
+}
+
 // BlobMinSquareSize returns the minimum square size that can contain shareCount
 // number of shares.
 func BlobMinSquareSize(shareCount int) int {
-	return share.RoundUpPowerOfTwo(int(math.Ceil(math.Sqrt(float64(shareCount)))))
+	return RoundUpPowerOfTwo(int(math.Ceil(math.Sqrt(float64(shareCount)))))
 }
 
 // SubTreeWidth returns the maximum number of leaves per subtree in the share
@@ -69,7 +90,7 @@ func SubTreeWidth(shareCount, subtreeRootThreshold int) int {
 
 	// use a power of two equal to or larger than the multiple of the subtree
 	// root threshold
-	s = share.RoundUpPowerOfTwo(s)
+	s = RoundUpPowerOfTwo(s)
 
 	// use the minimum of the subtree width and the min square size, this
 	// gurarantees that a valid value is returned

inclusion/blob_share_commitment_rules_test.go

@@ -5,8 +5,8 @@ import (
 	"testing"
 
 	"github.com/celestiaorg/go-square/inclusion"
-	"github.com/celestiaorg/go-square/share"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -133,7 +133,7 @@ func TestNextShareIndex(t *testing.T) {
 			name:          "at threshold",
 			cursor:        11,
 			blobLen:       defaultSubtreeRootThreshold,
-			squareSize:    share.RoundUpPowerOfTwo(defaultSubtreeRootThreshold),
+			squareSize:    inclusion.RoundUpPowerOfTwo(defaultSubtreeRootThreshold),
 			expectedIndex: 11,
 		},
 		{
@@ -257,6 +257,28 @@ func TestRoundUpByMultipleOf(t *testing.T) {
 	}
 }
 
+func TestRoundUpPowerOfTwo(t *testing.T) {
+	type testCase struct {
+		input int
+		want  int
+	}
+	testCases := []testCase{
+		{input: -1, want: 1},
+		{input: 0, want: 1},
+		{input: 1, want: 1},
+		{input: 2, want: 2},
+		{input: 4, want: 4},
+		{input: 5, want: 8},
+		{input: 8, want: 8},
+		{input: 11, want: 16},
+		{input: 511, want: 512},
+	}
+	for _, tc := range testCases {
+		got := inclusion.RoundUpPowerOfTwo(tc.input)
+		assert.Equal(t, tc.want, got)
+	}
+}
+
 func TestBlobMinSquareSize(t *testing.T) {
 	type testCase struct {
 		shareCount int
@@ -366,3 +388,24 @@ func TestSubTreeWidth(t *testing.T) {
 		})
 	}
 }
+
+func TestRoundDownPowerOfTwo(t *testing.T) {
+	type testCase struct {
+		input int
+		want  int
+	}
+	testCases := []testCase{
+		{input: 1, want: 1},
+		{input: 2, want: 2},
+		{input: 4, want: 4},
+		{input: 5, want: 4},
+		{input: 8, want: 8},
+		{input: 11, want: 8},
+		{input: 511, want: 256},
+	}
+	for _, tc := range testCases {
+		got, err := inclusion.RoundDownPowerOfTwo(tc.input)
+		require.NoError(t, err)
+		assert.Equal(t, tc.want, got)
+	}
+}

inclusion/commitment.go

@@ -95,7 +95,7 @@ func MerkleMountainRangeSizes(totalSize, maxTreeSize uint64) ([]uint64, error) {
 			treeSizes = append(treeSizes, maxTreeSize)
 			totalSize -= maxTreeSize
 		case totalSize < maxTreeSize:
-			treeSize, err := sh.RoundDownPowerOfTwo(totalSize)
+			treeSize, err := RoundDownPowerOfTwo(totalSize)
 			if err != nil {
 				return treeSizes, err
 			}

share/compact_shares_test.go

@@ -1,9 +1,11 @@
 package share
 
 import (
+	"bytes"
 	"context"
 	"crypto/sha256"
 	"fmt"
+	"math/rand"
 	"testing"
 	"time"
 
@@ -15,7 +17,7 @@ func TestCompactShareSplitter(t *testing.T) {
 	// note that this test is mainly for debugging purposes, the main round trip
 	// tests occur in TestMerge and Test_processCompactShares
 	css := NewCompactShareSplitter(TxNamespace, ShareVersionZero)
-	txs := GenerateRandomTxs(33, 200)
+	txs := generateRandomTxs(33, 200)
 	for _, tx := range txs {
 		err := css.WriteTx(tx)
 		require.NoError(t, err)
@@ -73,7 +75,7 @@ func Test_processCompactShares(t *testing.T) {
 
 		// run the tests with identically sized txs
 		t.Run(fmt.Sprintf("%s idendically sized", tc.name), func(t *testing.T) {
-			txs := GenerateRandomTxs(tc.txCount, tc.txSize)
+			txs := generateRandomTxs(tc.txCount, tc.txSize)
 
 			shares, _, _, err := SplitTxs(txs)
 			require.NoError(t, err)
@@ -91,7 +93,7 @@ func Test_processCompactShares(t *testing.T) {
 
 		// run the same tests using randomly sized txs with caps of tc.txSize
 		t.Run(fmt.Sprintf("%s randomly sized", tc.name), func(t *testing.T) {
-			txs := GenerateRandomlySizedTxs(tc.txCount, tc.txSize)
+			txs := generateRandomlySizedTxs(tc.txCount, tc.txSize)
 
 			txShares, _, _, err := SplitTxs(txs)
 			require.NoError(t, err)
@@ -109,7 +111,7 @@ func Test_processCompactShares(t *testing.T) {
 }
 
 func TestAllSplit(t *testing.T) {
-	txs := GenerateRandomlySizedTxs(1000, 150)
+	txs := generateRandomlySizedTxs(1000, 150)
 	txShares, _, _, err := SplitTxs(txs)
 	require.NoError(t, err)
 	resTxs, err := ParseTxs(txShares)
@@ -118,21 +120,46 @@ func TestAllSplit(t *testing.T) {
 }
 
 func TestParseRandomOutOfContextShares(t *testing.T) {
-	txs := GenerateRandomlySizedTxs(1000, 150)
+	txs := generateRandomlySizedTxs(1000, 150)
 	txShares, _, _, err := SplitTxs(txs)
 	require.NoError(t, err)
 
 	for i := 0; i < 1000; i++ {
-		start, length := GetRandomSubSlice(len(txShares))
+		start, length := getRandomSubSlice(len(txShares))
 		randomRange := NewRange(start, start+length)
 		resTxs, err := ParseTxs(txShares[randomRange.Start:randomRange.End])
 		require.NoError(t, err)
-		assert.True(t, CheckSubArray(txs, resTxs))
+		assert.True(t, checkSubArray(txs, resTxs))
 	}
 }
 
+// getRandomSubSlice returns two integers representing a randomly sized range in the interval [0, size]
+func getRandomSubSlice(size int) (start int, length int) {
+	length = rand.Intn(size + 1)
+	start = rand.Intn(size - length + 1)
+	return start, length
+}
+
+// checkSubArray returns whether subTxList is a subarray of txList
+func checkSubArray(txList [][]byte, subTxList [][]byte) bool {
+	for i := 0; i <= len(txList)-len(subTxList); i++ {
+		j := 0
+		for j = 0; j < len(subTxList); j++ {
+			tx := txList[i+j]
+			subTx := subTxList[j]
+			if !bytes.Equal(tx, subTx) {
+				break
+			}
+		}
+		if j == len(subTxList) {
+			return true
+		}
+	}
+	return false
+}
+
 func TestParseOutOfContextSharesUsingShareRanges(t *testing.T) {
-	txs := GenerateRandomlySizedTxs(1000, 150)
+	txs := generateRandomlySizedTxs(1000, 150)
 	txShares, _, shareRanges, err := SplitTxs(txs)
 	require.NoError(t, err)
 
@@ -152,7 +179,7 @@ func TestParseOutOfContextSharesUsingShareRanges(t *testing.T) {
 
 func TestCompactShareContainsInfoByte(t *testing.T) {
 	css := NewCompactShareSplitter(TxNamespace, ShareVersionZero)
-	txs := GenerateRandomTxs(1, ContinuationCompactShareContentSize/4)
+	txs := generateRandomTxs(1, ContinuationCompactShareContentSize/4)
 
 	for _, tx := range txs {
 		err := css.WriteTx(tx)
@@ -174,7 +201,7 @@ func TestCompactShareContainsInfoByte(t *testing.T) {
 
 func TestContiguousCompactShareContainsInfoByte(t *testing.T) {
 	css := NewCompactShareSplitter(TxNamespace, ShareVersionZero)
-	txs := GenerateRandomTxs(1, ContinuationCompactShareContentSize*4)
+	txs := generateRandomTxs(1, ContinuationCompactShareContentSize*4)
 
 	for _, tx := range txs {
 		err := css.WriteTx(tx)
@@ -200,7 +227,7 @@ func Test_parseCompactSharesErrors(t *testing.T) {
 		shares []Share
 	}
 
-	txs := GenerateRandomTxs(2, ContinuationCompactShareContentSize*4)
+	txs := generateRandomTxs(2, ContinuationCompactShareContentSize*4)
 	txShares, _, _, err := SplitTxs(txs)
 	require.NoError(t, err)
 	rawShares := ToBytes(txShares)
@@ -229,3 +256,15 @@ func Test_parseCompactSharesErrors(t *testing.T) {
 		})
 	}
 }
+
+func generateRandomlySizedTxs(count, maxSize int) [][]byte {
+	txs := make([][]byte, count)
+	for i := 0; i < count; i++ {
+		size := rand.Intn(maxSize)
+		if size == 0 {
+			size = 1
+		}
+		txs[i] = generateRandomTxs(1, size)[0]
+	}
+	return txs
+}

share/padding.go

@@ -10,7 +10,7 @@ import (
 // provided should be the namespace and shareVersion of the blob that precedes
 // this padding in the data square.
 func NamespacePaddingShare(ns Namespace, shareVersion uint8) (Share, error) {
-	b, err := NewBuilder(ns, shareVersion, true)
+	b, err := newBuilder(ns, shareVersion, true)
 	if err != nil {
 		return Share{}, err
 	}