bbgo_origin/pkg/strategy/flashcrash/strategy.go

139 lines
4.1 KiB
Go
Raw Normal View History

2020-11-07 04:00:45 +00:00
// flashcrash strategy tries to place the orders at 30%~50% of the current price,
// so that you can catch the orders while flashcrash happens
package flashcrash
import (
"context"
2020-11-12 06:50:08 +00:00
"sync"
2020-11-07 04:00:45 +00:00
log "github.com/sirupsen/logrus"
"github.com/c9s/bbgo/pkg/bbgo"
"github.com/c9s/bbgo/pkg/indicator"
"github.com/c9s/bbgo/pkg/types"
)
2021-02-03 01:08:05 +00:00
const ID = "flashcrash"
2020-11-07 04:00:45 +00:00
func init() {
2021-02-03 01:08:05 +00:00
bbgo.RegisterStrategy(ID, &Strategy{})
2020-11-07 04:00:45 +00:00
}
type Strategy struct {
// These fields will be filled from the config file (it translates YAML to JSON)
// Symbol is the symbol of market you want to run this strategy
Symbol string `json:"symbol"`
// Interval is the interval used to trigger order updates
Interval types.Interval `json:"interval"`
// GridNum is the grid number, how many orders you want to places
GridNum int `json:"gridNumber"`
Percentage float64 `json:"percentage"`
// BaseQuantity is the quantity you want to submit for each order.
BaseQuantity float64 `json:"baseQuantity"`
// activeOrders is the locally maintained active order book of the maker orders.
activeOrders *bbgo.LocalActiveOrderBook
// Injection fields start
// --------------------------
// Market stores the configuration of the market, for example, VolumePrecision, PricePrecision, MinLotSize... etc
// This field will be injected automatically since we defined the Symbol field.
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
2020-11-12 06:50:08 +00:00
// Graceful shutdown function
*bbgo.Graceful
2020-11-07 04:00:45 +00:00
// --------------------------
// ewma is the exponential weighted moving average indicator
ewma *indicator.EWMA
}
2021-02-03 01:08:05 +00:00
func (s *Strategy) ID() string {
return ID
}
2020-11-07 04:00:45 +00:00
func (s *Strategy) updateOrders(orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) {
if err := session.Exchange.CancelOrders(context.Background(), s.activeOrders.Bids.Orders()...); err != nil {
log.WithError(err).Errorf("cancel order error")
}
s.updateBidOrders(orderExecutor, session)
}
func (s *Strategy) updateBidOrders(orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) {
quoteCurrency := s.Market.QuoteCurrency
balances := session.Account.Balances()
balance, ok := balances[quoteCurrency]
2020-11-10 06:18:54 +00:00
if !ok || balance.Available <= 0 {
log.Infof("insufficient balance of %s: %f", quoteCurrency, balance.Available.Float64())
2020-11-07 04:00:45 +00:00
return
}
var startPrice = s.ewma.Last() * s.Percentage
var submitOrders []types.SubmitOrder
2020-11-07 04:19:57 +00:00
for i := 0; i < s.GridNum; i++ {
2020-11-07 04:00:45 +00:00
submitOrders = append(submitOrders, types.SubmitOrder{
Symbol: s.Symbol,
Side: types.SideTypeBuy,
Type: types.OrderTypeLimit,
Market: s.Market,
Quantity: s.BaseQuantity,
Price: startPrice,
TimeInForce: "GTC",
})
startPrice *= s.Percentage
}
orders, err := orderExecutor.SubmitOrders(context.Background(), submitOrders...)
if err != nil {
log.WithError(err).Error("submit bid order error")
return
}
s.activeOrders.Add(orders...)
}
func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: string(s.Interval)})
}
func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) error {
// we don't persist orders so that we can not clear the previous orders for now. just need time to support this.
s.activeOrders = bbgo.NewLocalActiveOrderBook()
s.activeOrders.BindStream(session.UserDataStream)
2020-11-12 06:50:08 +00:00
s.Graceful.OnShutdown(func(ctx context.Context, wg *sync.WaitGroup) {
2020-11-12 06:59:47 +00:00
defer wg.Done()
2020-11-12 06:50:08 +00:00
log.Infof("canceling active orders...")
if err := session.Exchange.CancelOrders(ctx, s.activeOrders.Orders()...); err != nil {
log.WithError(err).Errorf("cancel order error")
}
})
s.ewma = s.StandardIndicatorSet.EWMA(types.IntervalWindow{
2020-11-07 04:00:45 +00:00
Interval: s.Interval,
Window: 25,
})
2021-05-27 19:15:29 +00:00
session.MarketDataStream.OnKLineClosed(func(kline types.KLine) {
2020-11-07 04:00:45 +00:00
s.updateOrders(orderExecutor, session)
})
// TODO: move this to the stream onConnect handler
s.updateOrders(orderExecutor, session)
return nil
}