package binance import ( "fmt" "time" "github.com/adshao/go-binance/v2/futures" "github.com/pkg/errors" "github.com/c9s/bbgo/pkg/fixedpoint" "github.com/c9s/bbgo/pkg/types" ) func toGlobalFuturesAccountInfo(account *futures.Account) *types.FuturesAccountInfo { return &types.FuturesAccountInfo{ Assets: toGlobalFuturesUserAssets(account.Assets), Positions: toGlobalFuturesPositions(account.Positions), TotalInitialMargin: fixedpoint.MustNewFromString(account.TotalInitialMargin), TotalMaintMargin: fixedpoint.MustNewFromString(account.TotalMaintMargin), TotalMarginBalance: fixedpoint.MustNewFromString(account.TotalMarginBalance), TotalOpenOrderInitialMargin: fixedpoint.MustNewFromString(account.TotalOpenOrderInitialMargin), TotalPositionInitialMargin: fixedpoint.MustNewFromString(account.TotalPositionInitialMargin), TotalUnrealizedProfit: fixedpoint.MustNewFromString(account.TotalUnrealizedProfit), TotalWalletBalance: fixedpoint.MustNewFromString(account.TotalWalletBalance), UpdateTime: account.UpdateTime, } } func toGlobalFuturesBalance(balances []*futures.Balance) types.BalanceMap { retBalances := make(types.BalanceMap) for _, balance := range balances { retBalances[balance.Asset] = types.Balance{ Currency: balance.Asset, Available: fixedpoint.MustNewFromString(balance.AvailableBalance), } } return retBalances } func toGlobalFuturesPositions(futuresPositions []*futures.AccountPosition) types.FuturesPositionMap { retFuturesPositions := make(types.FuturesPositionMap) for _, futuresPosition := range futuresPositions { retFuturesPositions[futuresPosition.Symbol] = types.FuturesPosition{ // TODO: types.FuturesPosition Isolated: futuresPosition.Isolated, AverageCost: fixedpoint.MustNewFromString(futuresPosition.EntryPrice), ApproximateAverageCost: fixedpoint.MustNewFromString(futuresPosition.EntryPrice), Base: fixedpoint.MustNewFromString(futuresPosition.PositionAmt), Quote: fixedpoint.MustNewFromString(futuresPosition.Notional), PositionRisk: &types.PositionRisk{ Leverage: fixedpoint.MustNewFromString(futuresPosition.Leverage), }, Symbol: futuresPosition.Symbol, UpdateTime: futuresPosition.UpdateTime, } } return retFuturesPositions } func toGlobalFuturesUserAssets(assets []*futures.AccountAsset) (retAssets types.FuturesAssetMap) { retFuturesAssets := make(types.FuturesAssetMap) for _, futuresAsset := range assets { retFuturesAssets[futuresAsset.Asset] = types.FuturesUserAsset{ Asset: futuresAsset.Asset, InitialMargin: fixedpoint.MustNewFromString(futuresAsset.InitialMargin), MaintMargin: fixedpoint.MustNewFromString(futuresAsset.MaintMargin), MarginBalance: fixedpoint.MustNewFromString(futuresAsset.MarginBalance), MaxWithdrawAmount: fixedpoint.MustNewFromString(futuresAsset.MaxWithdrawAmount), OpenOrderInitialMargin: fixedpoint.MustNewFromString(futuresAsset.OpenOrderInitialMargin), PositionInitialMargin: fixedpoint.MustNewFromString(futuresAsset.PositionInitialMargin), UnrealizedProfit: fixedpoint.MustNewFromString(futuresAsset.UnrealizedProfit), WalletBalance: fixedpoint.MustNewFromString(futuresAsset.WalletBalance), } } return retFuturesAssets } func toLocalFuturesOrderType(orderType types.OrderType) (futures.OrderType, error) { switch orderType { // case types.OrderTypeLimitMaker: // return futures.OrderTypeLimitMaker, nil //TODO case types.OrderTypeLimit, types.OrderTypeLimitMaker: return futures.OrderTypeLimit, nil // case types.OrderTypeStopLimit: // return futures.OrderTypeStopLossLimit, nil //TODO // case types.OrderTypeStopMarket: // return futures.OrderTypeStopLoss, nil //TODO case types.OrderTypeMarket: return futures.OrderTypeMarket, nil } return "", fmt.Errorf("can not convert to local order, order type %s not supported", orderType) } func toGlobalFuturesOrders(futuresOrders []*futures.Order, isIsolated bool) (orders []types.Order, err error) { for _, futuresOrder := range futuresOrders { order, err := toGlobalFuturesOrder(futuresOrder, isIsolated) if err != nil { return orders, err } orders = append(orders, *order) } return orders, err } func toGlobalFuturesOrder(futuresOrder *futures.Order, isIsolated bool) (*types.Order, error) { return &types.Order{ SubmitOrder: types.SubmitOrder{ ClientOrderID: futuresOrder.ClientOrderID, Symbol: futuresOrder.Symbol, Side: toGlobalFuturesSideType(futuresOrder.Side), Type: toGlobalFuturesOrderType(futuresOrder.Type), ReduceOnly: futuresOrder.ReduceOnly, ClosePosition: futuresOrder.ClosePosition, Quantity: fixedpoint.MustNewFromString(futuresOrder.OrigQuantity), Price: fixedpoint.MustNewFromString(futuresOrder.Price), TimeInForce: types.TimeInForce(futuresOrder.TimeInForce), }, Exchange: types.ExchangeBinance, OrderID: uint64(futuresOrder.OrderID), Status: toGlobalFuturesOrderStatus(futuresOrder.Status), ExecutedQuantity: fixedpoint.MustNewFromString(futuresOrder.ExecutedQuantity), CreationTime: types.Time(millisecondTime(futuresOrder.Time)), UpdateTime: types.Time(millisecondTime(futuresOrder.UpdateTime)), IsFutures: true, }, nil } func toGlobalFuturesTrade(t futures.AccountTrade) (*types.Trade, error) { // skip trade ID that is the same. however this should not happen var side types.SideType if t.Buyer { side = types.SideTypeBuy } else { side = types.SideTypeSell } price, err := fixedpoint.NewFromString(t.Price) if err != nil { return nil, errors.Wrapf(err, "price parse error, price: %+v", t.Price) } quantity, err := fixedpoint.NewFromString(t.Quantity) if err != nil { return nil, errors.Wrapf(err, "quantity parse error, quantity: %+v", t.Quantity) } var quoteQuantity fixedpoint.Value if len(t.QuoteQuantity) > 0 { quoteQuantity, err = fixedpoint.NewFromString(t.QuoteQuantity) if err != nil { return nil, errors.Wrapf(err, "quote quantity parse error, quoteQuantity: %+v", t.QuoteQuantity) } } else { quoteQuantity = price.Mul(quantity) } fee, err := fixedpoint.NewFromString(t.Commission) if err != nil { return nil, errors.Wrapf(err, "commission parse error, commission: %+v", t.Commission) } return &types.Trade{ ID: uint64(t.ID), OrderID: uint64(t.OrderID), Price: price, Symbol: t.Symbol, Exchange: "binance", Quantity: quantity, QuoteQuantity: quoteQuantity, Side: side, IsBuyer: t.Buyer, IsMaker: t.Maker, Fee: fee, FeeCurrency: t.CommissionAsset, Time: types.Time(millisecondTime(t.Time)), IsFutures: true, }, nil } func toGlobalFuturesSideType(side futures.SideType) types.SideType { switch side { case futures.SideTypeBuy: return types.SideTypeBuy case futures.SideTypeSell: return types.SideTypeSell default: log.Errorf("can not convert futures side type, unknown side type: %q", side) return "" } } func toGlobalFuturesOrderType(orderType futures.OrderType) types.OrderType { switch orderType { // FIXME: handle this order type // case futures.OrderTypeTrailingStopMarket: case futures.OrderTypeTakeProfit: return types.OrderTypeStopLimit case futures.OrderTypeTakeProfitMarket: return types.OrderTypeStopMarket case futures.OrderTypeStopMarket: return types.OrderTypeStopMarket case futures.OrderTypeLimit: return types.OrderTypeLimit case futures.OrderTypeMarket: return types.OrderTypeMarket default: log.Errorf("unsupported binance futures order type: %s", orderType) return "" } } func toGlobalFuturesOrderStatus(orderStatus futures.OrderStatusType) types.OrderStatus { switch orderStatus { case futures.OrderStatusTypeNew: return types.OrderStatusNew case futures.OrderStatusTypeRejected: return types.OrderStatusRejected case futures.OrderStatusTypeCanceled: return types.OrderStatusCanceled case futures.OrderStatusTypePartiallyFilled: return types.OrderStatusPartiallyFilled case futures.OrderStatusTypeFilled: return types.OrderStatusFilled } return types.OrderStatus(orderStatus) } func convertPremiumIndex(index *futures.PremiumIndex) (*types.PremiumIndex, error) { markPrice, err := fixedpoint.NewFromString(index.MarkPrice) if err != nil { return nil, err } lastFundingRate, err := fixedpoint.NewFromString(index.LastFundingRate) if err != nil { return nil, err } nextFundingTime := time.Unix(0, index.NextFundingTime*int64(time.Millisecond)) t := time.Unix(0, index.Time*int64(time.Millisecond)) return &types.PremiumIndex{ Symbol: index.Symbol, MarkPrice: markPrice, NextFundingTime: nextFundingTime, LastFundingRate: lastFundingRate, Time: t, }, nil } func convertPositionRisk(risk *futures.PositionRisk) (*types.PositionRisk, error) { leverage, err := fixedpoint.NewFromString(risk.Leverage) if err != nil { return nil, err } liquidationPrice, err := fixedpoint.NewFromString(risk.LiquidationPrice) if err != nil { return nil, err } return &types.PositionRisk{ Leverage: leverage, LiquidationPrice: liquidationPrice, }, nil }