Update tail padded shares with NMT wrapper

p2p/ipld/wrapper/nmt_wrapper.go

@@ -1,19 +1,14 @@
 package wrapper
 
 import (
-	"bytes"
 	"fmt"
 
 	"github.com/lazyledger/nmt"
-	"github.com/lazyledger/nmt/namespace"
 	"github.com/lazyledger/rsmt2d"
 
 	"github.com/lazyledger/lazyledger-core/types/consts"
 )
 
-// emptyNamepsaceID occurs when a share is empty and indicates that
-var emptyNamespaceID = namespace.ID{0, 0, 0, 0, 0, 0, 0, 0}
-
 // Fulfills the rsmt2d.Tree interface and rsmt2d.TreeConstructorFn function
 var _ rsmt2d.TreeConstructorFn = ErasuredNamespacedMerkleTree{}.Constructor
 var _ rsmt2d.Tree = &ErasuredNamespacedMerkleTree{}
@@ -53,28 +48,17 @@ func (w ErasuredNamespacedMerkleTree) Constructor() rsmt2d.Tree {
 // rsmt.Tree interface. NOTE: panics if an error is encountered while pushing or
 // if the tree size is exceeded.
 func (w *ErasuredNamespacedMerkleTree) Push(data []byte, idx rsmt2d.SquareIndex) {
-	// determine the namespace based on where in the tree we're pushing
-	nsID := make(namespace.ID, consts.NamespaceSize)
-
 	if idx.Axis+1 > 2*uint(w.squareSize) || idx.Cell+1 > 2*uint(w.squareSize) {
 		panic(fmt.Sprintf("pushed past predetermined square size: boundary at %d index at %+v", 2*w.squareSize, idx))
 	}
-
-	// use the parity namespace if the cell is not in Q0 of the extended
-	// datasquare if the cell is empty it means we got an empty block so we need
-	// to use TailPaddingNamespaceID
+	nidAndData := make([]byte, consts.NamespaceSize+len(data))
+	copy(nidAndData[consts.NamespaceSize:], data)
+	// use the parity namespace if the cell is not in Q0 of the extended data square
 	if idx.Axis+1 > uint(w.squareSize) || idx.Cell+1 > uint(w.squareSize) {
-		copy(nsID, consts.ParitySharesNamespaceID)
+		copy(nidAndData[:consts.NamespaceSize], consts.ParitySharesNamespaceID)
 	} else {
-		// empty shares use the TailPaddingNamespaceID if the data is empty, so
-		// here we check if the share is empty (namepsace == [0,0,0,0,0,0,0,0])
-		if bytes.Equal(data[:consts.NamespaceSize], emptyNamespaceID) {
-			copy(nsID, consts.TailPaddingNamespaceID)
-		} else {
-			copy(nsID, data[:consts.NamespaceSize])
-		}
+		copy(nidAndData[:consts.NamespaceSize], data[:consts.NamespaceSize])
 	}
-	nidAndData := append(append(make([]byte, 0, consts.NamespaceSize+len(data)), nsID...), data...)
 	// push to the underlying tree
 	err := w.tree.Push(nidAndData)
 	// panic on error

types/block.go

@@ -1268,7 +1268,7 @@ func (data *Data) ComputeShares() (NamespacedShares, int) {
 		wantLen = consts.MinSharecount
 	}
 
-	tailShares := GenerateTailPaddingShares(wantLen-curLen, consts.ShareSize)
+	tailShares := TailPaddingShares(wantLen - curLen)
 
 	return append(append(append(append(
 		txShares,

types/block_test.go

@@ -241,7 +241,7 @@ func TestNilDataAvailabilityHeaderHashDoesntCrash(t *testing.T) {
 func TestEmptyBlockData(t *testing.T) {
 	blockData := Data{}
 	shares, _ := blockData.ComputeShares()
-	assert.Equal(t, GenerateTailPaddingShares(consts.MinSquareSize, consts.ShareSize), shares)
+	assert.Equal(t, TailPaddingShares(1), shares)
 }
 
 func TestCommit(t *testing.T) {

types/share_splitting.go

@@ -110,10 +110,20 @@ func getNextChunk(rawDatas [][]byte, outerIndex int, innerIndex int, width int)
 	return rawData, outerIndex, innerIndex, startIndex
 }
 
-func GenerateTailPaddingShares(n int, shareWidth int) NamespacedShares {
+// tail is filler for all tail padded shares
+// it is allocated once and used everywhere
+var tail = append(
+	append(make([]byte, 0, consts.ShareSize), consts.TailPaddingNamespaceID...),
+	bytes.Repeat([]byte{0}, consts.ShareSize-consts.NamespaceSize)...,
+)
+
+func TailPaddingShares(n int) NamespacedShares {
 	shares := make([]NamespacedShare, n)
 	for i := 0; i < n; i++ {
-		shares[i] = NamespacedShare{bytes.Repeat([]byte{0}, shareWidth), consts.TailPaddingNamespaceID}
+		shares[i] = NamespacedShare{
+			Share: tail,
+			ID:    consts.TailPaddingNamespaceID,
+		}
 	}
 	return shares
 }