lint

go/.golangci.yml

@@ -1,14 +1,14 @@
 run:
-  tests: false
-  # timeout for analysis, e.g. 30s, 5m, default is 1m
+  tests: true
+  #   # timeout for analysis, e.g. 30s, 5m, default is 1m
   timeout: 5m
 
 linters:
   disable-all: true
   enable:
-    - depguard
-    - dogsled
     - exportloopref
+    - errcheck
+    - gci
     - goconst
     - gocritic
     - gofumpt
@@ -18,9 +18,99 @@ linters:
     - ineffassign
     - misspell
     - nakedret
-    - nolintlint
     - staticcheck
+    - thelper
+    - typecheck
     - stylecheck
+    - revive
     - typecheck
+    - tenv
     - unconvert
+    # Prefer unparam over revive's unused param. It is more thorough in its checking.
+    - unparam
     - unused
+    - misspell
+
+issues:
+  exclude-rules:
+    - text: 'differs only by capitalization to method'
+      linters:
+        - revive
+    - text: 'Use of weak random number generator'
+      linters:
+        - gosec
+
+  max-issues-per-linter: 10000
+  max-same-issues: 10000
+
+linters-settings:
+  gci:
+    sections:
+      - standard # Standard section: captures all standard packages.
+      - default # Default section: contains all imports that could not be matched to another section type.
+      - blank # blank imports
+      - dot # dot imports
+      - prefix(cosmossdk.io)
+      - prefix(github.com/cosmos/cosmos-sdk)
+      - prefix(github.com/cometbft/cometbft)
+      - prefix(github.com/cosmos/ics23)
+    custom-order: true
+  revive:
+    enable-all-rules: true
+    # Do NOT whine about the following, full explanation found in:
+    # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#description-of-available-rules
+    rules:
+      - name: use-any
+        disabled: true
+      - name: if-return
+        disabled: true
+      - name: max-public-structs
+        disabled: true
+      - name: cognitive-complexity
+        disabled: true
+      - name: argument-limit
+        disabled: true
+      - name: cyclomatic
+        disabled: true
+      - name: file-header
+        disabled: true
+      - name: function-length
+        disabled: true
+      - name: function-result-limit
+        disabled: true
+      - name: line-length-limit
+        disabled: true
+      - name: flag-parameter
+        disabled: true
+      - name: add-constant
+        disabled: true
+      - name: empty-lines
+        disabled: true
+      - name: banned-characters
+        disabled: true
+      - name: deep-exit
+        disabled: true
+      - name: confusing-results
+        disabled: true
+      - name: unused-parameter
+        disabled: true
+      - name: modifies-value-receiver
+        disabled: true
+      - name: early-return
+        disabled: true
+      - name: nested-structs
+        disabled: true
+      - name: confusing-naming
+        disabled: true
+      - name: defer
+        disabled: true
+      # Disabled in favour of unparam.
+      - name: unused-parameter
+        disabled: true
+      - name: unhandled-error
+        disabled: false
+        arguments:
+          - 'fmt.Printf'
+          - 'fmt.Print'
+          - 'fmt.Println'
+          - 'myFunction'

go/compress.go

@@ -95,14 +95,14 @@ func compressStep(step *InnerOp, lookup *[]*InnerOp, registry map[string]int32)
 	}
 
 	// load from cache if there
-        if num, ok := registry[string(bz)]; ok {
+	if num, ok := registry[string(bz)]; ok {
 		return num
 	}
 
 	// create new step if not there
 	num := int32(len(*lookup))
 	*lookup = append(*lookup, step)
-        registry[string(bz)] = num	
+	registry[string(bz)] = num
 	return num
 }
 

go/go.mod

@@ -1,11 +1,17 @@
 module github.com/cosmos/ics23/go
 
-go 1.19
+go 1.21
 
 require (
-	github.com/cosmos/gogoproto v1.4.3
+	github.com/cosmos/gogoproto v1.4.11
 	golang.org/x/crypto v0.2.0
 )
 
+require (
+	github.com/google/go-cmp v0.5.9 // indirect
+	golang.org/x/exp v0.0.0-20230811145659-89c5cff77bcb // indirect
+	google.golang.org/protobuf v1.31.0 // indirect
+)
+
 // subject to the dragonberry vulnerability
 retract [v0.0.0, v0.7.0]

go/go.sum

@@ -1,4 +1,14 @@
-github.com/cosmos/gogoproto v1.4.3 h1:RP3yyVREh9snv/lsOvmsAPQt8f44LgL281X0IOIhhcI=
-github.com/cosmos/gogoproto v1.4.3/go.mod h1:0hLIG5TR7IvV1fme1HCFKjfzW9X2x0Mo+RooWXCnOWU=
+github.com/cosmos/gogoproto v1.4.11 h1:LZcMHrx4FjUgrqQSWeaGC1v/TeuVFqSLa43CC6aWR2g=
+github.com/cosmos/gogoproto v1.4.11/go.mod h1:/g39Mh8m17X8Q/GDEs5zYTSNaNnInBSohtaxzQnYq1Y=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 golang.org/x/crypto v0.2.0 h1:BRXPfhNivWL5Yq0BGQ39a2sW6t44aODpfxkWjYdzewE=
 golang.org/x/crypto v0.2.0/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
+golang.org/x/exp v0.0.0-20230811145659-89c5cff77bcb h1:mIKbk8weKhSeLH2GmUTrvx8CjkyJmnU1wFmg59CUjFA=
+golang.org/x/exp v0.0.0-20230811145659-89c5cff77bcb/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=

go/ops.go

@@ -12,7 +12,6 @@ import (
 	_ "crypto/sha256"
 	// adds sha512 capability to crypto.SHA512
 	_ "crypto/sha512"
-
 	// adds ripemd160 capability to crypto.RIPEMD160
 	_ "golang.org/x/crypto/ripemd160" //nolint:staticcheck
 )
@@ -164,15 +163,24 @@ func doHash(hashOp HashOp, preimage []byte) ([]byte, error) {
 	case HashOp_BITCOIN:
 		// ripemd160(sha256(x))
 		sha := crypto.SHA256.New()
-		sha.Write(preimage)
+		_, err := sha.Write(preimage)
+		if err != nil {
+			return nil, err
+		}
 		tmp := sha.Sum(nil)
-		hash := crypto.RIPEMD160.New()
-		hash.Write(tmp)
-		return hash.Sum(nil), nil
+		bitcoinHash := crypto.RIPEMD160.New()
+		_, err = bitcoinHash.Write(tmp)
+		if err != nil {
+			return nil, err
+		}
+		return bitcoinHash.Sum(nil), nil
 	case HashOp_SHA512_256:
-		hash := crypto.SHA512_256.New()
-		hash.Write(preimage)
-		return hash.Sum(nil), nil
+		shaHash := crypto.SHA512_256.New()
+		_, err := shaHash.Write(preimage)
+		if err != nil {
+			return nil, err
+		}
+		return shaHash.Sum(nil), nil
 	}
 	return nil, fmt.Errorf("unsupported hashop: %d", hashOp)
 }
@@ -183,7 +191,10 @@ type hasher interface {
 
 func hashBz(h hasher, preimage []byte) ([]byte, error) {
 	hh := h.New()
-	hh.Write(preimage)
+	_, err := hh.Write(preimage)
+	if err != nil {
+		return nil, err
+	}
 	return hh.Sum(nil), nil
 }
 
@@ -193,8 +204,8 @@ func prepareLeafData(hashOp HashOp, lengthOp LengthOp, data []byte) ([]byte, err
 	if err != nil {
 		return nil, err
 	}
-	ldata, err := doLengthOp(lengthOp, hdata)
-	return ldata, err
+
+	return doLengthOp(lengthOp, hdata)
 }
 
 func validateSpec(spec *ProofSpec) bool {

go/ops_data_test.go

@@ -17,6 +17,7 @@ type LeafOpTestStruct struct {
 }
 
 func LeafOpTestData(t *testing.T) map[string]LeafOpTestStruct {
+	t.Helper()
 	fname := filepath.Join("..", "testdata", "TestLeafOpData.json")
 	ffile, err := os.Open(fname)
 	if err != nil {
@@ -39,6 +40,7 @@ type InnerOpTestStruct struct {
 }
 
 func InnerOpTestData(t *testing.T) map[string]InnerOpTestStruct {
+	t.Helper()
 	fname := filepath.Join("..", "testdata", "TestInnerOpData.json")
 	ffile, err := os.Open(fname)
 	if err != nil {
@@ -60,6 +62,7 @@ type DoHashTestStruct struct {
 }
 
 func DoHashTestData(t *testing.T) map[string]DoHashTestStruct {
+	t.Helper()
 	fname := filepath.Join("..", "testdata", "TestDoHashData.json")
 	ffile, err := os.Open(fname)
 	if err != nil {

go/ops_test.go

@@ -14,13 +14,13 @@ func TestLeafOp(t *testing.T) {
 			res, err := tc.Op.Apply(tc.Key, tc.Value)
 			// short-circuit with error case
 			if tc.IsErr && err == nil {
-				t.Fatal("Expected error, but got none")
+				t.Fatal("expected error, but got none")
 			}
-			if tc.IsErr == false && err != nil {
+			if !tc.IsErr && err != nil {
 				t.Fatal(err)
 			}
 			if !bytes.Equal(res, tc.Expected) {
-				t.Errorf("Bad result: %s vs %s", toHex(res), toHex(tc.Expected))
+				t.Errorf("bad result: %s vs %s", toHex(res), toHex(tc.Expected))
 			}
 		})
 	}
@@ -35,7 +35,7 @@ func TestInnerOp(t *testing.T) {
 			if tc.IsErr && err == nil {
 				t.Fatal("Expected error, but got none")
 			}
-			if tc.IsErr == false && err != nil {
+			if !tc.IsErr && err != nil {
 				t.Fatal(err)
 			}
 			if !bytes.Equal(res, tc.Expected) {

go/proof.go

@@ -200,7 +200,7 @@ func (p *ExistenceProof) CheckAgainstSpec(spec *ProofSpec) error {
 		if err := inner.CheckAgainstSpec(spec, layerNum); err != nil {
 			return fmt.Errorf("inner, %w", err)
 		}
-		layerNum += 1
+		layerNum++
 	}
 	return nil
 }
@@ -367,7 +367,7 @@ func getPadding(spec *InnerSpec, branch int32) (minPrefix, maxPrefix, suffix int
 
 	// count how many children are in the suffix
 	suffix = (len(spec.ChildOrder) - 1 - idx) * int(spec.ChildSize)
-	return
+	return minPrefix, maxPrefix, suffix
 }
 
 // leftBranchesAreEmpty returns true if the padding bytes correspond to all empty siblings

go/proof_data_test.go

@@ -14,6 +14,7 @@ type ExistenceProofTestStruct struct {
 }
 
 func ExistenceProofTestData(t *testing.T) map[string]ExistenceProofTestStruct {
+	t.Helper()
 	fname := filepath.Join("..", "testdata", "TestExistenceProofData.json")
 	ffile, err := os.Open(fname)
 	if err != nil {
@@ -35,6 +36,7 @@ type CheckLeafTestStruct struct {
 }
 
 func CheckLeafTestData(t *testing.T) map[string]CheckLeafTestStruct {
+	t.Helper()
 	fname := filepath.Join("..", "testdata", "TestCheckLeafData.json")
 	ffile, err := os.Open(fname)
 	if err != nil {
@@ -56,6 +58,7 @@ type CheckAgainstSpecTestStruct struct {
 }
 
 func CheckAgainstSpecTestData(t *testing.T) map[string]CheckAgainstSpecTestStruct {
+	t.Helper()
 	fname := filepath.Join("..", "testdata", "TestCheckAgainstSpecData.json")
 	ffile, err := os.Open(fname)
 	if err != nil {
@@ -94,6 +97,7 @@ type EmptyBranchTestStruct struct {
 }
 
 func EmptyBranchTestData(t *testing.T) []EmptyBranchTestStruct {
+	t.Helper()
 	emptyChild := SpecWithEmptyChild.InnerSpec.EmptyChild
 
 	return []EmptyBranchTestStruct{

go/proof_test.go

@@ -12,11 +12,14 @@ func TestExistenceProof(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			res, err := tc.Proof.Calculate()
 			// short-circuit with error case
-			if tc.IsErr && err == nil {
-				t.Fatal("Expected error, but got none")
-			}
-			if tc.IsErr == false && err != nil {
-				t.Fatal(err)
+			if tc.IsErr {
+				if err == nil {
+					t.Fatal("Expected error, but got none")
+				}
+			} else {
+				if err != nil {
+					t.Fatal(err)
+				}
 			}
 			if !bytes.Equal(res, tc.Expected) {
 				t.Errorf("Bad result: %s vs %s", toHex(res), toHex(tc.Expected))