package ftx import ( "context" "errors" "fmt" "math" "sort" "strconv" "strings" "sync" "time" "github.com/shopspring/decimal" "github.com/thrasher-corp/gocryptotrader/common" "github.com/thrasher-corp/gocryptotrader/config" "github.com/thrasher-corp/gocryptotrader/currency" exchange "github.com/thrasher-corp/gocryptotrader/exchanges" "github.com/thrasher-corp/gocryptotrader/exchanges/account" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" "github.com/thrasher-corp/gocryptotrader/exchanges/deposit" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" "github.com/thrasher-corp/gocryptotrader/exchanges/margin" "github.com/thrasher-corp/gocryptotrader/exchanges/order" "github.com/thrasher-corp/gocryptotrader/exchanges/orderbook" "github.com/thrasher-corp/gocryptotrader/exchanges/protocol" "github.com/thrasher-corp/gocryptotrader/exchanges/request" "github.com/thrasher-corp/gocryptotrader/exchanges/stream" "github.com/thrasher-corp/gocryptotrader/exchanges/ticker" "github.com/thrasher-corp/gocryptotrader/exchanges/trade" "github.com/thrasher-corp/gocryptotrader/log" "github.com/thrasher-corp/gocryptotrader/portfolio/withdraw" ) // GetDefaultConfig returns a default exchange config func (f *FTX) GetDefaultConfig() (*config.Exchange, error) { f.SetDefaults() exchCfg := new(config.Exchange) exchCfg.Name = f.Name exchCfg.HTTPTimeout = exchange.DefaultHTTPTimeout exchCfg.BaseCurrencies = f.BaseCurrencies err := f.SetupDefaults(exchCfg) if err != nil { return nil, err } if f.Features.Supports.RESTCapabilities.AutoPairUpdates { err = f.UpdateTradablePairs(context.TODO(), true) if err != nil { return nil, err } } return exchCfg, nil } // SetDefaults sets the basic defaults for FTX func (f *FTX) SetDefaults() { f.Name = "FTX" f.Enabled = true f.Verbose = true f.API.CredentialsValidator.RequiresKey = true f.API.CredentialsValidator.RequiresSecret = true spot := currency.PairStore{ RequestFormat: ¤cy.PairFormat{ Uppercase: true, Delimiter: "/", }, ConfigFormat: ¤cy.PairFormat{ Uppercase: true, Delimiter: "/", }, } futures := currency.PairStore{ RequestFormat: ¤cy.PairFormat{ Uppercase: true, Delimiter: "-", }, ConfigFormat: ¤cy.PairFormat{ Uppercase: true, Delimiter: "-", }, } err := f.StoreAssetPairFormat(asset.Spot, spot) if err != nil { log.Errorln(log.ExchangeSys, err) } err = f.StoreAssetPairFormat(asset.Futures, futures) if err != nil { log.Errorln(log.ExchangeSys, err) } f.Features = exchange.Features{ Supports: exchange.FeaturesSupported{ REST: true, Websocket: true, RESTCapabilities: protocol.Features{ TickerFetching: true, TickerBatching: true, KlineFetching: true, TradeFetching: true, OrderbookFetching: true, AutoPairUpdates: true, AccountInfo: true, GetOrder: true, GetOrders: true, CancelOrders: true, CancelOrder: true, SubmitOrder: true, TradeFee: true, FiatDepositFee: true, FiatWithdrawalFee: true, CryptoWithdrawalFee: true, CryptoDeposit: true, CryptoWithdrawal: true, MultiChainDeposits: true, MultiChainWithdrawals: true, }, WebsocketCapabilities: protocol.Features{ OrderbookFetching: true, TradeFetching: true, Subscribe: true, Unsubscribe: true, GetOrders: true, GetOrder: true, }, WithdrawPermissions: exchange.AutoWithdrawCrypto, Kline: kline.ExchangeCapabilitiesSupported{ DateRanges: true, Intervals: true, }, }, Enabled: exchange.FeaturesEnabled{ AutoPairUpdates: true, Kline: kline.ExchangeCapabilitiesEnabled{ Intervals: map[string]bool{ kline.FifteenSecond.Word(): true, kline.OneMin.Word(): true, kline.FiveMin.Word(): true, kline.FifteenMin.Word(): true, kline.OneHour.Word(): true, kline.FourHour.Word(): true, kline.OneDay.Word(): true, }, ResultLimit: 5000, }, }, } f.Requester, err = request.New(f.Name, common.NewHTTPClientWithTimeout(exchange.DefaultHTTPTimeout), request.WithLimiter(request.NewBasicRateLimit(ratePeriod, rateLimit))) if err != nil { log.Errorln(log.ExchangeSys, err) } f.API.Endpoints = f.NewEndpoints() err = f.API.Endpoints.SetDefaultEndpoints(map[exchange.URL]string{ exchange.RestSpot: ftxAPIURL, exchange.WebsocketSpot: ftxWSURL, }) if err != nil { log.Errorln(log.ExchangeSys, err) } f.Websocket = stream.New() f.WebsocketResponseMaxLimit = exchange.DefaultWebsocketResponseMaxLimit f.WebsocketResponseCheckTimeout = exchange.DefaultWebsocketResponseCheckTimeout f.WebsocketOrderbookBufferLimit = exchange.DefaultWebsocketOrderbookBufferLimit } // Setup takes in the supplied exchange configuration details and sets params func (f *FTX) Setup(exch *config.Exchange) error { err := exch.Validate() if err != nil { return err } if !exch.Enabled { f.SetEnabled(false) return nil } err = f.SetupDefaults(exch) if err != nil { return err } wsEndpoint, err := f.API.Endpoints.GetURL(exchange.WebsocketSpot) if err != nil { return err } err = f.Websocket.Setup(&stream.WebsocketSetup{ ExchangeConfig: exch, DefaultURL: ftxWSURL, RunningURL: wsEndpoint, Connector: f.WsConnect, Subscriber: f.Subscribe, Unsubscriber: f.Unsubscribe, GenerateSubscriptions: f.GenerateDefaultSubscriptions, Features: &f.Features.Supports.WebsocketCapabilities, TradeFeed: f.Features.Enabled.TradeFeed, FillsFeed: f.Features.Enabled.FillsFeed, }) if err != nil { return err } if err = f.CurrencyPairs.IsAssetEnabled(asset.Futures); err == nil { err = f.LoadCollateralWeightings(context.TODO()) if err != nil { log.Errorf(log.ExchangeSys, "%s failed to store collateral weightings. Err: %s", f.Name, err) } } return f.Websocket.SetupNewConnection(stream.ConnectionSetup{ ResponseCheckTimeout: exch.WebsocketResponseCheckTimeout, ResponseMaxLimit: exch.WebsocketResponseMaxLimit, }) } // Start starts the FTX go routine func (f *FTX) Start(wg *sync.WaitGroup) error { if wg == nil { return fmt.Errorf("%T %w", wg, common.ErrNilPointer) } wg.Add(1) go func() { f.Run() wg.Done() }() return nil } // Run implements the FTX wrapper func (f *FTX) Run() { if f.Verbose { log.Debugf(log.ExchangeSys, "%s Websocket: %s.", f.Name, common.IsEnabled(f.Websocket.IsEnabled())) f.PrintEnabledPairs() } err := f.UpdateOrderExecutionLimits(context.TODO(), asset.Empty) if err != nil { log.Errorf(log.ExchangeSys, "%s failed to set exchange order execution limits. Err: %v", f.Name, err) } if !f.GetEnabledFeatures().AutoPairUpdates { return } err = f.UpdateTradablePairs(context.TODO(), false) if err != nil { log.Errorf(log.ExchangeSys, "%s failed to update tradable pairs. Err: %s", f.Name, err) } } // FetchTradablePairs returns a list of the exchanges tradable pairs func (f *FTX) FetchTradablePairs(ctx context.Context, a asset.Item) ([]string, error) { if !f.SupportsAsset(a) { return nil, fmt.Errorf("asset type of %s is not supported by %s", a, f.Name) } markets, err := f.GetMarkets(ctx) if err != nil { return nil, err } format, err := f.GetPairFormat(a, false) if err != nil { return nil, err } var pairs []string switch a { case asset.Spot: for x := range markets { if markets[x].MarketType == spotString { curr, err := currency.NewPairFromString(markets[x].Name) if err != nil { return nil, err } pairs = append(pairs, format.Format(curr)) } } case asset.Futures: for x := range markets { if markets[x].MarketType == futuresString { curr, err := currency.NewPairFromString(markets[x].Name) if err != nil { return nil, err } pairs = append(pairs, format.Format(curr)) } } } return pairs, nil } // UpdateTradablePairs updates the exchanges available pairs and stores // them in the exchanges config func (f *FTX) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error { assets := f.GetAssetTypes(false) for x := range assets { pairs, err := f.FetchTradablePairs(ctx, assets[x]) if err != nil { return err } p, err := currency.NewPairsFromStrings(pairs) if err != nil { return err } err = f.UpdatePairs(p, assets[x], false, forceUpdate) if err != nil { return err } } return nil } // UpdateTickers updates the ticker for all currency pairs of a given asset type func (f *FTX) UpdateTickers(ctx context.Context, a asset.Item) error { allPairs, err := f.GetEnabledPairs(a) if err != nil { return err } markets, err := f.GetMarkets(ctx) if err != nil { return err } for p := range allPairs { formattedPair, err := f.FormatExchangeCurrency(allPairs[p], a) if err != nil { return err } for x := range markets { if markets[x].Name != formattedPair.String() { continue } var resp ticker.Price resp.Pair, err = currency.NewPairFromString(markets[x].Name) if err != nil { return err } resp.Last = markets[x].Last resp.Bid = markets[x].Bid resp.Ask = markets[x].Ask resp.LastUpdated = time.Now() resp.AssetType = a resp.ExchangeName = f.Name err = ticker.ProcessTicker(&resp) if err != nil { return err } } } return nil } // UpdateTicker updates and returns the ticker for a currency pair func (f *FTX) UpdateTicker(ctx context.Context, p currency.Pair, a asset.Item) (*ticker.Price, error) { formattedPair, err := f.FormatExchangeCurrency(p, a) if err != nil { return nil, err } market, err := f.GetMarket(ctx, formattedPair.String()) if err != nil { return nil, err } var resp ticker.Price resp.Pair, err = currency.NewPairFromString(market.Name) if err != nil { return nil, err } resp.Last = market.Last resp.Bid = market.Bid resp.Ask = market.Ask resp.LastUpdated = time.Now() resp.AssetType = a resp.ExchangeName = f.Name err = ticker.ProcessTicker(&resp) if err != nil { return nil, err } return ticker.GetTicker(f.Name, p, a) } // FetchTicker returns the ticker for a currency pair func (f *FTX) FetchTicker(ctx context.Context, p currency.Pair, assetType asset.Item) (*ticker.Price, error) { tickerNew, err := ticker.GetTicker(f.Name, p, assetType) if err != nil { return f.UpdateTicker(ctx, p, assetType) } return tickerNew, nil } // FetchOrderbook returns orderbook base on the currency pair func (f *FTX) FetchOrderbook(ctx context.Context, c currency.Pair, assetType asset.Item) (*orderbook.Base, error) { ob, err := orderbook.Get(f.Name, c, assetType) if err != nil { return f.UpdateOrderbook(ctx, c, assetType) } return ob, nil } // UpdateOrderbook updates and returns the orderbook for a currency pair func (f *FTX) UpdateOrderbook(ctx context.Context, p currency.Pair, assetType asset.Item) (*orderbook.Base, error) { book := &orderbook.Base{ Exchange: f.Name, Pair: p, Asset: assetType, VerifyOrderbook: f.CanVerifyOrderbook, } formattedPair, err := f.FormatExchangeCurrency(p, assetType) if err != nil { return book, err } tempResp, err := f.GetOrderbook(ctx, formattedPair.String(), 100) if err != nil { return book, err } book.Bids = make(orderbook.Items, 0, len(tempResp.Bids)) for x := range tempResp.Bids { // Bear tokens have illiquid books and contain negative place holders. if tempResp.Bids[x].Size < 0 && strings.Contains(p.String(), "BEAR") { continue } book.Bids = append(book.Bids, orderbook.Item{ Amount: tempResp.Bids[x].Size, Price: tempResp.Bids[x].Price, }) } book.Asks = make(orderbook.Items, 0, len(tempResp.Asks)) for y := range tempResp.Asks { // Bear tokens have illiquid books and contain negative place holders. if tempResp.Asks[y].Size < 0 && strings.Contains(p.String(), "BEAR") { continue } book.Asks = append(book.Asks, orderbook.Item{ Amount: tempResp.Asks[y].Size, Price: tempResp.Asks[y].Price, }) } err = book.Process() if err != nil { return book, err } return orderbook.Get(f.Name, p, assetType) } // UpdateAccountInfo retrieves balances for all enabled currencies func (f *FTX) UpdateAccountInfo(ctx context.Context, a asset.Item) (account.Holdings, error) { creds, err := f.GetCredentials(ctx) if err != nil { return account.Holdings{}, err } var resp account.Holdings var data AllWalletBalances if creds.SubAccount != "" { balances, err := f.GetBalances(ctx, false, false) if err != nil { return resp, err } data = make(AllWalletBalances) data[creds.SubAccount] = balances } else { // Get all wallet balances used so we can transfer between accounts if // needed. var err error data, err = f.GetAllWalletBalances(ctx) if err != nil { return resp, err } } for subName, balances := range data { // "main" defines the main account in the sub account list var acc = account.SubAccount{ID: subName, AssetType: a} for x := range balances { // the Free field includes borrow amount with available holdings // Using AvailableWithoutBorrow allows for a more accurate picture of balance hold := balances[x].Total - balances[x].AvailableWithoutBorrow acc.Currencies = append(acc.Currencies, account.Balance{ CurrencyName: balances[x].Coin, Total: balances[x].Total, Hold: hold, AvailableWithoutBorrow: balances[x].AvailableWithoutBorrow, Borrowed: balances[x].SpotBorrow, Free: balances[x].Free, }) } resp.Accounts = append(resp.Accounts, acc) } resp.Exchange = f.Name if err := account.Process(&resp, creds); err != nil { return account.Holdings{}, err } return resp, nil } // FetchAccountInfo retrieves balances for all enabled currencies func (f *FTX) FetchAccountInfo(ctx context.Context, assetType asset.Item) (account.Holdings, error) { creds, err := f.GetCredentials(ctx) if err != nil { return account.Holdings{}, err } acc, err := account.GetHoldings(f.Name, creds, assetType) if err != nil { return f.UpdateAccountInfo(ctx, assetType) } return acc, nil } // GetFundingHistory returns funding history, deposits and // withdrawals func (f *FTX) GetFundingHistory(ctx context.Context) ([]exchange.FundHistory, error) { depositData, err := f.FetchDepositHistory(ctx) if err != nil { return nil, err } withdrawalData, err := f.FetchWithdrawalHistory(ctx) if err != nil { return nil, err } fundingData := make([]exchange.FundHistory, 0, len(depositData)+len(withdrawalData)) for x := range depositData { fundingData = append(fundingData, exchange.FundHistory{ Fee: depositData[x].Fee, Timestamp: depositData[x].Time, ExchangeName: f.Name, CryptoToAddress: depositData[x].Address.Address, CryptoTxID: depositData[x].TxID, CryptoChain: depositData[x].Address.Method, Status: depositData[x].Status, Amount: depositData[x].Size, Currency: depositData[x].Coin, TransferID: strconv.FormatInt(depositData[x].ID, 10), }) } for y := range withdrawalData { fundingData = append(fundingData, exchange.FundHistory{ Fee: withdrawalData[y].Fee, Timestamp: withdrawalData[y].Time, ExchangeName: f.Name, CryptoToAddress: withdrawalData[y].Address, CryptoTxID: withdrawalData[y].TXID, CryptoChain: withdrawalData[y].Method, Status: withdrawalData[y].Status, Amount: withdrawalData[y].Size, Currency: withdrawalData[y].Coin, TransferID: strconv.FormatInt(withdrawalData[y].ID, 10), }) } return fundingData, nil } // GetWithdrawalsHistory returns previous withdrawals data func (f *FTX) GetWithdrawalsHistory(ctx context.Context, c currency.Code, _ asset.Item) (resp []exchange.WithdrawalHistory, err error) { return nil, common.ErrNotYetImplemented } // GetRecentTrades returns the most recent trades for a currency and asset func (f *FTX) GetRecentTrades(ctx context.Context, p currency.Pair, assetType asset.Item) ([]trade.Data, error) { return f.GetHistoricTrades(ctx, p, assetType, time.Now().Add(-time.Minute*15), time.Now()) } // GetHistoricTrades returns historic trade data within the timeframe provided // FTX returns trades from the end date and iterates towards the start date func (f *FTX) GetHistoricTrades(ctx context.Context, p currency.Pair, assetType asset.Item, timestampStart, timestampEnd time.Time) ([]trade.Data, error) { if err := common.StartEndTimeCheck(timestampStart, timestampEnd); err != nil { return nil, fmt.Errorf("invalid time range supplied. Start: %v End %v %w", timestampStart, timestampEnd, err) } var err error p, err = f.FormatExchangeCurrency(p, assetType) if err != nil { return nil, err } endTime := timestampEnd var resp []trade.Data allTrades: for { var trades []TradeData trades, err = f.GetTrades(ctx, p.String(), timestampStart.Unix(), endTime.Unix(), 0) if err != nil { if errors.Is(err, errStartTimeCannotBeAfterEndTime) { break } return nil, err } if len(trades) == 0 { break } for i := 0; i < len(trades); i++ { if timestampStart.Equal(trades[i].Time) || trades[i].Time.Before(timestampStart) { // reached end of trades to crawl break allTrades } if trades[i].Time.After(endTime) { continue } var side order.Side side, err = order.StringToOrderSide(trades[i].Side) if err != nil { return nil, err } resp = append(resp, trade.Data{ TID: strconv.FormatInt(trades[i].ID, 10), Exchange: f.Name, CurrencyPair: p, AssetType: assetType, Side: side, Price: trades[i].Price, Amount: trades[i].Size, Timestamp: trades[i].Time, }) } endTime = trades[len(trades)-1].Time } err = f.AddTradesToBuffer(resp...) if err != nil { return nil, err } sort.Sort(trade.ByDate(resp)) return trade.FilterTradesByTime(resp, timestampStart, timestampEnd), nil } // SubmitOrder submits a new order func (f *FTX) SubmitOrder(ctx context.Context, s *order.Submit) (*order.SubmitResponse, error) { if err := s.Validate(); err != nil { return nil, err } if s.Side == order.Ask { s.Side = order.Sell } if s.Side == order.Bid { s.Side = order.Buy } fPair, err := f.FormatExchangeCurrency(s.Pair, s.AssetType) if err != nil { return nil, err } tempResp, err := f.Order(ctx, fPair.String(), s.Side.Lower(), s.Type.Lower(), s.ReduceOnly, s.ImmediateOrCancel, s.PostOnly, s.ClientOrderID, s.Price, s.Amount) if err != nil { return nil, err } return s.DeriveSubmitResponse(strconv.FormatInt(tempResp.ID, 10)) } // ModifyOrder will allow of changing orderbook placement and limit to // market conversion func (f *FTX) ModifyOrder(ctx context.Context, action *order.Modify) (*order.ModifyResponse, error) { if err := action.Validate(); err != nil { return nil, err } var id string var remainingAmount float64 switch { case action.TriggerPrice != 0: var a TriggerOrderData a, err := f.ModifyTriggerOrder(ctx, action.OrderID, action.Type.String(), action.Amount, action.TriggerPrice, action.Price, 0) if err != nil { return nil, err } id = strconv.FormatInt(a.ID, 10) remainingAmount = a.Size - a.FilledSize case action.OrderID == "": o, err := f.ModifyOrderByClientID(ctx, action.ClientOrderID, action.ClientOrderID, action.Price, action.Amount) if err != nil { return nil, err } id = strconv.FormatInt(o.ID, 10) remainingAmount = o.RemainingSize default: o, err := f.ModifyPlacedOrder(ctx, action.OrderID, action.ClientOrderID, action.Price, action.Amount) if err != nil { return nil, err } id = strconv.FormatInt(o.ID, 10) remainingAmount = o.RemainingSize } resp, err := action.DeriveModifyResponse() if err != nil { return nil, err } resp.OrderID = id resp.RemainingAmount = remainingAmount return resp, nil } // CancelOrder cancels an order by its corresponding ID number func (f *FTX) CancelOrder(ctx context.Context, o *order.Cancel) error { if err := o.Validate(o.StandardCancel()); err != nil { return err } if o.ClientOrderID != "" { _, err := f.DeleteOrderByClientID(ctx, o.ClientOrderID) return err } _, err := f.DeleteOrder(ctx, o.OrderID) return err } // CancelBatchOrders cancels an orders by their corresponding ID numbers func (f *FTX) CancelBatchOrders(ctx context.Context, o []order.Cancel) (order.CancelBatchResponse, error) { return order.CancelBatchResponse{}, common.ErrNotYetImplemented } // CancelAllOrders cancels all orders associated with a currency pair func (f *FTX) CancelAllOrders(ctx context.Context, orderCancellation *order.Cancel) (order.CancelAllResponse, error) { if err := orderCancellation.Validate(); err != nil { return order.CancelAllResponse{}, err } var resp order.CancelAllResponse formattedPair, err := f.FormatExchangeCurrency(orderCancellation.Pair, orderCancellation.AssetType) if err != nil { return resp, err } orders, err := f.GetOpenOrders(ctx, formattedPair.String()) if err != nil { return resp, err } tempMap := make(map[string]string) for x := range orders { _, err := f.DeleteOrder(ctx, strconv.FormatInt(orders[x].ID, 10)) if err != nil { tempMap[strconv.FormatInt(orders[x].ID, 10)] = "Cancellation Failed" continue } tempMap[strconv.FormatInt(orders[x].ID, 10)] = "Success" } resp.Status = tempMap return resp, nil } // GetCompatible gets compatible variables for order vars func (s *OrderData) GetCompatible(ctx context.Context, f *FTX) (OrderVars, error) { var resp OrderVars switch s.Side { case order.Buy.Lower(): resp.Side = order.Buy case order.Sell.Lower(): resp.Side = order.Sell default: resp.Side = order.UnknownSide } switch s.Status { case strings.ToLower(order.New.String()): resp.Status = order.New case strings.ToLower(order.Open.String()): resp.Status = order.Open case closedStatus: if s.FilledSize != 0 && s.FilledSize != s.Size { resp.Status = order.PartiallyCancelled } if s.FilledSize == 0 { resp.Status = order.Cancelled } if s.FilledSize == s.Size { resp.Status = order.Filled } default: resp.Status = order.AnyStatus } var feeBuilder exchange.FeeBuilder feeBuilder.PurchasePrice = s.AvgFillPrice feeBuilder.Amount = s.Size resp.OrderType = order.Market if strings.EqualFold(s.Type, order.Limit.String()) { resp.OrderType = order.Limit feeBuilder.IsMaker = true } fee, err := f.GetFee(ctx, &feeBuilder) if err != nil { return resp, err } resp.Fee = fee return resp, nil } // GetOrderInfo returns order information based on order ID func (f *FTX) GetOrderInfo(ctx context.Context, orderID string, _ currency.Pair, _ asset.Item) (order.Detail, error) { var resp order.Detail orderData, err := f.GetOrderStatus(ctx, orderID) if err != nil { return resp, err } orderAssetType, err := f.GetPairAssetType(orderData.Market) if err != nil { return resp, err } resp.OrderID = strconv.FormatInt(orderData.ID, 10) resp.Amount = orderData.Size resp.ClientOrderID = orderData.ClientID resp.Date = orderData.CreatedAt resp.Exchange = f.Name resp.ExecutedAmount = orderData.Size - orderData.RemainingSize resp.Pair = orderData.Market resp.AssetType = orderAssetType resp.Price = orderData.Price resp.RemainingAmount = orderData.RemainingSize orderVars, err := orderData.GetCompatible(ctx, f) if err != nil { return resp, err } resp.Status = orderVars.Status resp.Side = orderVars.Side resp.Type = orderVars.OrderType resp.Fee = orderVars.Fee return resp, nil } // GetDepositAddress returns a deposit address for a specified currency func (f *FTX) GetDepositAddress(ctx context.Context, cryptocurrency currency.Code, _, chain string) (*deposit.Address, error) { a, err := f.FetchDepositAddress(ctx, cryptocurrency, chain) if err != nil { return nil, err } return &deposit.Address{ Address: a.Address, Tag: a.Tag, }, nil } // WithdrawCryptocurrencyFunds returns a withdrawal ID when a withdrawal is // submitted func (f *FTX) WithdrawCryptocurrencyFunds(ctx context.Context, withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) { if err := withdrawRequest.Validate(); err != nil { return nil, err } resp, err := f.Withdraw(ctx, withdrawRequest.Currency, withdrawRequest.Crypto.Address, withdrawRequest.Crypto.AddressTag, withdrawRequest.TradePassword, withdrawRequest.Crypto.Chain, strconv.FormatInt(withdrawRequest.OneTimePassword, 10), withdrawRequest.Amount) if err != nil { return nil, err } return &withdraw.ExchangeResponse{ ID: strconv.FormatInt(resp.ID, 10), Status: resp.Status, }, nil } // WithdrawFiatFunds returns a withdrawal ID when a withdrawal is // submitted func (f *FTX) WithdrawFiatFunds(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) { return nil, common.ErrFunctionNotSupported } // WithdrawFiatFundsToInternationalBank returns a withdrawal ID when a // withdrawal is submitted func (f *FTX) WithdrawFiatFundsToInternationalBank(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) { return nil, common.ErrFunctionNotSupported } // GetWebsocket returns a pointer to the exchange websocket func (f *FTX) GetWebsocket() (*stream.Websocket, error) { return f.Websocket, nil } // GetActiveOrders retrieves any orders that are active/open func (f *FTX) GetActiveOrders(ctx context.Context, getOrdersRequest *order.GetOrdersRequest) ([]order.Detail, error) { if err := getOrdersRequest.Validate(); err != nil { return nil, err } var resp []order.Detail for x := range getOrdersRequest.Pairs { assetType, err := f.GetPairAssetType(getOrdersRequest.Pairs[x]) if err != nil { return resp, err } formattedPair, err := f.FormatExchangeCurrency(getOrdersRequest.Pairs[x], assetType) if err != nil { return nil, err } var tempResp order.Detail orderData, err := f.GetOpenOrders(ctx, formattedPair.String()) if err != nil { return resp, err } for y := range orderData { tempResp.OrderID = strconv.FormatInt(orderData[y].ID, 10) tempResp.Amount = orderData[y].Size tempResp.AssetType = assetType tempResp.ClientOrderID = orderData[y].ClientID tempResp.Date = orderData[y].CreatedAt tempResp.Exchange = f.Name tempResp.ExecutedAmount = orderData[y].Size - orderData[y].RemainingSize tempResp.Pair = orderData[y].Market tempResp.Price = orderData[y].Price tempResp.RemainingAmount = orderData[y].RemainingSize var orderVars OrderVars orderVars, err = f.compatibleOrderVars(ctx, orderData[y].Side, orderData[y].Status, orderData[y].Type, orderData[y].Size, orderData[y].FilledSize, orderData[y].AvgFillPrice) if err != nil { return resp, err } tempResp.Status = orderVars.Status tempResp.Side = orderVars.Side tempResp.Type = orderVars.OrderType tempResp.Fee = orderVars.Fee resp = append(resp, tempResp) } triggerOrderData, err := f.GetOpenTriggerOrders(ctx, formattedPair.String(), getOrdersRequest.Type.String()) if err != nil { return resp, err } for z := range triggerOrderData { var p currency.Pair p, err = currency.NewPairFromString(triggerOrderData[z].Market) if err != nil { return nil, err } tempResp.OrderID = strconv.FormatInt(triggerOrderData[z].ID, 10) tempResp.Amount = triggerOrderData[z].Size tempResp.AssetType = assetType tempResp.Date = triggerOrderData[z].CreatedAt tempResp.Exchange = f.Name tempResp.ExecutedAmount = triggerOrderData[z].FilledSize tempResp.Pair = p tempResp.Price = triggerOrderData[z].AvgFillPrice tempResp.RemainingAmount = triggerOrderData[z].Size - triggerOrderData[z].FilledSize tempResp.TriggerPrice = triggerOrderData[z].TriggerPrice orderVars, err := f.compatibleOrderVars(ctx, triggerOrderData[z].Side, triggerOrderData[z].Status, triggerOrderData[z].OrderType, triggerOrderData[z].Size, triggerOrderData[z].FilledSize, triggerOrderData[z].AvgFillPrice) if err != nil { return resp, err } tempResp.Status = orderVars.Status tempResp.Side = orderVars.Side tempResp.Type = orderVars.OrderType tempResp.Fee = orderVars.Fee resp = append(resp, tempResp) } } return resp, nil } // GetOrderHistory retrieves account order information // Can Limit response to specific order status func (f *FTX) GetOrderHistory(ctx context.Context, request *order.GetOrdersRequest) ([]order.Detail, error) { if err := request.Validate(); err != nil { return nil, err } var resp []order.Detail for x := range request.Pairs { var d order.Detail fp, err := f.FormatExchangeCurrency(request.Pairs[x], request.AssetType) if err != nil { return nil, err } history, err := f.FetchOrderHistory(ctx, fp.String(), request.StartTime, request.EndTime, "") if err != nil { return nil, err } for y := range history { d.OrderID = strconv.FormatInt(history[y].ID, 10) d.Amount = history[y].Size d.AssetType = request.AssetType d.AverageExecutedPrice = history[y].AvgFillPrice d.ClientOrderID = history[y].ClientID d.Date = history[y].CreatedAt d.Exchange = f.Name d.ExecutedAmount = history[y].Size - history[y].RemainingSize d.Pair = history[y].Market d.Price = history[y].Price d.RemainingAmount = history[y].RemainingSize var orderVars OrderVars orderVars, err = f.compatibleOrderVars(ctx, history[y].Side, history[y].Status, history[y].Type, history[y].Size, history[y].FilledSize, history[y].AvgFillPrice) if err != nil { return resp, err } d.Status = orderVars.Status d.Side = orderVars.Side d.Type = orderVars.OrderType d.Fee = orderVars.Fee resp = append(resp, d) } var side, t string if request.Side != order.UnknownSide { side = request.Side.Lower() } if request.Type != order.UnknownType { t = request.Type.Lower() } triggerOrderData, err := f.GetTriggerOrderHistory(ctx, fp.String(), request.StartTime, request.EndTime, side, t, "") if err != nil { return nil, err } for z := range triggerOrderData { var p currency.Pair p, err = currency.NewPairFromString(triggerOrderData[z].Market) if err != nil { return nil, err } d.OrderID = strconv.FormatInt(triggerOrderData[z].ID, 10) d.Amount = triggerOrderData[z].Size d.AssetType = request.AssetType d.Date = triggerOrderData[z].CreatedAt d.Exchange = f.Name d.ExecutedAmount = triggerOrderData[z].FilledSize d.Pair = p d.Price = triggerOrderData[z].AvgFillPrice d.RemainingAmount = triggerOrderData[z].Size - triggerOrderData[z].FilledSize d.TriggerPrice = triggerOrderData[z].TriggerPrice var orderVars OrderVars orderVars, err = f.compatibleOrderVars(ctx, triggerOrderData[z].Side, triggerOrderData[z].Status, triggerOrderData[z].OrderType, triggerOrderData[z].Size, triggerOrderData[z].FilledSize, triggerOrderData[z].AvgFillPrice) if err != nil { return nil, err } d.Status = orderVars.Status d.Side = orderVars.Side d.Type = orderVars.OrderType d.Fee = orderVars.Fee d.InferCostsAndTimes() resp = append(resp, d) } } return resp, nil } // GetFeeByType returns an estimate of fee based on the type of transaction func (f *FTX) GetFeeByType(ctx context.Context, feeBuilder *exchange.FeeBuilder) (float64, error) { if feeBuilder == nil { return 0, fmt.Errorf("%T %w", feeBuilder, common.ErrNilPointer) } return f.GetFee(ctx, feeBuilder) } // SubscribeToWebsocketChannels appends to ChannelsToSubscribe // which lets websocket.manageSubscriptions handle subscribing func (f *FTX) SubscribeToWebsocketChannels(channels []stream.ChannelSubscription) error { return f.Websocket.SubscribeToChannels(channels) } // UnsubscribeToWebsocketChannels removes from ChannelsToSubscribe // which lets websocket.manageSubscriptions handle unsubscribing func (f *FTX) UnsubscribeToWebsocketChannels(channels []stream.ChannelSubscription) error { return f.Websocket.UnsubscribeChannels(channels) } // AuthenticateWebsocket sends an authentication message to the websocket func (f *FTX) AuthenticateWebsocket(ctx context.Context) error { return f.WsAuth(ctx) } // ValidateCredentials validates current credentials used for wrapper // functionality func (f *FTX) ValidateCredentials(ctx context.Context, assetType asset.Item) error { _, err := f.UpdateAccountInfo(ctx, assetType) return f.CheckTransientError(err) } // GetHistoricCandles returns candles between a time period for a set time interval func (f *FTX) GetHistoricCandles(ctx context.Context, p currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { if err := f.ValidateKline(p, a, interval); err != nil { return kline.Item{}, err } formattedPair, err := f.FormatExchangeCurrency(p, a) if err != nil { return kline.Item{}, err } ohlcData, err := f.GetHistoricalData(ctx, formattedPair.String(), int64(interval.Duration().Seconds()), int64(f.Features.Enabled.Kline.ResultLimit), start, end) if err != nil { return kline.Item{}, err } ret := kline.Item{ Exchange: f.Name, Pair: p, Asset: a, Interval: interval, } for x := range ohlcData { ret.Candles = append(ret.Candles, kline.Candle{ Time: ohlcData[x].StartTime, Open: ohlcData[x].Open, High: ohlcData[x].High, Low: ohlcData[x].Low, Close: ohlcData[x].Close, Volume: ohlcData[x].Volume, }) } return ret, nil } // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (f *FTX) GetHistoricCandlesExtended(ctx context.Context, p currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { if err := f.ValidateKline(p, a, interval); err != nil { return kline.Item{}, err } ret := kline.Item{ Exchange: f.Name, Pair: p, Asset: a, Interval: interval, } dates, err := kline.CalculateCandleDateRanges(start, end, interval, f.Features.Enabled.Kline.ResultLimit) if err != nil { return kline.Item{}, err } formattedPair, err := f.FormatExchangeCurrency(p, a) if err != nil { return kline.Item{}, err } for x := range dates.Ranges { var ohlcData []OHLCVData ohlcData, err = f.GetHistoricalData(ctx, formattedPair.String(), int64(interval.Duration().Seconds()), int64(f.Features.Enabled.Kline.ResultLimit), dates.Ranges[x].Start.Time, dates.Ranges[x].End.Time) if err != nil { return kline.Item{}, err } for i := range ohlcData { ret.Candles = append(ret.Candles, kline.Candle{ Time: ohlcData[i].StartTime, Open: ohlcData[i].Open, High: ohlcData[i].High, Low: ohlcData[i].Low, Close: ohlcData[i].Close, Volume: ohlcData[i].Volume, }) } } dates.SetHasDataFromCandles(ret.Candles) summary := dates.DataSummary(false) if len(summary) > 0 { log.Warnf(log.ExchangeSys, "%v - %v", f.Name, summary) } ret.RemoveDuplicates() ret.RemoveOutsideRange(start, end) ret.SortCandlesByTimestamp(false) return ret, nil } // UpdateOrderExecutionLimits sets exchange executions for a required asset type func (f *FTX) UpdateOrderExecutionLimits(ctx context.Context, _ asset.Item) error { limits, err := f.FetchExchangeLimits(ctx) if err != nil { return fmt.Errorf("cannot update exchange execution limits: %w", err) } return f.LoadLimits(limits) } // GetAvailableTransferChains returns the available transfer blockchains for the specific // cryptocurrency func (f *FTX) GetAvailableTransferChains(ctx context.Context, cryptocurrency currency.Code) ([]string, error) { coins, err := f.GetCoins(ctx) if err != nil { return nil, err } var availableChains []string for x := range coins { if strings.EqualFold(coins[x].ID, cryptocurrency.String()) { for y := range coins[x].Methods { availableChains = append(availableChains, coins[x].Methods[y]) } } } return availableChains, nil } // CalculatePNL determines the PNL of a given position based on the PNLCalculatorRequest func (f *FTX) CalculatePNL(ctx context.Context, pnl *order.PNLCalculatorRequest) (*order.PNLResult, error) { if pnl == nil { return nil, fmt.Errorf("%v %w", f.Name, order.ErrNilPNLCalculator) } result := &order.PNLResult{ Time: pnl.Time, IsOrder: true, } creds, err := f.GetCredentials(ctx) if err != nil { return nil, err } if pnl.CalculateOffline { // PNLCalculator matches FTX's pnl calculation method calc := order.PNLCalculator{} result, err = calc.CalculatePNL(ctx, pnl) if err != nil { return nil, fmt.Errorf("%s %s %w", f.Name, creds.SubAccount, err) } } ep := pnl.EntryPrice.InexactFloat64() info, err := f.GetAccountInfo(ctx) if err != nil { return nil, err } if info.Liquidating || info.Collateral <= 0 { result.IsLiquidated = true return result, fmt.Errorf("%s %s %w", f.Name, creds.SubAccount, order.ErrPositionLiquidated) } for i := range info.Positions { if !pnl.Pair.Equal(info.Positions[i].Future) { continue } if info.Positions[i].EntryPrice != ep { continue } result.UnrealisedPNL = decimal.NewFromFloat(info.Positions[i].UnrealizedPNL) result.RealisedPNLBeforeFees = decimal.NewFromFloat(info.Positions[i].RealizedPNL) result.Price = decimal.NewFromFloat(info.Positions[i].Cost) return result, nil } // order no longer active, use offline calculation calc := order.PNLCalculator{} result, err = calc.CalculatePNL(ctx, pnl) if err != nil { return nil, fmt.Errorf("%s %s %w", f.Name, creds.SubAccount, err) } return result, nil } // ScaleCollateral takes your totals and scales them according to FTX's rules func (f *FTX) ScaleCollateral(ctx context.Context, calc *order.CollateralCalculator) (*order.CollateralByCurrency, error) { if calc.CalculateOffline { result := &order.CollateralByCurrency{ Currency: calc.CollateralCurrency, TotalFunds: calc.FreeCollateral.Add(calc.LockedCollateral), AvailableForUseAsCollateral: calc.FreeCollateral, FairMarketValue: calc.USDPrice, ScaledCurrency: currency.USD, UnrealisedPNL: calc.UnrealisedPNL, ScaledUsed: calc.LockedCollateral, } if calc.CollateralCurrency.Equal(currency.USD) { // FTX bases scales all collateral into USD amounts result.CollateralContribution = calc.FreeCollateral result.Weighting = decimal.NewFromInt(1) result.FairMarketValue = decimal.NewFromInt(1) return result, nil } result.ScaledCurrency = currency.USD if calc.USDPrice.IsZero() { return nil, fmt.Errorf("%s %s %w to scale collateral", f.Name, calc.CollateralCurrency, order.ErrUSDValueRequired) } if calc.FreeCollateral.IsZero() && calc.LockedCollateral.IsZero() { return result, nil } collateralWeight, ok := f.collateralWeight[calc.CollateralCurrency.Item] if !ok { return nil, fmt.Errorf("%s %s %w", f.Name, calc.CollateralCurrency, errCollateralCurrencyNotFound) } if calc.FreeCollateral.IsPositive() { if collateralWeight.InitialMarginFractionFactor == 0 { return nil, fmt.Errorf("%s %s %w", f.Name, calc.CollateralCurrency, errCollateralInitialMarginFractionMissing) } var scaling decimal.Decimal if calc.IsForNewPosition { scaling = decimal.NewFromFloat(collateralWeight.Initial) } else { scaling = decimal.NewFromFloat(collateralWeight.Total) } if scaling.IsZero() { result.SkipContribution = true } result.Weighting = scaling one := decimal.NewFromInt(1) freeSqrt := decimal.NewFromFloat(math.Sqrt(calc.FreeCollateral.InexactFloat64())) lockedSqrt := decimal.NewFromFloat(math.Sqrt(calc.LockedCollateral.InexactFloat64())) onePointOne := decimal.NewFromFloat(1.1) imf := decimal.NewFromFloat(collateralWeight.InitialMarginFractionFactor) freeWeight := onePointOne.Div(one.Add(imf.Mul(freeSqrt))) lockedWeight := onePointOne.Div(one.Add(imf.Mul(lockedSqrt))) result.CollateralContribution = calc.FreeCollateral.Mul(calc.USDPrice).Mul(decimal.Min(scaling, freeWeight)) result.ScaledUsed = calc.LockedCollateral.Mul(calc.USDPrice).Mul(decimal.Min(scaling, lockedWeight)) } else { result.CollateralContribution = calc.FreeCollateral.Mul(calc.USDPrice) result.ScaledUsed = calc.LockedCollateral.Mul(calc.USDPrice) } if !result.UnrealisedPNL.IsZero() && result.ScaledUsedBreakdown != nil { result.CollateralContribution = decimal.Min(result.CollateralContribution, result.CollateralContribution.Sub(result.UnrealisedPNL)).Sub(result.ScaledUsedBreakdown.LockedAsCollateral) } return result, nil } resp, err := f.calculateTotalCollateralOnline(ctx, &order.TotalCollateralCalculator{ CollateralAssets: []order.CollateralCalculator{*calc}, }, nil, ) if err != nil { return nil, err } if len(resp.BreakdownByCurrency) == 0 { return nil, fmt.Errorf("%v %v %w", f.Name, calc.CollateralCurrency, errCollateralCurrencyNotFound) } return &resp.BreakdownByCurrency[0], nil } // CalculateTotalCollateral scales collateral and determines how much collateral you can use for positions func (f *FTX) CalculateTotalCollateral(ctx context.Context, calc *order.TotalCollateralCalculator) (*order.TotalCollateralResponse, error) { if calc == nil { return nil, fmt.Errorf("%v CalculateTotalCollateral %w", f.Name, common.ErrNilPointer) } var pos []PositionData var err error if calc.FetchPositions { pos, err = f.GetPositions(ctx, true) if err != nil { return nil, fmt.Errorf("%v CalculateTotalCollateral GetPositions %w", f.Name, err) } } if !calc.CalculateOffline { return f.calculateTotalCollateralOnline(ctx, calc, pos) } result := order.TotalCollateralResponse{ CollateralCurrency: currency.USD, } for i := range calc.CollateralAssets { if len(pos) > 0 { // ensure we use supplied position data calc.CollateralAssets[i].UnrealisedPNL = decimal.Zero for j := range pos { if !pos[j].Future.Base.Equal(calc.CollateralAssets[i].CollateralCurrency) { continue } calc.CollateralAssets[i].UnrealisedPNL = calc.CollateralAssets[i].UnrealisedPNL.Add(decimal.NewFromFloat(pos[j].UnrealizedPNL)) } } var collateralByCurrency *order.CollateralByCurrency collateralByCurrency, err = f.ScaleCollateral(ctx, &calc.CollateralAssets[i]) if err != nil { if errors.Is(err, errCollateralCurrencyNotFound) { log.Error(log.ExchangeSys, err) continue } if errors.Is(err, order.ErrUSDValueRequired) { if collateralByCurrency == nil { return nil, err } collateralByCurrency.Error = err result.BreakdownByCurrency = append(result.BreakdownByCurrency, *collateralByCurrency) continue } return nil, err } result.AvailableCollateral = result.AvailableCollateral.Add(collateralByCurrency.CollateralContribution) result.UnrealisedPNL = result.UnrealisedPNL.Add(collateralByCurrency.UnrealisedPNL) if collateralByCurrency.SkipContribution { continue } result.UsedCollateral = result.UsedCollateral.Add(collateralByCurrency.ScaledUsed) result.BreakdownByCurrency = append(result.BreakdownByCurrency, *collateralByCurrency) } if !result.UnrealisedPNL.IsZero() && result.UsedBreakdown != nil { result.AvailableCollateral = decimal.Min(result.AvailableCollateral, result.AvailableCollateral.Add(result.UnrealisedPNL)).Sub(result.UsedBreakdown.LockedAsCollateral) } return &result, nil } func (f *FTX) calculateTotalCollateralOnline(ctx context.Context, calc *order.TotalCollateralCalculator, pos []PositionData) (*order.TotalCollateralResponse, error) { if calc == nil { return nil, fmt.Errorf("%v CalculateTotalCollateral %w", f.Name, common.ErrNilPointer) } if len(calc.CollateralAssets) == 0 { return nil, fmt.Errorf("%v calculateTotalCollateralOnline %w, no currencies supplied", f.Name, errCollateralCurrencyNotFound) } if calc.CalculateOffline { return nil, fmt.Errorf("%v calculateTotalCollateralOnline %w", f.Name, order.ErrOfflineCalculationSet) } c, err := f.GetCollateral(ctx, false) if err != nil { return nil, fmt.Errorf("%s %w", f.Name, err) } mc, err := f.GetCollateral(ctx, true) if err != nil { return nil, fmt.Errorf("%s %w", f.Name, err) } result := order.TotalCollateralResponse{ CollateralCurrency: currency.USD, AvailableCollateral: c.CollateralAvailable, AvailableMaintenanceCollateral: mc.CollateralAvailable, TotalValueOfPositiveSpotBalances: c.PositiveSpotBalanceTotal, CollateralContributedByPositiveSpotBalances: c.CollateralFromPositiveSpotBalances, } balances, err := f.GetBalances(ctx, true, true) if err != nil { return nil, fmt.Errorf("%s %w", f.Name, err) } for x := range calc.CollateralAssets { if calc.CollateralAssets[x].CalculateOffline { return nil, fmt.Errorf("%v %v %v calculateTotalCollateralOnline %w", f.Name, calc.CollateralAssets[x].Asset, calc.CollateralAssets[x].CollateralCurrency, order.ErrOfflineCalculationSet) } currencyBreakdown := order.CollateralByCurrency{ Currency: calc.CollateralAssets[x].CollateralCurrency, TotalFunds: calc.CollateralAssets[x].FreeCollateral.Add(calc.CollateralAssets[x].LockedCollateral), AvailableForUseAsCollateral: calc.CollateralAssets[x].FreeCollateral, ScaledCurrency: currency.USD, } if len(pos) > 0 { // use pos unrealisedPNL, not calc.collateralAssets' calc.CollateralAssets[x].UnrealisedPNL = decimal.Zero for i := range pos { if !pos[i].Future.Base.Equal(calc.CollateralAssets[x].CollateralCurrency) { continue } calc.CollateralAssets[x].UnrealisedPNL = calc.CollateralAssets[x].UnrealisedPNL.Add(decimal.NewFromFloat(pos[i].UnrealizedPNL)) } } currencyBreakdown.UnrealisedPNL = calc.CollateralAssets[x].UnrealisedPNL for y := range c.PositiveBalances { if !c.PositiveBalances[y].Coin.Equal(calc.CollateralAssets[x].CollateralCurrency) { continue } currencyBreakdown.Weighting = c.PositiveBalances[y].CollateralWeight currencyBreakdown.FairMarketValue = c.PositiveBalances[y].ApproximateFairMarketValue currencyBreakdown.CollateralContribution = c.PositiveBalances[y].AvailableIgnoringCollateral.Mul(c.PositiveBalances[y].ApproximateFairMarketValue).Mul(currencyBreakdown.Weighting) currencyBreakdown.AdditionalCollateralUsed = c.PositiveBalances[y].CollateralUsed currencyBreakdown.FairMarketValue = c.PositiveBalances[y].ApproximateFairMarketValue currencyBreakdown.AvailableForUseAsCollateral = c.PositiveBalances[y].AvailableIgnoringCollateral } for y := range c.NegativeBalances { if !c.NegativeBalances[y].Coin.Equal(calc.CollateralAssets[x].CollateralCurrency) { continue } currencyBreakdown.Weighting = c.NegativeBalances[y].CollateralWeight currencyBreakdown.FairMarketValue = c.NegativeBalances[y].ApproximateFairMarketValue currencyBreakdown.CollateralContribution = c.NegativeBalances[y].AvailableIgnoringCollateral.Mul(c.NegativeBalances[y].ApproximateFairMarketValue).Mul(currencyBreakdown.Weighting) currencyBreakdown.AdditionalCollateralUsed = c.NegativeBalances[y].CollateralUsed currencyBreakdown.FairMarketValue = c.NegativeBalances[y].ApproximateFairMarketValue currencyBreakdown.AvailableForUseAsCollateral = c.NegativeBalances[y].AvailableIgnoringCollateral } if currencyBreakdown.Weighting.IsZero() { currencyBreakdown.SkipContribution = true } for y := range balances { // used to determine how collateral is being used if !balances[y].Coin.Equal(calc.CollateralAssets[x].CollateralCurrency) { continue } // staked values are in their own currency, scale it lockedS := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedInStakes) lockedC := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedAsCollateral) lockedF := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedInFeeVoucher) lockedN := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedInNFTBids) lockedO := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedInSpotOrders) lockedFO := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedInSpotMarginFundingOffers) locked := decimal.Sum(lockedS, lockedC, lockedF, lockedN, lockedO, lockedFO) if !locked.IsZero() || balances[y].SpotBorrow > 0 { if result.UsedBreakdown == nil { result.UsedBreakdown = &order.UsedCollateralBreakdown{} } var resetWeightingToZero bool if currencyBreakdown.Weighting.IsZero() { // this is to ensure we're not hiding any locked values // when collateral contribution is zero (eg FTT with collateral disabled) resetWeightingToZero = true currencyBreakdown.Weighting = decimal.NewFromInt(1) } var resetFairMarketToZero bool if currencyBreakdown.FairMarketValue.IsZero() { // this is another edge case for SRM_LOCKED rendering locked data currencyBreakdown.SkipContribution = true resetFairMarketToZero = true currencyBreakdown.FairMarketValue = decimal.NewFromInt(1) } currencyBreakdown.ScaledUsedBreakdown = &order.UsedCollateralBreakdown{ LockedInStakes: lockedS.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting), LockedInNFTBids: lockedN.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting), LockedInFeeVoucher: lockedF.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting), LockedInSpotMarginFundingOffers: lockedFO.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting), LockedInSpotOrders: lockedO.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting), LockedAsCollateral: lockedC.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting), } if resetWeightingToZero { currencyBreakdown.Weighting = decimal.Zero } if resetFairMarketToZero { currencyBreakdown.FairMarketValue = decimal.Zero } currencyBreakdown.ScaledUsed = locked.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting) if balances[y].SpotBorrow > 0 { currencyBreakdown.ScaledUsedBreakdown.UsedInSpotMarginBorrows = currencyBreakdown.CollateralContribution.Abs().Add(currencyBreakdown.AdditionalCollateralUsed) currencyBreakdown.ScaledUsed = currencyBreakdown.ScaledUsed.Add(currencyBreakdown.ScaledUsedBreakdown.UsedInSpotMarginBorrows) } if !currencyBreakdown.SkipContribution { result.UsedCollateral = result.UsedCollateral.Add(currencyBreakdown.ScaledUsed) result.UsedBreakdown.LockedInStakes = result.UsedBreakdown.LockedInStakes.Add(currencyBreakdown.ScaledUsedBreakdown.LockedInStakes) result.UsedBreakdown.LockedAsCollateral = result.UsedBreakdown.LockedAsCollateral.Add(currencyBreakdown.ScaledUsedBreakdown.LockedAsCollateral) result.UsedBreakdown.LockedInFeeVoucher = result.UsedBreakdown.LockedInFeeVoucher.Add(currencyBreakdown.ScaledUsedBreakdown.LockedInFeeVoucher) result.UsedBreakdown.LockedInNFTBids = result.UsedBreakdown.LockedInNFTBids.Add(currencyBreakdown.ScaledUsedBreakdown.LockedInNFTBids) result.UsedBreakdown.LockedInSpotOrders = result.UsedBreakdown.LockedInSpotOrders.Add(currencyBreakdown.ScaledUsedBreakdown.LockedInSpotOrders) result.UsedBreakdown.LockedInSpotMarginFundingOffers = result.UsedBreakdown.LockedInSpotMarginFundingOffers.Add(currencyBreakdown.ScaledUsedBreakdown.LockedInSpotMarginFundingOffers) result.UsedBreakdown.UsedInSpotMarginBorrows = result.UsedBreakdown.UsedInSpotMarginBorrows.Add(currencyBreakdown.ScaledUsedBreakdown.UsedInSpotMarginBorrows) } } } if calc.CollateralAssets[x].CollateralCurrency.Equal(currency.USD) { for y := range c.Positions { if result.UsedBreakdown == nil { result.UsedBreakdown = &order.UsedCollateralBreakdown{} } result.UsedBreakdown.UsedInPositions = result.UsedBreakdown.UsedInPositions.Add(c.Positions[y].CollateralUsed) } } result.BreakdownByCurrency = append(result.BreakdownByCurrency, currencyBreakdown) } for y := range c.Positions { result.BreakdownOfPositions = append(result.BreakdownOfPositions, order.CollateralByPosition{ PositionCurrency: c.Positions[y].Future, Size: c.Positions[y].Size, OpenOrderSize: c.Positions[y].OpenOrderSize, PositionSize: c.Positions[y].PositionSize, MarkPrice: c.Positions[y].MarkPrice, RequiredMargin: c.Positions[y].RequiredMargin, CollateralUsed: c.Positions[y].CollateralUsed, }) } return &result, nil } // GetFuturesPositions returns futures positions based on supplied request func (f *FTX) GetFuturesPositions(ctx context.Context, request *order.PositionsRequest) ([]order.PositionDetails, error) { if request == nil { return nil, fmt.Errorf("%w position request", common.ErrNilPointer) } if !request.Asset.IsFutures() { return nil, fmt.Errorf("%w '%s'", order.ErrNotFuturesAsset, request.Asset) } if err := f.CurrencyPairs.IsAssetEnabled(request.Asset); err != nil { return nil, err } enabledPairs, err := f.CurrencyPairs.GetPairs(request.Asset, true) if err != nil { return nil, err } for i := range request.Pairs { if !enabledPairs.Contains(request.Pairs[i], false) { return nil, fmt.Errorf("%w %v", currency.ErrPairNotFound, request.Pairs[i]) } } positionsDetails := make([]order.PositionDetails, len(request.Pairs)) for x := range request.Pairs { fillsOrders := make(map[string]*order.Detail) endTime := time.Now() allPositions: for { var fills []FillsData fills, err = f.GetFills(ctx, request.Pairs[x], request.Asset, request.StartDate, endTime) if err != nil { return nil, err } if len(fills) == 0 { break allPositions } sort.Slice(fills, func(i, j int) bool { return fills[i].ID < (fills[j].ID) }) for y := range fills { if request.StartDate.Equal(fills[y].Time) || fills[y].Time.Before(request.StartDate) { // reached end of trades to crawl break allPositions } if fills[y].Time.After(endTime) { continue } var side order.Side side, err = order.StringToOrderSide(fills[y].Side) if err != nil { return nil, err } oID := strconv.FormatInt(fills[y].ID, 10) _, ok := fillsOrders[oID] if !ok { fillsOrders[oID] = &order.Detail{ Fee: fills[y].Fee, FeeAsset: fills[y].FeeCurrency, Pair: request.Pairs[x], Price: fills[y].Price, Amount: fills[y].Size, Exchange: f.Name, OrderID: oID, Side: side, Status: order.Filled, AssetType: request.Asset, Date: fills[y].Time, } } } if endTime.Equal(fills[len(fills)-1].Time) { break allPositions } endTime = fills[len(fills)-1].Time } var ods []order.Detail for _, v := range fillsOrders { ods = append(ods, *v) } sort.Slice(ods, func(i, j int) bool { return ods[i].OrderID < (ods[j].OrderID) }) positionsDetails[x] = order.PositionDetails{ Exchange: f.Name, Asset: request.Asset, Pair: enabledPairs[x], Orders: ods, } } return positionsDetails, nil } // GetCollateralCurrencyForContract returns the collateral currency for an asset and contract pair func (f *FTX) GetCollateralCurrencyForContract(_ asset.Item, _ currency.Pair) (currency.Code, asset.Item, error) { return currency.USD, asset.Futures, nil } // GetCurrencyForRealisedPNL returns where to put realised PNL func (f *FTX) GetCurrencyForRealisedPNL(_ asset.Item, _ currency.Pair) (currency.Code, asset.Item, error) { return currency.USD, asset.Spot, nil } // GetMarginRatesHistory gets the margin rate history for the given currency, asset, pair // Can also include borrow rates, or lending income/borrow payments func (f *FTX) GetMarginRatesHistory(ctx context.Context, request *margin.RateHistoryRequest) (*margin.RateHistoryResponse, error) { if request == nil { return nil, fmt.Errorf("%w funding rate request is nil", common.ErrNilPointer) } if request.Currency.IsEmpty() { return nil, fmt.Errorf("%w funding rate request is empty", currency.ErrCurrencyCodeEmpty) } pairs, err := f.GetEnabledPairs(request.Asset) if err != nil { return nil, err } if !pairs.ContainsCurrency(request.Currency) { return nil, fmt.Errorf("%w '%v' in enabled pairs", currency.ErrCurrencyNotFound, request.Currency) } err = common.StartEndTimeCheck(request.StartDate, request.EndDate) if err != nil { return nil, err } var ( one = decimal.NewFromInt(1) fiveHundred = decimal.NewFromInt(500) twentyFour = decimal.NewFromInt(24) threeSixFive = decimal.NewFromInt(365) takerFeeRate, averageBorrowSize, averageLendSize decimal.Decimal borrowSizeLen, lendSizeLen int64 ) switch { case request.CalculateOffline: takerFeeRate = request.TakeFeeRate case request.GetBorrowRates: var accountInfo AccountInfoData accountInfo, err = f.GetAccountInfo(ctx) if err != nil { return nil, err } takerFeeRate = decimal.NewFromFloat(accountInfo.TakerFee) } response := &margin.RateHistoryResponse{ TakerFeeRate: takerFeeRate, } if request.CalculateOffline { if len(request.Rates) == 0 { return nil, fmt.Errorf("%w calculation requires rates", common.ErrCannotCalculateOffline) } response.Rates = request.Rates } else { var responseRates []margin.Rate endDate := request.EndDate for { var rates []MarginTransactionHistoryData rates, err = f.GetMarginMarketLendingHistory(ctx, request.Currency, request.StartDate, endDate) if err != nil { return nil, err } if len(rates) == 0 || rates[len(rates)-1].Time.Equal(endDate) { break } for i := range rates { if !rates[i].Coin.Equal(request.Currency) { continue } rate := margin.Rate{ Time: rates[i].Time, HourlyRate: decimal.NewFromFloat(rates[i].Rate), MarketBorrowSize: decimal.NewFromFloat(rates[i].Size), } rate.YearlyRate = rate.HourlyRate.Mul(twentyFour.Mul(threeSixFive)) if request.GetBorrowRates { rate.HourlyBorrowRate = rate.HourlyRate.Mul(one.Add(fiveHundred.Mul(takerFeeRate))) rate.YearlyBorrowRate = rate.HourlyBorrowRate.Mul(twentyFour.Mul(threeSixFive)) } responseRates = append(responseRates, rate) } if rates[len(rates)-1].Time.Before(request.StartDate) { break } endDate = rates[len(rates)-1].Time } if len(responseRates) == 0 { return nil, fmt.Errorf("%w no rates returned between %v-%v", common.ErrNoResponse, request.StartDate, request.EndDate) } sort.Slice(responseRates, func(i, j int) bool { return responseRates[i].Time.Before(responseRates[j].Time) }) response.Rates = responseRates } if request.GetPredictedRate { if request.CalculateOffline { return nil, fmt.Errorf("%w predicted rate is online only", common.ErrCannotCalculateOffline) } var borrowRates []MarginFundingData borrowRates, err = f.GetMarginLendingRates(ctx) if err != nil { return nil, err } for i := range borrowRates { if !borrowRates[i].Coin.Equal(request.Currency) { continue } response.PredictedRate = margin.Rate{ Time: response.Rates[len(response.Rates)-1].Time.Add(time.Hour), HourlyRate: decimal.NewFromFloat(borrowRates[i].Estimate), } response.PredictedRate.YearlyRate = response.PredictedRate.HourlyRate.Mul(twentyFour.Mul(threeSixFive)) if request.GetBorrowRates { response.PredictedRate.HourlyBorrowRate = response.PredictedRate.HourlyRate.Mul(one.Add(fiveHundred.Mul(takerFeeRate))) response.PredictedRate.YearlyBorrowRate = response.PredictedRate.HourlyBorrowRate.Mul(twentyFour.Mul(threeSixFive)) } } } if request.GetLendingPayments { if request.CalculateOffline { if request.TakeFeeRate.IsZero() { return nil, fmt.Errorf("%w taker fee unset", common.ErrCannotCalculateOffline) } for i := range request.Rates { response.Rates[i].LendingPayment.Payment = response.Rates[i].HourlyRate.Mul(response.Rates[i].LendingPayment.Size) response.SumLendingPayments = response.SumLendingPayments.Add(response.Rates[i].LendingPayment.Payment) averageLendSize = averageLendSize.Add(response.Rates[i].LendingPayment.Size) lendSizeLen++ } } else { endDate := request.EndDate for { var payments []MarginTransactionHistoryData payments, err = f.GetMarginLendingHistory(ctx, request.Currency, request.StartDate, endDate) if err != nil { return nil, err } if len(payments) == 0 || payments[len(payments)-1].Time.Equal(endDate) { break } for i := range payments { if !payments[i].Coin.Equal(request.Currency) { continue } for j := range response.Rates { if !response.Rates[j].Time.Equal(payments[i].Time) { continue } response.Rates[j].LendingPayment.Payment = decimal.NewFromFloat(payments[i].Proceeds) response.Rates[j].LendingPayment.Size = decimal.NewFromFloat(payments[i].Size) response.SumLendingPayments = response.SumLendingPayments.Add(response.Rates[j].LendingPayment.Payment) averageLendSize = averageLendSize.Add(response.Rates[j].LendingPayment.Size) lendSizeLen++ break } } if payments[len(payments)-1].Time.Before(request.StartDate) { break } endDate = payments[len(payments)-1].Time } } } if request.GetBorrowCosts { if request.CalculateOffline { if request.TakeFeeRate.IsZero() { return nil, fmt.Errorf("%w taker fee unset", common.ErrCannotCalculateOffline) } for i := range request.Rates { response.Rates[i].HourlyBorrowRate = response.Rates[i].HourlyRate.Mul(one.Add(fiveHundred.Mul(takerFeeRate))) response.Rates[i].YearlyBorrowRate = response.Rates[i].HourlyBorrowRate.Mul(one.Add(fiveHundred.Mul(takerFeeRate))) response.Rates[i].BorrowCost.Cost = response.Rates[i].HourlyBorrowRate.Mul(response.Rates[i].BorrowCost.Size) response.SumBorrowCosts = response.SumBorrowCosts.Add(response.Rates[i].BorrowCost.Cost) averageBorrowSize = averageBorrowSize.Add(response.Rates[i].BorrowCost.Size) borrowSizeLen++ } } else { endDate := request.EndDate for { var costs []MarginTransactionHistoryData costs, err = f.GetMarginBorrowHistory(ctx, request.StartDate, endDate) if err != nil { return nil, err } if len(costs) == 0 || costs[len(costs)-1].Time.Equal(endDate) { break } for i := range costs { if !costs[i].Coin.Equal(request.Currency) { continue } for j := range response.Rates { if !response.Rates[j].Time.Equal(costs[i].Time) { continue } response.Rates[j].BorrowCost.Cost = decimal.NewFromFloat(costs[i].Cost) response.Rates[j].BorrowCost.Size = decimal.NewFromFloat(costs[i].Size) response.SumBorrowCosts = response.SumBorrowCosts.Add(response.Rates[j].BorrowCost.Cost) averageBorrowSize = averageBorrowSize.Add(response.Rates[j].BorrowCost.Size) borrowSizeLen++ break } } if costs[len(costs)-1].Time.Before(request.StartDate) { break } endDate = costs[len(costs)-1].Time } } } if borrowSizeLen > 0 { response.AverageBorrowSize = averageBorrowSize.Div(decimal.NewFromInt(borrowSizeLen)) } if lendSizeLen > 0 { response.AverageLendingSize = averageLendSize.Div(decimal.NewFromInt(lendSizeLen)) } return response, nil } // GetPositionSummary returns an overview of a future position func (f *FTX) GetPositionSummary(ctx context.Context, request *order.PositionSummaryRequest) (*order.PositionSummary, error) { if request == nil { return nil, fmt.Errorf("%w PositionSummaryRequest", common.ErrNilPointer) } if !request.Asset.IsFutures() { return nil, fmt.Errorf("%w '%s' is not a futures asset", asset.ErrNotSupported, request.Asset) } if err := f.CurrencyPairs.IsAssetEnabled(request.Asset); err != nil { return nil, err } if request.CalculateOffline { one := decimal.NewFromInt(1) positionSize := request.CurrentSize.Mul(request.CurrentPrice) var marginFraction decimal.Decimal if positionSize.IsPositive() && request.TotalCollateral.IsPositive() { marginFraction = request.TotalCollateral.Div(positionSize).Mul(decimal.NewFromFloat(100)) } breakEvenPrice := request.OpeningPrice if !request.OpeningSize.Equal(request.CurrentSize) { breakEvenPrice = request.OpeningPrice.Mul(request.OpeningSize).Sub(request.CurrentSize.Mul(request.CurrentPrice)).Div(request.OpeningSize.Sub(request.CurrentSize)) } var maintenanceMarginRequirement, positionMaintenanceMarginFraction decimal.Decimal currSize := request.CurrentSize openSize := request.OpeningSize if request.Leverage.LessThanOrEqual(decimal.NewFromFloat(20)) { positionMaintenanceMarginFraction = decimal.NewFromFloat(0.03) } else { // leverage can never be above 20, but will remain in event of change in policy positionMaintenanceMarginFraction = decimal.NewFromFloat(0.006) } // baseIMF is always 1/20 as 20 is the max leverage baseIMF := one.Div(decimal.NewFromInt(20)) maintenanceMarginRequirement = decimal.Max(positionMaintenanceMarginFraction, decimal.NewFromFloat(0.6).Mul(baseIMF)) if request.Direction.IsShort() { currSize = currSize.Neg() openSize = openSize.Neg() } imf := one.Div(request.Leverage) // estimated liquidation price is not included in offline summary // the formula does not match the API output - despite the example matching // see https://help.ftx.com/hc/en-us/articles/360027668712-Liquidations vs // https://docs.ftx.com/#get-account-information return &order.PositionSummary{ MaintenanceMarginRequirement: maintenanceMarginRequirement, InitialMarginRequirement: imf, CollateralUsed: request.CollateralUsed, MarkPrice: request.CurrentPrice, CurrentSize: request.CurrentSize.Abs(), BreakEvenPrice: breakEvenPrice, AverageOpenPrice: request.OpeningPrice, RecentPNL: request.CurrentPrice.Mul(currSize).Sub(request.OpeningPrice.Mul(openSize)), MarginFraction: marginFraction, FreeCollateral: request.FreeCollateral, TotalCollateral: request.TotalCollateral, }, nil } positions, err := f.GetPositions(ctx, true) if err != nil { return nil, err } acc, err := f.GetAccountInfo(ctx) if err != nil { return nil, err } for i := range positions { if !positions[i].Future.Equal(request.Pair) { continue } return &order.PositionSummary{ MaintenanceMarginRequirement: decimal.NewFromFloat(positions[i].MaintenanceMarginRequirement), InitialMarginRequirement: decimal.NewFromFloat(positions[i].InitialMarginRequirement), EstimatedLiquidationPrice: decimal.NewFromFloat(positions[i].EstimatedLiquidationPrice), CollateralUsed: decimal.NewFromFloat(positions[i].CollateralUsed), MarkPrice: decimal.NewFromFloat(positions[i].EntryPrice), CurrentSize: decimal.NewFromFloat(positions[i].Size), BreakEvenPrice: decimal.NewFromFloat(positions[i].RecentBreakEvenPrice), AverageOpenPrice: decimal.NewFromFloat(positions[i].RecentAverageOpenPrice), RecentPNL: decimal.NewFromFloat(positions[i].RecentPNL), MarginFraction: decimal.NewFromFloat(acc.MarginFraction * 100), FreeCollateral: decimal.NewFromFloat(acc.FreeCollateral), TotalCollateral: decimal.NewFromFloat(acc.Collateral), }, nil } return nil, fmt.Errorf("unable to calculate position summary %w for %v %v", order.ErrPositionNotFound, request.Asset, request.Pair) } // GetFundingRates returns stats about funding rates for pairs func (f *FTX) GetFundingRates(ctx context.Context, request *order.FundingRatesRequest) ([]order.FundingRates, error) { if request == nil { return nil, fmt.Errorf("%w FundingRatesRequest", common.ErrNilPointer) } if len(request.Pairs) == 0 { return nil, currency.ErrCurrencyPairsEmpty } var limit int64 = 1000 err := common.StartEndTimeCheck(request.StartDate, request.EndDate) if err != nil { return nil, err } pairFmt, err := f.GetPairFormat(request.Asset, true) if err != nil { return nil, err } request.Pairs = request.Pairs.Format(pairFmt.Delimiter, pairFmt.Index, pairFmt.Uppercase) response := make([]order.FundingRates, 0, len(request.Pairs)) for x := range request.Pairs { var isPerp bool isPerp, err = f.IsPerpetualFutureCurrency(request.Asset, request.Pairs[x]) if err != nil { return nil, err } if !isPerp { return nil, fmt.Errorf("%w '%v' '%v'", order.ErrNotPerpetualFuture, request.Asset, request.Pairs[x]) } var ( rates []FundingRatesData fundingDetails []FundingPaymentsData stats FutureStatsData ) pairResponse := order.FundingRates{ Exchange: f.Name, Asset: request.Asset, Pair: request.Pairs[x], StartDate: request.StartDate, EndDate: request.EndDate, } endTime := request.EndDate allRates: for { rates, err = f.FundingRates(ctx, request.StartDate, endTime, request.Pairs[x], limit) if err != nil { return nil, err } if len(rates) == 0 { break allRates } responseRates: for y := range rates { if rates[y].Time.Before(request.StartDate) { break allRates } if rates[y].Time.After(endTime) { continue } for z := range pairResponse.FundingRates { if rates[y].Time.Equal(pairResponse.FundingRates[z].Time) { continue responseRates } } pairResponse.FundingRates = append(pairResponse.FundingRates, order.FundingRate{ Rate: decimal.NewFromFloat(rates[y].Rate), Time: rates[y].Time, }) } if endTime.Equal(rates[len(rates)-1].Time) || int64(len(rates)) < limit { break allRates } endTime = rates[len(rates)-1].Time } if len(pairResponse.FundingRates) == 0 { continue } if request.IncludePayments { fundingDetails, err = f.getFundingPayments(ctx, request.StartDate, request.EndDate, request.Pairs[x], limit) if err != nil { return nil, err } for y := range fundingDetails { for z := range pairResponse.FundingRates { if !fundingDetails[y].Time.Equal(pairResponse.FundingRates[z].Time) { continue } pairResponse.FundingRates[z].Payment = decimal.NewFromFloat(fundingDetails[y].Payment) pairResponse.PaymentSum = pairResponse.PaymentSum.Add(decimal.NewFromFloat(fundingDetails[y].Payment)) break } } } if request.IncludePredictedRate { stats, err = f.GetFutureStats(ctx, request.Pairs[x]) if err != nil { return nil, err } upcoming := order.FundingRate{ Rate: decimal.NewFromFloat(stats.NextFundingRate), Time: stats.NextFundingTime, } pairResponse.PredictedUpcomingRate = upcoming } sort.Slice(pairResponse.FundingRates, func(i, j int) bool { return pairResponse.FundingRates[i].Time.Before(pairResponse.FundingRates[j].Time) }) pairResponse.LatestRate = pairResponse.FundingRates[len(pairResponse.FundingRates)-1] response = append(response, pairResponse) } return response, nil } func (f *FTX) getFundingPayments(ctx context.Context, startDate, endDate time.Time, future currency.Pair, limit int64) ([]FundingPaymentsData, error) { requestEndTime := endDate var payments []FundingPaymentsData allRates: for { fundingDetails, err := f.FundingPayments(ctx, startDate, requestEndTime, future, limit) if err != nil { return nil, err } if len(fundingDetails) == 0 { break allRates } responseRates: for x := range fundingDetails { if fundingDetails[x].Time.Before(startDate) { break allRates } if fundingDetails[x].Time.After(requestEndTime) { continue } for y := range payments { if fundingDetails[x].Time.Equal(payments[y].Time) { continue responseRates } } payments = append(payments, fundingDetails[x]) } if requestEndTime.Equal(fundingDetails[len(fundingDetails)-1].Time) || int64(len(fundingDetails)) < limit { break allRates } requestEndTime = fundingDetails[len(fundingDetails)-1].Time } return payments, nil } // IsPerpetualFutureCurrency returns whether a currency is a perpetual future func (f *FTX) IsPerpetualFutureCurrency(a asset.Item, cp currency.Pair) (bool, error) { if err := f.CurrencyPairs.IsAssetEnabled(a); err != nil { return false, err } pairs, err := f.GetEnabledPairs(a) if err != nil { return false, err } if !pairs.Contains(cp, false) { return false, fmt.Errorf("%w '%v'", currency.ErrPairNotFound, cp) } return cp.Quote.Equal(currency.PERP) && a.IsFutures(), nil }