Fix rangeValCopy linter issues (#275)

* first pass of linter fixes for range val

* fixed the remaining issues for pointers

* changed as requested

.golangci.yml

@@ -66,7 +66,6 @@ linters-settings:
     disabled-checks:
       - wrapperFunc
       - importShadow
-      - rangeValCopy
       - methodExprCall
 
 issues:

config/config.go

@@ -733,76 +733,76 @@ func (c *Config) UpdateExchangeConfig(e *ExchangeConfig) error {
 // exchanges
 func (c *Config) CheckExchangeConfigValues() error {
 	exchanges := 0
-	for i, exch := range c.Exchanges {
-		if exch.Name == "GDAX" {
+	for i := range c.Exchanges {
+		if c.Exchanges[i].Name == "GDAX" {
 			c.Exchanges[i].Name = "CoinbasePro"
 		}
 
-		if exch.WebsocketURL != WebsocketURLNonDefaultMessage {
-			if exch.WebsocketURL == "" {
+		if c.Exchanges[i].WebsocketURL != WebsocketURLNonDefaultMessage {
+			if c.Exchanges[i].WebsocketURL == "" {
 				c.Exchanges[i].WebsocketURL = WebsocketURLNonDefaultMessage
 			}
 		}
 
-		if exch.APIURL != APIURLNonDefaultMessage {
-			if exch.APIURL == "" {
+		if c.Exchanges[i].APIURL != APIURLNonDefaultMessage {
+			if c.Exchanges[i].APIURL == "" {
 				// Set default if nothing set
 				c.Exchanges[i].APIURL = APIURLNonDefaultMessage
 			}
 		}
 
-		if exch.APIURLSecondary != APIURLNonDefaultMessage {
-			if exch.APIURLSecondary == "" {
+		if c.Exchanges[i].APIURLSecondary != APIURLNonDefaultMessage {
+			if c.Exchanges[i].APIURLSecondary == "" {
 				// Set default if nothing set
 				c.Exchanges[i].APIURLSecondary = APIURLNonDefaultMessage
 			}
 		}
 
-		if exch.Enabled {
-			if exch.Name == "" {
+		if c.Exchanges[i].Enabled {
+			if c.Exchanges[i].Name == "" {
 				return fmt.Errorf(ErrExchangeNameEmpty, i)
 			}
-			if len(exch.AvailablePairs) == 0 {
-				return fmt.Errorf(ErrExchangeAvailablePairsEmpty, exch.Name)
+			if len(c.Exchanges[i].AvailablePairs) == 0 {
+				return fmt.Errorf(ErrExchangeAvailablePairsEmpty, c.Exchanges[i].Name)
 			}
-			if len(exch.EnabledPairs) == 0 {
-				return fmt.Errorf(ErrExchangeEnabledPairsEmpty, exch.Name)
+			if len(c.Exchanges[i].EnabledPairs) == 0 {
+				return fmt.Errorf(ErrExchangeEnabledPairsEmpty, c.Exchanges[i].Name)
 			}
-			if len(exch.BaseCurrencies) == 0 {
-				return fmt.Errorf(ErrExchangeBaseCurrenciesEmpty, exch.Name)
+			if len(c.Exchanges[i].BaseCurrencies) == 0 {
+				return fmt.Errorf(ErrExchangeBaseCurrenciesEmpty, c.Exchanges[i].Name)
 			}
-			if exch.AuthenticatedAPISupport { // non-fatal error
-				if exch.APIKey == "" || exch.APISecret == "" ||
-					exch.APIKey == DefaultUnsetAPIKey ||
-					exch.APISecret == DefaultUnsetAPISecret {
+			if c.Exchanges[i].AuthenticatedAPISupport { // non-fatal error
+				if c.Exchanges[i].APIKey == "" || c.Exchanges[i].APISecret == "" ||
+					c.Exchanges[i].APIKey == DefaultUnsetAPIKey ||
+					c.Exchanges[i].APISecret == DefaultUnsetAPISecret {
 					c.Exchanges[i].AuthenticatedAPISupport = false
-					log.Warnf(WarningExchangeAuthAPIDefaultOrEmptyValues, exch.Name)
-				} else if exch.Name == "ITBIT" || exch.Name == "Bitstamp" || exch.Name == "COINUT" || exch.Name == "CoinbasePro" {
-					if exch.ClientID == "" || exch.ClientID == "ClientID" {
+					log.Warnf(WarningExchangeAuthAPIDefaultOrEmptyValues, c.Exchanges[i].Name)
+				} else if c.Exchanges[i].Name == "ITBIT" || c.Exchanges[i].Name == "Bitstamp" || c.Exchanges[i].Name == "COINUT" || c.Exchanges[i].Name == "CoinbasePro" {
+					if c.Exchanges[i].ClientID == "" || c.Exchanges[i].ClientID == "ClientID" {
 						c.Exchanges[i].AuthenticatedAPISupport = false
-						log.Warnf(WarningExchangeAuthAPIDefaultOrEmptyValues, exch.Name)
+						log.Warnf(WarningExchangeAuthAPIDefaultOrEmptyValues, c.Exchanges[i].Name)
 					}
 				}
 			}
-			if !exch.SupportsAutoPairUpdates {
-				lastUpdated := common.UnixTimestampToTime(exch.PairsLastUpdated)
+			if !c.Exchanges[i].SupportsAutoPairUpdates {
+				lastUpdated := common.UnixTimestampToTime(c.Exchanges[i].PairsLastUpdated)
 				lastUpdated = lastUpdated.AddDate(0, 0, configPairsLastUpdatedWarningThreshold)
 				if lastUpdated.Unix() <= time.Now().Unix() {
-					log.Warnf(WarningPairsLastUpdatedThresholdExceeded, exch.Name, configPairsLastUpdatedWarningThreshold)
+					log.Warnf(WarningPairsLastUpdatedThresholdExceeded, c.Exchanges[i].Name, configPairsLastUpdatedWarningThreshold)
 				}
 			}
 
-			if exch.HTTPTimeout <= 0 {
-				log.Warnf("Exchange %s HTTP Timeout value not set, defaulting to %v.", exch.Name, configDefaultHTTPTimeout)
+			if c.Exchanges[i].HTTPTimeout <= 0 {
+				log.Warnf("Exchange %s HTTP Timeout value not set, defaulting to %v.", c.Exchanges[i].Name, configDefaultHTTPTimeout)
 				c.Exchanges[i].HTTPTimeout = configDefaultHTTPTimeout
 			}
 
-			err := c.CheckPairConsistency(exch.Name)
+			err := c.CheckPairConsistency(c.Exchanges[i].Name)
 			if err != nil {
-				log.Errorf("Exchange %s: CheckPairConsistency error: %s", exch.Name, err)
+				log.Errorf("Exchange %s: CheckPairConsistency error: %s", c.Exchanges[i].Name, err)
 			}
 
-			if len(exch.BankAccounts) == 0 {
+			if len(c.Exchanges[i].BankAccounts) == 0 {
 				c.Exchanges[i].BankAccounts = append(c.Exchanges[i].BankAccounts, BankAccount{})
 			} else {
 				for y := range c.Exchanges[i].BankAccounts {
@@ -810,26 +810,26 @@ func (c *Config) CheckExchangeConfigValues() error {
 					if bankAccount.Enabled {
 						if bankAccount.BankName == "" || bankAccount.BankAddress == "" {
 							log.Warnf("banking details for %s is enabled but variables not set",
-								exch.Name)
+								c.Exchanges[i].Name)
 							bankAccount.Enabled = false
 						}
 
 						if bankAccount.AccountName == "" || bankAccount.AccountNumber == "" {
 							log.Warnf("banking account details for %s variables not set",
-								exch.Name)
+								c.Exchanges[i].Name)
 							bankAccount.Enabled = false
 						}
 
 						if bankAccount.SupportedCurrencies == "" {
 							log.Warnf("banking account details for %s acceptable funding currencies not set",
-								exch.Name)
+								c.Exchanges[i].Name)
 							bankAccount.Enabled = false
 						}
 
 						if bankAccount.BSBNumber == "" && bankAccount.IBAN == "" &&
 							bankAccount.SWIFTCode == "" {
 							log.Warnf("banking account details for %s critical banking numbers not set",
-								exch.Name)
+								c.Exchanges[i].Name)
 							bankAccount.Enabled = false
 						}
 					}

exchanges/anx/anx_wrapper.go

@@ -220,11 +220,11 @@ func (a *ANX) GetAccountInfo() (exchange.AccountInfo, error) {
 	}
 
 	var balance []exchange.AccountCurrencyInfo
-	for c, info := range raw.Wallets {
+	for c := range raw.Wallets {
 		balance = append(balance, exchange.AccountCurrencyInfo{
 			CurrencyName: currency.NewCode(c),
-			TotalValue:   info.AvailableBalance.Value,
-			Hold:         info.Balance.Value,
+			TotalValue:   raw.Wallets[c].AvailableBalance.Value,
+			Hold:         raw.Wallets[c].Balance.Value,
 		})
 	}
 
@@ -311,8 +311,8 @@ func (a *ANX) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.CancelAll
 	}
 
 	var orderIDs []string
-	for _, order := range placedOrders {
-		orderIDs = append(orderIDs, order.OrderID)
+	for i := range placedOrders {
+		orderIDs = append(orderIDs, placedOrders[i].OrderID)
 	}
 
 	resp, err := a.CancelOrderByIDs(orderIDs)
@@ -382,20 +382,20 @@ func (a *ANX) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([]ex
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range resp {
-		orderDate := time.Unix(order.Timestamp, 0)
-		orderType := exchange.OrderType(strings.ToUpper(order.OrderType))
+	for i := range resp {
+		orderDate := time.Unix(resp[i].Timestamp, 0)
+		orderType := exchange.OrderType(strings.ToUpper(resp[i].OrderType))
 
 		orderDetail := exchange.OrderDetail{
-			Amount: order.TradedCurrencyAmount,
-			CurrencyPair: currency.NewPairWithDelimiter(order.TradedCurrency,
-				order.SettlementCurrency, a.ConfigCurrencyPairFormat.Delimiter),
+			Amount: resp[i].TradedCurrencyAmount,
+			CurrencyPair: currency.NewPairWithDelimiter(resp[i].TradedCurrency,
+				resp[i].SettlementCurrency, a.ConfigCurrencyPairFormat.Delimiter),
 			OrderDate: orderDate,
 			Exchange:  a.Name,
-			ID:        order.OrderID,
+			ID:        resp[i].OrderID,
 			OrderType: orderType,
-			Price:     order.SettlementCurrencyAmount,
-			Status:    order.OrderStatus,
+			Price:     resp[i].SettlementCurrencyAmount,
+			Status:    resp[i].OrderStatus,
 		}
 
 		orders = append(orders, orderDetail)
@@ -418,20 +418,20 @@ func (a *ANX) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([]ex
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range resp {
-		orderDate := time.Unix(order.Timestamp, 0)
-		orderType := exchange.OrderType(strings.ToUpper(order.OrderType))
+	for i := range resp {
+		orderDate := time.Unix(resp[i].Timestamp, 0)
+		orderType := exchange.OrderType(strings.ToUpper(resp[i].OrderType))
 
 		orderDetail := exchange.OrderDetail{
-			Amount:    order.TradedCurrencyAmount,
+			Amount:    resp[i].TradedCurrencyAmount,
 			OrderDate: orderDate,
 			Exchange:  a.Name,
-			ID:        order.OrderID,
+			ID:        resp[i].OrderID,
 			OrderType: orderType,
-			Price:     order.SettlementCurrencyAmount,
-			Status:    order.OrderStatus,
-			CurrencyPair: currency.NewPairWithDelimiter(order.TradedCurrency,
-				order.SettlementCurrency,
+			Price:     resp[i].SettlementCurrencyAmount,
+			Status:    resp[i].OrderStatus,
+			CurrencyPair: currency.NewPairWithDelimiter(resp[i].TradedCurrency,
+				resp[i].SettlementCurrency,
 				a.ConfigCurrencyPairFormat.Delimiter),
 		}
 

exchanges/binance/binance.go

@@ -158,9 +158,9 @@ func (b *Binance) GetExchangeValidCurrencyPairs() ([]string, error) {
 		return nil, err
 	}
 
-	for _, symbol := range info.Symbols {
-		if symbol.Status == "TRADING" {
-			validCurrencyPairs = append(validCurrencyPairs, symbol.BaseAsset+"-"+symbol.QuoteAsset)
+	for i := range info.Symbols {
+		if info.Symbols[i].Status == "TRADING" {
+			validCurrencyPairs = append(validCurrencyPairs, info.Symbols[i].BaseAsset+"-"+info.Symbols[i].QuoteAsset)
 		}
 	}
 	return validCurrencyPairs, nil

exchanges/binance/binance_wrapper.go

@@ -275,10 +275,10 @@ func (b *Binance) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.Cance
 		return cancelAllOrdersResponse, err
 	}
 
-	for _, order := range openOrders {
-		_, err = b.CancelExistingOrder(order.Symbol, order.OrderID, "")
+	for i := range openOrders {
+		_, err = b.CancelExistingOrder(openOrders[i].Symbol, openOrders[i].OrderID, "")
 		if err != nil {
-			cancelAllOrdersResponse.OrderStatus[strconv.FormatInt(order.OrderID, 10)] = err.Error()
+			cancelAllOrdersResponse.OrderStatus[strconv.FormatInt(openOrders[i].OrderID, 10)] = err.Error()
 		}
 	}
 
@@ -344,21 +344,21 @@ func (b *Binance) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) (
 			return nil, err
 		}
 
-		for _, order := range resp {
-			orderSide := exchange.OrderSide(strings.ToUpper(order.Side))
-			orderType := exchange.OrderType(strings.ToUpper(order.Type))
-			orderDate := time.Unix(int64(order.Time), 0)
+		for i := range resp {
+			orderSide := exchange.OrderSide(strings.ToUpper(resp[i].Side))
+			orderType := exchange.OrderType(strings.ToUpper(resp[i].Type))
+			orderDate := time.Unix(int64(resp[i].Time), 0)
 
 			orders = append(orders, exchange.OrderDetail{
-				Amount:       order.OrigQty,
+				Amount:       resp[i].OrigQty,
 				OrderDate:    orderDate,
 				Exchange:     b.Name,
-				ID:           fmt.Sprintf("%v", order.OrderID),
+				ID:           fmt.Sprintf("%v", resp[i].OrderID),
 				OrderSide:    orderSide,
 				OrderType:    orderType,
-				Price:        order.Price,
-				Status:       order.Status,
-				CurrencyPair: currency.NewPairFromString(order.Symbol),
+				Price:        resp[i].Price,
+				Status:       resp[i].Status,
+				CurrencyPair: currency.NewPairFromString(resp[i].Symbol),
 			})
 		}
 	}
@@ -384,25 +384,25 @@ func (b *Binance) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) (
 			return nil, err
 		}
 
-		for _, order := range resp {
-			orderSide := exchange.OrderSide(strings.ToUpper(order.Side))
-			orderType := exchange.OrderType(strings.ToUpper(order.Type))
-			orderDate := time.Unix(int64(order.Time), 0)
+		for i := range resp {
+			orderSide := exchange.OrderSide(strings.ToUpper(resp[i].Side))
+			orderType := exchange.OrderType(strings.ToUpper(resp[i].Type))
+			orderDate := time.Unix(int64(resp[i].Time), 0)
 			// New orders are covered in GetOpenOrders
-			if order.Status == "NEW" {
+			if resp[i].Status == "NEW" {
 				continue
 			}
 
 			orders = append(orders, exchange.OrderDetail{
-				Amount:       order.OrigQty,
+				Amount:       resp[i].OrigQty,
 				OrderDate:    orderDate,
 				Exchange:     b.Name,
-				ID:           fmt.Sprintf("%v", order.OrderID),
+				ID:           fmt.Sprintf("%v", resp[i].OrderID),
 				OrderSide:    orderSide,
 				OrderType:    orderType,
-				Price:        order.Price,
-				CurrencyPair: currency.NewPairFromString(order.Symbol),
-				Status:       order.Status,
+				Price:        resp[i].Price,
+				CurrencyPair: currency.NewPairFromString(resp[i].Symbol),
+				Status:       resp[i].Status,
 			})
 		}
 	}

exchanges/bitfinex/bitfinex_wrapper.go

@@ -344,32 +344,32 @@ func (b *Bitfinex) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest)
 		return nil, err
 	}
 
-	for _, order := range resp {
-		orderSide := exchange.OrderSide(strings.ToUpper(order.Side))
-		timestamp, err := strconv.ParseInt(order.Timestamp, 10, 64)
+	for i := range resp {
+		orderSide := exchange.OrderSide(strings.ToUpper(resp[i].Side))
+		timestamp, err := strconv.ParseInt(resp[i].Timestamp, 10, 64)
 		if err != nil {
-			log.Warnf("Unable to convert timestamp '%v', leaving blank", order.Timestamp)
+			log.Warnf("Unable to convert timestamp '%v', leaving blank", resp[i].Timestamp)
 		}
 		orderDate := time.Unix(timestamp, 0)
 
 		orderDetail := exchange.OrderDetail{
-			Amount:          order.OriginalAmount,
+			Amount:          resp[i].OriginalAmount,
 			OrderDate:       orderDate,
 			Exchange:        b.Name,
-			ID:              fmt.Sprintf("%v", order.OrderID),
+			ID:              fmt.Sprintf("%v", resp[i].OrderID),
 			OrderSide:       orderSide,
-			Price:           order.Price,
-			RemainingAmount: order.RemainingAmount,
-			CurrencyPair:    currency.NewPairFromString(order.Symbol),
-			ExecutedAmount:  order.ExecutedAmount,
+			Price:           resp[i].Price,
+			RemainingAmount: resp[i].RemainingAmount,
+			CurrencyPair:    currency.NewPairFromString(resp[i].Symbol),
+			ExecutedAmount:  resp[i].ExecutedAmount,
 		}
 
 		switch {
-		case order.IsLive:
+		case resp[i].IsLive:
 			orderDetail.Status = string(exchange.ActiveOrderStatus)
-		case order.IsCancelled:
+		case resp[i].IsCancelled:
 			orderDetail.Status = string(exchange.CancelledOrderStatus)
-		case order.IsHidden:
+		case resp[i].IsHidden:
 			orderDetail.Status = string(exchange.HiddenOrderStatus)
 		default:
 			orderDetail.Status = string(exchange.UnknownOrderStatus)
@@ -377,7 +377,7 @@ func (b *Bitfinex) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest)
 
 		// API docs discrepency. Example contains prefixed "exchange "
 		// Return type suggests “market” / “limit” / “stop” / “trailing-stop”
-		orderType := strings.Replace(order.Type, "exchange ", "", 1)
+		orderType := strings.Replace(resp[i].Type, "exchange ", "", 1)
 		if orderType == "trailing-stop" {
 			orderDetail.OrderType = exchange.TrailingStopOrderType
 		} else {
@@ -404,32 +404,32 @@ func (b *Bitfinex) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest)
 		return nil, err
 	}
 
-	for _, order := range resp {
-		orderSide := exchange.OrderSide(strings.ToUpper(order.Side))
-		timestamp, err := strconv.ParseInt(order.Timestamp, 10, 64)
+	for i := range resp {
+		orderSide := exchange.OrderSide(strings.ToUpper(resp[i].Side))
+		timestamp, err := strconv.ParseInt(resp[i].Timestamp, 10, 64)
 		if err != nil {
-			log.Warnf("Unable to convert timestamp '%v', leaving blank", order.Timestamp)
+			log.Warnf("Unable to convert timestamp '%v', leaving blank", resp[i].Timestamp)
 		}
 		orderDate := time.Unix(timestamp, 0)
 
 		orderDetail := exchange.OrderDetail{
-			Amount:          order.OriginalAmount,
+			Amount:          resp[i].OriginalAmount,
 			OrderDate:       orderDate,
 			Exchange:        b.Name,
-			ID:              fmt.Sprintf("%v", order.OrderID),
+			ID:              fmt.Sprintf("%v", resp[i].OrderID),
 			OrderSide:       orderSide,
-			Price:           order.Price,
-			RemainingAmount: order.RemainingAmount,
-			ExecutedAmount:  order.ExecutedAmount,
-			CurrencyPair:    currency.NewPairFromString(order.Symbol),
+			Price:           resp[i].Price,
+			RemainingAmount: resp[i].RemainingAmount,
+			ExecutedAmount:  resp[i].ExecutedAmount,
+			CurrencyPair:    currency.NewPairFromString(resp[i].Symbol),
 		}
 
 		switch {
-		case order.IsLive:
+		case resp[i].IsLive:
 			orderDetail.Status = string(exchange.ActiveOrderStatus)
-		case order.IsCancelled:
+		case resp[i].IsCancelled:
 			orderDetail.Status = string(exchange.CancelledOrderStatus)
-		case order.IsHidden:
+		case resp[i].IsHidden:
 			orderDetail.Status = string(exchange.HiddenOrderStatus)
 		default:
 			orderDetail.Status = string(exchange.UnknownOrderStatus)
@@ -437,7 +437,7 @@ func (b *Bitfinex) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest)
 
 		// API docs discrepency. Example contains prefixed "exchange "
 		// Return type suggests “market” / “limit” / “stop” / “trailing-stop”
-		orderType := strings.Replace(order.Type, "exchange ", "", 1)
+		orderType := strings.Replace(resp[i].Type, "exchange ", "", 1)
 		if orderType == "trailing-stop" {
 			orderDetail.OrderType = exchange.TrailingStopOrderType
 		} else {

exchanges/bithumb/bithumb_wrapper.go

@@ -256,12 +256,12 @@ func (b *Bithumb) CancelAllOrders(orderCancellation *exchange.OrderCancellation)
 		allOrders = append(allOrders, orders.Data...)
 	}
 
-	for _, order := range allOrders {
+	for i := range allOrders {
 		_, err := b.CancelTrade(orderCancellation.Side.ToString(),
-			order.OrderID,
+			allOrders[i].OrderID,
 			orderCancellation.CurrencyPair.Base.String())
 		if err != nil {
-			cancelAllOrdersResponse.OrderStatus[order.OrderID] = err.Error()
+			cancelAllOrdersResponse.OrderStatus[allOrders[i].OrderID] = err.Error()
 		}
 	}
 
@@ -341,28 +341,28 @@ func (b *Bithumb) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) (
 		return nil, err
 	}
 
-	for _, order := range resp.Data {
-		if order.Status != "placed" {
+	for i := range resp.Data {
+		if resp.Data[i].Status != "placed" {
 			continue
 		}
 
-		orderDate := time.Unix(order.OrderDate, 0)
+		orderDate := time.Unix(resp.Data[i].OrderDate, 0)
 		orderDetail := exchange.OrderDetail{
-			Amount:          order.Units,
+			Amount:          resp.Data[i].Units,
 			Exchange:        b.Name,
-			ID:              order.OrderID,
+			ID:              resp.Data[i].OrderID,
 			OrderDate:       orderDate,
-			Price:           order.Price,
-			RemainingAmount: order.UnitsRemaining,
+			Price:           resp.Data[i].Price,
+			RemainingAmount: resp.Data[i].UnitsRemaining,
 			Status:          string(exchange.ActiveOrderStatus),
-			CurrencyPair: currency.NewPairWithDelimiter(order.OrderCurrency,
-				order.PaymentCurrency,
+			CurrencyPair: currency.NewPairWithDelimiter(resp.Data[i].OrderCurrency,
+				resp.Data[i].PaymentCurrency,
 				b.ConfigCurrencyPairFormat.Delimiter),
 		}
 
-		if order.Type == "bid" {
+		if resp.Data[i].Type == "bid" {
 			orderDetail.OrderSide = exchange.BuyOrderSide
-		} else if order.Type == "ask" {
+		} else if resp.Data[i].Type == "ask" {
 			orderDetail.OrderSide = exchange.SellOrderSide
 		}
 
@@ -386,27 +386,27 @@ func (b *Bithumb) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) (
 		return nil, err
 	}
 
-	for _, order := range resp.Data {
-		if order.Status == "placed" {
+	for i := range resp.Data {
+		if resp.Data[i].Status == "placed" {
 			continue
 		}
 
-		orderDate := time.Unix(order.OrderDate, 0)
+		orderDate := time.Unix(resp.Data[i].OrderDate, 0)
 		orderDetail := exchange.OrderDetail{
-			Amount:          order.Units,
+			Amount:          resp.Data[i].Units,
 			Exchange:        b.Name,
-			ID:              order.OrderID,
+			ID:              resp.Data[i].OrderID,
 			OrderDate:       orderDate,
-			Price:           order.Price,
-			RemainingAmount: order.UnitsRemaining,
-			CurrencyPair: currency.NewPairWithDelimiter(order.OrderCurrency,
-				order.PaymentCurrency,
+			Price:           resp.Data[i].Price,
+			RemainingAmount: resp.Data[i].UnitsRemaining,
+			CurrencyPair: currency.NewPairWithDelimiter(resp.Data[i].OrderCurrency,
+				resp.Data[i].PaymentCurrency,
 				b.ConfigCurrencyPairFormat.Delimiter),
 		}
 
-		if order.Type == "bid" {
+		if resp.Data[i].Type == "bid" {
 			orderDetail.OrderSide = exchange.BuyOrderSide
-		} else if order.Type == "ask" {
+		} else if resp.Data[i].Type == "ask" {
 			orderDetail.OrderSide = exchange.SellOrderSide
 		}
 

exchanges/bitmex/bitmex_wrapper.go

@@ -38,8 +38,8 @@ func (b *Bitmex) Run() {
 
 	} else {
 		var exchangeProducts []string
-		for _, info := range marketInfo {
-			exchangeProducts = append(exchangeProducts, info.Symbol)
+		for i := range marketInfo {
+			exchangeProducts = append(exchangeProducts, marketInfo[i].Symbol)
 		}
 
 		var NewExchangeProducts currency.Pairs
@@ -145,10 +145,10 @@ func (b *Bitmex) GetAccountInfo() (exchange.AccountInfo, error) {
 
 	// Need to update to add Margin/Liquidity availibilty
 	var balances []exchange.AccountCurrencyInfo
-	for _, data := range bal {
+	for i := range bal {
 		balances = append(balances, exchange.AccountCurrencyInfo{
-			CurrencyName: currency.NewCode(data.Currency),
-			TotalValue:   float64(data.WalletBalance),
+			CurrencyName: currency.NewCode(bal[i].Currency),
+			TotalValue:   float64(bal[i].WalletBalance),
 		})
 	}
 
@@ -247,8 +247,8 @@ func (b *Bitmex) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.Cancel
 		return cancelAllOrdersResponse, err
 	}
 
-	for _, order := range orders {
-		cancelAllOrdersResponse.OrderStatus[order.OrderID] = order.OrdRejReason
+	for i := range orders {
+		cancelAllOrdersResponse.OrderStatus[orders[i].OrderID] = orders[i].OrdRejReason
 	}
 
 	return cancelAllOrdersResponse, nil
@@ -324,23 +324,23 @@ func (b *Bitmex) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([
 		return nil, err
 	}
 
-	for _, order := range resp {
-		orderSide := orderSideMap[order.Side]
-		orderType := orderTypeMap[order.OrdType]
+	for i := range resp {
+		orderSide := orderSideMap[resp[i].Side]
+		orderType := orderTypeMap[resp[i].OrdType]
 		if orderType == "" {
 			orderType = exchange.UnknownOrderType
 		}
 
 		orderDetail := exchange.OrderDetail{
-			Price:     order.Price,
-			Amount:    float64(order.OrderQty),
+			Price:     resp[i].Price,
+			Amount:    float64(resp[i].OrderQty),
 			Exchange:  b.Name,
-			ID:        order.OrderID,
+			ID:        resp[i].OrderID,
 			OrderSide: orderSide,
 			OrderType: orderType,
-			Status:    order.OrdStatus,
-			CurrencyPair: currency.NewPairWithDelimiter(order.Symbol,
-				order.SettlCurrency,
+			Status:    resp[i].OrdStatus,
+			CurrencyPair: currency.NewPairWithDelimiter(resp[i].Symbol,
+				resp[i].SettlCurrency,
 				b.ConfigCurrencyPairFormat.Delimiter),
 		}
 
@@ -367,23 +367,23 @@ func (b *Bitmex) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([
 		return nil, err
 	}
 
-	for _, order := range resp {
-		orderSide := orderSideMap[order.Side]
-		orderType := orderTypeMap[order.OrdType]
+	for i := range resp {
+		orderSide := orderSideMap[resp[i].Side]
+		orderType := orderTypeMap[resp[i].OrdType]
 		if orderType == "" {
 			orderType = exchange.UnknownOrderType
 		}
 
 		orderDetail := exchange.OrderDetail{
-			Price:     order.Price,
-			Amount:    float64(order.OrderQty),
+			Price:     resp[i].Price,
+			Amount:    float64(resp[i].OrderQty),
 			Exchange:  b.Name,
-			ID:        order.OrderID,
+			ID:        resp[i].OrderID,
 			OrderSide: orderSide,
 			OrderType: orderType,
-			Status:    order.OrdStatus,
-			CurrencyPair: currency.NewPairWithDelimiter(order.Symbol,
-				order.SettlCurrency,
+			Status:    resp[i].OrdStatus,
+			CurrencyPair: currency.NewPairWithDelimiter(resp[i].Symbol,
+				resp[i].SettlCurrency,
 				b.ConfigCurrencyPairFormat.Delimiter),
 		}
 

exchanges/bittrex/bittrex_wrapper.go

@@ -248,10 +248,10 @@ func (b *Bittrex) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.Cance
 		return cancelAllOrdersResponse, err
 	}
 
-	for _, order := range openOrders.Result {
-		_, err := b.CancelExistingOrder(order.OrderUUID)
+	for i := range openOrders.Result {
+		_, err := b.CancelExistingOrder(openOrders.Result[i].OrderUUID)
 		if err != nil {
-			cancelAllOrdersResponse.OrderStatus[order.OrderUUID] = err.Error()
+			cancelAllOrdersResponse.OrderStatus[openOrders.Result[i].OrderUUID] = err.Error()
 		}
 	}
 
@@ -321,23 +321,23 @@ func (b *Bittrex) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) (
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range resp.Result {
-		orderDate, err := time.Parse(time.RFC3339, order.Opened)
+	for i := range resp.Result {
+		orderDate, err := time.Parse(time.RFC3339, resp.Result[i].Opened)
 		if err != nil {
 			log.Warnf("Exchange %v Func %v Order %v Could not parse date to unix with value of %v",
-				b.Name, "GetActiveOrders", order.OrderUUID, order.Opened)
+				b.Name, "GetActiveOrders", resp.Result[i].OrderUUID, resp.Result[i].Opened)
 		}
 
-		pair := currency.NewPairDelimiter(order.Exchange,
+		pair := currency.NewPairDelimiter(resp.Result[i].Exchange,
 			b.ConfigCurrencyPairFormat.Delimiter)
-		orderType := exchange.OrderType(strings.ToUpper(order.Type))
+		orderType := exchange.OrderType(strings.ToUpper(resp.Result[i].Type))
 
 		orders = append(orders, exchange.OrderDetail{
-			Amount:          order.Quantity,
-			RemainingAmount: order.QuantityRemaining,
-			Price:           order.Price,
+			Amount:          resp.Result[i].Quantity,
+			RemainingAmount: resp.Result[i].QuantityRemaining,
+			Price:           resp.Result[i].Price,
 			OrderDate:       orderDate,
-			ID:              order.OrderUUID,
+			ID:              resp.Result[i].OrderUUID,
 			Exchange:        b.Name,
 			OrderType:       orderType,
 			CurrencyPair:    pair,
@@ -366,26 +366,26 @@ func (b *Bittrex) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) (
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range resp.Result {
-		orderDate, err := time.Parse(time.RFC3339, order.TimeStamp)
+	for i := range resp.Result {
+		orderDate, err := time.Parse(time.RFC3339, resp.Result[i].TimeStamp)
 		if err != nil {
 			log.Warnf("Exchange %v Func %v Order %v Could not parse date to unix with value of %v",
-				b.Name, "GetActiveOrders", order.OrderUUID, order.Opened)
+				b.Name, "GetActiveOrders", resp.Result[i].OrderUUID, resp.Result[i].Opened)
 		}
 
-		pair := currency.NewPairDelimiter(order.Exchange,
+		pair := currency.NewPairDelimiter(resp.Result[i].Exchange,
 			b.ConfigCurrencyPairFormat.Delimiter)
-		orderType := exchange.OrderType(strings.ToUpper(order.Type))
+		orderType := exchange.OrderType(strings.ToUpper(resp.Result[i].Type))
 
 		orders = append(orders, exchange.OrderDetail{
-			Amount:          order.Quantity,
-			RemainingAmount: order.QuantityRemaining,
-			Price:           order.Price,
+			Amount:          resp.Result[i].Quantity,
+			RemainingAmount: resp.Result[i].QuantityRemaining,
+			Price:           resp.Result[i].Price,
 			OrderDate:       orderDate,
-			ID:              order.OrderUUID,
+			ID:              resp.Result[i].OrderUUID,
 			Exchange:        b.Name,
 			OrderType:       orderType,
-			Fee:             order.Commission,
+			Fee:             resp.Result[i].Commission,
 			CurrencyPair:    pair,
 		})
 	}

exchanges/btcc/btcc_websocket.go

@@ -301,9 +301,9 @@ func (b *BTCC) WsUpdateCurrencyPairs() error {
 			}
 
 			var availableTickers currency.Pairs
-			for _, tickerData := range tickers {
+			for i := range tickers {
 				availableTickers = append(availableTickers,
-					currency.NewPairFromString(tickerData.Symbol))
+					currency.NewPairFromString(tickers[i].Symbol))
 			}
 
 			err = b.UpdateCurrencies(availableTickers, false, true)

exchanges/btcmarkets/btcmarkets.go

@@ -268,15 +268,15 @@ func (b *BTCMarkets) GetOrders(currency, instrument string, limit, since int64,
 		return nil, errors.New(resp.ErrorMessage)
 	}
 
-	for _, order := range resp.Orders {
-		order.Price /= common.SatoshisPerBTC
-		order.OpenVolume /= common.SatoshisPerBTC
-		order.Volume /= common.SatoshisPerBTC
+	for i := range resp.Orders {
+		resp.Orders[i].Price /= common.SatoshisPerBTC
+		resp.Orders[i].OpenVolume /= common.SatoshisPerBTC
+		resp.Orders[i].Volume /= common.SatoshisPerBTC
 
-		for _, trade := range order.Trades {
-			trade.Fee /= common.SatoshisPerBTC
-			trade.Price /= common.SatoshisPerBTC
-			trade.Volume /= common.SatoshisPerBTC
+		for j := range resp.Orders[i].Trades {
+			resp.Orders[i].Trades[j].Fee /= common.SatoshisPerBTC
+			resp.Orders[i].Trades[j].Price /= common.SatoshisPerBTC
+			resp.Orders[i].Trades[j].Volume /= common.SatoshisPerBTC
 		}
 	}
 
@@ -301,15 +301,15 @@ func (b *BTCMarkets) GetOpenOrders() ([]Order, error) {
 		return nil, errors.New(resp.ErrorMessage)
 	}
 
-	for _, order := range resp.Orders {
-		order.Price /= common.SatoshisPerBTC
-		order.OpenVolume /= common.SatoshisPerBTC
-		order.Volume /= common.SatoshisPerBTC
+	for i := range resp.Orders {
+		resp.Orders[i].Price /= common.SatoshisPerBTC
+		resp.Orders[i].OpenVolume /= common.SatoshisPerBTC
+		resp.Orders[i].Volume /= common.SatoshisPerBTC
 
-		for _, trade := range order.Trades {
-			trade.Fee /= common.SatoshisPerBTC
-			trade.Price /= common.SatoshisPerBTC
-			trade.Volume /= common.SatoshisPerBTC
+		for j := range resp.Orders[i].Trades {
+			resp.Orders[i].Trades[j].Fee /= common.SatoshisPerBTC
+			resp.Orders[i].Trades[j].Price /= common.SatoshisPerBTC
+			resp.Orders[i].Trades[j].Volume /= common.SatoshisPerBTC
 		}
 	}
 

exchanges/btcmarkets/btcmarkets_wrapper.go

@@ -228,10 +228,10 @@ func (b *BTCMarkets) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.Ca
 	}
 
 	var orderList []int64
-	for _, order := range openOrders {
-		orderIDInt, err := strconv.ParseInt(order.ID, 10, 64)
+	for i := range openOrders {
+		orderIDInt, err := strconv.ParseInt(openOrders[i].ID, 10, 64)
 		if err != nil {
-			cancelAllOrdersResponse.OrderStatus[order.ID] = err.Error()
+			cancelAllOrdersResponse.OrderStatus[openOrders[i].ID] = err.Error()
 		}
 		orderList = append(orderList, orderIDInt)
 	}
@@ -242,9 +242,9 @@ func (b *BTCMarkets) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.Ca
 			return cancelAllOrdersResponse, err
 		}
 
-		for _, order := range orders {
+		for i := range orders {
 			if err != nil {
-				cancelAllOrdersResponse.OrderStatus[strconv.FormatInt(order.ID, 10)] = err.Error()
+				cancelAllOrdersResponse.OrderStatus[strconv.FormatInt(orders[i].ID, 10)] = err.Error()
 			}
 		}
 	}
@@ -273,27 +273,27 @@ func (b *BTCMarkets) GetOrderInfo(orderID string) (exchange.OrderDetail, error)
 		return OrderDetail, errors.New("no orders found")
 	}
 
-	for _, order := range orders {
+	for i := range orders {
 		var side exchange.OrderSide
-		if strings.EqualFold(order.OrderSide, exchange.AskOrderSide.ToString()) {
+		if strings.EqualFold(orders[i].OrderSide, exchange.AskOrderSide.ToString()) {
 			side = exchange.SellOrderSide
-		} else if strings.EqualFold(order.OrderSide, exchange.BidOrderSide.ToString()) {
+		} else if strings.EqualFold(orders[i].OrderSide, exchange.BidOrderSide.ToString()) {
 			side = exchange.BuyOrderSide
 		}
-		orderDate := time.Unix(int64(order.CreationTime), 0)
-		orderType := exchange.OrderType(strings.ToUpper(order.OrderType))
+		orderDate := time.Unix(int64(orders[i].CreationTime), 0)
+		orderType := exchange.OrderType(strings.ToUpper(orders[i].OrderType))
 
-		OrderDetail.Amount = order.Volume
+		OrderDetail.Amount = orders[i].Volume
 		OrderDetail.OrderDate = orderDate
 		OrderDetail.Exchange = b.GetName()
-		OrderDetail.ID = order.ID
-		OrderDetail.RemainingAmount = order.OpenVolume
+		OrderDetail.ID = orders[i].ID
+		OrderDetail.RemainingAmount = orders[i].OpenVolume
 		OrderDetail.OrderSide = side
 		OrderDetail.OrderType = orderType
-		OrderDetail.Price = order.Price
-		OrderDetail.Status = order.Status
-		OrderDetail.CurrencyPair = currency.NewPairWithDelimiter(order.Instrument,
-			order.Currency,
+		OrderDetail.Price = orders[i].Price
+		OrderDetail.Status = orders[i].Status
+		OrderDetail.CurrencyPair = currency.NewPairWithDelimiter(orders[i].Instrument,
+			orders[i].Currency,
 			b.ConfigCurrencyPairFormat.Delimiter)
 	}
 
@@ -347,41 +347,41 @@ func (b *BTCMarkets) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range resp {
+	for i := range resp {
 		var side exchange.OrderSide
-		if strings.EqualFold(order.OrderSide, exchange.AskOrderSide.ToString()) {
+		if strings.EqualFold(resp[i].OrderSide, exchange.AskOrderSide.ToString()) {
 			side = exchange.SellOrderSide
-		} else if strings.EqualFold(order.OrderSide, exchange.BidOrderSide.ToString()) {
+		} else if strings.EqualFold(resp[i].OrderSide, exchange.BidOrderSide.ToString()) {
 			side = exchange.BuyOrderSide
 		}
-		orderDate := time.Unix(int64(order.CreationTime), 0)
-		orderType := exchange.OrderType(strings.ToUpper(order.OrderType))
+		orderDate := time.Unix(int64(resp[i].CreationTime), 0)
+		orderType := exchange.OrderType(strings.ToUpper(resp[i].OrderType))
 
 		openOrder := exchange.OrderDetail{
-			ID:              order.ID,
-			Amount:          order.Volume,
+			ID:              resp[i].ID,
+			Amount:          resp[i].Volume,
 			Exchange:        b.Name,
-			RemainingAmount: order.OpenVolume,
+			RemainingAmount: resp[i].OpenVolume,
 			OrderDate:       orderDate,
 			OrderSide:       side,
 			OrderType:       orderType,
-			Price:           order.Price,
-			Status:          order.Status,
-			CurrencyPair: currency.NewPairWithDelimiter(order.Instrument,
-				order.Currency,
+			Price:           resp[i].Price,
+			Status:          resp[i].Status,
+			CurrencyPair: currency.NewPairWithDelimiter(resp[i].Instrument,
+				resp[i].Currency,
 				b.ConfigCurrencyPairFormat.Delimiter),
 		}
 
-		for _, trade := range order.Trades {
-			tradeDate := time.Unix(int64(trade.CreationTime), 0)
+		for j := range resp[i].Trades {
+			tradeDate := time.Unix(int64(resp[i].Trades[j].CreationTime), 0)
 			openOrder.Trades = append(openOrder.Trades, exchange.TradeHistory{
-				Amount:      trade.Volume,
+				Amount:      resp[i].Trades[j].Volume,
 				Exchange:    b.Name,
-				Price:       trade.Price,
-				TID:         trade.ID,
+				Price:       resp[i].Trades[j].Price,
+				TID:         resp[i].Trades[j].ID,
 				Timestamp:   tradeDate,
-				Fee:         trade.Fee,
-				Description: trade.Description,
+				Fee:         resp[i].Trades[j].Fee,
+				Description: resp[i].Trades[j].Description,
 			})
 		}
 
@@ -417,41 +417,41 @@ func (b *BTCMarkets) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range respOrders {
+	for i := range respOrders {
 		var side exchange.OrderSide
-		if strings.EqualFold(order.OrderSide, exchange.AskOrderSide.ToString()) {
+		if strings.EqualFold(respOrders[i].OrderSide, exchange.AskOrderSide.ToString()) {
 			side = exchange.SellOrderSide
-		} else if strings.EqualFold(order.OrderSide, exchange.BidOrderSide.ToString()) {
+		} else if strings.EqualFold(respOrders[i].OrderSide, exchange.BidOrderSide.ToString()) {
 			side = exchange.BuyOrderSide
 		}
-		orderDate := time.Unix(int64(order.CreationTime), 0)
-		orderType := exchange.OrderType(strings.ToUpper(order.OrderType))
+		orderDate := time.Unix(int64(respOrders[i].CreationTime), 0)
+		orderType := exchange.OrderType(strings.ToUpper(respOrders[i].OrderType))
 
 		openOrder := exchange.OrderDetail{
-			ID:              order.ID,
-			Amount:          order.Volume,
+			ID:              respOrders[i].ID,
+			Amount:          respOrders[i].Volume,
 			Exchange:        b.Name,
-			RemainingAmount: order.OpenVolume,
+			RemainingAmount: respOrders[i].OpenVolume,
 			OrderDate:       orderDate,
 			OrderSide:       side,
 			OrderType:       orderType,
-			Price:           order.Price,
-			Status:          order.Status,
-			CurrencyPair: currency.NewPairWithDelimiter(order.Instrument,
-				order.Currency,
+			Price:           respOrders[i].Price,
+			Status:          respOrders[i].Status,
+			CurrencyPair: currency.NewPairWithDelimiter(respOrders[i].Instrument,
+				respOrders[i].Currency,
 				b.ConfigCurrencyPairFormat.Delimiter),
 		}
 
-		for _, trade := range order.Trades {
-			tradeDate := time.Unix(int64(trade.CreationTime), 0)
+		for j := range respOrders[i].Trades {
+			tradeDate := time.Unix(int64(respOrders[i].Trades[j].CreationTime), 0)
 			openOrder.Trades = append(openOrder.Trades, exchange.TradeHistory{
-				Amount:      trade.Volume,
+				Amount:      respOrders[i].Trades[j].Volume,
 				Exchange:    b.Name,
-				Price:       trade.Price,
-				TID:         trade.ID,
+				Price:       respOrders[i].Trades[j].Price,
+				TID:         respOrders[i].Trades[j].ID,
 				Timestamp:   tradeDate,
-				Fee:         trade.Fee,
-				Description: trade.Description,
+				Fee:         respOrders[i].Trades[j].Fee,
+				Description: respOrders[i].Trades[j].Description,
 			})
 		}
 

exchanges/btse/btse_wrapper.go

@@ -216,7 +216,8 @@ func (b *BTSE) GetOrderInfo(orderID string) (exchange.OrderDetail, error) {
 		return od, errors.New("no orders found")
 	}
 
-	for _, o := range *o {
+	for i := range *o {
+		o := (*o)[i]
 		if o.ID != orderID {
 			continue
 		}
@@ -242,7 +243,8 @@ func (b *BTSE) GetOrderInfo(orderID string) (exchange.OrderDetail, error) {
 			return od, fmt.Errorf("unable to get order fills for orderID %s", orderID)
 		}
 
-		for _, f := range *fills {
+		for i := range *fills {
+			f := (*fills)[i]
 			createdAt, _ := time.Parse(time.RFC3339, f.CreatedAt)
 			od.Trades = append(od.Trades, exchange.TradeHistory{
 				Timestamp: createdAt,
@@ -294,7 +296,8 @@ func (b *BTSE) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([]e
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range *resp {
+	for i := range *resp {
+		order := (*resp)[i]
 		var side = exchange.BuyOrderSide
 		if strings.EqualFold(order.Side, exchange.AskOrderSide.ToString()) {
 			side = exchange.SellOrderSide
@@ -319,7 +322,8 @@ func (b *BTSE) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([]e
 			continue
 		}
 
-		for _, f := range *fills {
+		for i := range *fills {
+			f := (*fills)[i]
 			createdAt, _ := time.Parse(time.RFC3339, f.CreatedAt)
 			openOrder.Trades = append(openOrder.Trades, exchange.TradeHistory{
 				Timestamp: createdAt,

exchanges/coinbasepro/coinbasepro_wrapper.go

@@ -257,9 +257,9 @@ func (c *CoinbasePro) WithdrawFiatFunds(withdrawRequest *exchange.WithdrawReques
 	}
 
 	selectedWithdrawalMethod := PaymentMethod{}
-	for _, paymentMethod := range paymentMethods {
-		if withdrawRequest.BankName == paymentMethod.Name {
-			selectedWithdrawalMethod = paymentMethod
+	for i := range paymentMethods {
+		if withdrawRequest.BankName == paymentMethods[i].Name {
+			selectedWithdrawalMethod = paymentMethods[i]
 			break
 		}
 	}
@@ -298,9 +298,9 @@ func (c *CoinbasePro) GetFeeByType(feeBuilder *exchange.FeeBuilder) (float64, er
 // GetActiveOrders retrieves any orders that are active/open
 func (c *CoinbasePro) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([]exchange.OrderDetail, error) {
 	var respOrders []GeneralizedOrderResponse
-	for _, currency := range getOrdersRequest.Currencies {
+	for i := range getOrdersRequest.Currencies {
 		resp, err := c.GetOrders([]string{"open", "pending", "active"},
-			exchange.FormatExchangeCurrency(c.Name, currency).String())
+			exchange.FormatExchangeCurrency(c.Name, getOrdersRequest.Currencies[i]).String())
 		if err != nil {
 			return nil, err
 		}
@@ -308,21 +308,21 @@ func (c *CoinbasePro) GetActiveOrders(getOrdersRequest *exchange.GetOrdersReques
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range respOrders {
-		currency := currency.NewPairDelimiter(order.ProductID,
+	for i := range respOrders {
+		currency := currency.NewPairDelimiter(respOrders[i].ProductID,
 			c.ConfigCurrencyPairFormat.Delimiter)
-		orderSide := exchange.OrderSide(strings.ToUpper(order.Side))
-		orderType := exchange.OrderType(strings.ToUpper(order.Type))
-		orderDate, err := time.Parse(time.RFC3339, order.CreatedAt)
+		orderSide := exchange.OrderSide(strings.ToUpper(respOrders[i].Side))
+		orderType := exchange.OrderType(strings.ToUpper(respOrders[i].Type))
+		orderDate, err := time.Parse(time.RFC3339, respOrders[i].CreatedAt)
 		if err != nil {
 			log.Warnf("Exchange %v Func %v Order %v Could not parse date to unix with value of %v",
-				c.Name, "GetActiveOrders", order.ID, order.CreatedAt)
+				c.Name, "GetActiveOrders", respOrders[i].ID, respOrders[i].CreatedAt)
 		}
 
 		orders = append(orders, exchange.OrderDetail{
-			ID:             order.ID,
-			Amount:         order.Size,
-			ExecutedAmount: order.FilledSize,
+			ID:             respOrders[i].ID,
+			Amount:         respOrders[i].Size,
+			ExecutedAmount: respOrders[i].FilledSize,
 			OrderType:      orderType,
 			OrderDate:      orderDate,
 			OrderSide:      orderSide,
@@ -352,21 +352,21 @@ func (c *CoinbasePro) GetOrderHistory(getOrdersRequest *exchange.GetOrdersReques
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range respOrders {
-		currency := currency.NewPairDelimiter(order.ProductID,
+	for i := range respOrders {
+		currency := currency.NewPairDelimiter(respOrders[i].ProductID,
 			c.ConfigCurrencyPairFormat.Delimiter)
-		orderSide := exchange.OrderSide(strings.ToUpper(order.Side))
-		orderType := exchange.OrderType(strings.ToUpper(order.Type))
-		orderDate, err := time.Parse(time.RFC3339, order.CreatedAt)
+		orderSide := exchange.OrderSide(strings.ToUpper(respOrders[i].Side))
+		orderType := exchange.OrderType(strings.ToUpper(respOrders[i].Type))
+		orderDate, err := time.Parse(time.RFC3339, respOrders[i].CreatedAt)
 		if err != nil {
 			log.Warnf("Exchange %v Func %v Order %v Could not parse date to unix with value of %v",
-				c.Name, "GetActiveOrders", order.ID, order.CreatedAt)
+				c.Name, "GetActiveOrders", respOrders[i].ID, respOrders[i].CreatedAt)
 		}
 
 		orders = append(orders, exchange.OrderDetail{
-			ID:             order.ID,
-			Amount:         order.Size,
-			ExecutedAmount: order.FilledSize,
+			ID:             respOrders[i].ID,
+			Amount:         respOrders[i].Size,
+			ExecutedAmount: respOrders[i].FilledSize,
 			OrderType:      orderType,
 			OrderDate:      orderDate,
 			OrderSide:      orderSide,

exchanges/coinut/coinut_wrapper.go

@@ -476,17 +476,17 @@ func (c *COINUT) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range allTheOrders {
+	for i := range allTheOrders {
 		for instrument, allInstrumentData := range instruments.Instruments {
-			for _, instrumentData := range allInstrumentData {
-				if instrumentData.InstID == int(order.Order.InstrumentID) {
+			for j := range allInstrumentData {
+				if allInstrumentData[j].InstID == int(allTheOrders[i].Order.InstrumentID) {
 					currPair := currency.NewPairDelimiter(instrument, "")
-					orderSide := exchange.OrderSide(strings.ToUpper(order.Order.Side))
-					orderDate := time.Unix(order.Order.Timestamp, 0)
+					orderSide := exchange.OrderSide(strings.ToUpper(allTheOrders[i].Order.Side))
+					orderDate := time.Unix(allTheOrders[i].Order.Timestamp, 0)
 					orders = append(orders, exchange.OrderDetail{
-						ID:           strconv.FormatInt(order.Order.OrderID, 10),
-						Amount:       order.Order.Quantity,
-						Price:        order.Order.Price,
+						ID:           strconv.FormatInt(allTheOrders[i].Order.OrderID, 10),
+						Amount:       allTheOrders[i].Order.Quantity,
+						Price:        allTheOrders[i].Order.Price,
 						Exchange:     c.Name,
 						OrderSide:    orderSide,
 						OrderDate:    orderDate,

exchanges/exchange.go

@@ -988,9 +988,9 @@ func FilterOrdersBySide(orders *[]OrderDetail, orderSide OrderSide) {
 	}
 
 	var filteredOrders []OrderDetail
-	for _, orderDetail := range *orders {
-		if strings.EqualFold(string(orderDetail.OrderSide), string(orderSide)) {
-			filteredOrders = append(filteredOrders, orderDetail)
+	for i := range *orders {
+		if strings.EqualFold(string((*orders)[i].OrderSide), string(orderSide)) {
+			filteredOrders = append(filteredOrders, (*orders)[i])
 		}
 	}
 
@@ -1004,9 +1004,9 @@ func FilterOrdersByType(orders *[]OrderDetail, orderType OrderType) {
 	}
 
 	var filteredOrders []OrderDetail
-	for _, orderDetail := range *orders {
-		if strings.EqualFold(string(orderDetail.OrderType), string(orderType)) {
-			filteredOrders = append(filteredOrders, orderDetail)
+	for i := range *orders {
+		if strings.EqualFold(string((*orders)[i].OrderType), string(orderType)) {
+			filteredOrders = append(filteredOrders, (*orders)[i])
 		}
 	}
 
@@ -1021,9 +1021,9 @@ func FilterOrdersByTickRange(orders *[]OrderDetail, startTicks, endTicks time.Ti
 	}
 
 	var filteredOrders []OrderDetail
-	for _, orderDetail := range *orders {
-		if orderDetail.OrderDate.Unix() >= startTicks.Unix() && orderDetail.OrderDate.Unix() <= endTicks.Unix() {
-			filteredOrders = append(filteredOrders, orderDetail)
+	for i := range *orders {
+		if (*orders)[i].OrderDate.Unix() >= startTicks.Unix() && (*orders)[i].OrderDate.Unix() <= endTicks.Unix() {
+			filteredOrders = append(filteredOrders, (*orders)[i])
 		}
 	}
 
@@ -1038,16 +1038,16 @@ func FilterOrdersByCurrencies(orders *[]OrderDetail, currencies []currency.Pair)
 	}
 
 	var filteredOrders []OrderDetail
-	for _, orderDetail := range *orders {
+	for i := range *orders {
 		matchFound := false
 		for _, c := range currencies {
-			if !matchFound && orderDetail.CurrencyPair.EqualIncludeReciprocal(c) {
+			if !matchFound && (*orders)[i].CurrencyPair.EqualIncludeReciprocal(c) {
 				matchFound = true
 			}
 		}
 
 		if matchFound {
-			filteredOrders = append(filteredOrders, orderDetail)
+			filteredOrders = append(filteredOrders, (*orders)[i])
 		}
 	}
 

exchanges/gateio/gateio_wrapper.go

@@ -263,12 +263,12 @@ func (g *Gateio) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.Cancel
 	}
 
 	uniqueSymbols := make(map[string]string)
-	for _, openOrder := range openOrders.Orders {
-		uniqueSymbols[openOrder.CurrencyPair] = openOrder.CurrencyPair
+	for i := range openOrders.Orders {
+		uniqueSymbols[openOrders.Orders[i].CurrencyPair] = openOrders.Orders[i].CurrencyPair
 	}
 
-	for _, uniqueSymbol := range uniqueSymbols {
-		err = g.CancelAllExistingOrders(-1, uniqueSymbol)
+	for unique := range uniqueSymbols {
+		err = g.CancelAllExistingOrders(-1, uniqueSymbols[unique])
 		if err != nil {
 			return cancelAllOrdersResponse, err
 		}
@@ -352,21 +352,21 @@ func (g *Gateio) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range resp.Orders {
-		if order.Status != "open" {
+	for i := range resp.Orders {
+		if resp.Orders[i].Status != "open" {
 			continue
 		}
 
-		symbol := currency.NewPairDelimiter(order.CurrencyPair,
+		symbol := currency.NewPairDelimiter(resp.Orders[i].CurrencyPair,
 			g.ConfigCurrencyPairFormat.Delimiter)
-		side := exchange.OrderSide(strings.ToUpper(order.Type))
-		orderDate := time.Unix(order.Timestamp, 0)
+		side := exchange.OrderSide(strings.ToUpper(resp.Orders[i].Type))
+		orderDate := time.Unix(resp.Orders[i].Timestamp, 0)
 
 		orders = append(orders, exchange.OrderDetail{
-			ID:              order.OrderNumber,
-			Amount:          order.Amount,
-			Price:           order.Rate,
-			RemainingAmount: order.FilledAmount,
+			ID:              resp.Orders[i].OrderNumber,
+			Amount:          resp.Orders[i].Amount,
+			Price:           resp.Orders[i].Rate,
+			RemainingAmount: resp.Orders[i].FilledAmount,
 			OrderDate:       orderDate,
 			OrderSide:       side,
 			Exchange:        g.Name,

exchanges/gemini/gemini_wrapper.go

@@ -274,28 +274,28 @@ func (g *Gemini) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range resp {
-		symbol := currency.NewPairDelimiter(order.Symbol,
+	for i := range resp {
+		symbol := currency.NewPairDelimiter(resp[i].Symbol,
 			g.ConfigCurrencyPairFormat.Delimiter)
 		var orderType exchange.OrderType
-		if order.Type == "exchange limit" {
+		if resp[i].Type == "exchange limit" {
 			orderType = exchange.LimitOrderType
-		} else if order.Type == "market buy" || order.Type == "market sell" {
+		} else if resp[i].Type == "market buy" || resp[i].Type == "market sell" {
 			orderType = exchange.MarketOrderType
 		}
 
-		side := exchange.OrderSide(strings.ToUpper(order.Type))
-		orderDate := time.Unix(order.Timestamp, 0)
+		side := exchange.OrderSide(strings.ToUpper(resp[i].Type))
+		orderDate := time.Unix(resp[i].Timestamp, 0)
 
 		orders = append(orders, exchange.OrderDetail{
-			Amount:          order.OriginalAmount,
-			RemainingAmount: order.RemainingAmount,
-			ID:              fmt.Sprintf("%v", order.OrderID),
-			ExecutedAmount:  order.ExecutedAmount,
+			Amount:          resp[i].OriginalAmount,
+			RemainingAmount: resp[i].RemainingAmount,
+			ID:              fmt.Sprintf("%v", resp[i].OrderID),
+			ExecutedAmount:  resp[i].ExecutedAmount,
 			Exchange:        g.Name,
 			OrderType:       orderType,
 			OrderSide:       side,
-			Price:           order.Price,
+			Price:           resp[i].Price,
 			CurrencyPair:    symbol,
 			OrderDate:       orderDate,
 		})
@@ -325,28 +325,28 @@ func (g *Gemini) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([
 			return nil, err
 		}
 
-		for _, trade := range resp {
-			trade.BaseCurrency = currency.Base.String()
-			trade.QuoteCurrency = currency.Quote.String()
-			trades = append(trades, trade)
+		for i := range resp {
+			resp[i].BaseCurrency = currency.Base.String()
+			resp[i].QuoteCurrency = currency.Quote.String()
+			trades = append(trades, resp[i])
 		}
 	}
 
 	var orders []exchange.OrderDetail
-	for _, trade := range trades {
-		side := exchange.OrderSide(strings.ToUpper(trade.Type))
-		orderDate := time.Unix(trade.Timestamp, 0)
+	for i := range trades {
+		side := exchange.OrderSide(strings.ToUpper(trades[i].Type))
+		orderDate := time.Unix(trades[i].Timestamp, 0)
 
 		orders = append(orders, exchange.OrderDetail{
-			Amount:    trade.Amount,
-			ID:        fmt.Sprintf("%v", trade.OrderID),
+			Amount:    trades[i].Amount,
+			ID:        fmt.Sprintf("%v", trades[i].OrderID),
 			Exchange:  g.Name,
 			OrderDate: orderDate,
 			OrderSide: side,
-			Fee:       trade.FeeAmount,
-			Price:     trade.Price,
-			CurrencyPair: currency.NewPairWithDelimiter(trade.BaseCurrency,
-				trade.QuoteCurrency,
+			Fee:       trades[i].FeeAmount,
+			Price:     trades[i].Price,
+			CurrencyPair: currency.NewPairWithDelimiter(trades[i].BaseCurrency,
+				trades[i].QuoteCurrency,
 				g.ConfigCurrencyPairFormat.Delimiter),
 		})
 	}

exchanges/hitbtc/hitbtc.go

@@ -211,9 +211,9 @@ func (h *HitBTC) GetTicker(symbol string) (map[string]Ticker, error) {
 			return nil, err
 		}
 
-		for _, item := range resp1 {
-			if item.Symbol != "" {
-				ret[item.Symbol] = item
+		for i := range resp1 {
+			if resp1[i].Symbol != "" {
+				ret[resp1[i].Symbol] = resp1[i]
 			}
 		}
 	} else {
@@ -222,36 +222,36 @@ func (h *HitBTC) GetTicker(symbol string) (map[string]Ticker, error) {
 	}
 
 	if err == nil {
-		for x, y := range ret {
+		for i := range ret {
 			tick := Ticker{}
 
-			ask, _ := strconv.ParseFloat(y.Ask, 64)
+			ask, _ := strconv.ParseFloat(ret[i].Ask, 64)
 			tick.Ask = ask
 
-			bid, _ := strconv.ParseFloat(y.Bid, 64)
+			bid, _ := strconv.ParseFloat(ret[i].Bid, 64)
 			tick.Bid = bid
 
-			high, _ := strconv.ParseFloat(y.High, 64)
+			high, _ := strconv.ParseFloat(ret[i].High, 64)
 			tick.High = high
 
-			last, _ := strconv.ParseFloat(y.Last, 64)
+			last, _ := strconv.ParseFloat(ret[i].Last, 64)
 			tick.Last = last
 
-			low, _ := strconv.ParseFloat(y.Low, 64)
+			low, _ := strconv.ParseFloat(ret[i].Low, 64)
 			tick.Low = low
 
-			open, _ := strconv.ParseFloat(y.Open, 64)
+			open, _ := strconv.ParseFloat(ret[i].Open, 64)
 			tick.Open = open
 
-			vol, _ := strconv.ParseFloat(y.Volume, 64)
+			vol, _ := strconv.ParseFloat(ret[i].Volume, 64)
 			tick.Volume = vol
 
-			volQuote, _ := strconv.ParseFloat(y.VolumeQuote, 64)
+			volQuote, _ := strconv.ParseFloat(ret[i].VolumeQuote, 64)
 			tick.VolumeQuote = volQuote
 
-			tick.Symbol = y.Symbol
-			tick.Timestamp = y.Timestamp
-			result[x] = tick
+			tick.Symbol = ret[i].Symbol
+			tick.Timestamp = ret[i].Timestamp
+			result[i] = tick
 		}
 	}
 

exchanges/hitbtc/hitbtc_wrapper.go

@@ -236,8 +236,8 @@ func (h *HitBTC) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.Cancel
 		return cancelAllOrdersResponse, err
 	}
 
-	for _, order := range resp {
-		cancelAllOrdersResponse.OrderStatus[strconv.FormatInt(order.ID, 10)] = fmt.Sprintf("Could not cancel order %v. Status: %v", order.ID, order.Status)
+	for i := range resp {
+		cancelAllOrdersResponse.OrderStatus[strconv.FormatInt(resp[i].ID, 10)] = fmt.Sprintf("Could not cancel order %v. Status: %v", resp[i].ID, resp[i].Status)
 	}
 
 	return cancelAllOrdersResponse, nil
@@ -309,21 +309,21 @@ func (h *HitBTC) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range allOrders {
-		symbol := currency.NewPairDelimiter(order.Symbol,
+	for i := range allOrders {
+		symbol := currency.NewPairDelimiter(allOrders[i].Symbol,
 			h.ConfigCurrencyPairFormat.Delimiter)
-		side := exchange.OrderSide(strings.ToUpper(order.Side))
-		orderDate, err := time.Parse(time.RFC3339, order.CreatedAt)
+		side := exchange.OrderSide(strings.ToUpper(allOrders[i].Side))
+		orderDate, err := time.Parse(time.RFC3339, allOrders[i].CreatedAt)
 		if err != nil {
 			log.Warnf("Exchange %v Func %v Order %v Could not parse date to unix with value of %v",
-				h.Name, "GetActiveOrders", order.ID, order.CreatedAt)
+				h.Name, "GetActiveOrders", allOrders[i].ID, allOrders[i].CreatedAt)
 		}
 
 		orders = append(orders, exchange.OrderDetail{
-			ID:           order.ID,
-			Amount:       order.Quantity,
+			ID:           allOrders[i].ID,
+			Amount:       allOrders[i].Quantity,
 			Exchange:     h.Name,
-			Price:        order.Price,
+			Price:        allOrders[i].Price,
 			OrderDate:    orderDate,
 			OrderSide:    side,
 			CurrencyPair: symbol,
@@ -354,21 +354,21 @@ func (h *HitBTC) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range allOrders {
-		symbol := currency.NewPairDelimiter(order.Symbol,
+	for i := range allOrders {
+		symbol := currency.NewPairDelimiter(allOrders[i].Symbol,
 			h.ConfigCurrencyPairFormat.Delimiter)
-		side := exchange.OrderSide(strings.ToUpper(order.Side))
-		orderDate, err := time.Parse(time.RFC3339, order.CreatedAt)
+		side := exchange.OrderSide(strings.ToUpper(allOrders[i].Side))
+		orderDate, err := time.Parse(time.RFC3339, allOrders[i].CreatedAt)
 		if err != nil {
 			log.Warnf("Exchange %v Func %v Order %v Could not parse date to unix with value of %v",
-				h.Name, "GetOrderHistory", order.ID, order.CreatedAt)
+				h.Name, "GetOrderHistory", allOrders[i].ID, allOrders[i].CreatedAt)
 		}
 
 		orders = append(orders, exchange.OrderDetail{
-			ID:           order.ID,
-			Amount:       order.Quantity,
+			ID:           allOrders[i].ID,
+			Amount:       allOrders[i].Quantity,
 			Exchange:     h.Name,
-			Price:        order.Price,
+			Price:        allOrders[i].Price,
 			OrderDate:    orderDate,
 			OrderSide:    side,
 			CurrencyPair: symbol,

exchanges/huobi/huobi_wrapper.go

@@ -421,17 +421,17 @@ func (h *HUOBI) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([]
 			return nil, err
 		}
 
-		for _, order := range resp {
-			orderDate := time.Unix(order.CreatedAt, 0)
+		for i := range resp {
+			orderDate := time.Unix(resp[i].CreatedAt, 0)
 
 			orders = append(orders, exchange.OrderDetail{
-				ID:              fmt.Sprintf("%v", order.ID),
+				ID:              fmt.Sprintf("%v", resp[i].ID),
 				Exchange:        h.Name,
-				Amount:          order.Amount,
-				Price:           order.Price,
+				Amount:          resp[i].Amount,
+				Price:           resp[i].Price,
 				OrderDate:       orderDate,
-				ExecutedAmount:  order.FilledAmount,
-				RemainingAmount: (order.Amount - order.FilledAmount),
+				ExecutedAmount:  resp[i].FilledAmount,
+				RemainingAmount: (resp[i].Amount - resp[i].FilledAmount),
 				CurrencyPair:    c,
 			})
 		}
@@ -465,14 +465,14 @@ func (h *HUOBI) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([]
 			return nil, err
 		}
 
-		for _, order := range resp {
-			orderDate := time.Unix(order.CreatedAt, 0)
+		for i := range resp {
+			orderDate := time.Unix(resp[i].CreatedAt, 0)
 
 			orders = append(orders, exchange.OrderDetail{
-				ID:           fmt.Sprintf("%v", order.ID),
+				ID:           fmt.Sprintf("%v", resp[i].ID),
 				Exchange:     h.Name,
-				Amount:       order.Amount,
-				Price:        order.Price,
+				Amount:       resp[i].Amount,
+				Price:        resp[i].Price,
 				OrderDate:    orderDate,
 				CurrencyPair: c,
 			})

exchanges/huobihadax/huobihadax_wrapper.go

@@ -382,19 +382,19 @@ func (h *HUOBIHADAX) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range allOrders {
-		symbol := currency.NewPairDelimiter(order.Symbol,
+	for i := range allOrders {
+		symbol := currency.NewPairDelimiter(allOrders[i].Symbol,
 			h.ConfigCurrencyPairFormat.Delimiter)
-		orderDate := time.Unix(order.CreatedAt, 0)
+		orderDate := time.Unix(allOrders[i].CreatedAt, 0)
 
 		orders = append(orders, exchange.OrderDetail{
-			ID:              fmt.Sprintf("%v", order.ID),
+			ID:              fmt.Sprintf("%v", allOrders[i].ID),
 			Exchange:        h.Name,
-			Amount:          order.Amount,
-			Price:           order.Price,
+			Amount:          allOrders[i].Amount,
+			Price:           allOrders[i].Price,
 			OrderDate:       orderDate,
-			ExecutedAmount:  order.FilledAmount,
-			RemainingAmount: (order.Amount - order.FilledAmount),
+			ExecutedAmount:  allOrders[i].FilledAmount,
+			RemainingAmount: (allOrders[i].Amount - allOrders[i].FilledAmount),
 			CurrencyPair:    symbol,
 		})
 	}
@@ -430,16 +430,16 @@ func (h *HUOBIHADAX) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range allOrders {
-		symbol := currency.NewPairDelimiter(order.Symbol,
+	for i := range allOrders {
+		symbol := currency.NewPairDelimiter(allOrders[i].Symbol,
 			h.ConfigCurrencyPairFormat.Delimiter)
-		orderDate := time.Unix(order.CreatedAt, 0)
+		orderDate := time.Unix(allOrders[i].CreatedAt, 0)
 
 		orders = append(orders, exchange.OrderDetail{
-			ID:           fmt.Sprintf("%v", order.ID),
+			ID:           fmt.Sprintf("%v", allOrders[i].ID),
 			Exchange:     h.Name,
-			Amount:       order.Amount,
-			Price:        order.Price,
+			Amount:       allOrders[i].Amount,
+			Price:        allOrders[i].Price,
 			OrderDate:    orderDate,
 			CurrencyPair: symbol,
 		})

exchanges/itbit/itbit_wrapper.go

@@ -252,10 +252,10 @@ func (i *ItBit) CancelAllOrders(orderCancellation *exchange.OrderCancellation) (
 		return cancelAllOrdersResponse, err
 	}
 
-	for _, openOrder := range openOrders {
-		err = i.CancelExistingOrder(orderCancellation.WalletAddress, openOrder.ID)
+	for j := range openOrders {
+		err = i.CancelExistingOrder(orderCancellation.WalletAddress, openOrders[j].ID)
 		if err != nil {
-			cancelAllOrdersResponse.OrderStatus[openOrder.ID] = err.Error()
+			cancelAllOrdersResponse.OrderStatus[openOrders[j].ID] = err.Error()
 		}
 	}
 
@@ -325,22 +325,22 @@ func (i *ItBit) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([]
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range allOrders {
-		symbol := currency.NewPairDelimiter(order.Instrument,
+	for j := range allOrders {
+		symbol := currency.NewPairDelimiter(allOrders[j].Instrument,
 			i.ConfigCurrencyPairFormat.Delimiter)
-		side := exchange.OrderSide(strings.ToUpper(order.Side))
-		orderDate, err := time.Parse(time.RFC3339, order.CreatedTime)
+		side := exchange.OrderSide(strings.ToUpper(allOrders[j].Side))
+		orderDate, err := time.Parse(time.RFC3339, allOrders[j].CreatedTime)
 		if err != nil {
 			log.Warnf("Exchange %v Func %v Order %v Could not parse date to unix with value of %v",
-				i.Name, "GetActiveOrders", order.ID, order.CreatedTime)
+				i.Name, "GetActiveOrders", allOrders[j].ID, allOrders[j].CreatedTime)
 		}
 
 		orders = append(orders, exchange.OrderDetail{
-			ID:              order.ID,
+			ID:              allOrders[j].ID,
 			OrderSide:       side,
-			Amount:          order.Amount,
-			ExecutedAmount:  order.AmountFilled,
-			RemainingAmount: (order.Amount - order.AmountFilled),
+			Amount:          allOrders[j].Amount,
+			ExecutedAmount:  allOrders[j].AmountFilled,
+			RemainingAmount: (allOrders[j].Amount - allOrders[j].AmountFilled),
 			Exchange:        i.Name,
 			OrderDate:       orderDate,
 			CurrencyPair:    symbol,
@@ -373,26 +373,26 @@ func (i *ItBit) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([]
 	}
 
 	var orders []exchange.OrderDetail
-	for _, order := range allOrders {
-		if order.Type == "open" {
+	for j := range allOrders {
+		if allOrders[j].Type == "open" {
 			continue
 		}
 
-		symbol := currency.NewPairDelimiter(order.Instrument,
+		symbol := currency.NewPairDelimiter(allOrders[j].Instrument,
 			i.ConfigCurrencyPairFormat.Delimiter)
-		side := exchange.OrderSide(strings.ToUpper(order.Side))
-		orderDate, err := time.Parse(time.RFC3339, order.CreatedTime)
+		side := exchange.OrderSide(strings.ToUpper(allOrders[j].Side))
+		orderDate, err := time.Parse(time.RFC3339, allOrders[j].CreatedTime)
 		if err != nil {
 			log.Warnf("Exchange %v Func %v Order %v Could not parse date to unix with value of %v",
-				i.Name, "GetActiveOrders", order.ID, order.CreatedTime)
+				i.Name, "GetActiveOrders", allOrders[j].ID, allOrders[j].CreatedTime)
 		}
 
 		orders = append(orders, exchange.OrderDetail{
-			ID:              order.ID,
+			ID:              allOrders[j].ID,
 			OrderSide:       side,
-			Amount:          order.Amount,
-			ExecutedAmount:  order.AmountFilled,
-			RemainingAmount: (order.Amount - order.AmountFilled),
+			Amount:          allOrders[j].Amount,
+			ExecutedAmount:  allOrders[j].AmountFilled,
+			RemainingAmount: (allOrders[j].Amount - allOrders[j].AmountFilled),
 			Exchange:        i.Name,
 			OrderDate:       orderDate,
 			CurrencyPair:    symbol,

exchanges/kraken/kraken.go

@@ -216,16 +216,16 @@ func (k *Kraken) GetTicker(symbol string) (Ticker, error) {
 		return tick, fmt.Errorf("%s error: %s", k.Name, resp.Error)
 	}
 
-	for _, y := range resp.Data {
-		tick.Ask, _ = strconv.ParseFloat(y.Ask[0], 64)
-		tick.Bid, _ = strconv.ParseFloat(y.Bid[0], 64)
-		tick.Last, _ = strconv.ParseFloat(y.Last[0], 64)
-		tick.Volume, _ = strconv.ParseFloat(y.Volume[1], 64)
-		tick.VWAP, _ = strconv.ParseFloat(y.VWAP[1], 64)
-		tick.Trades = y.Trades[1]
-		tick.Low, _ = strconv.ParseFloat(y.Low[1], 64)
-		tick.High, _ = strconv.ParseFloat(y.High[1], 64)
-		tick.Open, _ = strconv.ParseFloat(y.Open, 64)
+	for i := range resp.Data {
+		tick.Ask, _ = strconv.ParseFloat(resp.Data[i].Ask[0], 64)
+		tick.Bid, _ = strconv.ParseFloat(resp.Data[i].Bid[0], 64)
+		tick.Last, _ = strconv.ParseFloat(resp.Data[i].Last[0], 64)
+		tick.Volume, _ = strconv.ParseFloat(resp.Data[i].Volume[1], 64)
+		tick.VWAP, _ = strconv.ParseFloat(resp.Data[i].VWAP[1], 64)
+		tick.Trades = resp.Data[i].Trades[1]
+		tick.Low, _ = strconv.ParseFloat(resp.Data[i].Low[1], 64)
+		tick.High, _ = strconv.ParseFloat(resp.Data[i].High[1], 64)
+		tick.Open, _ = strconv.ParseFloat(resp.Data[i].Open, 64)
 	}
 	return tick, nil
 }
@@ -256,18 +256,18 @@ func (k *Kraken) GetTickers(pairList string) (Tickers, error) {
 
 	tickers := make(Tickers)
 
-	for x, y := range resp.Data {
+	for i := range resp.Data {
 		tick := Ticker{}
-		tick.Ask, _ = strconv.ParseFloat(y.Ask[0], 64)
-		tick.Bid, _ = strconv.ParseFloat(y.Bid[0], 64)
-		tick.Last, _ = strconv.ParseFloat(y.Last[0], 64)
-		tick.Volume, _ = strconv.ParseFloat(y.Volume[1], 64)
-		tick.VWAP, _ = strconv.ParseFloat(y.VWAP[1], 64)
-		tick.Trades = y.Trades[1]
-		tick.Low, _ = strconv.ParseFloat(y.Low[1], 64)
-		tick.High, _ = strconv.ParseFloat(y.High[1], 64)
-		tick.Open, _ = strconv.ParseFloat(y.Open, 64)
-		tickers[x] = tick
+		tick.Ask, _ = strconv.ParseFloat(resp.Data[i].Ask[0], 64)
+		tick.Bid, _ = strconv.ParseFloat(resp.Data[i].Bid[0], 64)
+		tick.Last, _ = strconv.ParseFloat(resp.Data[i].Last[0], 64)
+		tick.Volume, _ = strconv.ParseFloat(resp.Data[i].Volume[1], 64)
+		tick.VWAP, _ = strconv.ParseFloat(resp.Data[i].VWAP[1], 64)
+		tick.Trades = resp.Data[i].Trades[1]
+		tick.Low, _ = strconv.ParseFloat(resp.Data[i].Low[1], 64)
+		tick.High, _ = strconv.ParseFloat(resp.Data[i].High[1], 64)
+		tick.Open, _ = strconv.ParseFloat(resp.Data[i].Open, 64)
+		tickers[i] = tick
 	}
 	return tickers, nil
 }

exchanges/kraken/kraken_wrapper.go

@@ -42,7 +42,8 @@ func (k *Kraken) Run() {
 		}
 
 		var exchangeProducts []string
-		for _, v := range assetPairs {
+		for i := range assetPairs {
+			v := assetPairs[i]
 			if common.StringContains(v.Altname, ".d") {
 				continue
 			}
@@ -327,20 +328,20 @@ func (k *Kraken) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([
 	}
 
 	var orders []exchange.OrderDetail
-	for ID, order := range resp.Open {
-		symbol := currency.NewPairDelimiter(order.Descr.Pair,
+	for i := range resp.Open {
+		symbol := currency.NewPairDelimiter(resp.Open[i].Descr.Pair,
 			k.ConfigCurrencyPairFormat.Delimiter)
-		orderDate := time.Unix(int64(order.StartTm), 0)
-		side := exchange.OrderSide(strings.ToUpper(order.Descr.Type))
+		orderDate := time.Unix(int64(resp.Open[i].StartTm), 0)
+		side := exchange.OrderSide(strings.ToUpper(resp.Open[i].Descr.Type))
 
 		orders = append(orders, exchange.OrderDetail{
-			ID:              ID,
-			Amount:          order.Vol,
-			RemainingAmount: (order.Vol - order.VolExec),
-			ExecutedAmount:  order.VolExec,
+			ID:              i,
+			Amount:          resp.Open[i].Vol,
+			RemainingAmount: (resp.Open[i].Vol - resp.Open[i].VolExec),
+			ExecutedAmount:  resp.Open[i].VolExec,
 			Exchange:        k.Name,
 			OrderDate:       orderDate,
-			Price:           order.Price,
+			Price:           resp.Open[i].Price,
 			OrderSide:       side,
 			CurrencyPair:    symbol,
 		})
@@ -371,20 +372,20 @@ func (k *Kraken) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([
 	}
 
 	var orders []exchange.OrderDetail
-	for ID, order := range resp.Closed {
-		symbol := currency.NewPairDelimiter(order.Descr.Pair,
+	for i := range resp.Closed {
+		symbol := currency.NewPairDelimiter(resp.Closed[i].Descr.Pair,
 			k.ConfigCurrencyPairFormat.Delimiter)
-		orderDate := time.Unix(int64(order.StartTm), 0)
-		side := exchange.OrderSide(strings.ToUpper(order.Descr.Type))
+		orderDate := time.Unix(int64(resp.Closed[i].StartTm), 0)
+		side := exchange.OrderSide(strings.ToUpper(resp.Closed[i].Descr.Type))
 
 		orders = append(orders, exchange.OrderDetail{
-			ID:              ID,
-			Amount:          order.Vol,
-			RemainingAmount: (order.Vol - order.VolExec),
-			ExecutedAmount:  order.VolExec,
+			ID:              i,
+			Amount:          resp.Closed[i].Vol,
+			RemainingAmount: (resp.Closed[i].Vol - resp.Closed[i].VolExec),
+			ExecutedAmount:  resp.Closed[i].VolExec,
 			Exchange:        k.Name,
 			OrderDate:       orderDate,
-			Price:           order.Price,
+			Price:           resp.Closed[i].Price,
 			OrderSide:       side,
 			CurrencyPair:    symbol,
 		})

exchanges/localbitcoins/localbitcoins_wrapper.go

@@ -200,23 +200,23 @@ func (l *LocalBitcoins) SubmitOrder(p currency.Pair, side exchange.OrderSide, _
 	// The only details we have are the params above
 	var adID string
 	ads, err := l.Getads()
-	for _, i := range ads.AdList {
-		if i.Data.PriceEquation == params.PriceEquation &&
-			i.Data.Lat == float64(params.Latitude) &&
-			i.Data.Lon == float64(params.Longitude) &&
-			i.Data.City == params.City &&
-			i.Data.Location == params.Location &&
-			i.Data.CountryCode == params.CountryCode &&
-			i.Data.Currency == params.Currency &&
-			i.Data.AccountInfo == params.AccountInfo &&
-			i.Data.BankName == params.BankName &&
-			i.Data.SMSVerficationRequired == params.SMSVerficationRequired &&
-			i.Data.TrackMaxAmount == params.TrackMaxAmount &&
-			i.Data.RequireTrustedByAdvertiser == params.RequireTrustedByAdvertiser &&
-			i.Data.OnlineProvider == params.OnlineProvider &&
-			i.Data.TradeType == params.TradeType &&
-			i.Data.MinAmount == fmt.Sprintf("%v", params.MinAmount) {
-			adID = fmt.Sprintf("%v", i.Data.AdID)
+	for i := range ads.AdList {
+		if ads.AdList[i].Data.PriceEquation == params.PriceEquation &&
+			ads.AdList[i].Data.Lat == float64(params.Latitude) &&
+			ads.AdList[i].Data.Lon == float64(params.Longitude) &&
+			ads.AdList[i].Data.City == params.City &&
+			ads.AdList[i].Data.Location == params.Location &&
+			ads.AdList[i].Data.CountryCode == params.CountryCode &&
+			ads.AdList[i].Data.Currency == params.Currency &&
+			ads.AdList[i].Data.AccountInfo == params.AccountInfo &&
+			ads.AdList[i].Data.BankName == params.BankName &&
+			ads.AdList[i].Data.SMSVerficationRequired == params.SMSVerficationRequired &&
+			ads.AdList[i].Data.TrackMaxAmount == params.TrackMaxAmount &&
+			ads.AdList[i].Data.RequireTrustedByAdvertiser == params.RequireTrustedByAdvertiser &&
+			ads.AdList[i].Data.OnlineProvider == params.OnlineProvider &&
+			ads.AdList[i].Data.TradeType == params.TradeType &&
+			ads.AdList[i].Data.MinAmount == fmt.Sprintf("%v", params.MinAmount) {
+			adID = fmt.Sprintf("%v", ads.AdList[i].Data.AdID)
 		}
 	}
 
@@ -250,11 +250,11 @@ func (l *LocalBitcoins) CancelAllOrders(_ *exchange.OrderCancellation) (exchange
 		return cancelAllOrdersResponse, err
 	}
 
-	for _, ad := range ads.AdList {
-		adIDString := strconv.FormatInt(ad.Data.AdID, 10)
+	for i := range ads.AdList {
+		adIDString := strconv.FormatInt(ads.AdList[i].Data.AdID, 10)
 		err = l.DeleteAd(adIDString)
 		if err != nil {
-			cancelAllOrdersResponse.OrderStatus[strconv.FormatInt(ad.Data.AdID, 10)] = err.Error()
+			cancelAllOrdersResponse.OrderStatus[strconv.FormatInt(ads.AdList[i].Data.AdID, 10)] = err.Error()
 		}
 	}
 
@@ -318,32 +318,32 @@ func (l *LocalBitcoins) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequ
 	}
 
 	var orders []exchange.OrderDetail
-	for _, trade := range resp {
-		orderDate, err := time.Parse(time.RFC3339, trade.Data.CreatedAt)
+	for i := range resp {
+		orderDate, err := time.Parse(time.RFC3339, resp[i].Data.CreatedAt)
 		if err != nil {
 			log.Warnf("Exchange %v Func %v Order %v Could not parse date to unix with value of %v",
 				l.Name,
 				"GetActiveOrders",
-				trade.Data.Advertisement.ID,
-				trade.Data.CreatedAt)
+				resp[i].Data.Advertisement.ID,
+				resp[i].Data.CreatedAt)
 		}
 
 		var side exchange.OrderSide
-		if trade.Data.IsBuying {
+		if resp[i].Data.IsBuying {
 			side = exchange.BuyOrderSide
-		} else if trade.Data.IsSelling {
+		} else if resp[i].Data.IsSelling {
 			side = exchange.SellOrderSide
 		}
 
 		orders = append(orders, exchange.OrderDetail{
-			Amount:    trade.Data.AmountBTC,
-			Price:     trade.Data.Amount,
-			ID:        fmt.Sprintf("%v", trade.Data.Advertisement.ID),
+			Amount:    resp[i].Data.AmountBTC,
+			Price:     resp[i].Data.Amount,
+			ID:        fmt.Sprintf("%v", resp[i].Data.Advertisement.ID),
 			OrderDate: orderDate,
-			Fee:       trade.Data.FeeBTC,
+			Fee:       resp[i].Data.FeeBTC,
 			OrderSide: side,
 			CurrencyPair: currency.NewPairWithDelimiter(currency.BTC.String(),
-				trade.Data.Currency,
+				resp[i].Data.Currency,
 				l.ConfigCurrencyPairFormat.Delimiter),
 			Exchange: l.Name,
 		})
@@ -379,44 +379,44 @@ func (l *LocalBitcoins) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequ
 	allTrades = append(allTrades, resp...)
 
 	var orders []exchange.OrderDetail
-	for _, trade := range allTrades {
-		orderDate, err := time.Parse(time.RFC3339, trade.Data.CreatedAt)
+	for i := range allTrades {
+		orderDate, err := time.Parse(time.RFC3339, allTrades[i].Data.CreatedAt)
 		if err != nil {
 			log.Warnf("Exchange %v Func %v Order %v Could not parse date to unix with value of %v",
 				l.Name,
 				"GetActiveOrders",
-				trade.Data.Advertisement.ID,
-				trade.Data.CreatedAt)
+				allTrades[i].Data.Advertisement.ID,
+				allTrades[i].Data.CreatedAt)
 		}
 
 		var side exchange.OrderSide
-		if trade.Data.IsBuying {
+		if allTrades[i].Data.IsBuying {
 			side = exchange.BuyOrderSide
-		} else if trade.Data.IsSelling {
+		} else if allTrades[i].Data.IsSelling {
 			side = exchange.SellOrderSide
 		}
 
 		status := ""
 
 		switch {
-		case trade.Data.ReleasedAt != "" && trade.Data.ReleasedAt != null:
+		case allTrades[i].Data.ReleasedAt != "" && allTrades[i].Data.ReleasedAt != null:
 			status = "Released"
-		case trade.Data.CanceledAt != "" && trade.Data.CanceledAt != null:
+		case allTrades[i].Data.CanceledAt != "" && allTrades[i].Data.CanceledAt != null:
 			status = "Cancelled"
-		case trade.Data.ClosedAt != "" && trade.Data.ClosedAt != null:
+		case allTrades[i].Data.ClosedAt != "" && allTrades[i].Data.ClosedAt != null:
 			status = "Closed"
 		}
 
 		orders = append(orders, exchange.OrderDetail{
-			Amount:    trade.Data.AmountBTC,
-			Price:     trade.Data.Amount,
-			ID:        fmt.Sprintf("%v", trade.Data.Advertisement.ID),
+			Amount:    allTrades[i].Data.AmountBTC,
+			Price:     allTrades[i].Data.Amount,
+			ID:        fmt.Sprintf("%v", allTrades[i].Data.Advertisement.ID),
 			OrderDate: orderDate,
-			Fee:       trade.Data.FeeBTC,
+			Fee:       allTrades[i].Data.FeeBTC,
 			OrderSide: side,
 			Status:    status,
 			CurrencyPair: currency.NewPairWithDelimiter(currency.BTC.String(),
-				trade.Data.Currency,
+				allTrades[i].Data.Currency,
 				l.ConfigCurrencyPairFormat.Delimiter),
 			Exchange: l.Name,
 		})

exchanges/okgroup/okgroup.go

@@ -256,9 +256,11 @@ func (o *OKGroup) PlaceSpotOrder(request *PlaceSpotOrderRequest) (resp PlaceSpot
 func (o *OKGroup) PlaceMultipleSpotOrders(request []PlaceSpotOrderRequest) (map[string][]PlaceSpotOrderResponse, []error) {
 	currencyPairOrders := make(map[string]int)
 	resp := make(map[string][]PlaceSpotOrderResponse)
-	for _, order := range request {
-		currencyPairOrders[order.InstrumentID]++
+
+	for i := range request {
+		currencyPairOrders[request[i].InstrumentID]++
 	}
+
 	if len(currencyPairOrders) > 4 {
 		return resp, []error{errors.New("up to 4 trading pairs")}
 	}
@@ -456,8 +458,8 @@ func (o *OKGroup) PlaceMarginOrder(request *PlaceSpotOrderRequest) (resp PlaceSp
 func (o *OKGroup) PlaceMultipleMarginOrders(request []PlaceSpotOrderRequest) (map[string][]PlaceSpotOrderResponse, []error) {
 	currencyPairOrders := make(map[string]int)
 	resp := make(map[string][]PlaceSpotOrderResponse)
-	for _, order := range request {
-		currencyPairOrders[order.InstrumentID]++
+	for i := range request {
+		currencyPairOrders[request[i].InstrumentID]++
 	}
 	if len(currencyPairOrders) > 4 {
 		return resp, []error{errors.New("up to 4 trading pairs")}

exchanges/okgroup/okgroup_websocket.go

@@ -490,26 +490,26 @@ func (o *OKGroup) ResubscribeToChannel(channel string) {
 // logDataResponse will log the details of any websocket data event
 // where there is no websocket datahandler for it
 func logDataResponse(response *WebsocketDataResponse) {
-	for _, data := range response.Data {
+	for i := range response.Data {
 		log.Errorf("Unhandled channel: '%v'. Instrument '%v' Timestamp '%v', Data '%v",
 			response.Table,
-			data.InstrumentID,
-			data.Timestamp,
-			data)
+			response.Data[i].InstrumentID,
+			response.Data[i].Timestamp,
+			response.Data[i])
 	}
 }
 
 // wsProcessTickers converts ticker data and sends it to the datahandler
 func (o *OKGroup) wsProcessTickers(response *WebsocketDataResponse) {
-	for _, tickerData := range response.Data {
-		instrument := currency.NewPairDelimiter(tickerData.InstrumentID, "-")
+	for i := range response.Data {
+		instrument := currency.NewPairDelimiter(response.Data[i].InstrumentID, "-")
 		o.Websocket.DataHandler <- exchange.TickerData{
-			Timestamp:  tickerData.Timestamp,
+			Timestamp:  response.Data[i].Timestamp,
 			Exchange:   o.GetName(),
 			AssetType:  o.GetAssetTypeFromTableName(response.Table),
-			HighPrice:  tickerData.High24H,
-			LowPrice:   tickerData.Low24H,
-			ClosePrice: tickerData.Last,
+			HighPrice:  response.Data[i].High24H,
+			LowPrice:   response.Data[i].Low24H,
+			ClosePrice: response.Data[i].Last,
 			Pair:       instrument,
 		}
 	}
@@ -517,28 +517,28 @@ func (o *OKGroup) wsProcessTickers(response *WebsocketDataResponse) {
 
 // wsProcessTrades converts trade data and sends it to the datahandler
 func (o *OKGroup) wsProcessTrades(response *WebsocketDataResponse) {
-	for _, trade := range response.Data {
-		instrument := currency.NewPairDelimiter(trade.InstrumentID, "-")
+	for i := range response.Data {
+		instrument := currency.NewPairDelimiter(response.Data[i].InstrumentID, "-")
 		o.Websocket.DataHandler <- exchange.TradeData{
-			Amount:       trade.Qty,
+			Amount:       response.Data[i].Qty,
 			AssetType:    o.GetAssetTypeFromTableName(response.Table),
 			CurrencyPair: instrument,
 			EventTime:    time.Now().Unix(),
 			Exchange:     o.GetName(),
-			Price:        trade.WebsocketTradeResponse.Price,
-			Side:         trade.Side,
-			Timestamp:    trade.Timestamp,
+			Price:        response.Data[i].WebsocketTradeResponse.Price,
+			Side:         response.Data[i].Side,
+			Timestamp:    response.Data[i].Timestamp,
 		}
 	}
 }
 
 // wsProcessCandles converts candle data and sends it to the data handler
 func (o *OKGroup) wsProcessCandles(response *WebsocketDataResponse) {
-	for _, candle := range response.Data {
-		instrument := currency.NewPairDelimiter(candle.InstrumentID, "-")
-		timeData, err := time.Parse(time.RFC3339Nano, candle.WebsocketCandleResponse.Candle[0])
+	for i := range response.Data {
+		instrument := currency.NewPairDelimiter(response.Data[i].InstrumentID, "-")
+		timeData, err := time.Parse(time.RFC3339Nano, response.Data[i].WebsocketCandleResponse.Candle[0])
 		if err != nil {
-			log.Warnf("%v Time data could not be parsed: %v", o.GetName(), candle.Candle[0])
+			log.Warnf("%v Time data could not be parsed: %v", o.GetName(), response.Data[i].Candle[0])
 		}
 
 		candleIndex := strings.LastIndex(response.Table, okGroupWsCandle)
@@ -555,11 +555,11 @@ func (o *OKGroup) wsProcessCandles(response *WebsocketDataResponse) {
 			Timestamp: timeData,
 			Interval:  candleInterval,
 		}
-		klineData.OpenPrice, _ = strconv.ParseFloat(candle.Candle[1], 64)
-		klineData.HighPrice, _ = strconv.ParseFloat(candle.Candle[2], 64)
-		klineData.LowPrice, _ = strconv.ParseFloat(candle.Candle[3], 64)
-		klineData.ClosePrice, _ = strconv.ParseFloat(candle.Candle[4], 64)
-		klineData.Volume, _ = strconv.ParseFloat(candle.Candle[5], 64)
+		klineData.OpenPrice, _ = strconv.ParseFloat(response.Data[i].Candle[1], 64)
+		klineData.HighPrice, _ = strconv.ParseFloat(response.Data[i].Candle[2], 64)
+		klineData.LowPrice, _ = strconv.ParseFloat(response.Data[i].Candle[3], 64)
+		klineData.ClosePrice, _ = strconv.ParseFloat(response.Data[i].Candle[4], 64)
+		klineData.Volume, _ = strconv.ParseFloat(response.Data[i].Candle[5], 64)
 
 		o.Websocket.DataHandler <- klineData
 	}

exchanges/okgroup/okgroup_wrapper.go

@@ -198,14 +198,14 @@ func (o *OKGroup) GetFundingHistory() (resp []exchange.FundHistory, err error) {
 		})
 	}
 	accountWithdrawlHistory, err := o.GetAccountWithdrawalHistory("")
-	for _, withdrawal := range accountWithdrawlHistory {
+	for i := range accountWithdrawlHistory {
 		resp = append(resp, exchange.FundHistory{
-			Amount:       withdrawal.Amount,
-			Currency:     withdrawal.Currency,
+			Amount:       accountWithdrawlHistory[i].Amount,
+			Currency:     accountWithdrawlHistory[i].Currency,
 			ExchangeName: o.Name,
-			Status:       OrderStatus[withdrawal.Status],
-			Timestamp:    withdrawal.Timestamp,
-			TransferID:   withdrawal.Txid,
+			Status:       OrderStatus[accountWithdrawlHistory[i].Status],
+			Timestamp:    accountWithdrawlHistory[i].Timestamp,
+			TransferID:   accountWithdrawlHistory[i].Txid,
 			TransferType: "withdrawal",
 		})
 	}
@@ -362,14 +362,14 @@ func (o *OKGroup) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) (
 		if err != nil {
 			return resp, err
 		}
-		for _, openOrder := range spotOpenOrders {
+		for i := range spotOpenOrders {
 			resp = append(resp, exchange.OrderDetail{
-				Amount:         openOrder.Size,
+				Amount:         spotOpenOrders[i].Size,
 				CurrencyPair:   currency,
 				Exchange:       o.Name,
-				ExecutedAmount: openOrder.FilledSize,
-				OrderDate:      openOrder.Timestamp,
-				Status:         openOrder.Status,
+				ExecutedAmount: spotOpenOrders[i].FilledSize,
+				OrderDate:      spotOpenOrders[i].Timestamp,
+				Status:         spotOpenOrders[i].Status,
 			})
 		}
 	}
@@ -388,18 +388,18 @@ func (o *OKGroup) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) (
 		if err != nil {
 			return resp, err
 		}
-		for _, openOrder := range spotOpenOrders {
+		for i := range spotOpenOrders {
 			resp = append(resp, exchange.OrderDetail{
-				ID:             openOrder.OrderID,
-				Price:          openOrder.Price,
-				Amount:         openOrder.Size,
+				ID:             spotOpenOrders[i].OrderID,
+				Price:          spotOpenOrders[i].Price,
+				Amount:         spotOpenOrders[i].Size,
 				CurrencyPair:   currency,
 				Exchange:       o.Name,
-				OrderSide:      exchange.OrderSide(openOrder.Side),
-				OrderType:      exchange.OrderType(openOrder.Type),
-				ExecutedAmount: openOrder.FilledSize,
-				OrderDate:      openOrder.Timestamp,
-				Status:         openOrder.Status,
+				OrderSide:      exchange.OrderSide(spotOpenOrders[i].Side),
+				OrderType:      exchange.OrderType(spotOpenOrders[i].Type),
+				ExecutedAmount: spotOpenOrders[i].FilledSize,
+				OrderDate:      spotOpenOrders[i].Timestamp,
+				Status:         spotOpenOrders[i].Status,
 			})
 		}
 	}