package grid2 import ( "context" "fmt" "math" "sort" "strconv" "strings" "sync" "time" "github.com/cenkalti/backoff/v4" "github.com/google/uuid" "github.com/pkg/errors" "github.com/prometheus/client_golang/prometheus" "github.com/sirupsen/logrus" "go.uber.org/multierr" "github.com/c9s/bbgo/pkg/bbgo" "github.com/c9s/bbgo/pkg/fixedpoint" "github.com/c9s/bbgo/pkg/types" "github.com/c9s/bbgo/pkg/util" ) const ID = "grid2" const orderTag = "grid2" var log = logrus.WithField("strategy", ID) const maxNumberOfOrderTradesQueryTries = 10 const historyRollbackDuration = 3 * 24 * time.Hour const historyRollbackOrderIdRange = 1000 const queryOrderTradesRetryDelay = 500 * time.Millisecond func init() { // Register the pointer of the strategy struct, // so that bbgo knows what struct to be used to unmarshal the configs (YAML or JSON) // Note: built-in strategies need to imported manually in the bbgo cmd package. bbgo.RegisterStrategy(ID, &Strategy{}) } type PrettyPins []Pin func (pp PrettyPins) String() string { var ss []string for _, p := range pp { price := fixedpoint.Value(p) ss = append(ss, price.String()) } return fmt.Sprintf("%v", ss) } //go:generate mockgen -destination=mocks/order_executor.go -package=mocks . OrderExecutor type OrderExecutor interface { SubmitOrders(ctx context.Context, submitOrders ...types.SubmitOrder) (types.OrderSlice, error) ClosePosition(ctx context.Context, percentage fixedpoint.Value, tags ...string) error GracefulCancel(ctx context.Context, orders ...types.Order) error ActiveMakerOrders() *bbgo.ActiveOrderBook } type advancedOrderCancelApi interface { CancelAllOrders(ctx context.Context) ([]types.Order, error) CancelOrdersBySymbol(ctx context.Context, symbol string) ([]types.Order, error) CancelOrdersByGroupID(ctx context.Context, groupID uint32) ([]types.Order, error) } //go:generate callbackgen -type Strategy type Strategy struct { Environment *bbgo.Environment // Market stores the configuration of the market, for example, VolumePrecision, PricePrecision, MinLotSize... etc // This field will be injected automatically since we defined the Symbol field. types.Market `json:"-"` // These fields will be filled from the config file (it translates YAML to JSON) Symbol string `json:"symbol"` // ProfitSpread is the fixed profit spread you want to submit the sell order // When ProfitSpread is enabled, the grid will shift up, e.g., // If you opened a grid with the price range 10_000 to 20_000 // With profit spread set to 3_000 // The sell orders will be placed in the range 13_000 to 23_000 // And the buy orders will be placed in the original price range 10_000 to 20_000 ProfitSpread fixedpoint.Value `json:"profitSpread"` // GridNum is the grid number, how many orders you want to post on the orderbook. GridNum int64 `json:"gridNumber"` AutoRange *types.SimpleDuration `json:"autoRange"` UpperPrice fixedpoint.Value `json:"upperPrice"` LowerPrice fixedpoint.Value `json:"lowerPrice"` // Compound option is used for buying more inventory when // the profit is made by the filled sell order. Compound bool `json:"compound"` // EarnBase option is used for earning profit in base currency. // e.g. earn BTC in BTCUSDT and earn ETH in ETHUSDT // instead of earn USDT in BTCUSD EarnBase bool `json:"earnBase"` // QuantityOrAmount embeds the Quantity field and the Amount field // If you set up the Quantity field or the Amount field, you don't need to set the QuoteInvestment and BaseInvestment bbgo.QuantityOrAmount // If Quantity and Amount is not set, we can use the quote investment to calculate our quantity. QuoteInvestment fixedpoint.Value `json:"quoteInvestment"` // BaseInvestment is the total base quantity you want to place as the sell order. BaseInvestment fixedpoint.Value `json:"baseInvestment"` TriggerPrice fixedpoint.Value `json:"triggerPrice"` StopLossPrice fixedpoint.Value `json:"stopLossPrice"` TakeProfitPrice fixedpoint.Value `json:"takeProfitPrice"` // CloseWhenCancelOrder option is used to close the grid if any of the order is canceled. // This option let you simply remote control the grid from the crypto exchange mobile app. CloseWhenCancelOrder bool `json:"closeWhenCancelOrder"` // KeepOrdersWhenShutdown option is used for keeping the grid orders when shutting down bbgo KeepOrdersWhenShutdown bool `json:"keepOrdersWhenShutdown"` // RecoverOrdersWhenStart option is used for recovering grid orders RecoverOrdersWhenStart bool `json:"recoverOrdersWhenStart"` // ClearOpenOrdersWhenStart // If this is set, when bbgo started, it will clear the open orders in the same market (by symbol) ClearOpenOrdersWhenStart bool `json:"clearOpenOrdersWhenStart"` ClearOpenOrdersIfMismatch bool `json:"clearOpenOrdersIfMismatch"` ClearDuplicatedPriceOpenOrders bool `json:"clearDuplicatedPriceOpenOrders"` // UseCancelAllOrdersApiWhenClose uses a different API to cancel all the orders on the market when closing a grid UseCancelAllOrdersApiWhenClose bool `json:"useCancelAllOrdersApiWhenClose"` // ResetPositionWhenStart resets the position when the strategy is started ResetPositionWhenStart bool `json:"resetPositionWhenStart"` // StopIfLessThanMinimalQuoteInvestment stops the strategy if the quote investment does not match StopIfLessThanMinimalQuoteInvestment bool `json:"stopIfLessThanMinimalQuoteInvestment"` OrderFillDelay types.Duration `json:"orderFillDelay"` // PrometheusLabels will be used as the base prometheus labels PrometheusLabels prometheus.Labels `json:"prometheusLabels"` // OrderGroupID is the group ID used for the strategy instance for canceling orders OrderGroupID uint32 `json:"orderGroupID"` LogFields logrus.Fields `json:"logFields"` // FeeRate is used for calculating the minimal profit spread. // it makes sure that your grid configuration is profitable. FeeRate fixedpoint.Value `json:"feeRate"` SkipSpreadCheck bool `json:"skipSpreadCheck"` RecoverGridByScanningTrades bool `json:"recoverGridByScanningTrades"` // Debug enables the debug mode Debug bool `json:"debug"` GridProfitStats *GridProfitStats `persistence:"grid_profit_stats"` Position *types.Position `persistence:"position"` // ExchangeSession is an injection field ExchangeSession *bbgo.ExchangeSession grid *Grid session *bbgo.ExchangeSession orderQueryService types.ExchangeOrderQueryService orderExecutor OrderExecutor historicalTrades *bbgo.TradeStore logger *logrus.Entry gridReadyCallbacks []func() gridProfitCallbacks []func(stats *GridProfitStats, profit *GridProfit) gridClosedCallbacks []func() gridErrorCallbacks []func(err error) // filledOrderIDMap is used to prevent processing the same order ID twice. filledOrderIDMap *types.SyncOrderMap // mu is used for locking the grid object field, avoid double grid opening mu sync.Mutex tradingCtx, writeCtx context.Context cancelWrite context.CancelFunc } func (s *Strategy) ID() string { return ID } func (s *Strategy) Validate() error { if s.AutoRange == nil { if s.UpperPrice.IsZero() { return errors.New("upperPrice can not be zero, you forgot to set?") } if s.LowerPrice.IsZero() { return errors.New("lowerPrice can not be zero, you forgot to set?") } if s.UpperPrice.Compare(s.LowerPrice) <= 0 { return fmt.Errorf("upperPrice (%s) should not be less than or equal to lowerPrice (%s)", s.UpperPrice.String(), s.LowerPrice.String()) } } if s.GridNum == 0 || s.GridNum == 1 { return fmt.Errorf("gridNum can not be zero or one") } if !s.SkipSpreadCheck { if err := s.checkSpread(); err != nil { return errors.Wrapf(err, "spread is too small, please try to reduce your gridNum or increase the price range (upperPrice and lowerPrice)") } } if !s.QuantityOrAmount.IsSet() && s.QuoteInvestment.IsZero() { return fmt.Errorf("either quantity, amount or quoteInvestment must be set") } return nil } func (s *Strategy) Defaults() error { if s.LogFields == nil { s.LogFields = logrus.Fields{} } s.LogFields["symbol"] = s.Symbol s.LogFields["strategy"] = ID return nil } func (s *Strategy) Initialize() error { s.filledOrderIDMap = types.NewSyncOrderMap() s.logger = log.WithFields(s.LogFields) return nil } func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) { session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: types.Interval1m}) if s.AutoRange != nil { interval := s.AutoRange.Interval() session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: interval}) } } // InstanceID returns the instance identifier from the current grid configuration parameters func (s *Strategy) InstanceID() string { id := fmt.Sprintf("%s-%s-size-%d", ID, s.Symbol, s.GridNum) if s.AutoRange != nil { id += "-autoRange-" + s.AutoRange.String() } else { id += "-" + s.UpperPrice.String() + "-" + s.LowerPrice.String() } return id } func (s *Strategy) checkSpread() error { gridNum := fixedpoint.NewFromInt(s.GridNum) spread := s.ProfitSpread if spread.IsZero() { spread = s.UpperPrice.Sub(s.LowerPrice).Div(gridNum) } feeRate := s.FeeRate if feeRate.IsZero() { feeRate = fixedpoint.NewFromFloat(0.075 * 0.01) } // the min fee rate from 2 maker/taker orders (with 0.1 rate for profit) gridFeeRate := feeRate.Mul(fixedpoint.NewFromFloat(2.01)) if spread.Div(s.LowerPrice).Compare(gridFeeRate) < 0 { return fmt.Errorf("profitSpread %f %s is too small for lower price, less than the grid fee rate: %s", spread.Float64(), spread.Div(s.LowerPrice).Percentage(), gridFeeRate.Percentage()) } if spread.Div(s.UpperPrice).Compare(gridFeeRate) < 0 { return fmt.Errorf("profitSpread %f %s is too small for upper price, less than the grid fee rate: %s", spread.Float64(), spread.Div(s.UpperPrice).Percentage(), gridFeeRate.Percentage()) } return nil } func (s *Strategy) handleOrderCanceled(o types.Order) { s.logger.Infof("GRID ORDER CANCELED: %s", o.String()) ctx := context.Background() if s.CloseWhenCancelOrder { s.logger.Infof("one of the grid orders is canceled, now closing grid...") if err := s.CloseGrid(ctx); err != nil { s.logger.WithError(err).Errorf("graceful order cancel error") } } } func (s *Strategy) calculateProfit(o types.Order, buyPrice, buyQuantity fixedpoint.Value) *GridProfit { if s.EarnBase { // sell quantity - buy quantity profitQuantity := o.Quantity.Sub(buyQuantity) profit := &GridProfit{ Currency: s.Market.BaseCurrency, Profit: profitQuantity, Time: o.UpdateTime.Time(), Order: o, } return profit } // earn quote // (sell_price - buy_price) * quantity profitQuantity := o.Price.Sub(buyPrice).Mul(o.Quantity) profit := &GridProfit{ Currency: s.Market.QuoteCurrency, Profit: profitQuantity, Time: o.UpdateTime.Time(), Order: o, } return profit } func (s *Strategy) verifyOrderTrades(o types.Order, trades []types.Trade) bool { tq := aggregateTradesQuantity(trades) if tq.Compare(o.Quantity) != 0 { s.logger.Warnf("order trades missing. expected: %s got: %s", o.Quantity.String(), tq.String()) return false } return true } // aggregateOrderFee collects the base fee quantity from the given order // it falls back to query the trades via the RESTful API when the websocket trades are not all received. func (s *Strategy) aggregateOrderFee(o types.Order) (fixedpoint.Value, string) { // try to get the received trades (websocket trades) orderTrades := s.historicalTrades.GetOrderTrades(o) if len(orderTrades) > 0 { s.logger.Infof("found filled order trades: %+v", orderTrades) } feeCurrency := s.Market.BaseCurrency if o.Side == types.SideTypeSell { feeCurrency = s.Market.QuoteCurrency } for maxTries := maxNumberOfOrderTradesQueryTries; maxTries > 0; maxTries-- { // if one of the trades is missing, we need to query the trades from the RESTful API if s.verifyOrderTrades(o, orderTrades) { // if trades are verified fees := collectTradeFee(orderTrades) if fee, ok := fees[feeCurrency]; ok { return fee, feeCurrency } return fixedpoint.Zero, feeCurrency } // if we don't support orderQueryService, then we should just skip if s.orderQueryService == nil { return fixedpoint.Zero, feeCurrency } s.logger.Warnf("missing order trades or missing trade fee of order #%d, pulling order trades from the RESTful API", o.OrderID) // if orderQueryService is supported, use it to query the trades of the filled order apiOrderTrades, err := s.orderQueryService.QueryOrderTrades(context.Background(), types.OrderQuery{ Symbol: o.Symbol, OrderID: strconv.FormatUint(o.OrderID, 10), }) if err != nil { s.logger.WithError(err).Errorf("query order #%d trades error", o.OrderID) } else { s.logger.Infof("fetched api trades of order #%d: %+v", o.OrderID, apiOrderTrades) orderTrades = apiOrderTrades } } return fixedpoint.Zero, feeCurrency } func (s *Strategy) processFilledOrder(o types.Order) { var profit *GridProfit = nil // check order fee newSide := types.SideTypeSell newPrice := o.Price newQuantity := o.Quantity executedPrice := o.Price /* if o.AveragePrice.Sign() > 0 { executedPrice = o.AveragePrice } */ // will be used for calculating quantity orderExecutedQuoteAmount := o.Quantity.Mul(executedPrice) // collect trades for fee // fee calculation is used to reduce the order quantity // because when 1.0 BTC buy order is filled without FEE token, then we will actually get 1.0 * (1 - feeRate) BTC // if we don't reduce the sell quantity, than we might fail to place the sell order fee, feeCurrency := s.aggregateOrderFee(o) s.logger.Infof("GRID ORDER #%d %s FEE: %s %s", o.OrderID, o.Side, fee.String(), feeCurrency) // do 1 time retry if fee.IsZero() || feeCurrency == "" { time.Sleep(queryOrderTradesRetryDelay) fee, feeCurrency = s.aggregateOrderFee(o) if !fee.IsZero() { s.logger.Infof("FIXED GRID ORDER #%d %s FEE: %s %s", o.OrderID, o.Side, fee.String(), feeCurrency) } } switch o.Side { case types.SideTypeSell: newSide = types.SideTypeBuy if !s.ProfitSpread.IsZero() { newPrice = newPrice.Sub(s.ProfitSpread) } else { if pin, ok := s.grid.NextLowerPin(newPrice); ok { newPrice = fixedpoint.Value(pin) } } // use the profit to buy more inventory in the grid if s.Compound || s.EarnBase { // if it's not using the platform fee currency, reduce the quote quantity for the buy order if feeCurrency == s.Market.QuoteCurrency { orderExecutedQuoteAmount = orderExecutedQuoteAmount.Sub(fee) } // for quote amount, always round down with price precision to prevent the quote currency fund locking rounding issue origQuoteAmount := orderExecutedQuoteAmount orderExecutedQuoteAmount = orderExecutedQuoteAmount.Round(s.Market.PricePrecision, fixedpoint.Down) s.logger.Infof("round down %s %s order quote quantity %s to %s by quote precision %d", s.Symbol, newSide, origQuoteAmount.String(), orderExecutedQuoteAmount.String(), s.Market.PricePrecision) newQuantity = orderExecutedQuoteAmount.Div(newPrice) origQuantity := newQuantity newQuantity = newQuantity.Round(s.Market.VolumePrecision, fixedpoint.Down) s.logger.Infof("round down %s %s order base quantity %s to %s by base precision %d", s.Symbol, newSide, origQuantity.String(), newQuantity.String(), s.Market.VolumePrecision) newQuantity = fixedpoint.Max(newQuantity, s.Market.MinQuantity) } else if s.QuantityOrAmount.Quantity.Sign() > 0 { newQuantity = s.QuantityOrAmount.Quantity } // TODO: need to consider sell order fee for the profit calculation profit = s.calculateProfit(o, newPrice, newQuantity) case types.SideTypeBuy: newSide = types.SideTypeSell if !s.ProfitSpread.IsZero() { newPrice = newPrice.Add(s.ProfitSpread) } else { if pin, ok := s.grid.NextHigherPin(newPrice); ok { newPrice = fixedpoint.Value(pin) } } if feeCurrency == s.Market.BaseCurrency { newQuantity = newQuantity.Sub(fee) } // if EarnBase is enabled, we should sell less to get the same quote amount back if s.EarnBase { newQuantity = fixedpoint.Max(orderExecutedQuoteAmount.Div(newPrice).Sub(fee), s.Market.MinQuantity) } // always round down the base quantity for placing sell order to avoid the base currency fund locking issue origQuantity := newQuantity newQuantity = newQuantity.Round(s.Market.VolumePrecision, fixedpoint.Down) s.logger.Infof("round down sell order quantity %s to %s by base quantity precision %d", origQuantity.String(), newQuantity.String(), s.Market.VolumePrecision) } orderForm := types.SubmitOrder{ Symbol: s.Symbol, Market: s.Market, Type: types.OrderTypeLimit, Price: newPrice, Side: newSide, TimeInForce: types.TimeInForceGTC, Quantity: newQuantity, Tag: orderTag, GroupID: s.OrderGroupID, ClientOrderID: s.newClientOrderID(), } s.logger.Infof("SUBMIT GRID REVERSE ORDER: %s", orderForm.String()) writeCtx := s.getWriteContext() createdOrders, err := s.orderExecutor.SubmitOrders(writeCtx, orderForm) if err != nil { s.logger.WithError(err).Errorf("GRID REVERSE ORDER SUBMISSION ERROR: order: %s", orderForm.String()) return } s.logger.Infof("GRID REVERSE ORDER IS CREATED: %+v", createdOrders) // we calculate profit only when the order is placed successfully if profit != nil { s.GridProfitStats.AddProfit(profit) s.logger.Infof("GENERATED GRID PROFIT: %+v; TOTAL GRID PROFIT BECOMES: %f", profit, s.GridProfitStats.TotalQuoteProfit.Float64()) s.EmitGridProfit(s.GridProfitStats, profit) } } // handleOrderFilled is called when an order status is FILLED func (s *Strategy) handleOrderFilled(o types.Order) { if s.grid == nil { s.logger.Warn("grid is not opened yet, skip order update event") return } if s.filledOrderIDMap.Exists(o.OrderID) { s.logger.Warnf("duplicated id (%d) of filled order detected", o.OrderID) return } s.filledOrderIDMap.Add(o) s.logger.Infof("GRID ORDER FILLED: %s", o.String()) s.updateFilledOrderMetrics(o) s.processFilledOrder(o) } func (s *Strategy) checkRequiredInvestmentByQuantity(baseBalance, quoteBalance, quantity, lastPrice fixedpoint.Value, pins []Pin) (requiredBase, requiredQuote fixedpoint.Value, err error) { // check more investment budget details requiredBase = fixedpoint.Zero requiredQuote = fixedpoint.Zero // when we need to place a buy-to-sell conversion order, we need to mark the price si := -1 for i := len(pins) - 1; i >= 0; i-- { pin := pins[i] price := fixedpoint.Value(pin) // TODO: add fee if we don't have the platform token. BNB, OKB or MAX... if price.Compare(lastPrice) >= 0 { si = i // for orders that sell // if we still have the base balance if requiredBase.Add(quantity).Compare(baseBalance) <= 0 { requiredBase = requiredBase.Add(quantity) } else if i > 0 { // we do not want to sell at i == 0 // convert sell to buy quote and add to requiredQuote nextLowerPin := pins[i-1] nextLowerPrice := fixedpoint.Value(nextLowerPin) requiredQuote = requiredQuote.Add(quantity.Mul(nextLowerPrice)) } } else { // for orders that buy if i+1 == si { continue } requiredQuote = requiredQuote.Add(quantity.Mul(price)) } } if requiredBase.Compare(baseBalance) > 0 && requiredQuote.Compare(quoteBalance) > 0 { return requiredBase, requiredQuote, fmt.Errorf("both base balance (%f %s) or quote balance (%f %s) is not enough, required = base %f + quote %f", baseBalance.Float64(), s.Market.BaseCurrency, quoteBalance.Float64(), s.Market.QuoteCurrency, requiredBase.Float64(), requiredQuote.Float64()) } if requiredBase.Compare(baseBalance) > 0 { return requiredBase, requiredQuote, fmt.Errorf("base balance (%f %s), required = base %f", baseBalance.Float64(), s.Market.BaseCurrency, requiredBase.Float64(), ) } if requiredQuote.Compare(quoteBalance) > 0 { return requiredBase, requiredQuote, fmt.Errorf("quote balance (%f %s) is not enough, required = quote %f", quoteBalance.Float64(), s.Market.QuoteCurrency, requiredQuote.Float64(), ) } return requiredBase, requiredQuote, nil } func (s *Strategy) checkRequiredInvestmentByAmount(baseBalance, quoteBalance, amount, lastPrice fixedpoint.Value, pins []Pin) (requiredBase, requiredQuote fixedpoint.Value, err error) { // check more investment budget details requiredBase = fixedpoint.Zero requiredQuote = fixedpoint.Zero // when we need to place a buy-to-sell conversion order, we need to mark the price si := -1 for i := len(pins) - 1; i >= 0; i-- { pin := pins[i] price := fixedpoint.Value(pin) // TODO: add fee if we don't have the platform token. BNB, OKB or MAX... if price.Compare(lastPrice) >= 0 { si = i // for orders that sell // if we still have the base balance quantity := amount.Div(lastPrice) if requiredBase.Add(quantity).Compare(baseBalance) <= 0 { requiredBase = requiredBase.Add(quantity) } else if i > 0 { // we do not want to sell at i == 0 // convert sell to buy quote and add to requiredQuote nextLowerPin := pins[i-1] nextLowerPrice := fixedpoint.Value(nextLowerPin) requiredQuote = requiredQuote.Add(quantity.Mul(nextLowerPrice)) } } else { // for orders that buy if s.ProfitSpread.IsZero() && i+1 == si { continue } requiredQuote = requiredQuote.Add(amount) } } if requiredBase.Compare(baseBalance) > 0 && requiredQuote.Compare(quoteBalance) > 0 { return requiredBase, requiredQuote, fmt.Errorf("both base balance (%f %s) or quote balance (%f %s) is not enough, required = base %f + quote %f", baseBalance.Float64(), s.Market.BaseCurrency, quoteBalance.Float64(), s.Market.QuoteCurrency, requiredBase.Float64(), requiredQuote.Float64()) } if requiredBase.Compare(baseBalance) > 0 { return requiredBase, requiredQuote, fmt.Errorf("base balance (%f %s), required = base %f", baseBalance.Float64(), s.Market.BaseCurrency, requiredBase.Float64(), ) } if requiredQuote.Compare(quoteBalance) > 0 { return requiredBase, requiredQuote, fmt.Errorf("quote balance (%f %s) is not enough, required = quote %f", quoteBalance.Float64(), s.Market.QuoteCurrency, requiredQuote.Float64(), ) } return requiredBase, requiredQuote, nil } func (s *Strategy) calculateQuoteInvestmentQuantity(quoteInvestment, lastPrice fixedpoint.Value, pins []Pin) (fixedpoint.Value, error) { // quoteInvestment = (p1 * q) + (p2 * q) + (p3 * q) + .... // => // quoteInvestment = (p1 + p2 + p3) * q // q = quoteInvestment / (p1 + p2 + p3) totalQuotePrice := fixedpoint.Zero si := len(pins) cntOrder := 0 for i := len(pins) - 1; i >= 0; i-- { pin := pins[i] price := fixedpoint.Value(pin) if price.Compare(lastPrice) >= 0 { si = i // do not place sell order on the bottom price if i == 0 { continue } // for orders that sell // if we still have the base balance // quantity := amount.Div(lastPrice) if s.ProfitSpread.Sign() > 0 { totalQuotePrice = totalQuotePrice.Add(price) } else { // we do not want to sell at i == 0 // convert sell to buy quote and add to requiredQuote nextLowerPin := pins[i-1] nextLowerPrice := fixedpoint.Value(nextLowerPin) totalQuotePrice = totalQuotePrice.Add(nextLowerPrice) } cntOrder++ } else { // for orders that buy if s.ProfitSpread.IsZero() && i+1 == si { continue } // should never place a buy order at the upper price if i == len(pins)-1 { continue } totalQuotePrice = totalQuotePrice.Add(price) cntOrder++ } } orderDusts := fixedpoint.NewFromFloat(math.Pow10(-s.Market.PricePrecision) * float64(cntOrder)) adjustedQuoteInvestment := quoteInvestment.Sub(orderDusts) q := adjustedQuoteInvestment.Div(totalQuotePrice) s.logger.Infof("calculateQuoteInvestmentQuantity: adjustedQuoteInvestment=%f sumOfPrice=%f quantity=%f", adjustedQuoteInvestment.Float64(), totalQuotePrice.Float64(), q.Float64()) return q, nil } func (s *Strategy) calculateBaseQuoteInvestmentQuantity(quoteInvestment, baseInvestment, lastPrice fixedpoint.Value, pins []Pin) (fixedpoint.Value, error) { s.logger.Infof("calculating quantity by base/quote investment: %f / %f", baseInvestment.Float64(), quoteInvestment.Float64()) // q_p1 = q_p2 = q_p3 = q_p4 // baseInvestment = q_p1 + q_p2 + q_p3 + q_p4 + .... // baseInvestment = numberOfSellOrders * q // maxBaseQuantity = baseInvestment / numberOfSellOrders // if maxBaseQuantity < minQuantity or maxBaseQuantity * priceLowest < minNotional // then reduce the numberOfSellOrders numberOfSellOrders := 0 for i := len(pins) - 1; i >= 0; i-- { pin := pins[i] price := fixedpoint.Value(pin) sellPrice := price if s.ProfitSpread.Sign() > 0 { sellPrice = sellPrice.Add(s.ProfitSpread) } if sellPrice.Compare(lastPrice) < 0 { break } numberOfSellOrders++ } // if the maxBaseQuantity is less than minQuantity, then we need to reduce the number of the sell orders // so that the quantity can be increased. maxNumberOfSellOrders := numberOfSellOrders + 1 minBaseQuantity := fixedpoint.Max(s.Market.MinNotional.Div(lastPrice), s.Market.MinQuantity) maxBaseQuantity := fixedpoint.Zero for maxBaseQuantity.Compare(s.Market.MinQuantity) <= 0 || maxBaseQuantity.Compare(minBaseQuantity) <= 0 { maxNumberOfSellOrders-- maxBaseQuantity = baseInvestment.Div(fixedpoint.NewFromInt(int64(maxNumberOfSellOrders))) } s.logger.Infof("grid base investment sell orders: %d", maxNumberOfSellOrders) if maxNumberOfSellOrders > 0 { s.logger.Infof("grid base investment quantity: %f (base investment) / %d (number of sell orders) = %f (base quantity per order)", baseInvestment.Float64(), maxNumberOfSellOrders, maxBaseQuantity.Float64()) } // calculate quantity with quote investment totalQuotePrice := fixedpoint.Zero // quoteInvestment = (p1 * q) + (p2 * q) + (p3 * q) + .... // => // quoteInvestment = (p1 + p2 + p3) * q // maxBuyQuantity = quoteInvestment / (p1 + p2 + p3) si := -1 for i := len(pins) - 1 - maxNumberOfSellOrders; i >= 0; i-- { pin := pins[i] price := fixedpoint.Value(pin) // buy price greater than the last price will trigger taker order. if price.Compare(lastPrice) >= 0 { si = i // when profit spread is set, we count all the grid prices as buy prices if s.ProfitSpread.Sign() > 0 { totalQuotePrice = totalQuotePrice.Add(price) } else if i > 0 { // when profit spread is not set // we do not want to place sell order at i == 0 // here we submit an order to convert a buy order into a sell order nextLowerPin := pins[i-1] nextLowerPrice := fixedpoint.Value(nextLowerPin) // requiredQuote = requiredQuote.Add(quantity.Mul(nextLowerPrice)) totalQuotePrice = totalQuotePrice.Add(nextLowerPrice) } } else { // for orders that buy if s.ProfitSpread.IsZero() && i+1 == si { continue } // should never place a buy order at the upper price if i == len(pins)-1 { continue } totalQuotePrice = totalQuotePrice.Add(price) } } quoteSideQuantity := quoteInvestment.Div(totalQuotePrice) if maxNumberOfSellOrders > 0 { return fixedpoint.Min(quoteSideQuantity, maxBaseQuantity), nil } return quoteSideQuantity, nil } func (s *Strategy) newTriggerPriceHandler(ctx context.Context, session *bbgo.ExchangeSession) types.KLineCallback { return types.KLineWith(s.Symbol, types.Interval1m, func(k types.KLine) { if s.TriggerPrice.Compare(k.High) > 0 || s.TriggerPrice.Compare(k.Low) < 0 { return } if s.grid != nil { return } s.logger.Infof("the last price %f hits triggerPrice %f, opening grid", k.Close.Float64(), s.TriggerPrice.Float64()) if err := s.openGrid(ctx, session); err != nil { s.logger.WithError(err).Errorf("failed to setup grid orders") return } }) } func (s *Strategy) newOrderUpdateHandler(ctx context.Context, session *bbgo.ExchangeSession) func(o types.Order) { return func(o types.Order) { if s.OrderFillDelay > 0 { time.Sleep(s.OrderFillDelay.Duration()) } s.handleOrderFilled(o) // sync the profits to redis bbgo.Sync(ctx, s) s.updateGridNumOfOrdersMetricsWithLock() s.updateOpenOrderPricesMetrics(s.orderExecutor.ActiveMakerOrders().Orders()) } } func (s *Strategy) newStopLossPriceHandler(ctx context.Context, session *bbgo.ExchangeSession) types.KLineCallback { return types.KLineWith(s.Symbol, types.Interval1m, func(k types.KLine) { if s.StopLossPrice.Compare(k.Low) < 0 { return } s.logger.Infof("last low price %f hits stopLossPrice %f, closing grid", k.Low.Float64(), s.StopLossPrice.Float64()) if err := s.CloseGrid(ctx); err != nil { s.logger.WithError(err).Errorf("can not close grid") return } base := s.Position.GetBase() if base.Sign() < 0 { return } s.logger.Infof("position base %f > 0, closing position...", base.Float64()) if err := s.orderExecutor.ClosePosition(ctx, fixedpoint.One, "grid2:stopLoss"); err != nil { s.logger.WithError(err).Errorf("can not close position") return } }) } func (s *Strategy) newTakeProfitHandler(ctx context.Context, session *bbgo.ExchangeSession) types.KLineCallback { return types.KLineWith(s.Symbol, types.Interval1m, func(k types.KLine) { if s.TakeProfitPrice.Compare(k.High) > 0 { return } s.logger.Infof("last high price %f hits takeProfitPrice %f, closing grid", k.High.Float64(), s.TakeProfitPrice.Float64()) if err := s.CloseGrid(ctx); err != nil { s.logger.WithError(err).Errorf("can not close grid") return } base := s.Position.GetBase() if base.Sign() < 0 { return } s.logger.Infof("position base %f > 0, closing position...", base.Float64()) if err := s.orderExecutor.ClosePosition(ctx, fixedpoint.One, "grid2:takeProfit"); err != nil { s.logger.WithError(err).Errorf("can not close position") return } }) } func (s *Strategy) OpenGrid(ctx context.Context) error { return s.openGrid(ctx, s.session) } // TODO: make sure the context here is the trading context or the shutdown context? func (s *Strategy) cancelAll(ctx context.Context) error { var werr error session := s.session if session == nil { session = s.ExchangeSession } service, support := session.Exchange.(advancedOrderCancelApi) if s.UseCancelAllOrdersApiWhenClose && !support { s.logger.Warnf("advancedOrderCancelApi interface is not implemented, fallback to default graceful cancel, exchange %T", session) s.UseCancelAllOrdersApiWhenClose = false } if s.UseCancelAllOrdersApiWhenClose { s.logger.Infof("useCancelAllOrdersApiWhenClose is set, using advanced order cancel api for canceling...") for { s.logger.Infof("checking %s open orders...", s.Symbol) openOrders, err := queryOpenOrdersUntilSuccessful(ctx, session.Exchange, s.Symbol) if err != nil { s.logger.WithError(err).Errorf("CancelOrdersByGroupID api call error") werr = multierr.Append(werr, err) } if len(openOrders) == 0 { break } s.logger.Infof("found %d open orders left, using cancel all orders api", len(openOrders)) s.logger.Infof("using cancal all orders api for canceling grid orders...") if err := cancelAllOrdersUntilSuccessful(ctx, service); err != nil { s.logger.WithError(err).Errorf("CancelAllOrders api call error") werr = multierr.Append(werr, err) } time.Sleep(1 * time.Second) } } else { if err := s.orderExecutor.GracefulCancel(ctx); err != nil { werr = multierr.Append(werr, err) } } return werr } // CloseGrid closes the grid orders func (s *Strategy) CloseGrid(ctx context.Context) error { s.logger.Infof("closing %s grid", s.Symbol) defer s.EmitGridClosed() bbgo.Sync(ctx, s) // now we can cancel the open orders s.logger.Infof("canceling grid orders...") err := s.cancelAll(ctx) // free the grid object s.setGrid(nil) s.updateGridNumOfOrdersMetricsWithLock() return err } func (s *Strategy) newGrid() *Grid { grid := NewGrid(s.LowerPrice, s.UpperPrice, fixedpoint.NewFromInt(s.GridNum), s.Market.TickSize) grid.CalculateArithmeticPins() return grid } // openGrid // 1) if quantity or amount is set, we should use quantity/amount directly instead of using investment amount to calculate. // 2) if baseInvestment, quoteInvestment is set, then we should calculate the quantity from the given base investment and quote investment. func (s *Strategy) openGrid(ctx context.Context, session *bbgo.ExchangeSession) error { // grid object guard s.mu.Lock() defer s.mu.Unlock() if s.grid != nil { return nil } grid := s.newGrid() s.grid = grid s.logger.Info("OPENING GRID: ", s.grid.String()) lastPrice, err := s.getLastTradePrice(ctx, session) if err != nil { return errors.Wrap(err, "failed to get the last trade price") } // check if base and quote are enough var totalBase = fixedpoint.Zero var totalQuote = fixedpoint.Zero baseBalance, ok := session.Account.Balance(s.Market.BaseCurrency) if ok { totalBase = baseBalance.Available } quoteBalance, ok := session.Account.Balance(s.Market.QuoteCurrency) if ok { totalQuote = quoteBalance.Available } // shift 1 grid because we will start from the buy order // if the buy order is filled, then we will submit another sell order at the higher grid. if s.QuantityOrAmount.IsSet() { if quantity := s.QuantityOrAmount.Quantity; !quantity.IsZero() { if _, _, err2 := s.checkRequiredInvestmentByQuantity(totalBase, totalQuote, lastPrice, s.QuantityOrAmount.Quantity, s.grid.Pins); err != nil { return err2 } } if amount := s.QuantityOrAmount.Amount; !amount.IsZero() { if _, _, err2 := s.checkRequiredInvestmentByAmount(totalBase, totalQuote, lastPrice, amount, s.grid.Pins); err != nil { return err2 } } } else { // calculate the quantity from the investment configuration if !s.QuoteInvestment.IsZero() && !s.BaseInvestment.IsZero() { quantity, err2 := s.calculateBaseQuoteInvestmentQuantity(s.QuoteInvestment, s.BaseInvestment, lastPrice, s.grid.Pins) if err2 != nil { return err2 } s.QuantityOrAmount.Quantity = quantity } else if !s.QuoteInvestment.IsZero() { quantity, err2 := s.calculateQuoteInvestmentQuantity(s.QuoteInvestment, lastPrice, s.grid.Pins) if err2 != nil { return err2 } s.QuantityOrAmount.Quantity = quantity } } // if base investment and quote investment is set, when we should check if the // investment configuration is valid with the current balances if !s.BaseInvestment.IsZero() && !s.QuoteInvestment.IsZero() { if s.BaseInvestment.Compare(totalBase) > 0 { return fmt.Errorf("baseInvestment setup %f is greater than the total base balance %f", s.BaseInvestment.Float64(), totalBase.Float64()) } if s.QuoteInvestment.Compare(totalQuote) > 0 { return fmt.Errorf("quoteInvestment setup %f is greater than the total quote balance %f", s.QuoteInvestment.Float64(), totalQuote.Float64()) } } var submitOrders []types.SubmitOrder if !s.BaseInvestment.IsZero() || !s.QuoteInvestment.IsZero() { submitOrders, err = s.generateGridOrders(s.QuoteInvestment, s.BaseInvestment, lastPrice) } else { submitOrders, err = s.generateGridOrders(totalQuote, totalBase, lastPrice) } if err != nil { return err } s.debugGridOrders(submitOrders, lastPrice) writeCtx := s.getWriteContext(ctx) createdOrders, err2 := s.orderExecutor.SubmitOrders(writeCtx, submitOrders...) if err2 != nil { return err2 } // try to always emit grid ready defer s.EmitGridReady() // update the number of orders to metrics baseLabels := s.newPrometheusLabels() metricsGridNumOfOrders.With(baseLabels).Set(float64(len(createdOrders))) var orderIds []uint64 for _, order := range createdOrders { orderIds = append(orderIds, order.OrderID) s.logger.Info(order.String()) } sort.Slice(orderIds, func(i, j int) bool { return orderIds[i] < orderIds[j] }) if len(orderIds) > 0 { s.GridProfitStats.InitialOrderID = orderIds[0] bbgo.Sync(ctx, s) } s.logger.Infof("ALL GRID ORDERS SUBMITTED") s.updateGridNumOfOrdersMetrics(grid) s.updateOpenOrderPricesMetrics(createdOrders) return nil } func (s *Strategy) updateFilledOrderMetrics(order types.Order) { labels := s.newPrometheusLabels() labels["side"] = order.Side.String() metricsGridFilledOrderPrice.With(labels).Set(order.Price.Float64()) } func (s *Strategy) updateGridNumOfOrdersMetricsWithLock() { s.updateGridNumOfOrdersMetrics(s.getGrid()) } func (s *Strategy) updateGridNumOfOrdersMetrics(grid *Grid) { baseLabels := s.newPrometheusLabels() makerOrders := s.orderExecutor.ActiveMakerOrders() numOfOrders := makerOrders.NumOfOrders() metricsGridNumOfOrders.With(baseLabels).Set(float64(numOfOrders)) metricsGridLowerPrice.With(baseLabels).Set(s.LowerPrice.Float64()) metricsGridUpperPrice.With(baseLabels).Set(s.UpperPrice.Float64()) metricsGridQuoteInvestment.With(baseLabels).Set(s.QuoteInvestment.Float64()) metricsGridBaseInvestment.With(baseLabels).Set(s.BaseInvestment.Float64()) if grid != nil { gridNum := grid.Size.Int() metricsGridNum.With(baseLabels).Set(float64(gridNum)) numOfMissingOrders := gridNum - 1 - numOfOrders metricsGridNumOfMissingOrders.With(baseLabels).Set(float64(numOfMissingOrders)) var numOfOrdersWithCorrectPrice int priceSet := make(map[fixedpoint.Value]struct{}) for _, order := range makerOrders.Orders() { // filter out duplicated prices if _, ok := priceSet[order.Price]; ok { continue } priceSet[order.Price] = struct{}{} if grid.HasPin(Pin(order.Price)) { numOfOrdersWithCorrectPrice++ } } numOfMissingOrdersWithCorrectPrice := gridNum - 1 - numOfOrdersWithCorrectPrice metricsGridNumOfOrdersWithCorrectPrice.With(baseLabels).Set(float64(numOfOrdersWithCorrectPrice)) metricsGridNumOfMissingOrdersWithCorrectPrice.With(baseLabels).Set(float64(numOfMissingOrdersWithCorrectPrice)) } } func (s *Strategy) updateOpenOrderPricesMetrics(orders []types.Order) { orders = sortOrdersByPriceAscending(orders) num := len(orders) s.deleteOpenOrderPricesMetrics() for idx, order := range orders { labels := s.newPrometheusLabels() labels["side"] = order.Side.String() labels["ith"] = strconv.Itoa(num - idx) metricsGridOrderPrices.With(labels).Set(order.Price.Float64()) } } func (s *Strategy) deleteOpenOrderPricesMetrics() { for i := 1; i <= int(s.GridNum); i++ { ithStr := strconv.Itoa(i) labels := s.newPrometheusLabels() labels["side"] = "BUY" labels["ith"] = ithStr metricsGridOrderPrices.Delete(labels) labels = s.newPrometheusLabels() labels["side"] = "SELL" labels["ith"] = ithStr metricsGridOrderPrices.Delete(labels) } } func sortOrdersByPriceAscending(orders []types.Order) []types.Order { sort.Slice(orders, func(i, j int) bool { a := orders[i] b := orders[j] return a.Price.Compare(b.Price) < 0 }) return orders } func (s *Strategy) debugGridOrders(submitOrders []types.SubmitOrder, lastPrice fixedpoint.Value) { if !s.Debug { return } var sb strings.Builder sb.WriteString("GRID ORDERS [\n") for i, order := range submitOrders { if i > 0 && lastPrice.Compare(order.Price) >= 0 && lastPrice.Compare(submitOrders[i-1].Price) <= 0 { sb.WriteString(fmt.Sprintf(" - LAST PRICE: %f\n", lastPrice.Float64())) } sb.WriteString(" - " + order.String() + "\n") } sb.WriteString("] END OF GRID ORDERS") s.logger.Infof(sb.String()) } func (s *Strategy) debugOrders(desc string, orders []types.Order) { if !s.Debug { return } var sb strings.Builder if desc == "" { desc = "ORDERS" } sb.WriteString(desc + " [\n") for i, order := range orders { sb.WriteString(fmt.Sprintf(" - %d) %s\n", i, order.String())) } sb.WriteString("]") s.logger.Infof(sb.String()) } func (s *Strategy) debugLog(format string, args ...interface{}) { if !s.Debug { return } s.logger.Infof(format, args...) } func (s *Strategy) generateGridOrders(totalQuote, totalBase, lastPrice fixedpoint.Value) ([]types.SubmitOrder, error) { var pins = s.grid.Pins var usedBase = fixedpoint.Zero var usedQuote = fixedpoint.Zero var submitOrders []types.SubmitOrder // si is for sell order price index var si = len(pins) for i := len(pins) - 1; i >= 0; i-- { pin := pins[i] price := fixedpoint.Value(pin) sellPrice := price // when profitSpread is set, the sell price is shift upper with the given spread if s.ProfitSpread.Sign() > 0 { sellPrice = sellPrice.Add(s.ProfitSpread) } quantity := s.QuantityOrAmount.Quantity if quantity.IsZero() { quantity = s.QuantityOrAmount.Amount.Div(price) } // TODO: add fee if we don't have the platform token. BNB, OKB or MAX... if price.Compare(lastPrice) >= 0 { si = i // do not place sell order when i == 0 if i == 0 { continue } if usedBase.Add(quantity).Compare(totalBase) < 0 { submitOrders = append(submitOrders, types.SubmitOrder{ Symbol: s.Symbol, Type: types.OrderTypeLimit, Side: types.SideTypeSell, Price: sellPrice, Quantity: quantity, Market: s.Market, TimeInForce: types.TimeInForceGTC, Tag: orderTag, GroupID: s.OrderGroupID, ClientOrderID: s.newClientOrderID(), }) usedBase = usedBase.Add(quantity) } else { // if we don't have enough base asset // then we need to place a buy order at the next price. nextPin := pins[i-1] nextPrice := fixedpoint.Value(nextPin) submitOrders = append(submitOrders, types.SubmitOrder{ Symbol: s.Symbol, Type: types.OrderTypeLimit, Side: types.SideTypeBuy, Price: nextPrice, Quantity: quantity, Market: s.Market, TimeInForce: types.TimeInForceGTC, Tag: orderTag, GroupID: s.OrderGroupID, ClientOrderID: s.newClientOrderID(), }) quoteQuantity := quantity.Mul(nextPrice) usedQuote = usedQuote.Add(quoteQuantity) } } else { // if price spread is not enabled, and we have already placed a sell order index on the top of this price, // then we should skip if s.ProfitSpread.IsZero() && i+1 == si { continue } // should never place a buy order at the upper price if i == len(pins)-1 { continue } quoteQuantity := quantity.Mul(price) if usedQuote.Add(quoteQuantity).Compare(totalQuote) > 0 { s.logger.Warnf("used quote %f > total quote %f, this should not happen", usedQuote.Add(quoteQuantity).Float64(), totalQuote.Float64()) continue } submitOrders = append(submitOrders, types.SubmitOrder{ Symbol: s.Symbol, Type: types.OrderTypeLimit, Side: types.SideTypeBuy, Price: price, Quantity: quantity, Market: s.Market, TimeInForce: types.TimeInForceGTC, Tag: orderTag, GroupID: s.OrderGroupID, ClientOrderID: s.newClientOrderID(), }) usedQuote = usedQuote.Add(quoteQuantity) } } return submitOrders, nil } func (s *Strategy) clearOpenOrders(ctx context.Context, session *bbgo.ExchangeSession) error { // clear open orders when start openOrders, err := queryOpenOrdersUntilSuccessful(ctx, session.Exchange, s.Symbol) if err != nil { return err } return cancelOrdersUntilSuccessful(ctx, session.Exchange, openOrders...) } func (s *Strategy) getLastTradePrice(ctx context.Context, session *bbgo.ExchangeSession) (fixedpoint.Value, error) { if bbgo.IsBackTesting { price, ok := session.LastPrice(s.Symbol) if !ok { return fixedpoint.Zero, fmt.Errorf("last price of %s not found", s.Symbol) } return price, nil } tickers, err := session.Exchange.QueryTickers(ctx, s.Symbol) if err != nil { return fixedpoint.Zero, err } if ticker, ok := tickers[s.Symbol]; ok { if !ticker.Last.IsZero() { return ticker.Last, nil } // fallback to buy price return ticker.Buy, nil } return fixedpoint.Zero, fmt.Errorf("%s ticker price not found", s.Symbol) } func calculateMinimalQuoteInvestment(market types.Market, grid *Grid) fixedpoint.Value { // upperPrice for buy order lowerPrice := grid.LowerPrice minQuantity := fixedpoint.Max(market.MinNotional.Div(lowerPrice), market.MinQuantity) var pins = grid.Pins var totalQuote = fixedpoint.Zero for i := len(pins) - 2; i >= 0; i-- { pin := pins[i] price := fixedpoint.Value(pin) totalQuote = totalQuote.Add(price.Mul(minQuantity)) } return totalQuote } func (s *Strategy) checkMinimalQuoteInvestment(grid *Grid) error { minimalQuoteInvestment := calculateMinimalQuoteInvestment(s.Market, grid) if s.QuoteInvestment.Compare(minimalQuoteInvestment) <= 0 { return fmt.Errorf("need at least %f %s for quote investment, %f %s given", minimalQuoteInvestment.Float64(), s.Market.QuoteCurrency, s.QuoteInvestment.Float64(), s.Market.QuoteCurrency) } return nil } func (s *Strategy) recoverGridWithOpenOrdersByScanningTrades(ctx context.Context, historyService types.ExchangeTradeHistoryService, openOrdersOnGrid []types.Order) error { if s.orderQueryService == nil { return fmt.Errorf("orderQueryService is nil, it can't get orders by trade") } // set grid grid := s.newGrid() s.setGrid(grid) // add open orders to active order book s.addOrdersToActiveOrderBook(openOrdersOnGrid) expectedOrderNums := s.GridNum - 1 openOrdersOnGridNums := int64(len(openOrdersOnGrid)) s.debugLog("open orders nums: %d, expected nums: %d", openOrdersOnGridNums, expectedOrderNums) if expectedOrderNums == openOrdersOnGridNums { // no need to recover return nil } else if expectedOrderNums < openOrdersOnGridNums { return fmt.Errorf("amount of grid's open orders should not > amount of expected grid's orders") } // 1. build pin-order map pinOrdersOpen, err := s.buildPinOrderMap(grid.Pins, openOrdersOnGrid) if err != nil { return errors.Wrapf(err, "failed to build pin order map with open orders") } // 2. build the filled pin-order map by querying trades pinOrdersFilled, err := s.buildFilledPinOrderMapFromTrades(ctx, historyService, pinOrdersOpen) if err != nil { return errors.Wrapf(err, "failed to build filled pin order map") } // 3. get the filled orders from pin-order map filledOrders := pinOrdersFilled.AscendingOrders() numFilledOrders := len(filledOrders) if numFilledOrders == int(expectedOrderNums-openOrdersOnGridNums) { // nums of filled order is the same as Size - 1 - num(open orders) } else if numFilledOrders == int(expectedOrderNums-openOrdersOnGridNums+1) { filledOrders = filledOrders[1:] } else { return fmt.Errorf("not reasonable num of filled orders") } // 4. verify the grid if err := s.verifyFilledGrid(s.grid.Pins, pinOrdersOpen, filledOrders); err != nil { return errors.Wrapf(err, "verify grid with error") } s.debugOrders("emit filled orders", filledOrders) // 5. emit the filled orders activeOrderBook := s.orderExecutor.ActiveMakerOrders() for _, filledOrder := range filledOrders { activeOrderBook.EmitFilled(filledOrder) } // 6. emit grid ready s.EmitGridReady() // 7. debug and send metrics // wait for the reverse order to be placed time.Sleep(2 * time.Second) debugGrid(s.logger, grid, s.orderExecutor.ActiveMakerOrders()) s.updateGridNumOfOrdersMetricsWithLock() s.updateOpenOrderPricesMetrics(s.orderExecutor.ActiveMakerOrders().Orders()) return nil } func (s *Strategy) verifyFilledGrid(pins []Pin, pinOrders PinOrderMap, filledOrders []types.Order) error { s.debugLog("pins: %+v", pins) s.debugLog("open pin orders:\n%s", pinOrders.String()) s.debugOrders("filled orders", filledOrders) for _, filledOrder := range filledOrders { price := filledOrder.Price if o, exist := pinOrders[price]; !exist { return fmt.Errorf("the price (%+v) is not in pins", price) } else if o.OrderID != 0 { return fmt.Errorf("there is already an order at this price (%+v)", price) } else { pinOrders[price] = filledOrder } } s.debugLog("filled pin orders:\n%+v", pinOrders.String()) side := types.SideTypeBuy for _, pin := range pins { order, exist := pinOrders[fixedpoint.Value(pin)] if !exist { return fmt.Errorf("there is no order at price (%+v)", pin) } // if there is order with OrderID = 0, means we hit the empty pin // there must be only one empty pin in the grid // all orders below this pin need to be bid orders, above this pin need to be ask orders if order.OrderID == 0 { if side == types.SideTypeBuy { side = types.SideTypeSell continue } return fmt.Errorf("not only one empty order in this grid") } if order.Side != side { return fmt.Errorf("the side is wrong") } } if side != types.SideTypeSell { return fmt.Errorf("there is no empty pin in the grid") } return nil } // buildPinOrderMap build the pin-order map with grid and open orders. // The keys of this map contains all required pins of this grid. // If the Order of the pin is empty types.Order (OrderID == 0), it means there is no open orders at this pin. func (s *Strategy) buildPinOrderMap(pins []Pin, openOrders []types.Order) (PinOrderMap, error) { pinOrderMap := make(PinOrderMap) for _, pin := range pins { pinOrderMap[fixedpoint.Value(pin)] = types.Order{} } for _, openOrder := range openOrders { pin := openOrder.Price v, exist := pinOrderMap[pin] if !exist { return nil, fmt.Errorf("the price of the order (id: %d) is not in pins", openOrder.OrderID) } if v.OrderID != 0 { return nil, fmt.Errorf("there are duplicated open orders at the same pin") } pinOrderMap[pin] = openOrder } return pinOrderMap, nil } // buildFilledPinOrderMapFromTrades will query the trades from last 24 hour and use them to build a pin order map // It will skip the orders on pins at which open orders are already func (s *Strategy) buildFilledPinOrderMapFromTrades(ctx context.Context, historyService types.ExchangeTradeHistoryService, pinOrdersOpen PinOrderMap) (PinOrderMap, error) { pinOrdersFilled := make(PinOrderMap) // existedOrders is used to avoid re-query the same orders existedOrders := pinOrdersOpen.SyncOrderMap() var limit int64 = 1000 // get the filled orders when bbgo is down in order from trades // [NOTE] only retrieve from last 24 hours !!! var fromTradeID uint64 = 0 for { trades, err := historyService.QueryTrades(ctx, s.Symbol, &types.TradeQueryOptions{ LastTradeID: fromTradeID, Limit: limit, }) if err != nil { return nil, errors.Wrapf(err, "failed to query trades to recover the grid with open orders") } s.debugLog("QueryTrades return %d trades", len(trades)) for _, trade := range trades { s.debugLog(trade.String()) if existedOrders.Exists(trade.OrderID) { // already queries, skip continue } order, err := s.orderQueryService.QueryOrder(ctx, types.OrderQuery{ OrderID: strconv.FormatUint(trade.OrderID, 10), }) if err != nil { return nil, errors.Wrapf(err, "failed to query order by trade") } s.debugLog("%s (group_id: %d)", order.String(), order.GroupID) // avoid query this order again existedOrders.Add(*order) // add 1 to avoid duplicate fromTradeID = trade.ID + 1 // this trade doesn't belong to this grid if order.GroupID != s.OrderGroupID { continue } // checked the trade's order is filled order pin := order.Price v, exist := pinOrdersOpen[pin] if !exist { return nil, fmt.Errorf("the price of the order with the same GroupID is not in pins") } // skip open orders on grid if v.OrderID != 0 { continue } // check the order's creation time if pinOrder, exist := pinOrdersFilled[pin]; exist && pinOrder.CreationTime.Time().After(order.CreationTime.Time()) { // do not replace the pin order if the order's creation time is not after pin order's creation time // this situation should not happen actually, because the trades is already sorted. s.logger.Infof("pinOrder's creation time (%s) should not be after order's creation time (%s)", pinOrder.CreationTime, order.CreationTime) continue } pinOrdersFilled[pin] = *order // wait 100 ms to avoid rate limit time.Sleep(100 * time.Millisecond) } // stop condition if int64(len(trades)) < limit { break } } return pinOrdersFilled, nil } func (s *Strategy) recoverGridWithOpenOrders(ctx context.Context, historyService types.ExchangeTradeHistoryService, openOrders []types.Order) error { grid := s.newGrid() s.logger.Infof("GRID RECOVER: %s", grid.String()) lastOrderID := uint64(1) now := time.Now() firstOrderTime := now.AddDate(0, 0, -7) lastOrderTime := firstOrderTime if since, until, ok := scanOrderCreationTimeRange(openOrders); ok { firstOrderTime = since lastOrderTime = until } _ = lastOrderTime // for MAX exchange we need the order ID to query the closed order history if s.GridProfitStats != nil && s.GridProfitStats.InitialOrderID > 0 { lastOrderID = s.GridProfitStats.InitialOrderID s.logger.Infof("found initial order id #%d from grid stats", lastOrderID) } else { if oid, ok := findEarliestOrderID(openOrders); ok { lastOrderID = oid s.logger.Infof("found earliest order id #%d from open orders", lastOrderID) } } // Allocate a local order book for querying the history orders orderBook := bbgo.NewActiveOrderBook(s.Symbol) // Ensure that orders are grid orders // The price must be at the grid pin gridOrders := grid.FilterOrders(openOrders) for _, gridOrder := range gridOrders { orderBook.Add(gridOrder) } // if all open orders are the grid orders, then we don't have to recover s.logger.Infof("GRID RECOVER: verifying pins %v", PrettyPins(grid.Pins)) missingPrices := scanMissingPinPrices(orderBook, grid.Pins) if numMissing := len(missingPrices); numMissing <= 1 { s.logger.Infof("GRID RECOVER: no missing grid prices, stop re-playing order history") s.addOrdersToActiveOrderBook(gridOrders) s.setGrid(grid) s.EmitGridReady() s.updateGridNumOfOrdersMetricsWithLock() s.updateOpenOrderPricesMetrics(s.orderExecutor.ActiveMakerOrders().Orders()) return nil } else { s.logger.Infof("GRID RECOVER: found missing prices: %v", missingPrices) // Note that for MAX Exchange, the order history API only uses fromID parameter to query history order. // The time range does not matter. // TODO: handle context correctly startTime := firstOrderTime endTime := now maxTries := 5 localHistoryRollbackDuration := historyRollbackDuration for maxTries > 0 { maxTries-- if err := s.replayOrderHistory(ctx, grid, orderBook, historyService, startTime, endTime, lastOrderID); err != nil { return err } // Verify if there are still missing prices missingPrices = scanMissingPinPrices(orderBook, grid.Pins) if len(missingPrices) <= 1 { // skip this order history loop and start recovering break } // history rollback range startTime = startTime.Add(-localHistoryRollbackDuration) if newFromOrderID := lastOrderID - historyRollbackOrderIdRange; newFromOrderID > 1 { lastOrderID = newFromOrderID } s.logger.Infof("GRID RECOVER: there are still more than two missing orders, rolling back query start time to earlier time point %s, fromID %d", startTime.String(), lastOrderID) localHistoryRollbackDuration = localHistoryRollbackDuration * 2 } } debugGrid(s.logger, grid, orderBook) // note that the tmpOrders contains FILLED and NEW orders tmpOrders := orderBook.Orders() // if all orders on the order book are active orders, we don't need to recover. if isCompleteGridOrderBook(orderBook, s.GridNum) { s.logger.Infof("GRID RECOVER: all orders are active orders, do not need recover") s.addOrdersToActiveOrderBook(gridOrders) s.setGrid(grid) s.EmitGridReady() s.updateGridNumOfOrdersMetricsWithLock() s.updateOpenOrderPricesMetrics(s.orderExecutor.ActiveMakerOrders().Orders()) return nil } // for reverse order recovering, we need the orders to be sort by update time ascending-ly types.SortOrdersUpdateTimeAscending(tmpOrders) // we will only submit reverse orders for filled orders filledOrders := types.OrdersFilled(tmpOrders) // if the number of FILLED orders and NEW orders equals to GridNum, then we need to remove an extra filled order for the replay events if len(tmpOrders) == int(s.GridNum) && len(filledOrders) > 0 { // remove the latest updated order because it's near the empty slot filledOrders = filledOrders[1:] } s.logger.Infof("GRID RECOVER: found %d/%d filled grid orders, gridNumber=%d, will re-replay the order event in the following order:", len(filledOrders), len(tmpOrders), int(s.GridNum)) for i, o := range filledOrders { s.logger.Infof("%d) %s", i+1, o.String()) } // before we re-play the orders, // we need to add these open orders to the active order book s.addOrdersToActiveOrderBook(gridOrders) s.setGrid(grid) s.EmitGridReady() s.updateGridNumOfOrdersMetricsWithLock() s.updateOpenOrderPricesMetrics(s.orderExecutor.ActiveMakerOrders().Orders()) for i := range filledOrders { // avoid using the iterator o := filledOrders[i] s.processFilledOrder(o) time.Sleep(100 * time.Millisecond) } // wait for the reverse order to be placed time.Sleep(2 * time.Second) s.logger.Infof("GRID RECOVER COMPLETE") debugGrid(s.logger, grid, s.orderExecutor.ActiveMakerOrders()) s.updateGridNumOfOrdersMetricsWithLock() s.updateOpenOrderPricesMetrics(s.orderExecutor.ActiveMakerOrders().Orders()) return nil } func (s *Strategy) addOrdersToActiveOrderBook(gridOrders []types.Order) { activeOrderBook := s.orderExecutor.ActiveMakerOrders() for _, gridOrder := range gridOrders { // put the order back to the active order book so that we can receive order update activeOrderBook.Add(gridOrder) } } func (s *Strategy) setGrid(grid *Grid) { s.mu.Lock() s.grid = grid s.mu.Unlock() } func (s *Strategy) getGrid() *Grid { s.mu.Lock() grid := s.grid s.mu.Unlock() return grid } // replayOrderHistory queries the closed order history from the API and rebuild the orderbook from the order history. // startTime, endTime is the time range of the order history. func (s *Strategy) replayOrderHistory(ctx context.Context, grid *Grid, orderBook *bbgo.ActiveOrderBook, historyService types.ExchangeTradeHistoryService, startTime, endTime time.Time, lastOrderID uint64) error { // a simple guard, in reality, this startTime is not possible to exceed the endTime // because the queries closed orders might still in the range. orderIdChanged := true for startTime.Before(endTime) && orderIdChanged { closedOrders, err := historyService.QueryClosedOrders(ctx, s.Symbol, startTime, endTime, lastOrderID) if err != nil { return err } // need to prevent infinite loop for: // if there is only one order and the order creation time matches our startTime if len(closedOrders) == 0 || len(closedOrders) == 1 && closedOrders[0].OrderID == lastOrderID { break } // for each closed order, if it's newer than the open order's update time, we will update it. orderIdChanged = false for _, closedOrder := range closedOrders { if closedOrder.OrderID > lastOrderID { lastOrderID = closedOrder.OrderID orderIdChanged = true } // skip orders that are not limit order if closedOrder.Type != types.OrderTypeLimit { continue } // skip canceled orders (?) if closedOrder.Status == types.OrderStatusCanceled { continue } creationTime := closedOrder.CreationTime.Time() if creationTime.After(startTime) { startTime = creationTime } // skip non-grid order prices if !grid.HasPrice(closedOrder.Price) { continue } existingOrder := orderBook.Lookup(func(o types.Order) bool { return o.Price.Eq(closedOrder.Price) }) if existingOrder == nil { orderBook.Add(closedOrder) } else { // To update order, we need to remove the old order, because it's using order ID as the key of the map. if creationTime.After(existingOrder.CreationTime.Time()) { orderBook.Remove(*existingOrder) orderBook.Add(closedOrder) } } } } return nil } // isCompleteGridOrderBook checks if the number of open orders == gridNum - 1 and all orders are active order func isCompleteGridOrderBook(orderBook *bbgo.ActiveOrderBook, gridNum int64) bool { tmpOrders := orderBook.Orders() activeOrders := types.OrdersActive(tmpOrders) return len(activeOrders) == int(gridNum)-1 } func findEarliestOrderID(orders []types.Order) (uint64, bool) { if len(orders) == 0 { return 0, false } earliestOrderID := orders[0].OrderID for _, o := range orders { if o.OrderID < earliestOrderID { earliestOrderID = o.OrderID } } return earliestOrderID, true } // scanOrderCreationTimeRange finds the earliest creation time and the latest creation time from the given orders func scanOrderCreationTimeRange(orders []types.Order) (time.Time, time.Time, bool) { if len(orders) == 0 { return time.Time{}, time.Time{}, false } firstOrderTime := orders[0].CreationTime.Time() lastOrderTime := firstOrderTime for _, o := range orders { createTime := o.CreationTime.Time() if createTime.Before(firstOrderTime) { firstOrderTime = createTime } else if createTime.After(lastOrderTime) { lastOrderTime = createTime } } return firstOrderTime, lastOrderTime, true } // scanMissingPinPrices finds the missing grid order prices func scanMissingPinPrices(orderBook *bbgo.ActiveOrderBook, pins []Pin) PriceMap { // Add all open orders to the local order book gridPrices := make(PriceMap) missingPrices := make(PriceMap) for _, pin := range pins { price := fixedpoint.Value(pin) gridPrices[price.String()] = price existingOrder := orderBook.Lookup(func(o types.Order) bool { return o.Price.Compare(price) == 0 }) if existingOrder == nil { missingPrices[price.String()] = price } } return missingPrices } func (s *Strategy) newPrometheusLabels() prometheus.Labels { labels := prometheus.Labels{ "exchange": "default", "symbol": s.Symbol, } if s.session != nil { labels["exchange"] = s.session.Name } if s.PrometheusLabels == nil { return labels } return mergeLabels(s.PrometheusLabels, labels) } func (s *Strategy) CleanUp(ctx context.Context) error { if s.ExchangeSession != nil { s.session = s.ExchangeSession } _ = s.Initialize() defer s.EmitGridClosed() return s.cancelAll(ctx) } func (s *Strategy) getWriteContext(fallbackCtxList ...context.Context) context.Context { if s.writeCtx != nil { return s.writeCtx } for _, c := range fallbackCtxList { if c != nil { return c } } if s.tradingCtx != nil { return s.tradingCtx } // final fallback to context background return context.Background() } func (s *Strategy) Run(ctx context.Context, _ bbgo.OrderExecutor, session *bbgo.ExchangeSession) error { instanceID := s.InstanceID() // allocate a context for write operation (submitting orders) s.tradingCtx = ctx s.writeCtx, s.cancelWrite = context.WithCancel(ctx) s.session = session if service, ok := session.Exchange.(types.ExchangeOrderQueryService); ok { s.orderQueryService = service } if s.OrderGroupID == 0 { s.OrderGroupID = util.FNV32(instanceID) % math.MaxInt32 } if s.AutoRange != nil { indicatorSet := session.StandardIndicatorSet(s.Symbol) interval := s.AutoRange.Interval() pivotLow := indicatorSet.PivotLow(types.IntervalWindow{Interval: interval, Window: s.AutoRange.Num}) pivotHigh := indicatorSet.PivotHigh(types.IntervalWindow{Interval: interval, Window: s.AutoRange.Num}) s.UpperPrice = fixedpoint.NewFromFloat(pivotHigh.Last()) s.LowerPrice = fixedpoint.NewFromFloat(pivotLow.Last()) s.logger.Infof("autoRange is enabled, using pivot high %f and pivot low %f", s.UpperPrice.Float64(), s.LowerPrice.Float64()) } if s.ProfitSpread.Sign() > 0 { s.ProfitSpread = s.Market.TruncatePrice(s.ProfitSpread) } if s.GridProfitStats == nil { s.GridProfitStats = newGridProfitStats(s.Market) } if s.Position == nil { s.Position = types.NewPositionFromMarket(s.Market) } // initialize and register prometheus metrics if s.PrometheusLabels != nil { initMetrics(labelKeys(s.PrometheusLabels)) } else { initMetrics(nil) } registerMetrics() if s.ResetPositionWhenStart { s.Position.Reset() } // we need to check the minimal quote investment here, because we need the market info if s.QuoteInvestment.Sign() > 0 { grid := s.newGrid() if err := s.checkMinimalQuoteInvestment(grid); err != nil { if s.StopIfLessThanMinimalQuoteInvestment { s.logger.WithError(err).Errorf("check minimal quote investment failed, market info: %+v", s.Market) return err } else { // if no, just warning s.logger.WithError(err).Warnf("minimal quote investment may be not enough, market info: %+v", s.Market) } } } s.historicalTrades = bbgo.NewTradeStore() s.historicalTrades.EnablePrune = true s.historicalTrades.BindStream(session.UserDataStream) orderExecutor := bbgo.NewGeneralOrderExecutor(session, s.Symbol, ID, instanceID, s.Position) orderExecutor.BindEnvironment(s.Environment) orderExecutor.Bind() orderExecutor.TradeCollector().OnTrade(func(trade types.Trade, _, _ fixedpoint.Value) { s.GridProfitStats.AddTrade(trade) }) orderExecutor.TradeCollector().OnPositionUpdate(func(position *types.Position) { bbgo.Sync(ctx, s) }) orderExecutor.ActiveMakerOrders().OnFilled(s.newOrderUpdateHandler(ctx, session)) if s.logger != nil { orderExecutor.SetLogger(s.logger) } s.orderExecutor = orderExecutor s.OnGridProfit(func(stats *GridProfitStats, profit *GridProfit) { bbgo.Notify(profit) bbgo.Notify(stats) }) s.OnGridProfit(func(stats *GridProfitStats, profit *GridProfit) { labels := s.newPrometheusLabels() metricsGridProfit.With(labels).Set(stats.TotalQuoteProfit.Float64()) }) bbgo.OnShutdown(ctx, func(ctx context.Context, wg *sync.WaitGroup) { defer wg.Done() if s.cancelWrite != nil { s.cancelWrite() } if s.KeepOrdersWhenShutdown { s.logger.Infof("keepOrdersWhenShutdown is set, will keep the orders on the exchange") return } if err := s.CloseGrid(ctx); err != nil { s.logger.WithError(err).Errorf("grid graceful order cancel error") } }) if !s.TriggerPrice.IsZero() { session.MarketDataStream.OnKLineClosed(s.newTriggerPriceHandler(ctx, session)) } if !s.StopLossPrice.IsZero() { session.MarketDataStream.OnKLineClosed(s.newStopLossPriceHandler(ctx, session)) } if !s.TakeProfitPrice.IsZero() { session.MarketDataStream.OnKLineClosed(s.newTakeProfitHandler(ctx, session)) } // detect if there are previous grid orders on the order book session.UserDataStream.OnStart(func() { if s.ClearOpenOrdersWhenStart { s.logger.Infof("clearOpenOrdersWhenStart is set, clearing open orders...") if err := s.clearOpenOrders(ctx, session); err != nil { s.logger.WithError(err).Errorf("clearOpenOrdersWhenStart error") } } if s.ClearOpenOrdersIfMismatch { s.logger.Infof("clearOpenOrdersIfMismatch is set, checking mismatched orders...") mismatch, err := s.openOrdersMismatches(ctx, session) if err != nil { s.logger.WithError(err).Errorf("clearOpenOrdersIfMismatch error") } else if mismatch { if err2 := s.clearOpenOrders(ctx, session); err2 != nil { s.logger.WithError(err2).Errorf("clearOpenOrders error") } } } if s.ClearDuplicatedPriceOpenOrders { s.logger.Infof("clearDuplicatedPriceOpenOrders is set, finding duplicated open orders...") if err := s.cancelDuplicatedPriceOpenOrders(ctx, session); err != nil { s.logger.WithError(err).Errorf("cancelDuplicatedPriceOpenOrders error") } } }) // if TriggerPrice is zero, that means we need to open the grid when start up if s.TriggerPrice.IsZero() { // must call the openGrid method inside the OnStart callback because // it needs to receive the trades from the user data stream // // should try to avoid blocking the user data stream // callbacks are blocking operation session.UserDataStream.OnStart(func() { s.logger.Infof("user data stream started, initializing grid...") if !bbgo.IsBackTesting { go s.startProcess(ctx, session) } else { s.startProcess(ctx, session) } }) } return nil } func (s *Strategy) startProcess(ctx context.Context, session *bbgo.ExchangeSession) { if s.RecoverOrdersWhenStart { // do recover only when triggerPrice is not set and not in the back-test mode s.logger.Infof("recoverWhenStart is set, trying to recover grid orders...") if err := s.recoverGrid(ctx, session); err != nil { // if recover fail, return and do not open grid s.EmitGridError(errors.Wrapf(err, "failed to start process, recover error")) return } } // avoid using goroutine here for back-test if err := s.openGrid(ctx, session); err != nil { s.EmitGridError(errors.Wrapf(err, "failed to start process, setup grid orders error")) return } } func (s *Strategy) recoverGrid(ctx context.Context, session *bbgo.ExchangeSession) error { if s.RecoverGridByScanningTrades { s.debugLog("recover grid by scanning trades") return s.recoverGridByScanningTrades(ctx, session) } s.debugLog("recover grid by scanning orders") return s.recoverGridByScanningOrders(ctx, session) } func (s *Strategy) recoverGridByScanningOrders(ctx context.Context, session *bbgo.ExchangeSession) error { openOrders, err := queryOpenOrdersUntilSuccessful(ctx, session.Exchange, s.Symbol) if err != nil { return err } // do recover only when openOrders > 0 if len(openOrders) == 0 { s.logger.Warn("0 open orders, skip recovery process") return nil } s.logger.Infof("found %d open orders left on the %s order book", len(openOrders), s.Symbol) historyService, implemented := session.Exchange.(types.ExchangeTradeHistoryService) if !implemented { s.logger.Warn("ExchangeTradeHistoryService is not implemented, can not recover grid") return nil } if err := s.recoverGridWithOpenOrders(ctx, historyService, openOrders); err != nil { return errors.Wrap(err, "grid recover error") } return nil } func (s *Strategy) recoverGridByScanningTrades(ctx context.Context, session *bbgo.ExchangeSession) error { // no initial order id means we don't need to recover if s.GridProfitStats.InitialOrderID == 0 { s.logger.Debug("new strategy, no need to recover") return nil } openOrders, err := session.Exchange.QueryOpenOrders(ctx, s.Symbol) if err != nil { return err } s.logger.Infof("found %d open orders left on the %s order book", len(openOrders), s.Symbol) s.debugLog("recover grid with group id: %d", s.OrderGroupID) // filter out the order with the group id belongs to this grid var openOrdersOnGrid []types.Order for _, order := range openOrders { if order.GroupID == s.OrderGroupID { openOrdersOnGrid = append(openOrdersOnGrid, order) } } s.logger.Infof("found %d open orders belong to this grid on the %s order book", len(openOrdersOnGrid), s.Symbol) historyService, implemented := session.Exchange.(types.ExchangeTradeHistoryService) if !implemented { s.logger.Warn("ExchangeTradeHistoryService is not implemented, can not recover grid") return nil } if err := s.recoverGridWithOpenOrdersByScanningTrades(ctx, historyService, openOrdersOnGrid); err != nil { return errors.Wrap(err, "grid recover error") } return nil } // openOrdersMismatches verifies if the open orders are on the grid pins // return true if mismatches func (s *Strategy) openOrdersMismatches(ctx context.Context, session *bbgo.ExchangeSession) (bool, error) { openOrders, err := session.Exchange.QueryOpenOrders(ctx, s.Symbol) if err != nil { return false, err } if len(openOrders) == 0 { return false, nil } grid := s.newGrid() for _, o := range openOrders { // if any of the open order is not on the grid, or out of the range // we should cancel all of them if !grid.HasPrice(o.Price) || grid.OutOfRange(o.Price) { return true, nil } } return false, nil } func (s *Strategy) cancelDuplicatedPriceOpenOrders(ctx context.Context, session *bbgo.ExchangeSession) error { openOrders, err := queryOpenOrdersUntilSuccessful(ctx, session.Exchange, s.Symbol) if err != nil { return err } if len(openOrders) == 0 { return nil } dupOrders := s.findDuplicatedPriceOpenOrders(openOrders) if len(dupOrders) > 0 { s.debugOrders("DUPLICATED ORDERS", dupOrders) return session.Exchange.CancelOrders(ctx, dupOrders...) } s.logger.Infof("no duplicated order found") return nil } func (s *Strategy) findDuplicatedPriceOpenOrders(openOrders []types.Order) (dupOrders []types.Order) { orderBook := bbgo.NewActiveOrderBook(s.Symbol) for _, openOrder := range openOrders { existingOrder := orderBook.Lookup(func(o types.Order) bool { return o.Price.Compare(openOrder.Price) == 0 }) if existingOrder != nil { // found duplicated order // compare creation time and remove the latest created order // if the creation time equals, then we can just cancel one of them s.debugOrders( fmt.Sprintf("found duplicated order at price %s, comparing orders", openOrder.Price.String()), []types.Order{*existingOrder, openOrder}) dupOrder := *existingOrder if openOrder.CreationTime.After(existingOrder.CreationTime.Time()) { dupOrder = openOrder } else if openOrder.CreationTime.Before(existingOrder.CreationTime.Time()) { // override the existing order and take the existing order as a duplicated one orderBook.Add(openOrder) } dupOrders = append(dupOrders, dupOrder) } else { orderBook.Add(openOrder) } } return dupOrders } func (s *Strategy) newClientOrderID() string { if s.session != nil && s.session.ExchangeName == types.ExchangeMax { return uuid.New().String() } return "" } func generalBackoff(ctx context.Context, op backoff.Operation) (err error) { err = backoff.Retry(op, backoff.WithContext( backoff.WithMaxRetries( backoff.NewExponentialBackOff(), 101), ctx)) return err } func cancelAllOrdersUntilSuccessful(ctx context.Context, service advancedOrderCancelApi) error { var op = func() (err2 error) { _, err2 = service.CancelAllOrders(ctx) return err2 } return generalBackoff(ctx, op) } func cancelOrdersUntilSuccessful(ctx context.Context, ex types.Exchange, orders ...types.Order) error { var op = func() (err2 error) { err2 = ex.CancelOrders(ctx, orders...) return err2 } return generalBackoff(ctx, op) } func queryOpenOrdersUntilSuccessful(ctx context.Context, ex types.Exchange, symbol string) (openOrders []types.Order, err error) { var op = func() (err2 error) { openOrders, err2 = ex.QueryOpenOrders(ctx, symbol) return err2 } err = generalBackoff(ctx, op) return openOrders, err }