Check for all returned errors (#396)

* linter: add errcheck

Signed-off-by: Ignacio Hagopian <[email protected]>

* tests: do not ignore errors

Signed-off-by: Ignacio Hagopian <[email protected]>

* lint: fix warnings

Signed-off-by: Ignacio Hagopian <[email protected]>

* avoid ignoring errors in main code

Signed-off-by: Ignacio Hagopian <[email protected]>

* rebase fix

Signed-off-by: Ignacio Hagopian <[email protected]>

* make deepsource linter happy

Signed-off-by: Ignacio Hagopian <[email protected]>

* add more missing checks after rebase

Signed-off-by: Ignacio Hagopian <[email protected]>

---------

Signed-off-by: Ignacio Hagopian <[email protected]>

Author: jsign

.golangci.yml

@@ -12,17 +12,17 @@ run:
 linters:
   disable-all: true
   enable:
+    - errcheck
     - gofmt
     - staticcheck
-    - deadcode
     - goconst
     - goimports
     - gosimple
     - govet
     - ineffassign
     - misspell
     - unconvert
-    - varcheck
+    - unused
 
 linters-settings:
   gofmt:

benchs/main.go

@@ -17,9 +17,9 @@ func main() {
 func benchmarkInsertInExisting() {
 	f, _ := os.Create("cpu.prof")
 	g, _ := os.Create("mem.prof")
-	pprof.StartCPUProfile(f)
+	_ = pprof.StartCPUProfile(f)
 	defer pprof.StopCPUProfile()
-	defer pprof.WriteHeapProfile(g)
+	defer func() { _ = pprof.WriteHeapProfile(g) }()
 	// Number of existing leaves in tree
 	n := 1000000
 	// Leaves to be inserted afterwards
@@ -34,7 +34,9 @@ func benchmarkInsertInExisting() {
 		// Generate set of keys once
 		for i := 0; i < total; i++ {
 			key := make([]byte, 32)
-			rand.Read(key)
+			if _, err := rand.Read(key); err != nil {
+				panic(err)
+			}
 			if i < n {
 				keys[i] = key
 			} else {

conversion.go

@@ -55,7 +55,9 @@ func BatchNewLeafNode(nodesValues []BatchNewLeafNodeData) ([]LeafNode, error) {
 					c1c2frs[2*i], c1c2frs[2*i+1] = new(Fr), new(Fr)
 				}
 
-				banderwagon.BatchMapToScalarField(c1c2frs, c1c2points)
+				if err := banderwagon.BatchMapToScalarField(c1c2frs, c1c2points); err != nil {
+					return fmt.Errorf("mapping to scalar field: %s", err)
+				}
 
 				var poly [NodeWidth]Fr
 				poly[0].SetUint64(1)
@@ -145,7 +147,7 @@ func (n *InternalNode) InsertMigratedLeaves(leaves []LeafNode, resolver NodeReso
 	return nil
 }
 
-func (n *InternalNode) insertMigratedLeavesSubtree(leaves []LeafNode, resolver NodeResolverFn) error {
+func (n *InternalNode) insertMigratedLeavesSubtree(leaves []LeafNode, resolver NodeResolverFn) error { // skipcq: GO-R1005
 	for i := range leaves {
 		ln := leaves[i]
 		parent := n

debug_test.go

@@ -33,10 +33,18 @@ func TestJSON(t *testing.T) {
 	t.Parallel()
 
 	root := New()
-	root.Insert(zeroKeyTest, fourtyKeyTest, nil)
-	root.Insert(oneKeyTest, zeroKeyTest, nil)
-	root.Insert(forkOneKeyTest, zeroKeyTest, nil) // Force an internal node in the first layer.
-	root.Insert(fourtyKeyTest, oneKeyTest, nil)
+	if err := root.Insert(zeroKeyTest, fourtyKeyTest, nil); err != nil {
+		t.Fatal(err)
+	}
+	if err := root.Insert(oneKeyTest, zeroKeyTest, nil); err != nil {
+		t.Fatal(err)
+	}
+	if err := root.Insert(forkOneKeyTest, zeroKeyTest, nil); err != nil { // Force an internal node in the first layer.
+		t.Fatal(err)
+	}
+	if err := root.Insert(fourtyKeyTest, oneKeyTest, nil); err != nil {
+		t.Fatal(err)
+	}
 	root.(*InternalNode).children[152] = HashedNode{}
 	root.Commit()
 

encoding.go

@@ -109,11 +109,17 @@ func parseLeafNode(serialized []byte, depth byte) (VerkleNode, error) {
 		return nil, fmt.Errorf("leaf node commitments are not the correct size, expected at least %d, got %d", 3*banderwagon.UncompressedSize, len(serialized[leafC1CommitmentOffset:]))
 	}
 
-	ln.c1.SetBytesUncompressed(serialized[leafC1CommitmentOffset:leafC1CommitmentOffset+banderwagon.UncompressedSize], true)
+	if err := ln.c1.SetBytesUncompressed(serialized[leafC1CommitmentOffset:leafC1CommitmentOffset+banderwagon.UncompressedSize], true); err != nil {
+		return nil, fmt.Errorf("setting c1 commitment: %w", err)
+	}
 	ln.c2 = new(Point)
-	ln.c2.SetBytesUncompressed(serialized[leafC2CommitmentOffset:leafC2CommitmentOffset+banderwagon.UncompressedSize], true)
+	if err := ln.c2.SetBytesUncompressed(serialized[leafC2CommitmentOffset:leafC2CommitmentOffset+banderwagon.UncompressedSize], true); err != nil {
+		return nil, fmt.Errorf("setting c2 commitment: %w", err)
+	}
 	ln.commitment = new(Point)
-	ln.commitment.SetBytesUncompressed(serialized[leafCommitmentOffset:leafC1CommitmentOffset], true)
+	if err := ln.commitment.SetBytesUncompressed(serialized[leafCommitmentOffset:leafC1CommitmentOffset], true); err != nil {
+		return nil, fmt.Errorf("setting commitment: %w", err)
+	}
 	return ln, nil
 }
 
@@ -145,6 +151,8 @@ func CreateInternalNode(bitlist []byte, raw []byte, depth byte) (*InternalNode,
 	}
 
 	node.commitment = new(Point)
-	node.commitment.SetBytesUncompressed(raw, true)
+	if err := node.commitment.SetBytesUncompressed(raw, true); err != nil {
+		return nil, fmt.Errorf("setting commitment: %w", err)
+	}
 	return node, nil
 }

proof_ipa.go

@@ -350,15 +350,21 @@ func DeserializeProof(vp *VerkleProof, statediff StateDiff) (*Proof, error) {
 		commitments[i] = &commitment
 	}
 
-	multipoint.D.SetBytes(vp.D[:])
+	if err := multipoint.D.SetBytes(vp.D[:]); err != nil {
+		return nil, fmt.Errorf("setting D: %w", err)
+	}
 	multipoint.IPA.A_scalar.SetBytes(vp.IPAProof.FinalEvaluation[:])
 	multipoint.IPA.L = make([]Point, IPA_PROOF_DEPTH)
 	for i, b := range vp.IPAProof.CL {
-		multipoint.IPA.L[i].SetBytes(b[:])
+		if err := multipoint.IPA.L[i].SetBytes(b[:]); err != nil {
+			return nil, fmt.Errorf("setting L[%d]: %w", i, err)
+		}
 	}
 	multipoint.IPA.R = make([]Point, IPA_PROOF_DEPTH)
 	for i, b := range vp.IPAProof.CR {
-		multipoint.IPA.R[i].SetBytes(b[:])
+		if err := multipoint.IPA.R[i].SetBytes(b[:]); err != nil {
+			return nil, fmt.Errorf("setting R[%d]: %w", i, err)
+		}
 	}
 
 	// turn statediff into keys and values