bbgo_origin/pkg/strategy/schedule/strategy.go

221 lines
6.2 KiB
Go
Raw Normal View History

2021-05-02 10:03:41 +00:00
package schedule
import (
"context"
"fmt"
"github.com/pkg/errors"
2021-05-02 10:03:41 +00:00
log "github.com/sirupsen/logrus"
"github.com/c9s/bbgo/pkg/bbgo"
"github.com/c9s/bbgo/pkg/fixedpoint"
2021-05-02 10:03:41 +00:00
"github.com/c9s/bbgo/pkg/types"
)
const ID = "schedule"
func init() {
bbgo.RegisterStrategy(ID, &Strategy{})
}
type Strategy struct {
Market types.Market
// StandardIndicatorSet contains the standard indicators of a market (symbol)
// This field will be injected automatically since we defined the Symbol field.
*bbgo.StandardIndicatorSet
2021-05-02 10:03:41 +00:00
// Interval is the period that you want to submit order
Interval types.Interval `json:"interval"`
// Symbol is the symbol of the market
Symbol string `json:"symbol"`
// Side is the order side type, which can be buy or sell
Side types.SideType `json:"side,omitempty"`
2021-05-02 10:03:41 +00:00
bbgo.QuantityOrAmount
2021-05-02 10:03:41 +00:00
MaxBaseBalance fixedpoint.Value `json:"maxBaseBalance"`
BelowMovingAverage *bbgo.MovingAverageSettings `json:"belowMovingAverage,omitempty"`
AboveMovingAverage *bbgo.MovingAverageSettings `json:"aboveMovingAverage,omitempty"`
Position *types.Position `persistence:"position"`
session *bbgo.ExchangeSession
orderExecutor *bbgo.GeneralOrderExecutor
2021-05-02 10:03:41 +00:00
}
func (s *Strategy) ID() string {
return ID
}
func (s *Strategy) InstanceID() string {
return fmt.Sprintf("%s:%s", ID, s.Symbol)
}
2021-05-02 10:03:41 +00:00
func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
2022-05-19 01:48:36 +00:00
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.Interval})
2021-08-19 08:35:05 +00:00
if s.BelowMovingAverage != nil {
2022-05-19 01:48:36 +00:00
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.BelowMovingAverage.Interval})
2021-08-19 08:35:05 +00:00
}
if s.AboveMovingAverage != nil {
2022-05-19 01:48:36 +00:00
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.AboveMovingAverage.Interval})
2021-08-19 08:35:05 +00:00
}
2021-05-02 10:03:41 +00:00
}
func (s *Strategy) Validate() error {
if err := s.QuantityOrAmount.Validate(); err != nil {
return err
}
return nil
}
2021-05-02 10:03:41 +00:00
func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) error {
s.session = session
if s.StandardIndicatorSet == nil {
return errors.New("StandardIndicatorSet can not be nil, injection failed?")
}
if s.Position == nil {
s.Position = types.NewPositionFromMarket(s.Market)
}
instanceID := s.InstanceID()
s.orderExecutor = bbgo.NewGeneralOrderExecutor(session, s.Symbol, ID, instanceID, s.Position)
s.orderExecutor.TradeCollector().OnPositionUpdate(func(position *types.Position) {
2022-10-03 10:45:24 +00:00
bbgo.Sync(ctx, s)
})
s.orderExecutor.Bind()
2021-08-26 03:46:02 +00:00
var belowMA types.Float64Indicator
var aboveMA types.Float64Indicator
var err error
if s.BelowMovingAverage != nil {
belowMA, err = s.BelowMovingAverage.Indicator(s.StandardIndicatorSet)
if err != nil {
return err
}
}
if s.AboveMovingAverage != nil {
aboveMA, err = s.AboveMovingAverage.Indicator(s.StandardIndicatorSet)
if err != nil {
return err
}
}
2021-05-27 19:15:29 +00:00
session.MarketDataStream.OnKLineClosed(func(kline types.KLine) {
2021-05-02 10:03:41 +00:00
if kline.Symbol != s.Symbol {
return
}
2021-08-19 08:54:00 +00:00
if kline.Interval != s.Interval {
return
}
closePrice := kline.Close
closePriceF := closePrice.Float64()
quantity := s.QuantityOrAmount.CalculateQuantity(closePrice)
side := s.Side
if s.BelowMovingAverage != nil || s.AboveMovingAverage != nil {
match := false
// if any of the conditions satisfies then we execute order
if belowMA != nil && closePriceF < belowMA.Last() {
match = true
if s.BelowMovingAverage != nil {
if s.BelowMovingAverage.Side != nil {
side = *s.BelowMovingAverage.Side
}
// override the default quantity or amount
if s.BelowMovingAverage.QuantityOrAmount.IsSet() {
quantity = s.BelowMovingAverage.QuantityOrAmount.CalculateQuantity(closePrice)
}
}
} else if aboveMA != nil && closePriceF > aboveMA.Last() {
match = true
if s.AboveMovingAverage != nil {
if s.AboveMovingAverage.Side != nil {
side = *s.AboveMovingAverage.Side
}
if s.AboveMovingAverage.QuantityOrAmount.IsSet() {
quantity = s.AboveMovingAverage.QuantityOrAmount.CalculateQuantity(closePrice)
}
}
}
if !match {
bbgo.Notify("skip, the %s closed price %v is below or above moving average", s.Symbol, closePrice)
return
}
}
2021-05-02 10:03:41 +00:00
// calculate quote quantity for balance checking
quoteQuantity := quantity.Mul(closePrice)
// execute orders
switch side {
2021-05-02 10:03:41 +00:00
case types.SideTypeBuy:
if !s.MaxBaseBalance.IsZero() {
if baseBalance, ok := session.GetAccount().Balance(s.Market.BaseCurrency); ok {
total := baseBalance.Total()
if total.Add(quantity).Compare(s.MaxBaseBalance) >= 0 {
quantity = s.MaxBaseBalance.Sub(total)
quoteQuantity = quantity.Mul(closePrice)
}
}
}
quoteBalance, ok := session.GetAccount().Balance(s.Market.QuoteCurrency)
2021-05-02 10:03:41 +00:00
if !ok {
log.Errorf("can not place scheduled %s order, quote balance %s is empty", s.Symbol, s.Market.QuoteCurrency)
2021-05-02 10:03:41 +00:00
return
}
if quoteBalance.Available.Compare(quoteQuantity) < 0 {
bbgo.Notify("Can not place scheduled %s order: quote balance %s is not enough: %v < %v", s.Symbol, s.Market.QuoteCurrency, quoteBalance.Available, quoteQuantity)
log.Errorf("can not place scheduled %s order: quote balance %s is not enough: %v < %v", s.Symbol, s.Market.QuoteCurrency, quoteBalance.Available, quoteQuantity)
2021-05-02 10:03:41 +00:00
return
}
case types.SideTypeSell:
baseBalance, ok := session.GetAccount().Balance(s.Market.BaseCurrency)
2021-05-02 10:03:41 +00:00
if !ok {
log.Errorf("can not place scheduled %s order, base balance %s is empty", s.Symbol, s.Market.BaseCurrency)
2021-05-02 10:03:41 +00:00
return
}
quantity = fixedpoint.Min(quantity, baseBalance.Available)
quoteQuantity = quantity.Mul(closePrice)
}
2021-05-02 10:03:41 +00:00
if s.Market.IsDustQuantity(quantity, closePrice) {
log.Warnf("%s: quantity %f is too small", s.Symbol, quantity.Float64())
return
2021-05-02 10:03:41 +00:00
}
bbgo.Notify("Submitting scheduled %s order with quantity %s at price %s", s.Symbol, quantity.String(), closePrice.String())
_, err := s.orderExecutor.SubmitOrders(ctx, types.SubmitOrder{
2021-05-02 10:03:41 +00:00
Symbol: s.Symbol,
Side: side,
2021-05-02 10:03:41 +00:00
Type: types.OrderTypeMarket,
Quantity: quantity,
Market: s.Market,
2021-05-02 10:03:41 +00:00
})
if err != nil {
bbgo.Notify("Can not place scheduled %s order: submit error %s", s.Symbol, err.Error())
log.WithError(err).Errorf("can not place scheduled %s order error", s.Symbol)
2021-05-02 10:03:41 +00:00
}
})
return nil
}