CI: Fix golangci-lint linter issues, add prealloc linter and bump version depends for Go 1.18 (#915)

* Bump CI versions

* Specifically set go version as 1.17.x bumps it to 1.18

* Another

* Adjust AppVeyor

* Part 1 of linter issues

* Part 2

* Fix various linters and improvements

* Part 3

* Finishing touches

* Tests and EqualFold

* Fix nitterinos plus bonus requester jobs bump for exchanges with large number of tests

* Fix nitterinos and bump golangci-lint timeout for AppVeyor

* Address nits, ensure all books are returned on err due to syncer regression

* Fix the wiggins

* Fix duplication

* Fix nitterinos

exchanges/bittrex/bittrex.go

@@ -103,7 +103,7 @@ func (b *Bittrex) GetMarketSummary(ctx context.Context, marketName string) (Mark
 // GetOrderbook method returns current order book information by currency and depth.
 // "marketSymbol" ie ltc-btc
 // "depth" is either 1, 25 or 500. Server side, the depth defaults to 25.
-func (b *Bittrex) GetOrderbook(ctx context.Context, marketName string, depth int64) (OrderbookData, int64, error) {
+func (b *Bittrex) GetOrderbook(ctx context.Context, marketName string, depth int64) (*OrderbookData, int64, error) {
 	strDepth := strconv.FormatInt(depth, 10)
 
 	var resp OrderbookData
@@ -111,14 +111,14 @@ func (b *Bittrex) GetOrderbook(ctx context.Context, marketName string, depth int
 	resultHeader := http.Header{}
 	err := b.SendHTTPRequest(ctx, exchange.RestSpot, fmt.Sprintf(getOrderbook, marketName, strDepth), &resp, &resultHeader)
 	if err != nil {
-		return OrderbookData{}, 0, err
+		return nil, 0, err
 	}
 	sequence, err = strconv.ParseInt(resultHeader.Get("sequence"), 10, 64)
 	if err != nil {
-		return OrderbookData{}, 0, err
+		return nil, 0, err
 	}
 
-	return resp, sequence, nil
+	return &resp, sequence, nil
 }
 
 // GetMarketHistory retrieves the latest trades that have occurred for a specific market

exchanges/bittrex/bittrex_websocket.go

@@ -7,7 +7,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/url"
 	"strconv"
@@ -61,7 +61,7 @@ var defaultSpotSubscribedChannelsAuth = []string{
 type TickerCache struct {
 	MarketSummaries map[string]*MarketSummaryData
 	Tickers         map[string]*TickerData
-	sync.RWMutex
+	mu              sync.RWMutex
 }
 
 // WsConnect connects to a websocket feed
@@ -277,9 +277,9 @@ func (b *Bittrex) subscribeSlice(channelsToSubscribe []stream.ChannelSubscriptio
 		InvocationID: b.Websocket.Conn.GenerateMessageID(false),
 	}
 
-	var channels []string
+	channels := make([]string, len(channelsToSubscribe))
 	for i := range channelsToSubscribe {
-		channels = append(channels, channelsToSubscribe[i].Channel)
+		channels[i] = channelsToSubscribe[i].Channel
 	}
 	arguments := make([][]string, 0)
 	arguments = append(arguments, channels)
@@ -342,9 +342,9 @@ func (b *Bittrex) unsubscribeSlice(channelsToUnsubscribe []stream.ChannelSubscri
 		InvocationID: b.Websocket.Conn.GenerateMessageID(false),
 	}
 
-	var channels []string
+	channels := make([]string, len(channelsToUnsubscribe))
 	for i := range channelsToUnsubscribe {
-		channels = append(channels, channelsToUnsubscribe[i].Channel)
+		channels[i] = channelsToUnsubscribe[i].Channel
 	}
 	arguments := make([][]string, 0)
 	arguments = append(arguments, channels)
@@ -409,10 +409,16 @@ func (b *Bittrex) wsDecodeMessage(encodedMessage string, v interface{}) error {
 		return err
 	}
 	reader := flate.NewReader(bytes.NewBuffer(raw))
-	message, err := ioutil.ReadAll(reader)
+	message, err := io.ReadAll(reader)
 	if err != nil {
 		return err
 	}
+	if err = reader.Close(); err != nil {
+		log.Warnf(log.WebsocketMgr, "%s wsDecodeMessage: unable to close reader: %s",
+			b.Name,
+			err,
+		)
+	}
 	return json.Unmarshal(message, v)
 }
 
@@ -520,8 +526,8 @@ func (b *Bittrex) WsProcessUpdateTicker(tickerData TickerData) error {
 
 	tickerPrice, err := ticker.GetTicker(b.Name, pair, asset.Spot)
 	if err != nil {
-		b.tickerCache.Lock()
-		defer b.tickerCache.Unlock()
+		b.tickerCache.mu.Lock()
+		defer b.tickerCache.mu.Unlock()
 		if b.tickerCache.MarketSummaries[tickerData.Symbol] != nil {
 			marketSummaryData := b.tickerCache.MarketSummaries[tickerData.Symbol]
 			tickerPrice = b.constructTicker(tickerData, marketSummaryData, pair, asset.Spot)
@@ -550,8 +556,8 @@ func (b *Bittrex) WsProcessUpdateMarketSummary(marketSummaryData *MarketSummaryD
 
 	tickerPrice, err := ticker.GetTicker(b.Name, pair, asset.Spot)
 	if err != nil {
-		b.tickerCache.Lock()
-		defer b.tickerCache.Unlock()
+		b.tickerCache.mu.Lock()
+		defer b.tickerCache.mu.Unlock()
 		if b.tickerCache.Tickers[marketSummaryData.Symbol] != nil {
 			tickerData := b.tickerCache.Tickers[marketSummaryData.Symbol]
 			tickerPrice = b.constructTicker(*tickerData, marketSummaryData, pair, asset.Spot)

exchanges/bittrex/bittrex_wrapper.go

@@ -257,7 +257,7 @@ func (b *Bittrex) FetchTradablePairs(ctx context.Context, asset asset.Item) ([]s
 		return nil, err
 	}
 
-	var resp []string
+	resp := make([]string, 0, len(markets))
 	for x := range markets {
 		if markets[x].Status != "ONLINE" {
 			continue
@@ -358,42 +358,41 @@ func (b *Bittrex) FetchOrderbook(ctx context.Context, c currency.Pair, assetType
 
 // UpdateOrderbook updates and returns the orderbook for a currency pair
 func (b *Bittrex) UpdateOrderbook(ctx context.Context, p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
+	book := &orderbook.Base{
+		Exchange:        b.Name,
+		Pair:            p,
+		Asset:           assetType,
+		VerifyOrderbook: b.CanVerifyOrderbook,
+	}
+
 	formattedPair, err := b.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return nil, err
+		return book, err
 	}
 
 	// Valid order book depths are 1, 25 and 500
 	orderbookData, sequence, err := b.GetOrderbook(ctx,
 		formattedPair.String(), orderbookDepth)
 	if err != nil {
-		return nil, err
+		return book, err
 	}
 
-	book := &orderbook.Base{
-		Exchange:        b.Name,
-		Pair:            p,
-		Asset:           assetType,
-		VerifyOrderbook: b.CanVerifyOrderbook,
-		LastUpdateID:    sequence,
-	}
+	book.LastUpdateID = sequence
+	book.Bids = make(orderbook.Items, len(orderbookData.Bid))
+	book.Asks = make(orderbook.Items, len(orderbookData.Ask))
 
 	for x := range orderbookData.Bid {
-		book.Bids = append(book.Bids,
-			orderbook.Item{
-				Amount: orderbookData.Bid[x].Quantity,
-				Price:  orderbookData.Bid[x].Rate,
-			},
-		)
+		book.Bids[x] = orderbook.Item{
+			Amount: orderbookData.Bid[x].Quantity,
+			Price:  orderbookData.Bid[x].Rate,
+		}
 	}
 
 	for x := range orderbookData.Ask {
-		book.Asks = append(book.Asks,
-			orderbook.Item{
-				Amount: orderbookData.Ask[x].Quantity,
-				Price:  orderbookData.Ask[x].Rate,
-			},
-		)
+		book.Asks[x] = orderbook.Item{
+			Amount: orderbookData.Ask[x].Quantity,
+			Price:  orderbookData.Ask[x].Rate,
+		}
 	}
 	err = book.Process()
 	if err != nil {
@@ -411,14 +410,14 @@ func (b *Bittrex) UpdateAccountInfo(ctx context.Context, assetType asset.Item) (
 		return resp, err
 	}
 
-	var currencies []account.Balance
+	currencies := make([]account.Balance, len(balanceData))
 	for i := range balanceData {
-		currencies = append(currencies, account.Balance{
+		currencies[i] = account.Balance{
 			CurrencyName: currency.NewCode(balanceData[i].CurrencySymbol),
 			Total:        balanceData[i].Total,
 			Hold:         balanceData[i].Total - balanceData[i].Available,
 			Free:         balanceData[i].Available,
-		})
+		}
 	}
 
 	resp.Accounts = append(resp.Accounts, account.SubAccount{
@@ -441,18 +440,32 @@ func (b *Bittrex) FetchAccountInfo(ctx context.Context, assetType asset.Item) (a
 // GetFundingHistory returns funding history, deposits and
 // withdrawals
 func (b *Bittrex) GetFundingHistory(ctx context.Context) ([]exchange.FundHistory, error) {
-	var resp []exchange.FundHistory
 	closedDepositData, err := b.GetClosedDeposits(ctx)
 	if err != nil {
-		return resp, err
+		return nil, err
 	}
 	openDepositData, err := b.GetOpenDeposits(ctx)
 	if err != nil {
-		return resp, err
+		return nil, err
+	}
+	closedWithdrawalData, err := b.GetClosedWithdrawals(ctx)
+	if err != nil {
+		return nil, err
+	}
+	openWithdrawalData, err := b.GetOpenWithdrawals(ctx)
+	if err != nil {
+		return nil, err
 	}
-	// nolint: gocritic
-	depositData := append(closedDepositData, openDepositData...)
 
+	depositData := make([]DepositData, 0, len(closedDepositData)+len(openDepositData))
+	depositData = append(depositData, closedDepositData...)
+	depositData = append(depositData, openDepositData...)
+
+	withdrawalData := make([]WithdrawalData, 0, len(closedWithdrawalData)+len(openWithdrawalData))
+	withdrawalData = append(withdrawalData, closedWithdrawalData...)
+	withdrawalData = append(withdrawalData, openWithdrawalData...)
+
+	resp := make([]exchange.FundHistory, 0, len(depositData)+len(withdrawalData))
 	for x := range depositData {
 		resp = append(resp, exchange.FundHistory{
 			ExchangeName:    b.Name,
@@ -466,17 +479,6 @@ func (b *Bittrex) GetFundingHistory(ctx context.Context) ([]exchange.FundHistory
 			CryptoTxID:      depositData[x].TxID,
 		})
 	}
-	closedWithdrawalData, err := b.GetClosedWithdrawals(ctx)
-	if err != nil {
-		return resp, err
-	}
-	openWithdrawalData, err := b.GetOpenWithdrawals(ctx)
-	if err != nil {
-		return resp, err
-	}
-	// nolint: gocritic
-	withdrawalData := append(closedWithdrawalData, openWithdrawalData...)
-
 	for x := range withdrawalData {
 		resp = append(resp, exchange.FundHistory{
 			ExchangeName:    b.Name,
@@ -502,23 +504,24 @@ func (b *Bittrex) GetWithdrawalsHistory(ctx context.Context, c currency.Code) (r
 
 // GetRecentTrades returns the most recent trades for a currency and asset
 func (b *Bittrex) GetRecentTrades(ctx context.Context, p currency.Pair, assetType asset.Item) ([]trade.Data, error) {
-	var err error
 	formattedPair, err := b.FormatExchangeCurrency(p, assetType)
 	if err != nil {
 		return nil, err
 	}
+
 	tradeData, err := b.GetMarketHistory(ctx, formattedPair.String())
 	if err != nil {
 		return nil, err
 	}
-	var resp []trade.Data
+
+	resp := make([]trade.Data, len(tradeData))
 	for i := range tradeData {
 		var side order.Side
 		side, err = order.StringToOrderSide(tradeData[i].TakerSide)
 		if err != nil {
 			return nil, err
 		}
-		resp = append(resp, trade.Data{
+		resp[i] = trade.Data{
 			Exchange:     b.Name,
 			TID:          tradeData[i].ID,
 			CurrencyPair: formattedPair,
@@ -527,7 +530,7 @@ func (b *Bittrex) GetRecentTrades(ctx context.Context, p currency.Pair, assetTyp
 			Price:        tradeData[i].Rate,
 			Amount:       tradeData[i].Quantity,
 			Timestamp:    tradeData[i].ExecutedAt,
-		})
+		}
 	}
 
 	err = b.AddTradesToBuffer(resp...)
@@ -772,7 +775,7 @@ func (b *Bittrex) GetActiveOrders(ctx context.Context, req *order.GetOrdersReque
 		return nil, err
 	}
 
-	var resp []order.Detail
+	resp := make([]order.Detail, 0, len(orderData))
 	for i := range orderData {
 		pair, err := currency.NewPairDelimiter(orderData[i].MarketSymbol,
 			format.Delimiter)

exchanges/bittrex/bittrex_ws_orderbook.go

@@ -49,19 +49,19 @@ func (b *Bittrex) setupOrderbookManager() {
 
 // ProcessUpdateOB processes the websocket orderbook update
 func (b *Bittrex) ProcessUpdateOB(pair currency.Pair, message *OrderbookUpdateMessage) error {
-	var updateBids []orderbook.Item
+	updateBids := make([]orderbook.Item, len(message.BidDeltas))
 	for x := range message.BidDeltas {
-		updateBids = append(updateBids, orderbook.Item{
+		updateBids[x] = orderbook.Item{
 			Price:  message.BidDeltas[x].Rate,
 			Amount: message.BidDeltas[x].Quantity,
-		})
+		}
 	}
-	var updateAsks []orderbook.Item
+	updateAsks := make([]orderbook.Item, len(message.AskDeltas))
 	for x := range message.AskDeltas {
-		updateAsks = append(updateAsks, orderbook.Item{
+		updateAsks[x] = orderbook.Item{
 			Price:  message.AskDeltas[x].Rate,
 			Amount: message.AskDeltas[x].Quantity,
-		})
+		}
 	}
 
 	return b.Websocket.Orderbook.Update(&buffer.Update{
@@ -116,30 +116,33 @@ func (b *Bittrex) SeedLocalOBCache(ctx context.Context, p currency.Pair) error {
 	if err != nil {
 		return err
 	}
-	return b.SeedLocalCacheWithOrderBook(p, sequence, &ob)
+	return b.SeedLocalCacheWithOrderBook(p, sequence, ob)
 }
 
 // SeedLocalCacheWithOrderBook seeds the local orderbook cache
 func (b *Bittrex) SeedLocalCacheWithOrderBook(p currency.Pair, sequence int64, orderbookNew *OrderbookData) error {
-	var newOrderBook orderbook.Base
-	for i := range orderbookNew.Bid {
-		newOrderBook.Bids = append(newOrderBook.Bids, orderbook.Item{
-			Amount: orderbookNew.Bid[i].Quantity,
-			Price:  orderbookNew.Bid[i].Rate,
-		})
-	}
-	for i := range orderbookNew.Ask {
-		newOrderBook.Asks = append(newOrderBook.Asks, orderbook.Item{
-			Amount: orderbookNew.Ask[i].Quantity,
-			Price:  orderbookNew.Ask[i].Rate,
-		})
+	newOrderBook := orderbook.Base{
+		Pair:            p,
+		Asset:           asset.Spot,
+		Exchange:        b.Name,
+		LastUpdateID:    sequence,
+		VerifyOrderbook: b.CanVerifyOrderbook,
+		Bids:            make(orderbook.Items, len(orderbookNew.Bid)),
+		Asks:            make(orderbook.Items, len(orderbookNew.Ask)),
 	}
 
-	newOrderBook.Pair = p
-	newOrderBook.Asset = asset.Spot
-	newOrderBook.Exchange = b.Name
-	newOrderBook.LastUpdateID = sequence
-	newOrderBook.VerifyOrderbook = b.CanVerifyOrderbook
+	for i := range orderbookNew.Bid {
+		newOrderBook.Bids[i] = orderbook.Item{
+			Amount: orderbookNew.Bid[i].Quantity,
+			Price:  orderbookNew.Bid[i].Rate,
+		}
+	}
+	for i := range orderbookNew.Ask {
+		newOrderBook.Asks[i] = orderbook.Item{
+			Amount: orderbookNew.Ask[i].Quantity,
+			Price:  orderbookNew.Ask[i].Rate,
+		}
+	}
 
 	return b.Websocket.Orderbook.LoadSnapshot(&newOrderBook)
 }