fix: set reserved byte correctly

pkg/prove/proof.go

@@ -2,6 +2,7 @@ package prove
 
 import (
 	"errors"
+	"fmt"
 
 	"github.com/celestiaorg/celestia-app/pkg/appconsts"
 	"github.com/celestiaorg/celestia-app/pkg/shares"
@@ -97,20 +98,39 @@ func txSharePosition(txs types.Txs, txIndex uint64) (startSharePos, endSharePos
 		return startSharePos, endSharePos, errors.New("transaction index is greater than the number of txs")
 	}
 
-	totalLen := 0
+	prevTxTotalLen := 0
 	for i := uint64(0); i < txIndex; i++ {
 		txLen := len(txs[i])
-		totalLen += (shares.DelimLen(uint64(txLen)) + txLen)
+		prevTxTotalLen += (shares.DelimLen(uint64(txLen)) + txLen)
 	}
 
-	txLen := len(txs[txIndex])
-
-	startSharePos = uint64((totalLen) / appconsts.ContinuationCompactShareContentSize)
-	endSharePos = uint64((totalLen + txLen + shares.DelimLen(uint64(txLen))) / appconsts.ContinuationCompactShareContentSize)
+	currentTxLen := len(txs[txIndex])
+	currentTxTotalLen := shares.DelimLen(uint64(currentTxLen)) + currentTxLen
+	endOfCurrentTxLen := prevTxTotalLen + currentTxTotalLen
 
+	startSharePos = txShareIndex(prevTxTotalLen)
+	endSharePos = txShareIndex(endOfCurrentTxLen)
+	fmt.Printf("prevTxTotalLen: %d, endOfCurrentTxLen: %d, startSharePos: %d, endSharePos %d, currentTxTotalLen %d\n", prevTxTotalLen, endOfCurrentTxLen, startSharePos, endSharePos, currentTxTotalLen)
 	return startSharePos, endSharePos, nil
 }
 
+// txShareIndex returns the index of the compact share that would contain
+// transactions with totalTxLen
+func txShareIndex(totalTxLen int) (index uint64) {
+	if totalTxLen <= appconsts.FirstCompactShareContentSize {
+		return 0
+	}
+
+	index++
+	totalTxLen -= appconsts.FirstCompactShareContentSize
+
+	for totalTxLen > appconsts.ContinuationCompactShareContentSize {
+		index++
+		totalTxLen -= appconsts.ContinuationCompactShareContentSize
+	}
+	return index
+}
+
 // genRowShares progessively generates data square rows from block data
 func genRowShares(codec rsmt2d.Codec, data types.Data, startRow, endRow uint64) ([][][]byte, error) {
 	if endRow > data.OriginalSquareSize {

pkg/shares/compact_shares_test.go

@@ -62,7 +62,7 @@ func TestFuzz_processCompactShares(t *testing.T) {
 
 func Test_processCompactShares(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
+	// share, accounting for the tx length delimiter prepended to
 	// each tx. Note that the length delimiter can be 1 to 10 bytes (varint) but
 	// this test assumes it is 1 byte.
 	const exactTxShareSize = appconsts.ContinuationCompactShareContentSize - 1
@@ -81,7 +81,7 @@ func Test_processCompactShares(t *testing.T) {
 		{"single big tx", appconsts.ContinuationCompactShareContentSize * 4, 1},
 		{"many big txs", appconsts.ContinuationCompactShareContentSize * 4, 10},
 		{"single exact size tx", exactTxShareSize, 1},
-		{"many exact size txs", exactTxShareSize, 10},
+		{"many exact size txs", exactTxShareSize, 100},
 	}
 
 	for _, tc := range tests {

pkg/shares/parse_compact_shares.go

@@ -9,7 +9,8 @@ import (
 
 // parseCompactShares takes raw shares and extracts out transactions,
 // intermediate state roots, or evidence. The returned [][]byte do not have
-// namespaces, info bytes, or length delimiters and are ready to be unmarshalled
+// namespaces, info bytes, data length delimiter, or unit length
+// delimiters and are ready to be unmarshalled
 func parseCompactShares(shares [][]byte) (data [][]byte, err error) {
 	if len(shares) == 0 {
 		return nil, nil
@@ -44,7 +45,7 @@ func (ss *shareStack) resolve() ([][]byte, error) {
 	if !infoByte.IsMessageStart() {
 		return nil, errors.New("first share is not a message start")
 	}
-	err = ss.peel(ss.shares[0][appconsts.NamespaceSize+appconsts.ShareInfoBytes+appconsts.CompactShareReservedBytes:], true)
+	err = ss.peel(ss.shares[0][appconsts.NamespaceSize+appconsts.ShareInfoBytes+appconsts.FirstCompactShareDataLengthBytes+appconsts.CompactShareReservedBytes:], true)
 	return ss.data, err
 }
 

pkg/shares/share_splitting_test.go

@@ -26,11 +26,12 @@ func TestSplitTxs(t *testing.T) {
 			want: [][]uint8{
 				append([]uint8{
 					0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, // namespace id
-					0x1, // info byte
-					0x0, // reserved byte
+					0x1,                // info byte
+					0x2, 0x0, 0x0, 0x0, // 1 byte (unit)  + 1 byte (unit length) = 2 bytes message length
+					14,  // reserved byte
 					0x1, // unit length of first transaction
 					0xa, // data of first transaction
-				}, bytes.Repeat([]byte{0}, 244)...), // padding
+				}, bytes.Repeat([]byte{0}, 240)...), // padding
 			},
 		},
 		{
@@ -39,25 +40,27 @@ func TestSplitTxs(t *testing.T) {
 			want: [][]uint8{
 				append([]uint8{
 					0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, // namespace id
-					0x1, // info byte
-					0x0, // reserved byte
+					0x1,                // info byte
+					0x4, 0x0, 0x0, 0x0, // 2 bytes (first transaction) + 2 bytes (second transaction) = 4 bytes message length
+					14,  // reserved byte
 					0x1, // unit length of first transaction
 					0xa, // data of first transaction
 					0x1, // unit length of second transaction
 					0xb, // data of second transaction
-				}, bytes.Repeat([]byte{0}, 242)...), // padding
+				}, bytes.Repeat([]byte{0}, 238)...), // padding
 			},
 		},
 		{
 			name: "one large tx that spans two shares",
-			txs:  coretypes.Txs{bytes.Repeat([]byte{0xC}, 245)},
+			txs:  coretypes.Txs{bytes.Repeat([]byte{0xC}, 241)},
 			want: [][]uint8{
 				append([]uint8{
 					0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, // namespace id
-					0x1,    // info byte
-					0x0,    // BUG reserved byte should be non-zero see https://github.com/celestiaorg/celestia-app/issues/802
-					245, 1, // unit length of first transaction is 245
-				}, bytes.Repeat([]byte{0xc}, 244)...), // data of first transaction
+					0x1,          // info byte
+					243, 1, 0, 0, // 241 (unit) + 2 (unit length) = 243 message length
+					14,     // reserved byte
+					241, 1, // unit length of first transaction is 241
+				}, bytes.Repeat([]byte{0xc}, 240)...), // data of first transaction
 				append([]uint8{
 					0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, // namespace id
 					0x0, // info byte
@@ -68,31 +71,53 @@ func TestSplitTxs(t *testing.T) {
 		},
 		{
 			name: "one small tx then one large tx that spans two shares",
-			txs:  coretypes.Txs{coretypes.Tx{0xd}, bytes.Repeat([]byte{0xe}, 243)},
+			txs:  coretypes.Txs{coretypes.Tx{0xd}, bytes.Repeat([]byte{0xe}, 241)},
 			want: [][]uint8{
 				append([]uint8{
 					0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, // namespace id
-					0x1,    // info byte
-					0x0,    // BUG reserved byte should be non-zero see https://github.com/celestiaorg/celestia-app/issues/802
+					0x1,          // info byte
+					245, 1, 0, 0, // 2 bytes (first transaction) + 243 bytes (second transaction) = 245 bytes message length
+					14,     // reserved byte
 					1,      // unit length of first transaction
 					0xd,    // data of first transaction
-					243, 1, // unit length of second transaction is 243
-				}, bytes.Repeat([]byte{0xe}, 242)...), // data of first transaction
+					241, 1, // unit length of second transaction is 241
+				}, bytes.Repeat([]byte{0xe}, 238)...), // data of first transaction
+				append([]uint8{
+					0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, // namespace id
+					0x0,           // info byte
+					0x0,           // reserved byte
+					0xe, 0xe, 0xe, // continuation data of second transaction
+				}, bytes.Repeat([]byte{0x0}, 243)...), // padding
+			},
+		},
+		{
+			name: "one large tx that spans two shares then one small tx",
+			txs:  coretypes.Txs{bytes.Repeat([]byte{0xe}, 241), coretypes.Tx{0xd}},
+			want: [][]uint8{
+				append([]uint8{
+					0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, // namespace id
+					0x1,          // info byte
+					245, 1, 0, 0, // 243 bytes (first transaction) + 2 bytes (second transaction) = 245 bytes message length
+					14,     // reserved byte
+					241, 1, // unit length of first transaction is 241
+				}, bytes.Repeat([]byte{0xe}, 240)...), // data of first transaction
 				append([]uint8{
 					0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, // namespace id
 					0x0, // info byte
-					0x0, // reserved byte
-					0xe, // continuation data of second transaction
-				}, bytes.Repeat([]byte{0x0}, 245)...), // padding
+					11,  // reserved byte
+					0xe, // continuation data of first transaction
+					1,   // unit length of second transaction
+					0xd, // data of second transaction
+				}, bytes.Repeat([]byte{0x0}, 243)...), // padding
 			},
 		},
 	}
 	for _, tt := range testCases {
 		t.Run(tt.name, func(t *testing.T) {
 			got := SplitTxs(tt.txs)
 			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("SplitTxs(%#v) got %#v, want %#v", tt.txs, got, tt.want)
+				t.Errorf("SplitTxs()\n got %#v\n want %#v", got, tt.want)
 			}
 		})
 	}
-}
+} //