bbgo_origin/pkg/strategy/pivotshort/resistance.go

198 lines
6.7 KiB
Go
Raw Normal View History

package pivotshort
import (
"context"
"github.com/c9s/bbgo/pkg/bbgo"
"github.com/c9s/bbgo/pkg/datatype/floats"
"github.com/c9s/bbgo/pkg/fixedpoint"
"github.com/c9s/bbgo/pkg/indicator"
"github.com/c9s/bbgo/pkg/risk"
"github.com/c9s/bbgo/pkg/types"
)
type ResistanceShort struct {
Enabled bool `json:"enabled"`
Symbol string `json:"-"`
Market types.Market `json:"-"`
types.IntervalWindow
2022-07-02 10:51:17 +00:00
MinDistance fixedpoint.Value `json:"minDistance"`
GroupDistance fixedpoint.Value `json:"groupDistance"`
NumLayers int `json:"numLayers"`
LayerSpread fixedpoint.Value `json:"layerSpread"`
Quantity fixedpoint.Value `json:"quantity"`
Leverage fixedpoint.Value `json:"leverage"`
2022-07-02 10:51:17 +00:00
Ratio fixedpoint.Value `json:"ratio"`
TrendEMA *bbgo.TrendEMA `json:"trendEMA"`
session *bbgo.ExchangeSession
orderExecutor *bbgo.GeneralOrderExecutor
resistancePivot *indicator.PivotLow
2022-07-03 07:26:05 +00:00
resistancePrices []float64
currentResistancePrice fixedpoint.Value
activeOrders *bbgo.ActiveOrderBook
}
func (s *ResistanceShort) Subscribe(session *bbgo.ExchangeSession) {
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.Interval})
if s.TrendEMA != nil {
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.TrendEMA.Interval})
}
}
func (s *ResistanceShort) Bind(session *bbgo.ExchangeSession, orderExecutor *bbgo.GeneralOrderExecutor) {
if s.GroupDistance.IsZero() {
s.GroupDistance = fixedpoint.NewFromFloat(0.01)
}
s.session = session
s.orderExecutor = orderExecutor
s.activeOrders = bbgo.NewActiveOrderBook(s.Symbol)
s.activeOrders.OnFilled(func(o types.Order) {
// reset resistance price
s.currentResistancePrice = fixedpoint.Zero
})
s.activeOrders.BindStream(session.UserDataStream)
if s.TrendEMA != nil {
s.TrendEMA.Bind(session, orderExecutor)
2022-07-02 10:51:17 +00:00
}
s.resistancePivot = session.StandardIndicatorSet(s.Symbol).PivotLow(s.IntervalWindow)
// use the last kline from the history before we get the next closed kline
2022-07-27 03:30:32 +00:00
s.updateResistanceOrders(fixedpoint.NewFromFloat(s.resistancePivot.Last()))
session.MarketDataStream.OnKLineClosed(types.KLineWith(s.Symbol, s.Interval, func(kline types.KLine) {
// trend EMA protection
2022-07-28 03:29:27 +00:00
if s.TrendEMA != nil && !s.TrendEMA.GradientAllowed() {
return
}
position := s.orderExecutor.Position()
if position.IsOpened(kline.Close) {
return
}
s.updateResistanceOrders(kline.Close)
}))
}
2022-07-27 05:54:19 +00:00
// updateCurrentResistancePrice updates the current resistance price
// we should only update the resistance price when:
// 1) the close price is already above the current resistance price by (1 + minDistance)
// 2) the next resistance price is lower than the current resistance price.
func (s *ResistanceShort) updateCurrentResistancePrice(closePrice fixedpoint.Value) bool {
minDistance := s.MinDistance.Float64()
2022-07-03 07:26:05 +00:00
groupDistance := s.GroupDistance.Float64()
2022-07-27 03:30:32 +00:00
resistancePrices := findPossibleResistancePrices(closePrice.Float64()*(1.0+minDistance), groupDistance, s.resistancePivot.Values.Tail(6))
2022-07-03 07:26:05 +00:00
if len(resistancePrices) == 0 {
return false
}
log.Infof("%s close price: %f, min distance: %f, possible resistance prices: %+v", s.Symbol, closePrice.Float64(), minDistance, resistancePrices)
nextResistancePrice := fixedpoint.NewFromFloat(resistancePrices[0])
if s.currentResistancePrice.IsZero() {
s.currentResistancePrice = nextResistancePrice
return true
}
// if the current sell price is out-dated
// or
// the next resistance is lower than the current one.
minPriceToUpdate := s.currentResistancePrice.Mul(one.Add(s.MinDistance))
if closePrice.Compare(minPriceToUpdate) > 0 || nextResistancePrice.Compare(s.currentResistancePrice) < 0 {
2022-07-03 07:26:05 +00:00
s.currentResistancePrice = nextResistancePrice
return true
}
2022-07-03 07:26:05 +00:00
return false
}
func (s *ResistanceShort) updateResistanceOrders(closePrice fixedpoint.Value) {
ctx := context.Background()
resistanceUpdated := s.updateCurrentResistancePrice(closePrice)
2022-07-03 07:26:05 +00:00
if resistanceUpdated {
s.placeResistanceOrders(ctx, s.currentResistancePrice)
} else if s.activeOrders.NumOfOrders() == 0 && !s.currentResistancePrice.IsZero() {
2022-07-03 07:26:05 +00:00
s.placeResistanceOrders(ctx, s.currentResistancePrice)
}
}
func (s *ResistanceShort) placeResistanceOrders(ctx context.Context, resistancePrice fixedpoint.Value) {
totalQuantity, err := risk.CalculateBaseQuantity(s.session, s.Market, resistancePrice, s.Quantity, s.Leverage)
if err != nil {
log.WithError(err).Errorf("quantity calculation error")
}
if totalQuantity.IsZero() {
return
}
2022-07-27 05:01:19 +00:00
bbgo.Notify("Next %s resistance price at %f, updating resistance orders with total quantity %f", s.Symbol, s.currentResistancePrice.Float64(), totalQuantity.Float64())
numLayers := s.NumLayers
if numLayers == 0 {
numLayers = 1
}
numLayersF := fixedpoint.NewFromInt(int64(numLayers))
layerSpread := s.LayerSpread
quantity := totalQuantity.Div(numLayersF)
if s.activeOrders.NumOfOrders() > 0 {
if err := s.orderExecutor.GracefulCancelActiveOrderBook(ctx, s.activeOrders); err != nil {
log.WithError(err).Errorf("can not cancel resistance orders: %+v", s.activeOrders.Orders())
}
}
log.Infof("placing resistance orders: resistance price = %f, layer quantity = %f, num of layers = %d", resistancePrice.Float64(), quantity.Float64(), numLayers)
var sellPriceStart = resistancePrice.Mul(fixedpoint.One.Add(s.Ratio))
var orderForms []types.SubmitOrder
for i := 0; i < numLayers; i++ {
balances := s.session.GetAccount().Balances()
quoteBalance := balances[s.Market.QuoteCurrency]
baseBalance := balances[s.Market.BaseCurrency]
_ = quoteBalance
_ = baseBalance
spread := layerSpread.Mul(fixedpoint.NewFromInt(int64(i)))
price := sellPriceStart.Mul(one.Add(spread))
log.Infof("resistance sell price = %f", price.Float64())
log.Infof("placing resistance short order #%d: price = %f, quantity = %f", i, price.Float64(), quantity.Float64())
orderForms = append(orderForms, types.SubmitOrder{
Symbol: s.Symbol,
Side: types.SideTypeSell,
Type: types.OrderTypeLimitMaker,
Price: price,
Quantity: quantity,
Tag: "resistanceShort",
MarginSideEffect: types.SideEffectTypeMarginBuy,
})
}
createdOrders, err := s.orderExecutor.SubmitOrders(ctx, orderForms...)
if err != nil {
log.WithError(err).Errorf("can not place resistance order")
}
s.activeOrders.Add(createdOrders...)
}
func findPossibleSupportPrices(closePrice float64, groupDistance float64, lows []float64) []float64 {
return floats.Group(floats.Lower(lows, closePrice), groupDistance)
2022-07-02 10:51:17 +00:00
}
func findPossibleResistancePrices(closePrice float64, groupDistance float64, lows []float64) []float64 {
return floats.Group(floats.Higher(lows, closePrice), groupDistance)
2022-07-02 10:51:17 +00:00
}