fix: correct pruning condition in RS Decode for last part padding (#2794)

## Summary

- Fix a bug in `Decode` (`types/part_set.go`) where
`len(data[:(ops.Total()-1)])` compared a **part count** against
`lastPartLen` (a **byte length**). When `Total-1` numerically equaled
`lastPartLen`, pruning of RS padding was skipped, causing a Merkle root
mismatch and breaking RS recovery for block data sizes of `k * 65537`
bytes.
- Change the condition to `len(data[ops.Total()-1])` which correctly
compares the byte length of the last reconstructed part against the
expected unpadded length.
- Extract the pruning logic into a standalone `pruneLastPart` function
for testability.
- Replace the complex `TestDecodePruningBug` (which spun up full RS
encode/decode machinery) with a focused `TestPruneLastPart` unit test
that directly exercises the extracted function.

## Test plan

- [x] `TestPruneLastPart` passes for both subtests (prunes when padded,
no-op when already correct)
- [x] Existing `TestEncodingDecodingRoundTrip` continues to pass
- [ ] Run full `go test ./types/` suite

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: rootulp

types/part_set.go

@@ -363,6 +363,14 @@ func (ps *PartSet) IsReadyForDecoding() bool {
 	return ps.IsComplete()
 }
 
+// pruneLastPart trims the last original part to its true length, removing any
+// Reed-Solomon padding bytes that were added during encoding.
+func pruneLastPart(data [][]byte, lastIndex uint32, lastPartLen int) {
+	if len(data[lastIndex]) != lastPartLen {
+		data[lastIndex] = data[lastIndex][:lastPartLen]
+	}
+}
+
 // Decode uses the block parts that are provided to reconstruct the original
 // data. It throws an error if the PartSet is incomplete or the resulting root
 // is different from that in the PartSetHeader. Parts are fully complete with
@@ -410,9 +418,7 @@ func Decode(ops, eps *PartSet, lastPartLen int) (*PartSet, *PartSet, error) {
 	}
 
 	// prune the last part if we need to
-	if len(data[:(ops.Total()-1)]) != lastPartLen {
-		data[(ops.Total() - 1)] = data[(ops.Total() - 1)][:lastPartLen]
-	}
+	pruneLastPart(data, ops.Total()-1, lastPartLen)
 
 	// recalculate all of the proofs since we apparently don't have a function
 	// to generate a single proof... TODO: don't generate proofs for block parts

types/part_set_test.go

@@ -141,6 +141,26 @@ func TestEncodingDecodingRoundTrip(t *testing.T) {
 	}
 }
 
+func TestPruneLastPart(t *testing.T) {
+	tests := []struct {
+		name        string
+		partLen     int
+		lastPartLen int
+		wantLen     int
+	}{
+		{"prunes when padded", 100, 50, 50},
+		{"no-op when already correct", 50, 50, 50},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			lastIndex := uint32(1)
+			data := [][]byte{make([]byte, 100), make([]byte, tt.partLen)}
+			pruneLastPart(data, lastIndex, tt.lastPartLen)
+			require.Len(t, data[lastIndex], tt.wantLen)
+		})
+	}
+}
+
 func TestEncoding(t *testing.T) {
 	data := cmtrand.Bytes(testPartSize * 100)
 	partSet, err := NewPartSetFromData(data, testPartSize)