fix some deepsource comments

proof_ipa.go

@@ -143,7 +143,7 @@ func VerifyVerkleProof(proof *Proof, Cs []*Point, indices []uint8, ys []*Fr, tc
 func SerializeProof(proof *Proof) (*VerkleProof, StateDiff, error) {
 	otherstems := make([][31]byte, len(proof.PoaStems))
 	for i, stem := range proof.PoaStems {
-		copy(otherstems[i][:], stem[:])
+		copy(otherstems[i][:], stem)
 	}
 
 	cbp := make([][32]byte, len(proof.Cs))

proof_json.go

@@ -88,15 +88,15 @@ func (ipp *IPAProof) UnmarshalJSON(data []byte) error {
 		if err != nil {
 			return fmt.Errorf("error decoding hex string for CL[%d]: %s", i, aux.CL[i])
 		}
-		copy(ipp.CL[i][:], val[:])
+		copy(ipp.CL[i][:], val)
 		if len(aux.CR[i]) != 64 {
 			return fmt.Errorf("invalid hex string for CR[%d]: %s", i, aux.CR[i])
 		}
 		val, err = hex.DecodeString(aux.CR[i])
 		if err != nil {
 			return fmt.Errorf("error decoding hex string for CR[%d]: %s", i, aux.CR[i])
 		}
-		copy(ipp.CR[i][:], val[:])
+		copy(ipp.CR[i][:], val)
 	}
 	copy(ipp.FinalEvaluation[:], currentValueBytes)
 
@@ -114,7 +114,7 @@ type verkleProofMarshaller struct {
 func (vp *VerkleProof) MarshalJSON() ([]byte, error) {
 	aux := &verkleProofMarshaller{
 		OtherStems:            make([]string, len(vp.OtherStems)),
-		DepthExtensionPresent: hex.EncodeToString(vp.DepthExtensionPresent[:]),
+		DepthExtensionPresent: hex.EncodeToString(vp.DepthExtensionPresent),
 		CommitmentsByPath:     make([]string, len(vp.CommitmentsByPath)),
 		D:                     hex.EncodeToString(vp.D[:]),
 		IPAProof:              vp.IPAProof,

proof_test.go

@@ -354,10 +354,6 @@ func TestProofDeserialize(t *testing.T) {
 	}
 }
 
-func TestProofDeserializeErrors(t *testing.T) {
-	// TODO
-}
-
 func TestProofOfAbsenceEdgeCase(t *testing.T) {
 	root := New()
 	root.Commit()

tree_test.go

@@ -1122,19 +1122,14 @@ func TestRustBanderwagonBlock48(t *testing.T) {
 		"c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
 		"0000000000000000000000000000000000000000000000000000000000000000",
 	}
-	var (
-		vals        [][]byte
-		initialVals = map[string][]byte{}
-	)
+	var initialVals = map[string][]byte{}
 
 	for i, s := range valStrings {
 		if s == "" {
-			vals = append(vals, nil)
 			continue
 		}
 
 		v, _ := hex.DecodeString(s)
-		vals = append(vals, v)
 		tree.Insert(keys[i], v, nil)
 
 		initialVals[string(keys[i])] = v