From d69713f59d9452f241c55c3d900ca5748d0e8e4c Mon Sep 17 00:00:00 2001 From: Adam <31364354+MadCozBadd@users.noreply.github.com> Date: Wed, 10 Apr 2019 17:04:32 +1000 Subject: [PATCH] Fix rangeValCopy linter issues (#275) * first pass of linter fixes for range val * fixed the remaining issues for pointers * changed as requested --- .golangci.yml | 1 - config/config.go | 72 ++++++------ exchanges/anx/anx_wrapper.go | 46 ++++---- exchanges/binance/binance.go | 6 +- exchanges/binance/binance_wrapper.go | 44 +++---- exchanges/bitfinex/bitfinex_wrapper.go | 56 ++++----- exchanges/bithumb/bithumb_wrapper.go | 50 ++++---- exchanges/bitmex/bitmex_wrapper.go | 50 ++++---- exchanges/bittrex/bittrex_wrapper.go | 44 +++---- exchanges/btcc/btcc_websocket.go | 4 +- exchanges/btcmarkets/btcmarkets.go | 32 ++--- exchanges/btcmarkets/btcmarkets_wrapper.go | 110 +++++++++--------- exchanges/btse/btse_wrapper.go | 12 +- exchanges/coinbasepro/coinbasepro_wrapper.go | 46 ++++---- exchanges/coinut/coinut_wrapper.go | 16 +-- exchanges/exchange.go | 24 ++-- exchanges/gateio/gateio_wrapper.go | 26 ++--- exchanges/gemini/gemini_wrapper.go | 48 ++++---- exchanges/hitbtc/hitbtc.go | 30 ++--- exchanges/hitbtc/hitbtc_wrapper.go | 36 +++--- exchanges/huobi/huobi_wrapper.go | 24 ++-- exchanges/huobihadax/huobihadax_wrapper.go | 28 ++--- exchanges/itbit/itbit_wrapper.go | 44 +++---- exchanges/kraken/kraken.go | 42 +++---- exchanges/kraken/kraken_wrapper.go | 39 ++++--- .../localbitcoins/localbitcoins_wrapper.go | 90 +++++++------- exchanges/okgroup/okgroup.go | 10 +- exchanges/okgroup/okgroup_websocket.go | 50 ++++---- exchanges/okgroup/okgroup_wrapper.go | 40 +++---- 29 files changed, 563 insertions(+), 557 deletions(-) diff --git a/.golangci.yml b/.golangci.yml index 43d31819..ccb81b9d 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -66,7 +66,6 @@ linters-settings: disabled-checks: - wrapperFunc - importShadow - - rangeValCopy - methodExprCall issues: diff --git a/config/config.go b/config/config.go index c2c0c687..c0694d34 100644 --- a/config/config.go +++ b/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 } } diff --git a/exchanges/anx/anx_wrapper.go b/exchanges/anx/anx_wrapper.go index acc8198d..5c7c811c 100644 --- a/exchanges/anx/anx_wrapper.go +++ b/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), } diff --git a/exchanges/binance/binance.go b/exchanges/binance/binance.go index e0328799..3cf210d7 100644 --- a/exchanges/binance/binance.go +++ b/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 diff --git a/exchanges/binance/binance_wrapper.go b/exchanges/binance/binance_wrapper.go index d7554163..6ad78e9d 100644 --- a/exchanges/binance/binance_wrapper.go +++ b/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, }) } } diff --git a/exchanges/bitfinex/bitfinex_wrapper.go b/exchanges/bitfinex/bitfinex_wrapper.go index b77d6aaa..0f667fef 100644 --- a/exchanges/bitfinex/bitfinex_wrapper.go +++ b/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 { diff --git a/exchanges/bithumb/bithumb_wrapper.go b/exchanges/bithumb/bithumb_wrapper.go index 1bac973d..01a3ffeb 100644 --- a/exchanges/bithumb/bithumb_wrapper.go +++ b/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 } diff --git a/exchanges/bitmex/bitmex_wrapper.go b/exchanges/bitmex/bitmex_wrapper.go index dc23c46c..2a206756 100644 --- a/exchanges/bitmex/bitmex_wrapper.go +++ b/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), } diff --git a/exchanges/bittrex/bittrex_wrapper.go b/exchanges/bittrex/bittrex_wrapper.go index f4bd0fee..1d45cfcb 100644 --- a/exchanges/bittrex/bittrex_wrapper.go +++ b/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, }) } diff --git a/exchanges/btcc/btcc_websocket.go b/exchanges/btcc/btcc_websocket.go index 20be3b27..b365d971 100644 --- a/exchanges/btcc/btcc_websocket.go +++ b/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) diff --git a/exchanges/btcmarkets/btcmarkets.go b/exchanges/btcmarkets/btcmarkets.go index 7212af90..56ca2e26 100644 --- a/exchanges/btcmarkets/btcmarkets.go +++ b/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 } } diff --git a/exchanges/btcmarkets/btcmarkets_wrapper.go b/exchanges/btcmarkets/btcmarkets_wrapper.go index 04733c98..ce4a4fb5 100644 --- a/exchanges/btcmarkets/btcmarkets_wrapper.go +++ b/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, }) } diff --git a/exchanges/btse/btse_wrapper.go b/exchanges/btse/btse_wrapper.go index 75ba4409..5e7d3963 100644 --- a/exchanges/btse/btse_wrapper.go +++ b/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, diff --git a/exchanges/coinbasepro/coinbasepro_wrapper.go b/exchanges/coinbasepro/coinbasepro_wrapper.go index d0f5499a..91b4177b 100644 --- a/exchanges/coinbasepro/coinbasepro_wrapper.go +++ b/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, diff --git a/exchanges/coinut/coinut_wrapper.go b/exchanges/coinut/coinut_wrapper.go index 96760af5..01d57993 100644 --- a/exchanges/coinut/coinut_wrapper.go +++ b/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, diff --git a/exchanges/exchange.go b/exchanges/exchange.go index 090a54b2..64bf4e7f 100644 --- a/exchanges/exchange.go +++ b/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]) } } diff --git a/exchanges/gateio/gateio_wrapper.go b/exchanges/gateio/gateio_wrapper.go index f4f681a9..100240fc 100644 --- a/exchanges/gateio/gateio_wrapper.go +++ b/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, diff --git a/exchanges/gemini/gemini_wrapper.go b/exchanges/gemini/gemini_wrapper.go index 3ea4c1e5..d6b5718d 100644 --- a/exchanges/gemini/gemini_wrapper.go +++ b/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), }) } diff --git a/exchanges/hitbtc/hitbtc.go b/exchanges/hitbtc/hitbtc.go index 038d897a..134e4a6a 100644 --- a/exchanges/hitbtc/hitbtc.go +++ b/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 } } diff --git a/exchanges/hitbtc/hitbtc_wrapper.go b/exchanges/hitbtc/hitbtc_wrapper.go index 5c1f3bc9..2aa596fe 100644 --- a/exchanges/hitbtc/hitbtc_wrapper.go +++ b/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, diff --git a/exchanges/huobi/huobi_wrapper.go b/exchanges/huobi/huobi_wrapper.go index eac670e7..df86bea6 100644 --- a/exchanges/huobi/huobi_wrapper.go +++ b/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, }) diff --git a/exchanges/huobihadax/huobihadax_wrapper.go b/exchanges/huobihadax/huobihadax_wrapper.go index c1071852..847a99e0 100644 --- a/exchanges/huobihadax/huobihadax_wrapper.go +++ b/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, }) diff --git a/exchanges/itbit/itbit_wrapper.go b/exchanges/itbit/itbit_wrapper.go index deeff7ff..a5279dc3 100644 --- a/exchanges/itbit/itbit_wrapper.go +++ b/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, diff --git a/exchanges/kraken/kraken.go b/exchanges/kraken/kraken.go index ca16fa6c..9acb943a 100644 --- a/exchanges/kraken/kraken.go +++ b/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 } diff --git a/exchanges/kraken/kraken_wrapper.go b/exchanges/kraken/kraken_wrapper.go index fc9937e8..d19e9079 100644 --- a/exchanges/kraken/kraken_wrapper.go +++ b/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, }) diff --git a/exchanges/localbitcoins/localbitcoins_wrapper.go b/exchanges/localbitcoins/localbitcoins_wrapper.go index ff9f962e..8d084bbe 100644 --- a/exchanges/localbitcoins/localbitcoins_wrapper.go +++ b/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, }) diff --git a/exchanges/okgroup/okgroup.go b/exchanges/okgroup/okgroup.go index e454435e..aa61a5a6 100644 --- a/exchanges/okgroup/okgroup.go +++ b/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")} diff --git a/exchanges/okgroup/okgroup_websocket.go b/exchanges/okgroup/okgroup_websocket.go index 94e72fda..319c7da3 100644 --- a/exchanges/okgroup/okgroup_websocket.go +++ b/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 } diff --git a/exchanges/okgroup/okgroup_wrapper.go b/exchanges/okgroup/okgroup_wrapper.go index 8d0d3194..0d6c4e7b 100644 --- a/exchanges/okgroup/okgroup_wrapper.go +++ b/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, }) } }