chore: add golangci-lint config (celestiaorg#107)

While working on a different PR, my editor complained about failed
go-staticcheck warnings. For consistency across codebases, I adopted the
celestia-app golangci-lint config and fixed the lint errors in the
screenshot below. This repo already has a lint workflow that runs
[golangci-lint](https://golangci-lint.run/) so CI will run with these
linters moving forward (confirmed via verbose logging
[here](https://github.com/celestiaorg/nmt/actions/runs/4207167400/jobs/7301618009#step:4:33)).

## Screenshot

<img width="1441" alt="Screenshot 2023-02-17 at 2 48 43 PM"
src="https://user-images.githubusercontent.com/3699047/219778350-ebaac63e-c7e9-407e-8f73-7ca1f3d77786.png">

Author: rootulp

.github/workflows/lint.yml

@@ -24,4 +24,4 @@ jobs:
         with:
           version: latest
           args: --timeout 10m
-        if: env.GIT_DIFF
+        if: env.GIT_DIFF

.golangci.yml

@@ -0,0 +1,11 @@
+run:
+  timeout: 5m
+  modules-download-mode: readonly
+
+linters:
+  enable:
+    - exportloopref
+    - gofumpt
+    - misspell
+    - revive
+    - prealloc

hasher_test.go

@@ -3,7 +3,6 @@ package nmt
 import (
 	"crypto"
 	"crypto/sha256"
-	_ "crypto/sha256"
 	"reflect"
 	"testing"
 

nmt_test.go

@@ -619,7 +619,8 @@ func TestNMT_forgedNamespaceEmptinessProof(t *testing.T) {
 		append(namespace.ID{1}, []byte("leaf_0")...),
 		append(namespace.ID{1}, []byte("leaf_1")...),
 		append(namespace.ID{2}, []byte("leaf_2")...),
-		append(namespace.ID{2}, []byte("leaf_3")...)}
+		append(namespace.ID{2}, []byte("leaf_3")...),
+	}
 	// Init a tree with the namespace size as well as
 	// the underlying hash function:
 	tree := New(sha256.New(), NamespaceIDSize(1))

proof.go

@@ -120,8 +120,7 @@ func NewAbsenceProof(proofStart, proofEnd int, proofNodes [][]byte, leafHash []b
 //	`end-1` of the tree.
 //
 // `root` is the root of the NMT against which the `proof` is verified.
-func (proof Proof) VerifyNamespace(
-	h hash.Hash, nID namespace.ID, data [][]byte, root []byte) bool {
+func (proof Proof) VerifyNamespace(h hash.Hash, nID namespace.ID, data [][]byte, root []byte) bool {
 	nth := NewNmtHasher(h, nID.Size(), proof.isMaxNamespaceIDIgnored)
 	min := namespace.ID(MinNamespace(root, nID.Size()))
 	max := namespace.ID(MaxNamespace(root, nID.Size()))

subrootpaths.go

@@ -6,10 +6,10 @@ import (
 )
 
 var (
-	srpNotPowerOf2       = errors.New("GetSubrootPaths: Supplied square size is not a power of 2")
-	srpInvalidShareCount = errors.New("GetSubrootPaths: Can't compute path for 0 share count slice")
-	srpPastSquareSize    = errors.New("GetSubrootPaths: Share slice can't be past the square size")
-	srpInvalidIdxEnd     = errors.New("GetSubrootPaths: idxEnd must be larger than idxStart and shareCount")
+	errNotPowerOf2       = errors.New("GetSubrootPaths: Supplied square size is not a power of 2")
+	errInvalidShareCount = errors.New("GetSubrootPaths: Can't compute path for 0 share count slice")
+	errPastSquareSize    = errors.New("GetSubrootPaths: Share slice can't be past the square size")
+	errInvalidIdxEnd     = errors.New("GetSubrootPaths: idxEnd must be larger than idxStart and shareCount")
 )
 
 // merkle path to a node is equivalent to the index's binary representation
@@ -51,9 +51,8 @@ func prune(idxStart uint, idxEnd uint, maxWidth uint) [][]int {
 	if idxStart+1 >= idxEnd {
 		if idxStart%2 == 1 {
 			return [][]int{pathStart, pathEnd}
-		} else {
-			return [][]int{pathStart[:len(pathStart)-1]}
 		}
+		return [][]int{pathStart[:len(pathStart)-1]}
 	}
 
 	var prunedPaths [][]int
@@ -127,24 +126,24 @@ func GetSubrootPaths(squareSize uint, idxStart uint, shareCount uint) ([][][]int
 	// check squareSize is at least 2 and that it's
 	// a power of 2 by checking that only 1 bit is on
 	if squareSize < 2 || bits.OnesCount(squareSize) != 1 {
-		return nil, srpNotPowerOf2
+		return nil, errNotPowerOf2
 	}
 
 	// no path exists for 0 count slice
 	if shareCount == 0 {
-		return nil, srpInvalidShareCount
+		return nil, errInvalidShareCount
 	}
 
 	idxEnd := idxStart + shareCount
 	if idxEnd < idxStart || idxEnd < shareCount {
-		return nil, srpInvalidIdxEnd
+		return nil, errInvalidIdxEnd
 	}
 
 	shares := squareSize * squareSize
 
 	// sanity checking
 	if idxStart >= shares || idxEnd > shares {
-		return nil, srpPastSquareSize
+		return nil, errPastSquareSize
 	}
 
 	startRow := idxStart / squareSize

subrootpaths_test.go

@@ -20,12 +20,12 @@ func TestArgValidation(t *testing.T) {
 	}
 
 	tests := []test{
-		{input: pathSpan{squareSize: 0, startNode: 0, length: 0}, want: srpNotPowerOf2},
-		{input: pathSpan{squareSize: 1, startNode: 0, length: 1}, want: srpNotPowerOf2},
-		{input: pathSpan{squareSize: 20, startNode: 0, length: 1}, want: srpNotPowerOf2},
-		{input: pathSpan{squareSize: 4, startNode: 0, length: 17}, want: srpPastSquareSize},
-		{input: pathSpan{squareSize: 4, startNode: 0, length: 0}, want: srpInvalidShareCount},
-		{input: pathSpan{squareSize: 128, startNode: 1, length: 18446744073709551615}, want: srpInvalidIdxEnd},
+		{input: pathSpan{squareSize: 0, startNode: 0, length: 0}, want: errNotPowerOf2},
+		{input: pathSpan{squareSize: 1, startNode: 0, length: 1}, want: errNotPowerOf2},
+		{input: pathSpan{squareSize: 20, startNode: 0, length: 1}, want: errNotPowerOf2},
+		{input: pathSpan{squareSize: 4, startNode: 0, length: 17}, want: errPastSquareSize},
+		{input: pathSpan{squareSize: 4, startNode: 0, length: 0}, want: errInvalidShareCount},
+		{input: pathSpan{squareSize: 128, startNode: 1, length: 18446744073709551615}, want: errInvalidIdxEnd},
 	}
 
 	for _, tc := range tests {