bbgo_origin/pkg/strategy/support/strategy.go

package support

import (
	"context"
	"fmt"
	"sync"

	"github.com/sirupsen/logrus"

	"github.com/c9s/bbgo/pkg/bbgo"
	"github.com/c9s/bbgo/pkg/fixedpoint"
	"github.com/c9s/bbgo/pkg/indicator"
	"github.com/c9s/bbgo/pkg/types"
)

const ID = "support"

var log = logrus.WithField("strategy", ID)

var zeroiw = types.IntervalWindow{}

func init() {
	bbgo.RegisterStrategy(ID, &Strategy{})
}

type State struct {
	Position            *types.Position   `json:"position,omitempty"`
	CurrentHighestPrice *fixedpoint.Value `json:"currentHighestPrice,omitempty"`
}

type Target struct {
	ProfitPercentage      fixedpoint.Value                `json:"profitPercentage"`
	QuantityPercentage    fixedpoint.Value                `json:"quantityPercentage"`
	MarginOrderSideEffect types.MarginOrderSideEffectType `json:"marginOrderSideEffect"`
}

// PercentageTargetStop is a kind of stop order by setting fixed percentage target
type PercentageTargetStop struct {
	Targets []Target `json:"targets"`
}

// GenerateOrders generates the orders from the given targets
func (stop *PercentageTargetStop) GenerateOrders(market types.Market, pos *types.Position) []types.SubmitOrder {
	var price = pos.AverageCost
	var quantity = pos.GetBase()

	// submit target orders
	var targetOrders []types.SubmitOrder
	for _, target := range stop.Targets {
		targetPrice := price.Mul(fixedpoint.One.Add(target.ProfitPercentage))
		targetQuantity := quantity.Mul(target.QuantityPercentage)
		targetQuoteQuantity := targetPrice.Mul(targetQuantity)

		if targetQuoteQuantity.Compare(market.MinNotional) <= 0 {
			continue
		}

		if targetQuantity.Compare(market.MinQuantity) <= 0 {
			continue
		}

		targetOrders = append(targetOrders, types.SubmitOrder{
			Symbol:           market.Symbol,
			Market:           market,
			Type:             types.OrderTypeLimit,
			Side:             types.SideTypeSell,
			Price:            targetPrice,
			Quantity:         targetQuantity,
			MarginSideEffect: target.MarginOrderSideEffect,
			TimeInForce:      types.TimeInForceGTC,
		})
	}

	return targetOrders
}

type TrailingStopTarget struct {
	TrailingStopCallbackRatio fixedpoint.Value `json:"callbackRatio"`
	MinimumProfitPercentage   fixedpoint.Value `json:"minimumProfitPercentage"`
}

type TrailingStopControl struct {
	symbol           string
	market           types.Market
	marginSideEffect types.MarginOrderSideEffectType

	trailingStopCallbackRatio fixedpoint.Value
	minimumProfitPercentage   fixedpoint.Value

	CurrentHighestPrice fixedpoint.Value
	StopOrder           *types.Order
}

func (control *TrailingStopControl) UpdateCurrentHighestPrice(p fixedpoint.Value) bool {
	orig := control.CurrentHighestPrice
	control.CurrentHighestPrice = fixedpoint.Max(control.CurrentHighestPrice, p)
	return orig.Compare(control.CurrentHighestPrice) == 0
}

func (control *TrailingStopControl) IsHigherThanMin(minTargetPrice fixedpoint.Value) bool {
	targetPrice := control.CurrentHighestPrice.Mul(fixedpoint.One.Sub(control.trailingStopCallbackRatio))

	return targetPrice.Compare(minTargetPrice) >= 0
}

func (control *TrailingStopControl) GenerateStopOrder(quantity fixedpoint.Value) types.SubmitOrder {
	targetPrice := control.CurrentHighestPrice.Mul(fixedpoint.One.Sub(control.trailingStopCallbackRatio))

	orderForm := types.SubmitOrder{
		Symbol:           control.symbol,
		Market:           control.market,
		Side:             types.SideTypeSell,
		Type:             types.OrderTypeStopLimit,
		Quantity:         quantity,
		MarginSideEffect: control.marginSideEffect,
		TimeInForce:      types.TimeInForceGTC,

		Price:     targetPrice,
		StopPrice: targetPrice,
	}

	return orderForm
}

// Not implemented yet
// ResistanceStop is a kind of stop order by detecting resistance
// type ResistanceStop struct {
//	Interval      types.Interval   `json:"interval"`
//	sensitivity   fixedpoint.Value `json:"sensitivity"`
//	MinVolume     fixedpoint.Value `json:"minVolume"`
//	TakerBuyRatio fixedpoint.Value `json:"takerBuyRatio"`
// }

type Strategy struct {
	*bbgo.Persistence `json:"-"`
	*bbgo.Environment `json:"-"`

	session *bbgo.ExchangeSession

	Symbol string       `json:"symbol"`
	Market types.Market `json:"-"`

	// Interval for checking support
	Interval types.Interval `json:"interval"`

	// moving average window for checking support (support should be under the moving average line)
	TriggerMovingAverage types.IntervalWindow `json:"triggerMovingAverage"`

	// LongTermMovingAverage is the second moving average line for checking support position
	LongTermMovingAverage types.IntervalWindow `json:"longTermMovingAverage"`

	Quantity              fixedpoint.Value                `json:"quantity"`
	MinVolume             fixedpoint.Value                `json:"minVolume"`
	Sensitivity           fixedpoint.Value                `json:"sensitivity"`
	TakerBuyRatio         fixedpoint.Value                `json:"takerBuyRatio"`
	MarginOrderSideEffect types.MarginOrderSideEffectType `json:"marginOrderSideEffect"`
	Targets               []Target                        `json:"targets"`

	// Not implemented yet
	// ResistanceStop *ResistanceStop `json:"resistanceStop"`
	//
	// ResistanceTakerBuyRatio fixedpoint.Value `json:"resistanceTakerBuyRatio"`

	// Min BaseAsset balance to keep
	MinBaseAssetBalance fixedpoint.Value `json:"minBaseAssetBalance"`
	// Max BaseAsset balance to buy
	MaxBaseAssetBalance  fixedpoint.Value `json:"maxBaseAssetBalance"`
	MinQuoteAssetBalance fixedpoint.Value `json:"minQuoteAssetBalance"`

	ScaleQuantity *bbgo.PriceVolumeScale `json:"scaleQuantity"`

	orderExecutor *bbgo.GeneralOrderExecutor

	Position            *types.Position    `persistence:"position"`
	ProfitStats         *types.ProfitStats `persistence:"profit_stats"`
	TradeStats          *types.TradeStats  `persistence:"trade_stats"`
	CurrentHighestPrice fixedpoint.Value   `persistence:"current_highest_price"`

	state *State

	triggerEMA  *indicator.EWMA
	longTermEMA *indicator.EWMA

	// Trailing stop
	TrailingStopTarget  TrailingStopTarget `json:"trailingStopTarget"`
	trailingStopControl *TrailingStopControl

	// StrategyController
	bbgo.StrategyController
}

func (s *Strategy) ID() string {
	return ID
}

func (s *Strategy) InstanceID() string {
	return fmt.Sprintf("%s:%s", ID, s.Symbol)
}

func (s *Strategy) Validate() error {
	if s.Quantity.IsZero() && s.ScaleQuantity == nil {
		return fmt.Errorf("quantity or scaleQuantity can not be zero")
	}

	if s.MinVolume.IsZero() && s.Sensitivity.IsZero() {
		return fmt.Errorf("either minVolume nor sensitivity can not be zero")
	}

	return nil
}

func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
	session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.Interval})

	if s.TriggerMovingAverage != zeroiw {
		session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.TriggerMovingAverage.Interval})
	}

	if s.LongTermMovingAverage != zeroiw {
		session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.LongTermMovingAverage.Interval})
	}
}

func (s *Strategy) CurrentPosition() *types.Position {
	return s.Position
}

func (s *Strategy) ClosePosition(ctx context.Context, percentage fixedpoint.Value) error {
	base := s.Position.GetBase()
	if base.IsZero() {
		return fmt.Errorf("no opened %s position", s.Position.Symbol)
	}

	// make it negative
	quantity := base.Mul(percentage).Abs()
	side := types.SideTypeBuy
	if base.Sign() > 0 {
		side = types.SideTypeSell
	}

	if quantity.Compare(s.Market.MinQuantity) < 0 {
		return fmt.Errorf("order quantity %v is too small, less than %v", quantity, s.Market.MinQuantity)
	}

	submitOrder := types.SubmitOrder{
		Symbol:   s.Symbol,
		Side:     side,
		Type:     types.OrderTypeMarket,
		Quantity: quantity,
		Market:   s.Market,
	}

	bbgo.Notify("Submitting %s %s order to close position by %v", s.Symbol, side.String(), percentage, submitOrder)
	_, err := s.orderExecutor.SubmitOrders(ctx, submitOrder)
	return err
}

func (s *Strategy) submitOrders(ctx context.Context, orderExecutor bbgo.OrderExecutor, orderForms ...types.SubmitOrder) (types.OrderSlice, error) {
	return s.orderExecutor.SubmitOrders(ctx, orderForms...)
}

var slippageModifier = fixedpoint.NewFromFloat(1.003)

func (s *Strategy) calculateQuantity(session *bbgo.ExchangeSession, side types.SideType, closePrice fixedpoint.Value, volume fixedpoint.Value) (fixedpoint.Value, error) {
	var quantity fixedpoint.Value
	if s.Quantity.Sign() > 0 {
		quantity = s.Quantity
	} else if s.ScaleQuantity != nil {
		q, err := s.ScaleQuantity.Scale(closePrice.Float64(), volume.Float64())
		if err != nil {
			return fixedpoint.Zero, err
		}
		quantity = fixedpoint.NewFromFloat(q)
	}

	baseBalance, _ := session.GetAccount().Balance(s.Market.BaseCurrency)
	if side == types.SideTypeSell {
		// quantity = bbgo.AdjustQuantityByMaxAmount(quantity, closePrice, quota)
		if s.MinBaseAssetBalance.Sign() > 0 &&
			baseBalance.Total().Sub(quantity).Compare(s.MinBaseAssetBalance) < 0 {
			quota := baseBalance.Available.Sub(s.MinBaseAssetBalance)
			quantity = bbgo.AdjustQuantityByMaxAmount(quantity, closePrice, quota)
		}

	} else if side == types.SideTypeBuy {
		if s.MaxBaseAssetBalance.Sign() > 0 &&
			baseBalance.Total().Add(quantity).Compare(s.MaxBaseAssetBalance) > 0 {
			quota := s.MaxBaseAssetBalance.Sub(baseBalance.Total())
			quantity = bbgo.AdjustQuantityByMaxAmount(quantity, closePrice, quota)
		}

		quoteBalance, ok := session.GetAccount().Balance(s.Market.QuoteCurrency)
		if !ok {
			return fixedpoint.Zero, fmt.Errorf("quote balance %s not found", s.Market.QuoteCurrency)
		}

		// for spot, we need to modify the quantity according to the quote balance
		if !session.Margin {
			// add 0.3% for price slippage
			notional := closePrice.Mul(quantity).Mul(slippageModifier)

			if s.MinQuoteAssetBalance.Sign() > 0 &&
				quoteBalance.Available.Sub(notional).Compare(s.MinQuoteAssetBalance) < 0 {
				log.Warnf("modifying quantity %v according to the min quote asset balance %v %s",
					quantity,
					quoteBalance.Available,
					s.Market.QuoteCurrency)
				quota := quoteBalance.Available.Sub(s.MinQuoteAssetBalance)
				quantity = bbgo.AdjustQuantityByMinAmount(quantity, closePrice, quota)
			} else if notional.Compare(quoteBalance.Available) > 0 {
				log.Warnf("modifying quantity %v according to the quote asset balance %v %s",
					quantity,
					quoteBalance.Available,
					s.Market.QuoteCurrency)
				quantity = bbgo.AdjustQuantityByMaxAmount(quantity, closePrice, quoteBalance.Available)
			}
		}
	}

	return quantity, nil
}

func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) error {
	s.session = session
	instanceID := s.InstanceID()

	if s.Position == nil {
		s.Position = types.NewPositionFromMarket(s.Market)
	}

	if s.ProfitStats == nil {
		s.ProfitStats = types.NewProfitStats(s.Market)
	}

	// trade stats
	if s.TradeStats == nil {
		s.TradeStats = types.NewTradeStats(s.Symbol)
	}

	s.orderExecutor = bbgo.NewGeneralOrderExecutor(session, s.Symbol, ID, instanceID, s.Position)
	s.orderExecutor.BindEnvironment(s.Environment)
	s.orderExecutor.BindProfitStats(s.ProfitStats)
	s.orderExecutor.BindTradeStats(s.TradeStats)
	s.orderExecutor.Bind()

	// StrategyController
	s.Status = types.StrategyStatusRunning

	s.OnSuspend(func() {
		// Cancel all order
		_ = s.orderExecutor.GracefulCancel(ctx)
		bbgo.Sync(s)
	})

	s.OnEmergencyStop(func() {
		// Close 100% position
		percentage := fixedpoint.NewFromFloat(1.0)
		if err := s.ClosePosition(context.Background(), percentage); err != nil {
			errMsg := "failed to close position"
			log.WithError(err).Errorf(errMsg)
			bbgo.Notify(errMsg)
		}

		if err := s.Suspend(); err != nil {
			errMsg := "failed to suspend strategy"
			log.WithError(err).Errorf(errMsg)
			bbgo.Notify(errMsg)
		}
	})

	// set default values
	if s.Interval == "" {
		s.Interval = types.Interval5m
	}

	if s.Sensitivity.Sign() > 0 {
		volRange, err := s.ScaleQuantity.ByVolumeRule.Range()
		if err != nil {
			return err
		}

		scaleUp := fixedpoint.NewFromFloat(volRange[1])
		scaleLow := fixedpoint.NewFromFloat(volRange[0])
		s.MinVolume = scaleUp.Sub(scaleLow).
			Mul(fixedpoint.One.Sub(s.Sensitivity)).
			Add(scaleLow)
		log.Infof("adjusted minimal support volume to %s according to sensitivity %s", s.MinVolume.String(), s.Sensitivity.String())
	}

	standardIndicatorSet := session.StandardIndicatorSet(s.Symbol)

	if s.TriggerMovingAverage != zeroiw {
		s.triggerEMA = standardIndicatorSet.EWMA(s.TriggerMovingAverage)
	} else {
		s.triggerEMA = standardIndicatorSet.EWMA(types.IntervalWindow{
			Interval: s.Interval,
			Window:   99, // default window
		})
	}

	if s.LongTermMovingAverage != zeroiw {
		s.longTermEMA = standardIndicatorSet.EWMA(s.LongTermMovingAverage)
	}

	if !s.TrailingStopTarget.TrailingStopCallbackRatio.IsZero() {
		s.trailingStopControl = &TrailingStopControl{
			symbol:                    s.Symbol,
			market:                    s.Market,
			marginSideEffect:          s.MarginOrderSideEffect,
			trailingStopCallbackRatio: s.TrailingStopTarget.TrailingStopCallbackRatio,
			minimumProfitPercentage:   s.TrailingStopTarget.MinimumProfitPercentage,
			CurrentHighestPrice:       s.CurrentHighestPrice,
		}
	}

	if !s.TrailingStopTarget.TrailingStopCallbackRatio.IsZero() {
		// Update trailing stop when the position changes
		s.orderExecutor.TradeCollector().OnPositionUpdate(func(position *types.Position) {
			// StrategyController
			if s.Status != types.StrategyStatusRunning {
				return
			}

			if !position.IsLong() || position.IsDust(position.AverageCost) {
				return
			}

			s.updateStopOrder(ctx)
		})
	}

	session.MarketDataStream.OnKLineClosed(func(kline types.KLine) {
		// StrategyController
		if s.Status != types.StrategyStatusRunning {
			return
		}

		// skip k-lines from other symbols
		if kline.Symbol != s.Symbol {
			return
		}
		if kline.Interval != s.Interval {
			return
		}

		closePrice := kline.GetClose()
		highPrice := kline.GetHigh()

		// check our trailing stop
		if s.TrailingStopTarget.TrailingStopCallbackRatio.Sign() > 0 {
			if s.Position.IsLong() && !s.Position.IsDust(closePrice) {
				changed := s.trailingStopControl.UpdateCurrentHighestPrice(highPrice)
				if changed {
					// Cancel the original order
					s.updateStopOrder(ctx)
				}
			}
		}

		// check support volume
		if kline.Volume.Compare(s.MinVolume) < 0 {
			return
		}

		// check taker buy ratio, we need strong buy taker
		if s.TakerBuyRatio.Sign() > 0 {
			takerBuyRatio := kline.TakerBuyBaseAssetVolume.Div(kline.Volume)
			takerBuyBaseVolumeThreshold := kline.Volume.Mul(s.TakerBuyRatio)
			if takerBuyRatio.Compare(s.TakerBuyRatio) < 0 {
				bbgo.Notify("%s: taker buy base volume %s (volume ratio %s) is less than %s (volume ratio %s)",
					s.Symbol,
					kline.TakerBuyBaseAssetVolume.String(),
					takerBuyRatio.String(),
					takerBuyBaseVolumeThreshold.String(),
					kline.Volume.String(),
					s.TakerBuyRatio.String(),
					kline,
				)
				return
			}
		}

		if s.longTermEMA != nil && closePrice.Float64() < s.longTermEMA.Last() {
			bbgo.Notify("%s: closed price is below the long term moving average line %f, skipping this support",
				s.Symbol,
				s.longTermEMA.Last(),
				kline,
			)
			return
		}

		if s.triggerEMA != nil && closePrice.Float64() > s.triggerEMA.Last() {
			bbgo.Notify("%s: closed price is above the trigger moving average line %f, skipping this support",
				s.Symbol,
				s.triggerEMA.Last(),
				kline,
			)
			return
		}

		if s.triggerEMA != nil && s.longTermEMA != nil {
			bbgo.Notify("Found %s support: the close price %s is below trigger EMA %f and above long term EMA %f and volume %s > minimum volume %s",
				s.Symbol,
				closePrice.String(),
				s.triggerEMA.Last(),
				s.longTermEMA.Last(),
				kline.Volume.String(),
				s.MinVolume.String(),
				kline)
		} else {
			bbgo.Notify("Found %s support: the close price %s and volume %s > minimum volume %s",
				s.Symbol,
				closePrice.String(),
				kline.Volume.String(),
				s.MinVolume.String(),
				kline)
		}

		quantity, err := s.calculateQuantity(session, types.SideTypeBuy, closePrice, kline.Volume)
		if err != nil {
			log.WithError(err).Errorf("%s quantity calculation error", s.Symbol)
			return
		}

		orderForm := types.SubmitOrder{
			Symbol:           s.Symbol,
			Market:           s.Market,
			Side:             types.SideTypeBuy,
			Type:             types.OrderTypeMarket,
			Quantity:         quantity,
			MarginSideEffect: s.MarginOrderSideEffect,
		}

		bbgo.Notify("Submitting %s market order buy with quantity %s according to the base volume %s, taker buy base volume %s",
			s.Symbol,
			quantity.String(),
			kline.Volume.String(),
			kline.TakerBuyBaseAssetVolume.String(),
			orderForm)

		if _, err := s.submitOrders(ctx, orderExecutor, orderForm); err != nil {
			log.WithError(err).Error("submit order error")
			return
		}

		if s.TrailingStopTarget.TrailingStopCallbackRatio.IsZero() { // submit fixed target orders
			var targetOrders []types.SubmitOrder
			for _, target := range s.Targets {
				targetPrice := closePrice.Mul(fixedpoint.One.Add(target.ProfitPercentage))
				targetQuantity := quantity.Mul(target.QuantityPercentage)
				targetQuoteQuantity := targetPrice.Mul(targetQuantity)

				if targetQuoteQuantity.Compare(s.Market.MinNotional) <= 0 {
					continue
				}

				if targetQuantity.Compare(s.Market.MinQuantity) <= 0 {
					continue
				}

				targetOrders = append(targetOrders, types.SubmitOrder{
					Symbol:   kline.Symbol,
					Market:   s.Market,
					Type:     types.OrderTypeLimit,
					Side:     types.SideTypeSell,
					Price:    targetPrice,
					Quantity: targetQuantity,

					MarginSideEffect: target.MarginOrderSideEffect,
					TimeInForce:      types.TimeInForceGTC,
				})
			}

			_, err = s.orderExecutor.SubmitOrders(ctx, targetOrders...)
			if err != nil {
				bbgo.Notify("submit %s profit trailing stop order error: %s", s.Symbol, err.Error())
			}
		}
	})

	bbgo.OnShutdown(func(ctx context.Context, wg *sync.WaitGroup) {
		defer wg.Done()

		// Cancel trailing stop order
		if s.TrailingStopTarget.TrailingStopCallbackRatio.Sign() > 0 {
			_ = s.orderExecutor.GracefulCancel(ctx)
		}
	})

	return nil
}

func (s *Strategy) updateStopOrder(ctx context.Context) {
	// cancel the original stop order
	if s.trailingStopControl.StopOrder != nil {
		if err := s.session.Exchange.CancelOrders(ctx, *s.trailingStopControl.StopOrder); err != nil {
			log.WithError(err).Error("cancel order error")
		}
		s.trailingStopControl.StopOrder = nil
		s.orderExecutor.TradeCollector().Process()
	}

	// Calculate minimum target price
	var minTargetPrice = fixedpoint.Zero
	if s.trailingStopControl.minimumProfitPercentage.Sign() > 0 {
		minTargetPrice = s.Position.AverageCost.Mul(fixedpoint.One.Add(s.trailingStopControl.minimumProfitPercentage))
	}

	// Place new order if the target price is higher than the minimum target price
	if s.trailingStopControl.IsHigherThanMin(minTargetPrice) {
		orderForm := s.trailingStopControl.GenerateStopOrder(s.Position.Base)
		orders, err := s.orderExecutor.SubmitOrders(ctx, orderForm)
		if err != nil {
			bbgo.Notify("failed to submit the trailing stop order on %s", s.Symbol)
			log.WithError(err).Error("submit profit trailing stop order error")
		}

		if len(orders) == 0 {
			log.Error("unexpected error: len(createdOrders) = 0")
			return
		}

		s.trailingStopControl.StopOrder = &orders[0]
	}
}