mirror of
https://github.com/c9s/bbgo.git
synced 2024-11-27 01:05:15 +00:00
399 lines
13 KiB
Go
399 lines
13 KiB
Go
package bollgrid
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math"
|
|
"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 = "bollgrid"
|
|
|
|
var log = logrus.WithField("strategy", ID)
|
|
|
|
func init() {
|
|
// Register the pointer of the strategy struct,
|
|
// so that bbgo knows what struct to be used to unmarshal the configs (YAML or JSON)
|
|
// Note: built-in strategies need to imported manually in the bbgo cmd package.
|
|
bbgo.RegisterStrategy(ID, &Strategy{})
|
|
}
|
|
|
|
type Strategy struct {
|
|
// The notification system will be injected into the strategy automatically.
|
|
// This field will be injected automatically since it's a single exchange strategy.
|
|
*bbgo.Notifiability
|
|
|
|
// OrderExecutor is an interface for submitting order.
|
|
// This field will be injected automatically since it's a single exchange strategy.
|
|
bbgo.OrderExecutor
|
|
|
|
// if Symbol string field is defined, bbgo will know it's a symbol-based strategy
|
|
// The following embedded fields will be injected with the corresponding instances.
|
|
|
|
// MarketDataStore is a pointer only injection field. public trades, k-lines (candlestick)
|
|
// and order book updates are maintained in the market data store.
|
|
// This field will be injected automatically since we defined the Symbol field.
|
|
*bbgo.MarketDataStore
|
|
|
|
// StandardIndicatorSet contains the standard indicators of a market (symbol)
|
|
// This field will be injected automatically since we defined the Symbol field.
|
|
*bbgo.StandardIndicatorSet
|
|
|
|
// Graceful let you define the graceful shutdown handler
|
|
*bbgo.Graceful
|
|
|
|
// 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
|
|
|
|
// These fields will be filled from the config file (it translates YAML to JSON)
|
|
Symbol string `json:"symbol"`
|
|
|
|
// Interval is the interval used by the BOLLINGER indicator (which uses K-Line as its source price)
|
|
Interval types.Interval `json:"interval"`
|
|
|
|
// RepostInterval is the interval for re-posting maker orders
|
|
RepostInterval types.Interval `json:"repostInterval"`
|
|
|
|
// GridPips is the pips of grid
|
|
// e.g., 0.001, so that your orders will be submitted at price like 0.127, 0.128, 0.129, 0.130
|
|
GridPips fixedpoint.Value `json:"gridPips"`
|
|
|
|
ProfitSpread fixedpoint.Value `json:"profitSpread"`
|
|
|
|
// GridNum is the grid number, how many orders you want to post on the orderbook.
|
|
GridNum int `json:"gridNumber"`
|
|
|
|
// Quantity is the quantity you want to submit for each order.
|
|
Quantity float64 `json:"quantity"`
|
|
|
|
// activeOrders is the locally maintained active order book of the maker orders.
|
|
activeOrders *bbgo.LocalActiveOrderBook
|
|
|
|
profitOrders *bbgo.LocalActiveOrderBook
|
|
|
|
orders *bbgo.OrderStore
|
|
|
|
// boll is the BOLLINGER indicator we used for predicting the price.
|
|
boll *indicator.BOLL
|
|
|
|
CancelProfitOrdersOnShutdown bool `json: "shutdownCancelProfitOrders"`
|
|
}
|
|
|
|
func (s *Strategy) ID() string {
|
|
return ID
|
|
}
|
|
|
|
func (s *Strategy) Validate() error {
|
|
if s.ProfitSpread <= 0 {
|
|
// If profitSpread is empty or its value is negative
|
|
return fmt.Errorf("profit spread should bigger than 0")
|
|
}
|
|
if s.Quantity <= 0 {
|
|
// If quantity is empty or its value is negative
|
|
return fmt.Errorf("quantity should bigger than 0")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
|
|
if s.Interval == "" {
|
|
panic("bollgrid interval can not be empty")
|
|
}
|
|
|
|
// currently we need the 1m kline to update the last close price and indicators
|
|
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.Interval.String()})
|
|
|
|
if len(s.RepostInterval) > 0 && s.Interval != s.RepostInterval {
|
|
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.RepostInterval.String()})
|
|
}
|
|
}
|
|
|
|
func (s *Strategy) generateGridBuyOrders(session *bbgo.ExchangeSession) ([]types.SubmitOrder, error) {
|
|
balances := session.Account.Balances()
|
|
quoteBalance := balances[s.Market.QuoteCurrency].Available
|
|
if quoteBalance <= 0 {
|
|
return nil, fmt.Errorf("quote balance %s is zero: %f", s.Market.QuoteCurrency, quoteBalance.Float64())
|
|
}
|
|
|
|
upBand, downBand := s.boll.LastUpBand(), s.boll.LastDownBand()
|
|
if upBand <= 0.0 {
|
|
return nil, fmt.Errorf("up band == 0")
|
|
}
|
|
if downBand <= 0.0 {
|
|
return nil, fmt.Errorf("down band == 0")
|
|
}
|
|
|
|
currentPrice, ok := session.LastPrice(s.Symbol)
|
|
if !ok {
|
|
return nil, fmt.Errorf("last price not found")
|
|
}
|
|
|
|
if currentPrice > upBand || currentPrice < downBand {
|
|
return nil, fmt.Errorf("current price %f exceed the bollinger band %f <> %f", currentPrice, upBand, downBand)
|
|
}
|
|
|
|
ema99 := s.StandardIndicatorSet.EWMA(types.IntervalWindow{Interval: s.Interval, Window: 99})
|
|
ema25 := s.StandardIndicatorSet.EWMA(types.IntervalWindow{Interval: s.Interval, Window: 25})
|
|
ema7 := s.StandardIndicatorSet.EWMA(types.IntervalWindow{Interval: s.Interval, Window: 7})
|
|
if ema7.Last() > ema25.Last()*1.001 && ema25.Last() > ema99.Last()*1.0005 {
|
|
log.Infof("all ema lines trend up, skip buy")
|
|
return nil, nil
|
|
}
|
|
|
|
priceRange := upBand - downBand
|
|
gridSize := priceRange / float64(s.GridNum)
|
|
|
|
var orders []types.SubmitOrder
|
|
for price := upBand; price >= downBand; price -= gridSize {
|
|
if price >= currentPrice {
|
|
continue
|
|
}
|
|
// adjust buy quantity using current quote balance
|
|
quantity := bbgo.AdjustFloatQuantityByMaxAmount(s.Quantity, price, quoteBalance.Float64())
|
|
order := types.SubmitOrder{
|
|
Symbol: s.Symbol,
|
|
Side: types.SideTypeBuy,
|
|
Type: types.OrderTypeLimit,
|
|
Market: s.Market,
|
|
Quantity: quantity,
|
|
Price: price,
|
|
TimeInForce: "GTC",
|
|
}
|
|
quoteQuantity := fixedpoint.NewFromFloat(order.Quantity).MulFloat64(price)
|
|
if quantity < s.MinQuantity {
|
|
// don't submit this order if buy quantity is too small
|
|
log.Infof("quote balance %f is not enough, stop generating buy orders", quoteBalance.Float64())
|
|
break
|
|
}
|
|
quoteBalance = quoteBalance.Sub(quoteQuantity)
|
|
log.Infof("submitting order: %s", order.String())
|
|
orders = append(orders, order)
|
|
}
|
|
return orders, nil
|
|
}
|
|
|
|
func (s *Strategy) generateGridSellOrders(session *bbgo.ExchangeSession) ([]types.SubmitOrder, error) {
|
|
balances := session.Account.Balances()
|
|
baseBalance := balances[s.Market.BaseCurrency].Available
|
|
if baseBalance <= 0 {
|
|
return nil, fmt.Errorf("base balance %s is zero: %+v", s.Market.BaseCurrency, baseBalance.Float64())
|
|
}
|
|
|
|
upBand, downBand := s.boll.LastUpBand(), s.boll.LastDownBand()
|
|
if upBand <= 0.0 {
|
|
return nil, fmt.Errorf("up band == 0")
|
|
}
|
|
if downBand <= 0.0 {
|
|
return nil, fmt.Errorf("down band == 0")
|
|
}
|
|
|
|
currentPrice, ok := session.LastPrice(s.Symbol)
|
|
if !ok {
|
|
return nil, fmt.Errorf("last price not found")
|
|
}
|
|
|
|
if currentPrice > upBand || currentPrice < downBand {
|
|
return nil, fmt.Errorf("current price exceed the bollinger band")
|
|
}
|
|
|
|
ema99 := s.StandardIndicatorSet.EWMA(types.IntervalWindow{Interval: s.Interval, Window: 99})
|
|
ema25 := s.StandardIndicatorSet.EWMA(types.IntervalWindow{Interval: s.Interval, Window: 25})
|
|
ema7 := s.StandardIndicatorSet.EWMA(types.IntervalWindow{Interval: s.Interval, Window: 7})
|
|
if ema7.Last() < ema25.Last()*(1-0.004) && ema25.Last() < ema99.Last()*(1-0.0005) {
|
|
log.Infof("all ema lines trend down, skip sell")
|
|
return nil, nil
|
|
}
|
|
|
|
priceRange := upBand - downBand
|
|
gridSize := priceRange / float64(s.GridNum)
|
|
|
|
var orders []types.SubmitOrder
|
|
for price := downBand; price <= upBand; price += gridSize {
|
|
if price <= currentPrice {
|
|
continue
|
|
}
|
|
// adjust sell quantity using current base balance
|
|
quantity := math.Min(s.Quantity, baseBalance.Float64())
|
|
order := types.SubmitOrder{
|
|
Symbol: s.Symbol,
|
|
Side: types.SideTypeSell,
|
|
Type: types.OrderTypeLimit,
|
|
Market: s.Market,
|
|
Quantity: quantity,
|
|
Price: price,
|
|
TimeInForce: "GTC",
|
|
}
|
|
baseQuantity := fixedpoint.NewFromFloat(order.Quantity)
|
|
if quantity < s.MinQuantity {
|
|
// don't submit this order if sell quantity is too small
|
|
log.Infof("base balance %f is not enough, stop generating sell orders", baseBalance.Float64())
|
|
break
|
|
}
|
|
baseBalance = baseBalance.Sub(baseQuantity)
|
|
log.Infof("submitting order: %s", order.String())
|
|
orders = append(orders, order)
|
|
}
|
|
return orders, nil
|
|
}
|
|
|
|
func (s *Strategy) placeGridOrders(orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) {
|
|
sellOrders, err := s.generateGridSellOrders(session)
|
|
if err != nil {
|
|
log.Warn(err.Error())
|
|
}
|
|
createdSellOrders, err := orderExecutor.SubmitOrders(context.Background(), sellOrders...)
|
|
if err != nil {
|
|
log.WithError(err).Errorf("can not place sell orders")
|
|
}
|
|
|
|
buyOrders, err := s.generateGridBuyOrders(session)
|
|
if err != nil {
|
|
log.Warn(err.Error())
|
|
}
|
|
createdBuyOrders, err := orderExecutor.SubmitOrders(context.Background(), buyOrders...)
|
|
if err != nil {
|
|
log.WithError(err).Errorf("can not place buy orders")
|
|
}
|
|
|
|
createdOrders := append(createdSellOrders, createdBuyOrders...)
|
|
s.activeOrders.Add(createdOrders...)
|
|
s.orders.Add(createdOrders...)
|
|
}
|
|
|
|
func (s *Strategy) updateOrders(orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) {
|
|
if err := session.Exchange.CancelOrders(context.Background(), s.activeOrders.Orders()...); err != nil {
|
|
log.WithError(err).Errorf("cancel order error")
|
|
}
|
|
|
|
// skip order updates if up-band - down-band < min profit spread
|
|
if (s.boll.LastUpBand() - s.boll.LastDownBand()) <= s.ProfitSpread.Float64() {
|
|
log.Infof("boll: down band price == up band price, skipping...")
|
|
return
|
|
}
|
|
|
|
s.placeGridOrders(orderExecutor, session)
|
|
|
|
s.activeOrders.Print()
|
|
}
|
|
|
|
func (s *Strategy) submitReverseOrder(order types.Order, session *bbgo.ExchangeSession) {
|
|
balances := session.Account.Balances()
|
|
|
|
var side = order.Side.Reverse()
|
|
var price = order.Price
|
|
var quantity = order.Quantity
|
|
|
|
switch side {
|
|
case types.SideTypeSell:
|
|
price += s.ProfitSpread.Float64()
|
|
maxQuantity := balances[s.Market.BaseCurrency].Available.Float64()
|
|
quantity = math.Min(quantity, maxQuantity)
|
|
|
|
case types.SideTypeBuy:
|
|
price -= s.ProfitSpread.Float64()
|
|
maxQuantity := balances[s.Market.QuoteCurrency].Available.Float64() / price
|
|
quantity = math.Min(quantity, maxQuantity)
|
|
}
|
|
|
|
submitOrder := types.SubmitOrder{
|
|
Symbol: s.Symbol,
|
|
Side: side,
|
|
Type: types.OrderTypeLimit,
|
|
Quantity: quantity,
|
|
Price: price,
|
|
TimeInForce: "GTC",
|
|
}
|
|
|
|
log.Infof("submitting reverse order: %s against %s", submitOrder.String(), order.String())
|
|
|
|
createdOrders, err := s.OrderExecutor.SubmitOrders(context.Background(), submitOrder)
|
|
if err != nil {
|
|
log.WithError(err).Errorf("can not place orders")
|
|
return
|
|
}
|
|
|
|
s.profitOrders.Add(createdOrders...)
|
|
s.orders.Add(createdOrders...)
|
|
}
|
|
|
|
func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) error {
|
|
if s.GridNum == 0 {
|
|
s.GridNum = 2
|
|
}
|
|
|
|
s.boll = s.StandardIndicatorSet.BOLL(types.IntervalWindow{
|
|
Interval: s.Interval,
|
|
Window: 21,
|
|
}, 2.0)
|
|
|
|
s.orders = bbgo.NewOrderStore(s.Symbol)
|
|
s.orders.BindStream(session.Stream)
|
|
|
|
// 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.OnFilled(func(o types.Order) {
|
|
s.submitReverseOrder(o, session)
|
|
})
|
|
s.activeOrders.BindStream(session.Stream)
|
|
|
|
s.profitOrders = bbgo.NewLocalActiveOrderBook()
|
|
s.profitOrders.OnFilled(func(o types.Order) {
|
|
// we made profit here!
|
|
})
|
|
s.profitOrders.BindStream(session.Stream)
|
|
|
|
// setup graceful shutting down handler
|
|
s.Graceful.OnShutdown(func(ctx context.Context, wg *sync.WaitGroup) {
|
|
// call Done to notify the main process.
|
|
defer wg.Done()
|
|
log.Infof("canceling active orders...")
|
|
|
|
if err := session.Exchange.CancelOrders(ctx, s.activeOrders.Orders()...); err != nil {
|
|
log.WithError(err).Errorf("cancel order error")
|
|
}
|
|
|
|
if s.CancelProfitOrdersOnShutdown {
|
|
log.Infof("canceling profit orders...")
|
|
err := session.Exchange.CancelOrders(ctx, s.profitOrders.Orders()...)
|
|
|
|
if err != nil {
|
|
log.WithError(err).Errorf("cancel profit order error")
|
|
}
|
|
}
|
|
})
|
|
|
|
session.Stream.OnStart(func() {
|
|
log.Infof("connected, submitting the first round of the orders")
|
|
s.updateOrders(orderExecutor, session)
|
|
})
|
|
|
|
// avoid using time ticker since we will need back testing here
|
|
session.Stream.OnKLineClosed(func(kline types.KLine) {
|
|
// skip kline events that does not belong to this symbol
|
|
if kline.Symbol != s.Symbol {
|
|
log.Infof("%s != %s", kline.Symbol, s.Symbol)
|
|
return
|
|
}
|
|
|
|
if s.RepostInterval != "" {
|
|
// see if we have enough balances and then we create limit orders on the up band and the down band.
|
|
if s.RepostInterval == kline.Interval {
|
|
s.updateOrders(orderExecutor, session)
|
|
}
|
|
|
|
} else if s.Interval == kline.Interval {
|
|
s.updateOrders(orderExecutor, session)
|
|
}
|
|
})
|
|
|
|
return nil
|
|
}
|