mirror of
https://github.com/c9s/bbgo.git
synced 2024-11-27 01:05:15 +00:00
623 lines
19 KiB
Go
623 lines
19 KiB
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.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"`
|
|
|
|
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(ctx, 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(ctx, 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]
|
|
}
|
|
}
|