mirror of
https://github.com/c9s/bbgo.git
synced 2024-11-14 02:53:50 +00:00
480 lines
15 KiB
Go
480 lines
15 KiB
Go
package rsmaker
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math"
|
|
|
|
"github.com/c9s/bbgo/pkg/indicator"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/sirupsen/logrus"
|
|
|
|
"github.com/muesli/clusters"
|
|
"github.com/muesli/kmeans"
|
|
|
|
"github.com/c9s/bbgo/pkg/bbgo"
|
|
"github.com/c9s/bbgo/pkg/fixedpoint"
|
|
"github.com/c9s/bbgo/pkg/types"
|
|
)
|
|
|
|
const ID = "rsmaker"
|
|
|
|
var notionModifier = fixedpoint.NewFromFloat(1.1)
|
|
|
|
var log = logrus.WithField("strategy", ID)
|
|
|
|
func init() {
|
|
bbgo.RegisterStrategy(ID, &Strategy{})
|
|
}
|
|
|
|
type Strategy struct {
|
|
Environment *bbgo.Environment
|
|
StandardIndicatorSet *bbgo.StandardIndicatorSet
|
|
Market types.Market
|
|
|
|
// Symbol is the market symbol you want to trade
|
|
Symbol string `json:"symbol"`
|
|
|
|
// Interval is how long do you want to update your order price and quantity
|
|
Interval types.Interval `json:"interval"`
|
|
|
|
bbgo.QuantityOrAmount
|
|
|
|
// Spread is the price spread from the middle price.
|
|
// For ask orders, the ask price is ((bestAsk + bestBid) / 2 * (1.0 + spread))
|
|
// For bid orders, the bid price is ((bestAsk + bestBid) / 2 * (1.0 - spread))
|
|
// Spread can be set by percentage or floating number. e.g., 0.1% or 0.001
|
|
Spread fixedpoint.Value `json:"spread"`
|
|
|
|
// BidSpread overrides the spread setting, this spread will be used for the buy order
|
|
BidSpread fixedpoint.Value `json:"bidSpread,omitempty"`
|
|
|
|
// AskSpread overrides the spread setting, this spread will be used for the sell order
|
|
AskSpread fixedpoint.Value `json:"askSpread,omitempty"`
|
|
|
|
// MinProfitSpread is the minimal order price spread from the current average cost.
|
|
// For long position, you will only place sell order above the price (= average cost * (1 + minProfitSpread))
|
|
// For short position, you will only place buy order below the price (= average cost * (1 - minProfitSpread))
|
|
MinProfitSpread fixedpoint.Value `json:"minProfitSpread"`
|
|
|
|
// UseTickerPrice use the ticker api to get the mid price instead of the closed kline price.
|
|
// The back-test engine is kline-based, so the ticker price api is not supported.
|
|
// Turn this on if you want to do real trading.
|
|
UseTickerPrice bool `json:"useTickerPrice"`
|
|
|
|
// MaxExposurePosition is the maximum position you can hold
|
|
// +10 means you can hold 10 ETH long position by maximum
|
|
// -10 means you can hold -10 ETH short position by maximum
|
|
MaxExposurePosition fixedpoint.Value `json:"maxExposurePosition"`
|
|
|
|
// DynamicExposurePositionScale is used to define the exposure position range with the given percentage
|
|
// when DynamicExposurePositionScale is set,
|
|
// your MaxExposurePosition will be calculated dynamically according to the bollinger band you set.
|
|
DynamicExposurePositionScale *bbgo.PercentageScale `json:"dynamicExposurePositionScale"`
|
|
|
|
// Long means your position will be long position
|
|
// Currently not used yet
|
|
Long *bool `json:"long,omitempty"`
|
|
|
|
// Short means your position will be long position
|
|
// Currently not used yet
|
|
Short *bool `json:"short,omitempty"`
|
|
|
|
// DisableShort means you can don't want short position during the market making
|
|
// Set to true if you want to hold more spot during market making.
|
|
DisableShort bool `json:"disableShort"`
|
|
|
|
// BuyBelowNeutralSMA if true, the market maker will only place buy order when the current price is below the neutral band SMA.
|
|
BuyBelowNeutralSMA bool `json:"buyBelowNeutralSMA"`
|
|
|
|
// NeutralBollinger is the smaller range of the bollinger band
|
|
// If price is in this band, it usually means the price is oscillating.
|
|
// If price goes out of this band, we tend to not place sell orders or buy orders
|
|
NeutralBollinger *types.BollingerSetting `json:"neutralBollinger"`
|
|
|
|
// DefaultBollinger is the wide range of the bollinger band
|
|
// for controlling your exposure position
|
|
DefaultBollinger *types.BollingerSetting `json:"defaultBollinger"`
|
|
|
|
// DowntrendSkew is the order quantity skew for normal downtrend band.
|
|
// The price is still in the default bollinger band.
|
|
// greater than 1.0 means when placing buy order, place sell order with less quantity
|
|
// less than 1.0 means when placing sell order, place buy order with less quantity
|
|
DowntrendSkew fixedpoint.Value `json:"downtrendSkew"`
|
|
|
|
// UptrendSkew is the order quantity skew for normal uptrend band.
|
|
// The price is still in the default bollinger band.
|
|
// greater than 1.0 means when placing buy order, place sell order with less quantity
|
|
// less than 1.0 means when placing sell order, place buy order with less quantity
|
|
UptrendSkew fixedpoint.Value `json:"uptrendSkew"`
|
|
|
|
// TradeInBand
|
|
// When this is on, places orders only when the current price is in the bollinger band.
|
|
TradeInBand bool `json:"tradeInBand"`
|
|
|
|
// ShadowProtection is used to avoid placing bid order when price goes down strongly (without shadow)
|
|
ShadowProtection bool `json:"shadowProtection"`
|
|
ShadowProtectionRatio fixedpoint.Value `json:"shadowProtectionRatio"`
|
|
|
|
Position *types.Position `persistence:"position"`
|
|
ProfitStats *types.ProfitStats `persistence:"profit_stats"`
|
|
TradeStats *types.TradeStats `persistence:"trade_stats"`
|
|
|
|
bbgo.SmartStops
|
|
|
|
session *bbgo.ExchangeSession
|
|
orderExecutor *bbgo.GeneralOrderExecutor
|
|
book *types.StreamOrderBook
|
|
|
|
groupID uint32
|
|
|
|
// defaultBoll is the BOLLINGER indicator we used for predicting the price.
|
|
defaultBoll *indicator.BOLL
|
|
|
|
// neutralBoll is the neutral price section
|
|
neutralBoll *indicator.BOLL
|
|
|
|
// StrategyController
|
|
status types.StrategyStatus
|
|
}
|
|
|
|
func (s *Strategy) ID() string {
|
|
return ID
|
|
}
|
|
|
|
func (s *Strategy) Initialize() error {
|
|
return s.SmartStops.InitializeStopControllers(s.Symbol)
|
|
}
|
|
|
|
func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
|
|
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{
|
|
Interval: s.Interval,
|
|
})
|
|
// s.SmartStops.Subscribe(session)
|
|
}
|
|
|
|
func (s *Strategy) Validate() error {
|
|
if len(s.Symbol) == 0 {
|
|
return errors.New("symbol is required")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Strategy) CurrentPosition() *types.Position {
|
|
return s.Position
|
|
}
|
|
|
|
func (s *Strategy) ClosePosition(ctx context.Context, percentage fixedpoint.Value) error {
|
|
return s.orderExecutor.ClosePosition(ctx, percentage)
|
|
}
|
|
|
|
// StrategyController
|
|
func (s *Strategy) GetStatus() types.StrategyStatus {
|
|
return s.status
|
|
}
|
|
|
|
func (s *Strategy) Suspend(ctx context.Context) error {
|
|
s.status = types.StrategyStatusStopped
|
|
|
|
if err := s.orderExecutor.GracefulCancel(ctx); err != nil {
|
|
log.WithError(err).Errorf("graceful cancel order error")
|
|
}
|
|
|
|
bbgo.Sync(s)
|
|
return nil
|
|
}
|
|
|
|
func (s *Strategy) Resume(ctx context.Context) error {
|
|
s.status = types.StrategyStatusRunning
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Strategy) getCurrentAllowedExposurePosition(bandPercentage float64) (fixedpoint.Value, error) {
|
|
if s.DynamicExposurePositionScale != nil {
|
|
v, err := s.DynamicExposurePositionScale.Scale(bandPercentage)
|
|
if err != nil {
|
|
return fixedpoint.Zero, err
|
|
}
|
|
return fixedpoint.NewFromFloat(v), nil
|
|
}
|
|
|
|
return s.MaxExposurePosition, nil
|
|
}
|
|
|
|
func (s *Strategy) placeOrders(ctx context.Context, midPrice fixedpoint.Value, klines []*types.KLine) {
|
|
// preprocessing
|
|
max := 0.
|
|
min := 100000.
|
|
|
|
mv := 0.
|
|
for x := 0; x < 50; x++ {
|
|
if klines[x].High.Float64() > max {
|
|
max = klines[x].High.Float64()
|
|
}
|
|
if klines[x].Low.Float64() < min {
|
|
min = klines[x].High.Float64()
|
|
}
|
|
|
|
mv += klines[x].Volume.Float64()
|
|
}
|
|
mv = mv / 50
|
|
|
|
// logrus.Info(max, min)
|
|
// set up a random two-dimensional data set (float64 values between 0.0 and 1.0)
|
|
var d clusters.Observations
|
|
for x := 0; x < 50; x++ {
|
|
// if klines[x].High.Float64() < max || klines[x].Low.Float64() > min {
|
|
if klines[x].Volume.Float64() > mv*0.3 {
|
|
d = append(d, clusters.Coordinates{
|
|
klines[x].High.Float64(),
|
|
klines[x].Low.Float64(),
|
|
// klines[x].Open.Float64(),
|
|
// klines[x].Close.Float64(),
|
|
// klines[x].Volume.Float64(),
|
|
})
|
|
}
|
|
// }
|
|
|
|
}
|
|
log.Info(len(d))
|
|
|
|
// Partition the data points into 2 clusters
|
|
km := kmeans.New()
|
|
clusters, err := km.Partition(d, 3)
|
|
|
|
// for _, c := range clusters {
|
|
// fmt.Printf("Centered at x: %.2f y: %.2f\n", c.Center[0], c.Center[1])
|
|
// fmt.Printf("Matching data points: %+v\n\n", c.Observations)
|
|
// }
|
|
// clustered virtual kline_1's mid price
|
|
// vk1mp := fixedpoint.NewFromFloat((clusters[0].Center[0] + clusters[0].Center[1]) / 2.)
|
|
// clustered virtual kline_2's mid price
|
|
// vk2mp := fixedpoint.NewFromFloat((clusters[1].Center[0] + clusters[1].Center[1]) / 2.)
|
|
// clustered virtual kline_3's mid price
|
|
// vk3mp := fixedpoint.NewFromFloat((clusters[2].Center[0] + clusters[2].Center[1]) / 2.)
|
|
|
|
// clustered virtual kline_1's high price
|
|
vk1hp := fixedpoint.NewFromFloat(clusters[0].Center[0])
|
|
// clustered virtual kline_2's high price
|
|
vk2hp := fixedpoint.NewFromFloat(clusters[1].Center[0])
|
|
// clustered virtual kline_3's high price
|
|
vk3hp := fixedpoint.NewFromFloat(clusters[2].Center[0])
|
|
|
|
// clustered virtual kline_1's low price
|
|
vk1lp := fixedpoint.NewFromFloat(clusters[0].Center[1])
|
|
// clustered virtual kline_2's low price
|
|
vk2lp := fixedpoint.NewFromFloat(clusters[1].Center[1])
|
|
// clustered virtual kline_3's low price
|
|
vk3lp := fixedpoint.NewFromFloat(clusters[2].Center[1])
|
|
|
|
askPrice := fixedpoint.NewFromFloat(math.Max(math.Max(vk1hp.Float64(), vk2hp.Float64()), vk3hp.Float64())) // fixedpoint.NewFromFloat(math.Max(math.Max(vk1mp.Float64(), vk2mp.Float64()), vk3mp.Float64()))
|
|
bidPrice := fixedpoint.NewFromFloat(math.Min(math.Min(vk1lp.Float64(), vk2lp.Float64()), vk3lp.Float64())) // fixedpoint.NewFromFloat(math.Min(math.Min(vk1mp.Float64(), vk2mp.Float64()), vk3mp.Float64()))
|
|
|
|
// if vk1mp.Compare(vk2mp) > 0 {
|
|
// askPrice = vk1mp //.Mul(fixedpoint.NewFromFloat(1.001))
|
|
// bidPrice = vk2mp //.Mul(fixedpoint.NewFromFloat(0.999))
|
|
// } else if vk1mp.Compare(vk2mp) < 0 {
|
|
// askPrice = vk2mp //.Mul(fixedpoint.NewFromFloat(1.001))
|
|
// bidPrice = vk1mp //.Mul(fixedpoint.NewFromFloat(0.999))
|
|
// }
|
|
// midPrice.Mul(fixedpoint.One.Add(askSpread))
|
|
// midPrice.Mul(fixedpoint.One.Sub(bidSpread))
|
|
base := s.Position.GetBase()
|
|
// balances := s.session.GetAccount().Balances()
|
|
|
|
canSell := true
|
|
canBuy := true
|
|
|
|
// predMidPrice := (askPrice + bidPrice) / 2.
|
|
|
|
// if midPrice.Float64() > predMidPrice.Float64() {
|
|
// bidPrice = predMidPrice.Mul(fixedpoint.NewFromFloat(0.999))
|
|
// }
|
|
//
|
|
// if midPrice.Float64() < predMidPrice.Float64() {
|
|
// askPrice = predMidPrice.Mul(fixedpoint.NewFromFloat(1.001))
|
|
// }
|
|
//
|
|
// if midPrice.Float64() > askPrice.Float64() {
|
|
// canBuy = false
|
|
// askPrice = midPrice.Mul(fixedpoint.NewFromFloat(1.001))
|
|
// }
|
|
//
|
|
// if midPrice.Float64() < bidPrice.Float64() {
|
|
// canSell = false
|
|
// bidPrice = midPrice.Mul(fixedpoint.NewFromFloat(0.999))
|
|
// }
|
|
|
|
sellQuantity := s.QuantityOrAmount.CalculateQuantity(askPrice)
|
|
buyQuantity := s.QuantityOrAmount.CalculateQuantity(bidPrice)
|
|
|
|
sellOrder := types.SubmitOrder{
|
|
Symbol: s.Symbol,
|
|
Side: types.SideTypeSell,
|
|
Type: types.OrderTypeLimitMaker,
|
|
Quantity: sellQuantity,
|
|
Price: askPrice,
|
|
Market: s.Market,
|
|
GroupID: s.groupID,
|
|
}
|
|
buyOrder := types.SubmitOrder{
|
|
Symbol: s.Symbol,
|
|
Side: types.SideTypeBuy,
|
|
Type: types.OrderTypeLimitMaker,
|
|
Quantity: buyQuantity,
|
|
Price: bidPrice,
|
|
Market: s.Market,
|
|
GroupID: s.groupID,
|
|
}
|
|
|
|
var submitBuyOrders []types.SubmitOrder
|
|
var submitSellOrders []types.SubmitOrder
|
|
|
|
// baseBalance, hasBaseBalance := balances[s.Market.BaseCurrency]
|
|
// quoteBalance, hasQuoteBalance := balances[s.Market.QuoteCurrency]
|
|
|
|
downBand := s.defaultBoll.LastDownBand()
|
|
upBand := s.defaultBoll.LastUpBand()
|
|
sma := s.defaultBoll.LastSMA()
|
|
log.Infof("bollinger band: up %f sma %f down %f", upBand, sma, downBand)
|
|
|
|
bandPercentage := calculateBandPercentage(upBand, downBand, sma, midPrice.Float64())
|
|
log.Infof("mid price band percentage: %v", bandPercentage)
|
|
|
|
maxExposurePosition, err := s.getCurrentAllowedExposurePosition(bandPercentage)
|
|
if err != nil {
|
|
log.WithError(err).Errorf("can not calculate CurrentAllowedExposurePosition")
|
|
return
|
|
}
|
|
|
|
log.Infof("calculated max exposure position: %v", maxExposurePosition)
|
|
|
|
if maxExposurePosition.Sign() > 0 && base.Compare(maxExposurePosition) > 0 {
|
|
canBuy = false
|
|
}
|
|
|
|
if maxExposurePosition.Sign() > 0 {
|
|
if s.Long != nil && *s.Long && base.Sign() < 0 {
|
|
canSell = false
|
|
} else if base.Compare(maxExposurePosition.Neg()) < 0 {
|
|
canSell = false
|
|
}
|
|
}
|
|
|
|
if canSell {
|
|
submitSellOrders = append(submitSellOrders, sellOrder)
|
|
}
|
|
if canBuy {
|
|
submitBuyOrders = append(submitBuyOrders, buyOrder)
|
|
}
|
|
|
|
for i := range submitBuyOrders {
|
|
submitBuyOrders[i] = s.adjustOrderQuantity(submitBuyOrders[i])
|
|
}
|
|
|
|
for i := range submitSellOrders {
|
|
submitSellOrders[i] = s.adjustOrderQuantity(submitSellOrders[i])
|
|
}
|
|
|
|
if _, err := s.orderExecutor.SubmitOrders(ctx, submitBuyOrders...); err != nil {
|
|
log.WithError(err).Errorf("can not place orders")
|
|
}
|
|
if _, err := s.orderExecutor.SubmitOrders(ctx, submitSellOrders...); err != nil {
|
|
log.WithError(err).Errorf("can not place orders")
|
|
}
|
|
}
|
|
|
|
func (s *Strategy) adjustOrderQuantity(submitOrder types.SubmitOrder) types.SubmitOrder {
|
|
if submitOrder.Quantity.Mul(submitOrder.Price).Compare(s.Market.MinNotional) < 0 {
|
|
submitOrder.Quantity = bbgo.AdjustFloatQuantityByMinAmount(submitOrder.Quantity, submitOrder.Price, s.Market.MinNotional.Mul(notionModifier))
|
|
}
|
|
|
|
if submitOrder.Quantity.Compare(s.Market.MinQuantity) < 0 {
|
|
submitOrder.Quantity = fixedpoint.Max(submitOrder.Quantity, s.Market.MinQuantity)
|
|
}
|
|
|
|
return submitOrder
|
|
}
|
|
|
|
func (s *Strategy) Run(ctx context.Context, _ bbgo.OrderExecutor, session *bbgo.ExchangeSession) error {
|
|
instanceID := fmt.Sprintf("%s-%s", ID, s.Symbol)
|
|
|
|
s.status = types.StrategyStatusRunning
|
|
|
|
if s.Position == nil {
|
|
s.Position = types.NewPositionFromMarket(s.Market)
|
|
}
|
|
|
|
if s.ProfitStats == nil {
|
|
s.ProfitStats = types.NewProfitStats(s.Market)
|
|
}
|
|
|
|
if s.TradeStats == nil {
|
|
s.TradeStats = types.NewTradeStats(s.Symbol)
|
|
}
|
|
|
|
// initial required information
|
|
s.session = session
|
|
s.orderExecutor = bbgo.NewGeneralOrderExecutor(session, s.Symbol, ID, instanceID, s.Position)
|
|
s.orderExecutor.BindEnvironment(s.Environment)
|
|
s.orderExecutor.BindProfitStats(s.ProfitStats)
|
|
s.orderExecutor.BindTradeStats(s.TradeStats)
|
|
s.orderExecutor.TradeCollector().OnPositionUpdate(func(position *types.Position) {
|
|
bbgo.Sync(s)
|
|
})
|
|
s.orderExecutor.Bind()
|
|
|
|
s.neutralBoll = s.StandardIndicatorSet.BOLL(s.NeutralBollinger.IntervalWindow, s.NeutralBollinger.BandWidth)
|
|
s.defaultBoll = s.StandardIndicatorSet.BOLL(s.DefaultBollinger.IntervalWindow, s.DefaultBollinger.BandWidth)
|
|
|
|
// s.SmartStops.RunStopControllers(ctx, session, s.tradeCollector)
|
|
|
|
var klines []*types.KLine
|
|
session.MarketDataStream.OnKLineClosed(func(kline types.KLine) {
|
|
// StrategyController
|
|
if s.status != types.StrategyStatusRunning {
|
|
return
|
|
}
|
|
|
|
// if kline.Symbol != s.Symbol || kline.Interval != s.Interval {
|
|
// return
|
|
// }
|
|
|
|
if kline.Interval == s.Interval {
|
|
klines = append(klines, &kline)
|
|
}
|
|
|
|
if len(klines) > 50 {
|
|
if kline.Interval == s.Interval {
|
|
if err := s.orderExecutor.GracefulCancel(ctx); err != nil {
|
|
log.WithError(err).Errorf("graceful cancel order error")
|
|
}
|
|
|
|
s.placeOrders(ctx, kline.Close, klines[len(klines)-50:])
|
|
}
|
|
}
|
|
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
func calculateBandPercentage(up, down, sma, midPrice float64) float64 {
|
|
if midPrice < sma {
|
|
// should be negative percentage
|
|
return (midPrice - sma) / math.Abs(sma-down)
|
|
} else if midPrice > sma {
|
|
// should be positive percentage
|
|
return (midPrice - sma) / math.Abs(up-sma)
|
|
}
|
|
|
|
return 0.0
|
|
}
|
|
|
|
func inBetween(x, a, b float64) bool {
|
|
return a < x && x < b
|
|
}
|