From 3219bd08ec718e5e287615ae79cb60ec0a8a5796 Mon Sep 17 00:00:00 2001 From: anywhy Date: Sun, 27 Oct 2024 10:43:30 +0800 Subject: [PATCH] exit trailing stop add callback by high profit --- pkg/bbgo/exit_trailing_stop.go | 78 +++++++++++++++++++++-------- pkg/bbgo/exit_trailing_stop_test.go | 77 ++++++++++++++++++++++++++++ 2 files changed, 134 insertions(+), 21 deletions(-) diff --git a/pkg/bbgo/exit_trailing_stop.go b/pkg/bbgo/exit_trailing_stop.go index 5c6360af9d..481a1a0de8 100644 --- a/pkg/bbgo/exit_trailing_stop.go +++ b/pkg/bbgo/exit_trailing_stop.go @@ -16,6 +16,9 @@ type TrailingStop2 struct { // CallbackRate is the callback rate from the previous high price CallbackRate fixedpoint.Value `json:"callbackRate,omitempty"` + // CallbackProfitRate is the callback rate from the previous high profit + CallbackProfitRate fixedpoint.Value `json:"callbackProfitRate,omitempty"` + ActivationRatio fixedpoint.Value `json:"activationRatio,omitempty"` // ClosePosition is a percentage of the position to be closed @@ -31,7 +34,8 @@ type TrailingStop2 struct { Side types.SideType `json:"side,omitempty"` - latestHigh fixedpoint.Value + latestHigh fixedpoint.Value + latestHighProfit fixedpoint.Value // activated: when the price reaches the min profit price, we set the activated to true to enable trailing stop activated bool @@ -140,32 +144,48 @@ func (s *TrailingStop2) checkStopPrice(price fixedpoint.Value, position *types.P return nil } - switch s.Side { - case types.SideTypeBuy: - change := price.Sub(s.latestHigh).Div(s.latestHigh) - if change.Compare(s.CallbackRate) >= 0 { - // submit order - return s.triggerStop(price) - } - case types.SideTypeSell: - change := s.latestHigh.Sub(price).Div(s.latestHigh) - if change.Compare(s.CallbackRate) >= 0 { - // submit order - return s.triggerStop(price) - } - default: - if position.IsLong() { - change := s.latestHigh.Sub(price).Div(s.latestHigh) + if !s.CallbackRate.IsZero() { + switch s.Side { + case types.SideTypeBuy: + change := price.Sub(s.latestHigh).Div(s.latestHigh) if change.Compare(s.CallbackRate) >= 0 { // submit order return s.triggerStop(price) } - } else if position.IsShort() { - change := price.Sub(s.latestHigh).Div(s.latestHigh) + case types.SideTypeSell: + change := s.latestHigh.Sub(price).Div(s.latestHigh) if change.Compare(s.CallbackRate) >= 0 { // submit order return s.triggerStop(price) } + default: + if position.IsLong() { + change := s.latestHigh.Sub(price).Div(s.latestHigh) + if change.Compare(s.CallbackRate) >= 0 { + // submit order + return s.triggerStop(price) + } + } else if position.IsShort() { + change := price.Sub(s.latestHigh).Div(s.latestHigh) + if change.Compare(s.CallbackRate) >= 0 { + // submit order + return s.triggerStop(price) + } + } + } + } + + if !s.CallbackProfitRate.IsZero() { + if s.latestHighProfit.IsZero() { + s.latestHighProfit = position.UnrealizedProfit(price) + } else { + profit := position.UnrealizedProfit(price) + change := s.latestHighProfit.Sub(profit).Div(s.latestHighProfit) + if change.Compare(s.CallbackProfitRate) >= 0 { + // submit order + return s.triggerStop(price) + } + s.latestHighProfit = fixedpoint.Max(profit, s.latestHighProfit) } } @@ -177,16 +197,32 @@ func (s *TrailingStop2) triggerStop(price fixedpoint.Value) error { defer func() { s.activated = false s.latestHigh = fixedpoint.Zero + s.latestHighProfit = fixedpoint.Zero }() - Notify("[TrailingStop] %s %s tailingStop is triggered. price: %f callbackRate: %s", s.Symbol, s.ActivationRatio.Percentage(), price.Float64(), s.CallbackRate.Percentage()) + message := fmt.Sprintf("[TrailingStop] %s %s tailingStop is triggered. price: %f ", + s.Symbol, s.ActivationRatio.Percentage(), price.Float64()) + if !s.CallbackRate.IsZero() { + message += fmt.Sprintf(" callbackRate: %s", s.CallbackRate.Percentage()) + } + if !s.CallbackProfitRate.IsZero() { + message += fmt.Sprintf(" callbackProfitRate: %s", s.CallbackProfitRate.Percentage()) + } + Notify("%s", message) + ctx := context.Background() p := fixedpoint.One if !s.ClosePosition.IsZero() { p = s.ClosePosition } - tagName := fmt.Sprintf("trailingStop:activation=%s,callback=%s", s.ActivationRatio.Percentage(), s.CallbackRate.Percentage()) + tagName := fmt.Sprintf("trailingStop:activation=%s", s.ActivationRatio.Percentage()) + if !s.CallbackRate.IsZero() { + tagName += fmt.Sprintf(",callback=%s", s.CallbackRate.Percentage()) + } + if !s.CallbackProfitRate.IsZero() { + tagName += fmt.Sprintf(",callbackProfit=%s", s.CallbackProfitRate.Percentage()) + } return s.orderExecutor.ClosePosition(ctx, p, tagName) } diff --git a/pkg/bbgo/exit_trailing_stop_test.go b/pkg/bbgo/exit_trailing_stop_test.go index d43c6d70a5..fa9bfe017e 100644 --- a/pkg/bbgo/exit_trailing_stop_test.go +++ b/pkg/bbgo/exit_trailing_stop_test.go @@ -182,3 +182,80 @@ func TestTrailingStop_LongPosition(t *testing.T) { assert.False(t, stop.activated) } } + +func TestTrailingStop_CallbackProfitRate(t *testing.T) { + market := getTestMarket() + + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockEx := mocks.NewMockExchange(mockCtrl) + mockEx.EXPECT().NewStream().Return(&types.StandardStream{}).Times(2) + mockEx.EXPECT().SubmitOrder(gomock.Any(), types.SubmitOrder{ + Symbol: "BTCUSDT", + Side: types.SideTypeSell, + Type: types.OrderTypeMarket, + Market: market, + Quantity: fixedpoint.NewFromFloat(1.0), + Tag: "trailingStop:activation=1%,callbackProfit=10%", + MarginSideEffect: types.SideEffectTypeAutoRepay, + }) + + session := NewExchangeSession("test", mockEx) + assert.NotNil(t, session) + + session.markets[market.Symbol] = market + + position := types.NewPositionFromMarket(market) + position.AverageCost = fixedpoint.NewFromFloat(20000.0) + position.Base = fixedpoint.NewFromFloat(1.0) + + orderExecutor := NewGeneralOrderExecutor(session, "BTCUSDT", "test", "test-01", position) + + activationRatio := fixedpoint.NewFromFloat(0.01) + callbackProfitRatio := fixedpoint.NewFromFloat(0.1) + stop := &TrailingStop2{ + Symbol: "BTCUSDT", + Interval: types.Interval1m, + Side: types.SideTypeSell, + CallbackProfitRate: callbackProfitRatio, + ActivationRatio: activationRatio, + } + stop.Bind(session, orderExecutor) + + // the same price + currentPrice := fixedpoint.NewFromFloat(20000.0) + err := stop.checkStopPrice(currentPrice, position) + if assert.NoError(t, err) { + assert.False(t, stop.activated) + } + + // 20000 + 1% = 20200 + currentPrice = currentPrice.Mul(one.Add(activationRatio)) + assert.Equal(t, fixedpoint.NewFromFloat(20200.0), currentPrice) + + err = stop.checkStopPrice(currentPrice, position) + if assert.NoError(t, err) { + assert.True(t, stop.activated) + assert.Equal(t, fixedpoint.NewFromFloat(200), stop.latestHighProfit) + } + + // 20200 + 1% = 20402 + currentPrice = currentPrice.Mul(one.Add(activationRatio)) + assert.Equal(t, fixedpoint.NewFromFloat(20402.0), currentPrice) + + err = stop.checkStopPrice(currentPrice, position) + if assert.NoError(t, err) { + assert.Equal(t, fixedpoint.NewFromFloat(402), stop.latestHighProfit) + assert.True(t, stop.activated) + } + + // 20402 - 402*(1-10%) + currentPrice = currentPrice.Sub(stop.latestHighProfit.Mul(one.Sub(callbackProfitRatio))) + assert.Equal(t, fixedpoint.NewFromFloat(20040.2), currentPrice) + err = stop.checkStopPrice(currentPrice, position) + if assert.NoError(t, err) { + assert.False(t, stop.activated) + assert.Equal(t, fixedpoint.Zero, stop.latestHighProfit) + } +}