ci: fix linter

Author: thiagodeev

rpc/v8/block_test.go

@@ -179,7 +179,9 @@ func TestBlockTransactionCount(t *testing.T) {
 	t.Run("non-existent block hash", func(t *testing.T) {
 		mockReader.EXPECT().BlockHeaderByHash(gomock.Any()).Return(nil, db.ErrKeyNotFound)
 
-		count, rpcErr := handler.BlockTransactionCount(blockIDHash(t, new(felt.Felt).SetBytes([]byte("random"))))
+		count, rpcErr := handler.BlockTransactionCount(
+			blockIDHash(t, new(felt.Felt).SetBytes([]byte("random"))),
+		)
 		assert.Equal(t, uint64(0), count)
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
@@ -472,7 +474,11 @@ func TestBlockWithTxs(t *testing.T) {
 	require.NoError(t, err)
 	latestBlockHash := latestBlock.Hash
 
-	checkLatestBlock := func(t *testing.T, blockWithTxHashes *rpc.BlockWithTxHashes, blockWithTxs *rpc.BlockWithTxs) {
+	checkLatestBlock := func(
+		t *testing.T,
+		blockWithTxHashes *rpc.BlockWithTxHashes,
+		blockWithTxs *rpc.BlockWithTxs,
+	) {
 		t.Helper()
 		assert.Equal(t, blockWithTxHashes.BlockHeader, blockWithTxs.BlockHeader)
 		assert.Equal(t, len(blockWithTxHashes.TxnHashes), len(blockWithTxs.Transactions))

rpc/v8/class.go

@@ -111,7 +111,8 @@ func (h *Handler) Class(id BlockID, classHash felt.Felt) (*Class, *jsonrpc.Error
 			Program: c.Program,
 			EntryPoints: EntryPoints{
 				// Note that utils.Map returns nil if provided slice is nil
-				// but this is not the case here, because we rely on sn2core adapters that will set it to empty slice
+				// but this is not the case here, because we rely on sn2core adapters
+				// that will set it to empty slice if it's nil. In the API spec these fields are required.
 				// if it's nil. In the API spec these fields are required.
 				Constructor: utils.Map(c.Constructors, adaptEntryPoint),
 				External:    utils.Map(c.Externals, adaptEntryPoint),
@@ -132,7 +133,8 @@ func (h *Handler) Class(id BlockID, classHash felt.Felt) (*Class, *jsonrpc.Error
 			ContractClassVersion: c.SemanticVersion,
 			EntryPoints: EntryPoints{
 				// Note that utils.Map returns nil if provided slice is nil
-				// but this is not the case here, because we rely on sn2core adapters that will set it to empty slice
+				// but this is not the case here, because we rely on sn2core adapters
+				// that will set it to empty slice if it's nil. In the API spec these fields are required.
 				// if it's nil. In the API spec these fields are required.
 				Constructor: utils.Map(c.EntryPoints.Constructor, adaptEntryPoint),
 				External:    utils.Map(c.EntryPoints.External, adaptEntryPoint),
@@ -146,7 +148,8 @@ func (h *Handler) Class(id BlockID, classHash felt.Felt) (*Class, *jsonrpc.Error
 	return rpcClass, nil
 }
 
-// ClassAt gets the contract class definition in the given block instantiated by the given contract address
+// ClassAt gets the contract class definition in the given block instantiated by
+// the given contract address
 //
 // It follows the specification defined here:
 // https://github.com/starkware-libs/starknet-specs/blob/v0.8.1/api/starknet_api_openrpc.json#L482
@@ -158,7 +161,8 @@ func (h *Handler) ClassAt(id BlockID, address felt.Felt) (*Class, *jsonrpc.Error
 	return h.Class(id, *classHash)
 }
 
-// ClassHashAt gets the class hash for the contract deployed at the given address in the given block.
+// ClassHashAt gets the class hash for the contract deployed at the given address
+// in the given block.
 //
 // It follows the specification defined here:
 // https://github.com/starkware-libs/starknet-specs/blob/v0.8.1/api/starknet_api_openrpc.json#L442

rpc/v8/state_update.go

@@ -75,6 +75,7 @@ func (h *Handler) StateUpdate(id BlockID) (*StateUpdate, *jsonrpc.Error) {
 			update, err = h.bcReader.StateUpdateByNumber(height)
 		}
 	} else if id.IsPending() {
+		//nolint:staticcheck // Necessary for v8
 		var pending *core.Pending
 		pending, err = h.Pending()
 		if err == nil {

rpc/v8/sync_test.go

@@ -56,7 +56,9 @@ func TestSyncing(t *testing.T) {
 		assert.Equal(t, &rpc.Sync{Syncing: &defaultSyncState}, syncing)
 	})
 
-	synchronizer.EXPECT().HighestBlockHeader().Return(&core.Header{Number: 2, Hash: new(felt.Felt).SetUint64(2)}).Times(2)
+	synchronizer.EXPECT().HighestBlockHeader().Return(
+		&core.Header{Number: 2, Hash: new(felt.Felt).SetUint64(2)},
+	).Times(2)
 	t.Run("block height is equal to highest block", func(t *testing.T) {
 		mockReader.EXPECT().BlockHeaderByNumber(startingBlock).Return(&core.Header{}, nil)
 		mockReader.EXPECT().HeadsHeader().Return(&core.Header{Number: 2}, nil)
@@ -67,7 +69,10 @@ func TestSyncing(t *testing.T) {
 	})
 	t.Run("syncing", func(t *testing.T) {
 		mockReader.EXPECT().BlockHeaderByNumber(startingBlock).Return(&core.Header{Hash: &felt.Zero}, nil)
-		mockReader.EXPECT().HeadsHeader().Return(&core.Header{Number: 1, Hash: new(felt.Felt).SetUint64(1)}, nil)
+		mockReader.EXPECT().HeadsHeader().Return(
+			&core.Header{Number: 1, Hash: new(felt.Felt).SetUint64(1)},
+			nil,
+		)
 
 		currentBlockNumber := uint64(1)
 		highestBlockNumber := uint64(2)

rpc/v8/trace.go

@@ -48,8 +48,8 @@ type FunctionInvocation struct {
 	Calldata           []felt.Felt              `json:"calldata"`
 	CallerAddress      felt.Felt                `json:"caller_address"`
 	ClassHash          *felt.Felt               `json:"class_hash"`
-	EntryPointType     string                   `json:"entry_point_type"` // shouldnt we put it as enum here ?
-	CallType           string                   `json:"call_type"`        // shouldnt we put it as enum here ?
+	EntryPointType     string                   `json:"entry_point_type"`
+	CallType           string                   `json:"call_type"`
 	Result             []felt.Felt              `json:"result"`
 	Calls              []FunctionInvocation     `json:"calls"`
 	Events             []OrderedEvent           `json:"events"`

rpc/v8/trace_test.go

@@ -759,7 +759,7 @@ func TestAdaptVMTransactionTrace(t *testing.T) {
 			},
 			ConstructorInvocation: &vm.FunctionInvocation{},
 			FunctionInvocation:    &vm.ExecuteInvocation{},
-			StateDiff: &vm.StateDiff{ //nolint:dupl
+			StateDiff: &vm.StateDiff{ //nolint:dupl // Similar, but for different cases
 				StorageDiffs: []vm.StorageDiff{
 					{
 						Address: felt.Zero,
@@ -843,7 +843,7 @@ func TestAdaptVMTransactionTrace(t *testing.T) {
 					IsReverted: false,
 				},
 			},
-			StateDiff: &rpc.StateDiff{ //nolint:dupl
+			StateDiff: &rpc.StateDiff{ //nolint:dupl // Similar, but for different cases
 				StorageDiffs: []rpc.StorageDiff{
 					{
 						Address: felt.Zero,