Add linters

.golangci.yaml

@@ -112,6 +112,9 @@ linters:
     - exhaustruct
     - usetesting
     - nilnesserr
+    - prealloc
+    - makezero
+    - intrange
 
   # don't enable:
   # - asciicheck

blockchain/blockchain.go

@@ -916,7 +916,7 @@ func removeTxsAndReceipts(txn db.Transaction, blockNumber, numTxs uint64) error
 		Number: blockNumber,
 	}
 	// remove txs and receipts
-	for i := uint64(0); i < numTxs; i++ {
+	for i := range numTxs {
 		blockIDAndIndex.Index = i
 		reorgedTxn, err := transactionByBlockNumberAndIndex(txn, &blockIDAndIndex)
 		if err != nil {

blockchain/blockchain_test.go

@@ -331,7 +331,7 @@ func TestTransactionAndReceipt(t *testing.T) {
 	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
-	for i := uint64(0); i < 3; i++ {
+	for i := range uint64(3) {
 		b, err := gw.BlockByNumber(context.Background(), i)
 		require.NoError(t, err)
 
@@ -363,7 +363,7 @@ func TestTransactionAndReceipt(t *testing.T) {
 	})
 
 	t.Run("GetTransactionByHash and GetGetTransactionByBlockNumberAndIndex return same transaction", func(t *testing.T) {
-		for i := uint64(0); i < 3; i++ {
+		for i := range uint64(3) {
 			t.Run(fmt.Sprintf("mainnet block %v", i), func(t *testing.T) {
 				block, err := gw.BlockByNumber(context.Background(), i)
 				require.NoError(t, err)
@@ -382,7 +382,7 @@ func TestTransactionAndReceipt(t *testing.T) {
 	})
 
 	t.Run("GetReceipt returns expected receipt", func(t *testing.T) {
-		for i := uint64(0); i < 3; i++ {
+		for i := range uint64(3) {
 			t.Run(fmt.Sprintf("mainnet block %v", i), func(t *testing.T) {
 				block, err := gw.BlockByNumber(context.Background(), i)
 				require.NoError(t, err)
@@ -399,7 +399,7 @@ func TestTransactionAndReceipt(t *testing.T) {
 	})
 
 	t.Run("BlockCommitments returns expected values", func(t *testing.T) {
-		for i := uint64(0); i < 3; i++ {
+		for i := range uint64(3) {
 			t.Run(fmt.Sprintf("mainnet block %v", i), func(t *testing.T) {
 				commitments, err := chain.BlockCommitmentsByNumber(i)
 				require.NoError(t, err)
@@ -425,7 +425,7 @@ func TestState(t *testing.T) {
 	})
 
 	var existingBlockHash *felt.Felt
-	for i := uint64(0); i < 2; i++ {
+	for i := range uint64(2) {
 		block, err := gw.BlockByNumber(context.Background(), i)
 		require.NoError(t, err)
 		su, err := gw.StateUpdate(context.Background(), i)
@@ -546,7 +546,7 @@ func TestEvents(t *testing.T) {
 				var accEvents []*blockchain.FilteredEvent
 				var lastToken *blockchain.ContinuationToken
 				var gotEvents []*blockchain.FilteredEvent
-				for i := 0; i < len(allEvents)+1; i++ {
+				for range len(allEvents) + 1 {
 					gotEvents, lastToken, err = filter.Events(lastToken, chunkSize)
 					require.NoError(t, err)
 					accEvents = append(accEvents, gotEvents...)
@@ -603,7 +603,7 @@ func TestRevert(t *testing.T) {
 	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
-	for i := uint64(0); i < 3; i++ {
+	for i := range uint64(3) {
 		b, err := gw.BlockByNumber(context.Background(), i)
 		require.NoError(t, err)
 

clients/feeder/feeder.go

@@ -232,7 +232,7 @@ func (c *Client) get(ctx context.Context, queryURL string) (io.ReadCloser, error
 	var res *http.Response
 	var err error
 	wait := time.Duration(0)
-	for i := 0; i <= c.maxRetries; i++ {
+	for range c.maxRetries + 1 {
 		select {
 		case <-ctx.Done():
 			return nil, ctx.Err()

cmd/juno/dbcmd.go

@@ -200,11 +200,10 @@ func dbSize(cmd *cobra.Command, args []string) error {
 
 		withHistoryCount    uint
 		withoutHistoryCount uint
-
-		items [][]string
 	)
 
 	buckets := db.BucketValues()
+	items := make([][]string, 0, len(buckets)+3)
 	for _, b := range buckets {
 		fmt.Fprintf(cmd.OutOrStdout(), "Calculating size of %s, remaining buckets: %d\n", b, len(db.BucketValues())-int(b)-1)
 		bucketItem, err := pebble.CalculatePrefixSize(cmd.Context(), pebbleDB.(*pebble.DB), []byte{byte(b)}, true)

cmd/juno/juno_test.go

@@ -677,7 +677,7 @@ network: sepolia
 			require.True(t, len(tc.env)%2 == 0, "The number of env variables should be an even number")
 
 			if len(tc.env) > 0 {
-				for i := 0; i < len(tc.env)/2; i++ {
+				for i := range len(tc.env) / 2 {
 					require.NoError(t, os.Setenv(tc.env[2*i], tc.env[2*i+1]))
 				}
 			}
@@ -695,7 +695,7 @@ network: sepolia
 
 			assert.Equal(t, tc.expectedConfig, config)
 			if len(tc.env) > 0 {
-				for i := 0; i < len(tc.env)/2; i++ {
+				for i := range len(tc.env) / 2 {
 					require.NoError(t, os.Unsetenv(tc.env[2*i]))
 				}
 			}

core/crypto/ecdsa_test.go

@@ -70,7 +70,7 @@ func BenchmarkVerify(b *testing.B) {
 	var verified bool
 	var err error
 	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for range b.N {
 		verified, err = publicKey.Verify(&signature, msg)
 		require.NoError(b, err)
 	}

core/crypto/pedersen_hash_test.go

@@ -133,7 +133,7 @@ func BenchmarkPedersenArray(b *testing.B) {
 			randomFeltSls := genRandomFeltSls(b, i)
 			var f *felt.Felt
 			b.ResetTimer()
-			for n := 0; n < b.N; n++ {
+			for n := range b.N {
 				f = crypto.PedersenArray(randomFeltSls[n]...)
 			}
 			benchHashR = f
@@ -145,24 +145,24 @@ func BenchmarkPedersen(b *testing.B) {
 	randFelts := genRandomFeltPairs(b)
 	var f *felt.Felt
 	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
+	for n := range b.N {
 		f = crypto.Pedersen(randFelts[n][0], randFelts[n][1])
 	}
 	benchHashR = f
 }
 
 func genRandomFeltSls(b *testing.B, n int) [][]*felt.Felt {
-	var randomFeltSls [][]*felt.Felt
-	for j := 0; j < b.N; j++ {
+	randomFeltSls := make([][]*felt.Felt, 0, b.N)
+	for range b.N {
 		randomFeltSls = append(randomFeltSls, genRandomFelts(b, n))
 	}
 	return randomFeltSls
 }
 
 func genRandomFelts(b *testing.B, n int) []*felt.Felt {
 	b.Helper()
-	var felts []*felt.Felt
-	for i := 0; i < n; i++ {
+	felts := make([]*felt.Felt, 0, n)
+	for range n {
 		f, err := new(felt.Felt).SetRandom()
 		require.NoError(b, err)
 		felts = append(felts, f)
@@ -174,7 +174,7 @@ func genRandomFeltPairs(b *testing.B) [][2]*felt.Felt {
 	b.Helper()
 	var err error
 	randFelts := make([][2]*felt.Felt, b.N)
-	for i := 0; i < b.N; i++ {
+	for i := range b.N {
 		randFelts[i][0], err = new(felt.Felt).SetRandom()
 		require.NoError(b, err)
 		randFelts[i][1], err = new(felt.Felt).SetRandom()

core/crypto/poseidon_hash.go

@@ -45,7 +45,7 @@ func round(state []felt.Felt, full bool, index int) {
 func HadesPermutation(state []felt.Felt) {
 	initialiseRoundKeys.Do(setRoundKeys)
 	totalRounds := fullRounds + partialRounds
-	for i := 0; i < totalRounds; i++ {
+	for i := range totalRounds {
 		full := (i < fullRounds/2) || (totalRounds-i <= fullRounds/2)
 		round(state, full, i)
 	}
@@ -74,7 +74,7 @@ var one = new(felt.Felt).SetUint64(1)
 func PoseidonArray(elems ...*felt.Felt) *felt.Felt {
 	state := []felt.Felt{{}, {}, {}}
 
-	for i := 0; i < len(elems)/2; i++ {
+	for i := range len(elems) / 2 {
 		state[0].Add(&state[0], elems[2*i])
 		state[1].Add(&state[1], elems[2*i+1])
 		HadesPermutation(state)

core/crypto/poseidon_hash_test.go

@@ -63,7 +63,7 @@ func BenchmarkPoseidonArray(b *testing.B) {
 			randomFeltSls := genRandomFeltSls(b, i)
 			var f *felt.Felt
 			b.ResetTimer()
-			for n := 0; n < b.N; n++ {
+			for n := range b.N {
 				f = crypto.PoseidonArray(randomFeltSls[n]...)
 			}
 			benchHashR = f
@@ -76,7 +76,7 @@ func BenchmarkPoseidon(b *testing.B) {
 
 	var f *felt.Felt
 	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
+	for n := range b.N {
 		f = crypto.Poseidon(randFelts[n][0], randFelts[n][1])
 	}
 	benchHashR = f

core/receipt_test.go

@@ -95,7 +95,7 @@ func BenchmarkReceiptCommitment(b *testing.B) {
 	var f *felt.Felt
 	var err error
 	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for range b.N {
 		f, err = receiptCommitment(receipts)
 		require.NoError(b, err)
 	}

core/state_update_test.go

@@ -86,7 +86,7 @@ func BenchmarkStateDiffHash(b *testing.B) {
 	require.NoError(b, err)
 
 	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
+	for range b.N {
 		su.StateDiff.Hash()
 	}
 }

core/trie/proof.go

@@ -205,7 +205,7 @@ func VerifyRangeProof(root, first *felt.Felt, keys, values []*felt.Felt, proof *
 	}
 
 	// Ensure all keys are monotonically increasing and values contain no deletions
-	for i := 0; i < len(keys); i++ {
+	for i := range keys {
 		if i < len(keys)-1 && keys[i].Cmp(keys[i+1]) > 0 {
 			return false, errors.New("keys are not monotonic increasing")
 		}

core/trie/proof_test.go

@@ -204,7 +204,7 @@ func TestRangeProof(t *testing.T) {
 	root, err := tr.Root()
 	require.NoError(t, err)
 
-	for i := 0; i < 100; i++ {
+	for range 100 {
 		start := rand.Intn(n)
 		end := rand.Intn(n-start) + start + 1
 
@@ -233,7 +233,7 @@ func TestRangeProofWithNonExistentProof(t *testing.T) {
 	root, err := tr.Root()
 	require.NoError(t, err)
 
-	for i := 0; i < 100; i++ {
+	for range 100 {
 		start := rand.Intn(n)
 		end := rand.Intn(n-start) + start + 1
 
@@ -403,7 +403,7 @@ func TestSingleSideRangeProof(t *testing.T) {
 
 		keys := make([]*felt.Felt, i+1)
 		values := make([]*felt.Felt, i+1)
-		for j := 0; j < i+1; j++ {
+		for j := range i + 1 {
 			keys[j] = records[j].key
 			values[j] = records[j].value
 		}
@@ -531,7 +531,7 @@ func TestBadRangeProof(t *testing.T) {
 	root, err := tr.Root()
 	require.NoError(t, err)
 
-	for i := 0; i < 100; i++ {
+	for range 100 {
 		start := rand.Intn(len(records))
 		end := rand.Intn(len(records)-start) + start + 1
 
@@ -584,7 +584,7 @@ func TestBadRangeProof(t *testing.T) {
 func BenchmarkProve(b *testing.B) {
 	tr, records := randomTrie(b, 1000)
 	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for i := range b.N {
 		proof := trie.NewProofNodeSet()
 		key := records[i%len(records)].key
 		if err := tr.Prove(key, proof); err != nil {
@@ -598,7 +598,7 @@ func BenchmarkVerifyProof(b *testing.B) {
 	root, err := tr.Root()
 	require.NoError(b, err)
 
-	var proofs []*trie.ProofNodeSet
+	proofs := make([]*trie.ProofNodeSet, 0, len(records))
 	for _, record := range records {
 		proof := trie.NewProofNodeSet()
 		if err := tr.Prove(record.key, proof); err != nil {
@@ -608,7 +608,7 @@ func BenchmarkVerifyProof(b *testing.B) {
 	}
 
 	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for i := range b.N {
 		index := i % len(records)
 		if _, err := trie.VerifyProof(root, records[index].key, proofs[index], crypto.Pedersen); err != nil {
 			b.Fatal(err)
@@ -636,7 +636,7 @@ func BenchmarkVerifyRangeProof(b *testing.B) {
 	}
 
 	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for range b.N {
 		_, err := trie.VerifyRangeProof(root, keys[0], keys, values, proof)
 		require.NoError(b, err)
 	}
@@ -784,7 +784,7 @@ func randomTrie(t testing.TB, n int) (*trie.Trie, []*keyValue) {
 	require.NoError(t, err)
 
 	records := make([]*keyValue, n)
-	for i := 0; i < n; i++ {
+	for i := range n {
 		key := new(felt.Felt).SetUint64(uint64(rrand.Uint32() + 1))
 		records[i] = &keyValue{key: key, value: key}
 		_, err := tempTrie.Put(key, key)

core/trie/trie_test.go

@@ -164,7 +164,7 @@ func TestPutZero(t *testing.T) {
 		var keys []*felt.Felt
 
 		// put random 64 keys and record roots
-		for i := 0; i < 64; i++ {
+		for range 64 {
 			key, value := new(felt.Felt), new(felt.Felt)
 
 			_, err = key.SetRandom()
@@ -238,7 +238,7 @@ func TestTrie(t *testing.T) {
 		var keys []*felt.Felt
 
 		// put random 64 keys and record roots
-		for i := 0; i < 64; i++ {
+		for range 64 {
 			key, value := new(felt.Felt), new(felt.Felt)
 
 			_, err = key.SetRandom()
@@ -433,7 +433,7 @@ var benchTriePutR *felt.Felt
 
 func BenchmarkTriePut(b *testing.B) {
 	keys := make([]*felt.Felt, 0, b.N)
-	for i := 0; i < b.N; i++ {
+	for range b.N {
 		rnd, err := new(felt.Felt).SetRandom()
 		require.NoError(b, err)
 		keys = append(keys, rnd)
@@ -444,7 +444,7 @@ func BenchmarkTriePut(b *testing.B) {
 		var f *felt.Felt
 		var err error
 		b.ResetTimer()
-		for i := 0; i < b.N; i++ {
+		for i := range b.N {
 			f, err = t.Put(keys[i], one)
 			if err != nil {
 				return err

db/pebble/db_test.go

@@ -342,7 +342,7 @@ func TestPrefixSearch(t *testing.T) {
 
 		assert.Equal(t, len(expectedKeys), len(entries))
 
-		for i := 0; i < len(entries); i++ {
+		for i := range entries {
 			assert.Contains(t, expectedKeys, entries[i].key)
 		}
 

jsonrpc/server.go

@@ -620,7 +620,7 @@ func (s *Server) validateParam(param reflect.Value) error {
 			return err
 		}
 	case kind == reflect.Slice || kind == reflect.Array:
-		for i := 0; i < param.Len(); i++ {
+		for i := range param.Len() {
 			if err := s.validateParam(param.Index(i)); err != nil {
 				return err
 			}

jsonrpc/server_test.go

@@ -562,7 +562,7 @@ func BenchmarkHandle(b *testing.B) {
 	var header http.Header
 	var err error
 	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for range b.N {
 		_, header, err = server.HandleReader(context.Background(), strings.NewReader(request))
 		require.NoError(b, err)
 		require.NotNil(b, header)