fix all bugs with third and final refactor

types/shares.go

@@ -3,6 +3,7 @@ package types
 import (
 	"bytes"
 	"encoding/binary"
+	"errors"
 
 	"github.com/gogo/protobuf/proto"
 	tmbytes "github.com/lazyledger/lazyledger-core/libs/bytes"
@@ -150,6 +151,7 @@ func mintShare(nid namespace.ID, rawTxs [][]byte) (NamespacedShare, [][]byte) {
 		// If we don't have room, fill remaining data in the share with as much
 		// of the tx as possible
 		remaining := TxShareSize - len(rawData)
+
 		rawData = append(rawData, tx[:remaining]...)
 
 		// remove the portion of the tx that was added in this share
@@ -359,60 +361,65 @@ func processContiguousShares(shares [][]byte) (txs [][]byte, err error) {
 	if len(shares) == 0 {
 		return nil, nil
 	}
-	share := shares[0][NamespaceSize+ShareReservedBytes:]
-	share, txLen, err := parseDelimiter(share)
-	if err != nil {
-		return nil, err
-	}
 
-	for i := 0; i < len(shares); i++ {
-		var newTxs [][]byte
-		newTxs, share, txLen, err = collectTxsFromShare(share, txLen)
-		if err != nil {
-			return nil, err
-		}
-
-		// add the collected txs to the output
-		txs = append(txs, newTxs...)
-
-		// if there is no next share, the work is done
-		// if not, then we know there are more shares to process
-		if len(shares) == i+1 {
-			break
-		}
+	ss := newShareStack(shares)
+	return ss.resolve()
+}
 
-		nextShare := shares[i+1][NamespaceSize+ShareReservedBytes:]
+// shareStack hold variables for peel
+type shareStack struct {
+	shares [][]byte
+	txLen  uint64
+	txs    [][]byte
+	cursor int
+}
 
-		// if there is no current share remaining, process the next share
-		if len(share) == 0 {
-			share, txLen, err = parseDelimiter(nextShare)
-			if err != nil {
-				break
-			}
-			continue
-		}
+func newShareStack(shares [][]byte) *shareStack {
+	return &shareStack{shares: shares}
+}
 
-		// create the next share by merging the next share with the remaining of
-		// the current share
-		share = append(share, nextShare...)
+func (ss *shareStack) resolve() ([][]byte, error) {
+	if len(ss.shares) == 0 {
+		return nil, nil
 	}
-
-	return txs, err
+	err := ss.peel(ss.shares[0][NamespaceSize+ShareReservedBytes:], true)
+	return ss.txs, err
 }
 
-func collectTxsFromShare(share []byte, txLen uint64) (txs [][]byte, extra []byte, l uint64, err error) {
-	for uint64(len(share)) >= txLen {
-		tx := share[:txLen]
-		txs = append(txs, tx)
-
-		share = share[txLen:]
+// peel recursively parses each chunk of data (either a transaction,
+// intermediate state root, or evidence) and adds it to the underlying slice of data.
+func (ss *shareStack) peel(share []byte, delimited bool) (err error) {
+	if delimited {
+		var txLen uint64
 		share, txLen, err = parseDelimiter(share)
-		if txLen == 0 || err != nil {
-			share = nil
-			break
+		if err != nil {
+			return err
+		}
+		if txLen == 0 {
+			return nil
 		}
+		ss.txLen = txLen
+	}
+	safeLen := len(share) - binary.MaxVarintLen64
+	if safeLen < 0 {
+		safeLen = 0
+	}
+	if int(ss.txLen) <= safeLen {
+		ss.txs = append(ss.txs, share[:ss.txLen])
+		share = share[ss.txLen:]
+		return ss.peel(share, true)
+	}
+	if len(ss.shares) > ss.cursor+1 {
+		ss.cursor++
+		share := append(share, ss.shares[ss.cursor][NamespaceSize+ShareReservedBytes:]...)
+		return ss.peel(share, false)
+	}
+	if ss.txLen <= uint64(len(share)) {
+		ss.txs = append(ss.txs, share[:ss.txLen])
+		share = share[ss.txLen:]
+		return ss.peel(share, true)
 	}
-	return txs, share, txLen, err
+	return errors.New("failure to parse block data: transaction length exceeded data length")
 }
 
 // parseMessages iterates through raw shares and separates the contiguous chunks

types/shares_test.go

@@ -2,6 +2,7 @@ package types
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"math"
 	"math/rand"
@@ -239,9 +240,10 @@ func TestDataFromSquare(t *testing.T) {
 				tc.maxSize,
 			)
 
-			shares := data.ComputeShares().RawShares()
+			shares := data.ComputeShares()
+			rawShares := shares.RawShares()
 
-			eds, err := rsmt2d.ComputeExtendedDataSquare(shares, rsmt2d.RSGF8, rsmt2d.NewDefaultTree)
+			eds, err := rsmt2d.ComputeExtendedDataSquare(rawShares, rsmt2d.RSGF8, rsmt2d.NewDefaultTree)
 			if err != nil {
 				t.Error(err)
 			}
@@ -269,6 +271,21 @@ func TestDataFromSquare(t *testing.T) {
 	}
 }
 
+func TestFuzz_DataFromSquare(t *testing.T) {
+	t.Skip()
+	// run random shares through processContiguousShares for a minute
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+			TestDataFromSquare(t)
+		}
+	}
+}
+
 func Test_processContiguousShares(t *testing.T) {
 	// exactTxShareSize is the length of tx that will fit exactly into a single
 	// share, accounting for namespace id and the length delimiter prepended to
@@ -291,6 +308,7 @@ func Test_processContiguousShares(t *testing.T) {
 		{"single exact size tx", exactTxShareSize, 1},
 		{"many exact size txs", exactTxShareSize, 10},
 	}
+
 	for _, tc := range tests {
 		tc := tc
 
@@ -330,6 +348,21 @@ func Test_processContiguousShares(t *testing.T) {
 	}
 }
 
+func TestFuzz_processContiguousShares(t *testing.T) {
+	t.Skip()
+	// run random shares through processContiguousShares for a minute
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+			Test_processContiguousShares(t)
+		}
+	}
+}
+
 func Test_parseMsgShares(t *testing.T) {
 	// exactMsgShareSize is the length of message that will fit exactly into a single
 	// share, accounting for namespace id and the length delimiter prepended to