Futures order position tracking & FTX scaled collateral calculation

cmd/gctcli/commands.go

@@ -4941,7 +4941,7 @@ var getCollateralCommand = &cli.Command{
 		&cli.BoolFlag{
 			Name:    "calculateoffline",
 			Aliases: []string{"c"},
-			Usage:   "use local scaling methods instead of requesting additional API information, depending on individual exchange support",
+			Usage:   "use local scaling calculations instead of requesting the collateral values directly, depending on individual exchange support",
 		},
 		&cli.BoolFlag{
 			Name:    "includebreakdown",

engine/rpcserver.go

@@ -69,6 +69,7 @@ var (
 	errCurrencyPairInvalid  = errors.New("currency provided is not found in the available pairs list")
 	errNoTrades             = errors.New("no trades returned from supplied params")
 	errNilRequestData       = errors.New("nil request data received, cannot continue")
+	errNoAccountInformation = errors.New("account information does not exist")
 )
 
 // RPCServer struct
@@ -4125,6 +4126,9 @@ func (s *RPCServer) GetFuturesPositions(ctx context.Context, r *gctrpc.GetFuture
 	if err != nil {
 		return nil, err
 	}
+	if !a.IsFutures() {
+		return nil, fmt.Errorf("%s %w", a, order.ErrNotFuturesAsset)
+	}
 	var start, end time.Time
 	if r.StartDate != "" {
 		start, err = time.Parse(common.SimpleTimeFormat, r.StartDate)
@@ -4168,7 +4172,10 @@ func (s *RPCServer) GetFuturesPositions(ctx context.Context, r *gctrpc.GetFuture
 	if err != nil {
 		return nil, err
 	}
-	response := &gctrpc.GetFuturesPositionsResponse{}
+	b := exch.GetBase()
+	response := &gctrpc.GetFuturesPositionsResponse{
+		SubAccount: b.API.Credentials.Subaccount,
+	}
 	var totalRealisedPNL, totalUnrealisedPNL decimal.Decimal
 	for i := range pos {
 		if r.PositionLimit > 0 && len(response.Positions) >= int(r.PositionLimit) {
@@ -4264,50 +4271,75 @@ func (s *RPCServer) GetCollateral(ctx context.Context, r *gctrpc.GetCollateralRe
 	if err != nil {
 		return nil, err
 	}
+	if !a.IsFutures() {
+		return nil, fmt.Errorf("%s %w", a, order.ErrNotFuturesAsset)
+	}
 	ai, err := exch.FetchAccountInfo(ctx, a)
 	if err != nil {
 		return nil, err
 	}
-
 	var calculators []order.CollateralCalculator
-	var acc account.SubAccount
+	var acc *account.SubAccount
 	if r.SubAccount != "" {
 		for i := range ai.Accounts {
 			if strings.EqualFold(r.SubAccount, ai.Accounts[i].ID) {
-				acc = ai.Accounts[i]
+				acc = &ai.Accounts[i]
 				break
 			}
 		}
 	} else if len(ai.Accounts) > 0 {
-		acc = ai.Accounts[0]
+		acc = &ai.Accounts[0]
+	}
+	if acc == nil {
+		return nil, fmt.Errorf("%w for %s %s and stored credentials", errNoAccountInformation, exch.GetName(), r.SubAccount)
 	}
 	for i := range acc.Currencies {
-		if acc.Currencies[i].TotalValue == 0 {
-			continue
-		}
-		calculators = append(calculators, order.CollateralCalculator{
+		cal := order.CollateralCalculator{
 			CalculateOffline:   r.CalculateOffline,
 			CollateralCurrency: acc.Currencies[i].CurrencyName,
 			Asset:              a,
 			CollateralAmount:   decimal.NewFromFloat(acc.Currencies[i].TotalValue),
-		})
+		}
+		if r.CalculateOffline && !acc.Currencies[i].CurrencyName.Match(currency.USD) {
+			var tick *ticker.Price
+			tick, err = exch.FetchTicker(ctx, currency.NewPair(acc.Currencies[i].CurrencyName, currency.USD), asset.Spot)
+			if err != nil {
+				log.Errorf(log.GRPCSys, fmt.Sprintf("GetCollateral offline calculation via FetchTicker %s %s", exch.GetName(), err))
+				continue
+			}
+			if tick.Last == 0 {
+				continue
+			}
+			cal.USDPrice = decimal.NewFromFloat(tick.Last)
+		}
+		calculators = append(calculators, cal)
 	}
 
 	collateral, err := exch.CalculateTotalCollateral(ctx, calculators)
 	if err != nil {
 		return nil, err
 	}
+	subAccount := r.SubAccount
+	if subAccount == "" {
+		b := exch.GetBase()
+		subAccount = b.API.Credentials.Subaccount
+	}
 
 	result := &gctrpc.GetCollateralResponse{
+		SubAccount:      subAccount,
 		TotalCollateral: collateral.TotalCollateral.String(),
 	}
 	if r.IncludeBreakdown {
 		for i := range collateral.BreakdownByCurrency {
-			result.CurrencyBreakdown = append(result.CurrencyBreakdown, &gctrpc.CollateralForCurrency{
+			cb := &gctrpc.CollateralForCurrency{
 				Currency:         collateral.BreakdownByCurrency[i].Currency.String(),
 				ScaledCollateral: collateral.BreakdownByCurrency[i].Amount.String(),
 				ScaledToCurrency: collateral.BreakdownByCurrency[i].ValueCurrency.String(),
-			})
+			}
+			if collateral.BreakdownByCurrency[i].Error != nil {
+				cb.Error = collateral.BreakdownByCurrency[i].Error.Error()
+			}
+			result.CurrencyBreakdown = append(result.CurrencyBreakdown, cb)
 		}
 	}
 	return result, nil

engine/rpcserver_test.go

@@ -2049,6 +2049,12 @@ func TestGetFuturesPositions(t *testing.T) {
 		Available:    currency.Pairs{cp},
 		Enabled:      currency.Pairs{cp},
 	}
+	b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
+		AssetEnabled: convert.BoolPtr(true),
+		ConfigFormat: &currency.PairFormat{},
+		Available:    currency.Pairs{cp},
+		Enabled:      currency.Pairs{cp},
+	}
 	fakeExchange := fExchange{
 		IBotExchange: exch,
 	}
@@ -2079,8 +2085,8 @@ func TestGetFuturesPositions(t *testing.T) {
 		},
 		Verbose: true,
 	})
-	if err != nil {
-		t.Error(err)
+	if !errors.Is(err, nil) {
+		t.Errorf("received '%v', expected '%v'", err, nil)
 	}
 	if r == nil {
 		t.Fatal("expected not nil response")
@@ -2091,6 +2097,20 @@ func TestGetFuturesPositions(t *testing.T) {
 	if r.TotalOrders != 1 {
 		t.Fatal("expected 1 order")
 	}
+
+	_, err = s.GetFuturesPositions(context.Background(), &gctrpc.GetFuturesPositionsRequest{
+		Exchange: fakeExchangeName,
+		Asset:    asset.Spot.String(),
+		Pair: &gctrpc.CurrencyPair{
+			Delimiter: currency.DashDelimiter,
+			Base:      cp.Base.String(),
+			Quote:     cp.Quote.String(),
+		},
+		Verbose: true,
+	})
+	if !errors.Is(err, order.ErrNotFuturesAsset) {
+		t.Errorf("received '%v', expected '%v'", err, order.ErrNotFuturesAsset)
+	}
 }
 
 func TestGetCollateral(t *testing.T) {
@@ -2116,6 +2136,12 @@ func TestGetCollateral(t *testing.T) {
 		Available:    currency.Pairs{cp},
 		Enabled:      currency.Pairs{cp},
 	}
+	b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
+		AssetEnabled: convert.BoolPtr(true),
+		ConfigFormat: &currency.PairFormat{},
+		Available:    currency.Pairs{cp},
+		Enabled:      currency.Pairs{cp},
+	}
 	fakeExchange := fExchange{
 		IBotExchange: exch,
 	}
@@ -2155,4 +2181,14 @@ func TestGetCollateral(t *testing.T) {
 	if r.TotalCollateral != "1337" {
 		t.Error("expected 1337")
 	}
+
+	_, err = s.GetCollateral(context.Background(), &gctrpc.GetCollateralRequest{
+		Exchange:         fakeExchangeName,
+		Asset:            asset.Spot.String(),
+		IncludeBreakdown: true,
+		SubAccount:       "1337",
+	})
+	if !errors.Is(err, order.ErrNotFuturesAsset) {
+		t.Errorf("received '%v', expected '%v'", err, order.ErrNotFuturesAsset)
+	}
 }

exchanges/ftx/ftx.go

@@ -40,6 +40,7 @@ const (
 	getHistoricalData    = "/markets/%s/candles"
 	getFutures           = "/futures"
 	getFuture            = "/futures/"
+	getExpiredFutures    = "/expired_futures"
 	getFutureStats       = "/futures/%s/stats"
 	getFundingRates      = "/funding_rates"
 	getIndexWeights      = "/indexes/%s/weights"
@@ -309,6 +310,36 @@ func (f *FTX) GetFutureStats(ctx context.Context, futureName string) (FutureStat
 	return resp.Data, f.SendHTTPRequest(ctx, exchange.RestSpot, fmt.Sprintf(getFutureStats, futureName), &resp)
 }
 
+// GetExpiredFuture returns information on an expired futures contract
+func (f *FTX) GetExpiredFuture(ctx context.Context, pair currency.Pair) (FuturesData, error) {
+	resp := struct {
+		Data []FuturesData `json:"result"`
+	}{}
+
+	p, err := f.FormatSymbol(pair, asset.Futures)
+	if err != nil {
+		return FuturesData{}, err
+	}
+	err = f.SendHTTPRequest(ctx, exchange.RestSpot, getExpiredFutures, &resp)
+	if err != nil {
+		return FuturesData{}, err
+	}
+	for i := range resp.Data {
+		if resp.Data[i].Name == p {
+			return resp.Data[i], nil
+		}
+	}
+	return FuturesData{}, fmt.Errorf("%s %s %w", f.Name, p, currency.ErrPairNotFound)
+}
+
+// GetExpiredFutures returns information on expired futures contracts
+func (f *FTX) GetExpiredFutures(ctx context.Context) ([]FuturesData, error) {
+	resp := struct {
+		Data []FuturesData `json:"result"`
+	}{}
+	return resp.Data, f.SendHTTPRequest(ctx, exchange.RestSpot, getExpiredFutures, &resp)
+}
+
 // GetFundingRates gets data on funding rates
 func (f *FTX) GetFundingRates(ctx context.Context, startTime, endTime time.Time, future string) ([]FundingRatesData, error) {
 	resp := struct {

exchanges/ftx/ftx_test.go

@@ -1774,7 +1774,8 @@ func TestScaleCollateral(t *testing.T) {
 				CalculateOffline:   true,
 			})
 			if err != nil {
-				if errors.Is(err, errCollateralCurrencyNotFound) {
+				if errors.Is(err, errCollateralCurrencyNotFound) ||
+					errors.Is(err, order.ErrUSDValueRequired) {
 					continue
 				}
 				t.Error(err)
@@ -1796,6 +1797,19 @@ func TestScaleCollateral(t *testing.T) {
 			}
 			liquidationScaling += scaled.InexactFloat64()
 
+			_, err = f.ScaleCollateral(context.Background(), &order.CollateralCalculator{
+				CollateralCurrency: currency.NewCode(coin),
+				Asset:              asset.Spot,
+				Side:               order.Buy,
+				CollateralAmount:   decimal.NewFromFloat(v[v2].Total),
+				USDPrice:           decimal.Zero,
+				IsLiquidating:      true,
+				CalculateOffline:   true,
+			})
+			if !errors.Is(err, order.ErrUSDValueRequired) {
+				t.Errorf("received '%v' exepected '%v'", err, order.ErrUSDValueRequired)
+			}
+
 			_, err = f.ScaleCollateral(context.Background(), &order.CollateralCalculator{
 				CollateralCurrency: currency.NewCode(coin),
 				Asset:              asset.Spot,
@@ -2017,3 +2031,19 @@ func TestCollateralWeightHasData(t *testing.T) {
 		t.Error("expected true")
 	}
 }
+
+func TestGetExpiredFutures(t *testing.T) {
+	t.Parallel()
+	_, err := f.GetExpiredFutures(context.Background())
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestGetExpiredFuture(t *testing.T) {
+	t.Parallel()
+	_, err := f.GetExpiredFuture(context.Background(), currency.NewPairWithDelimiter("BTC", "1231", "-"))
+	if err != nil {
+		t.Error(err)
+	}
+}