mirror of
https://github.com/c9s/bbgo.git
synced 2024-11-25 16:25:16 +00:00
610 lines
18 KiB
Go
610 lines
18 KiB
Go
package liquiditymaker
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
log "github.com/sirupsen/logrus"
|
|
|
|
"github.com/c9s/bbgo/pkg/bbgo"
|
|
"github.com/c9s/bbgo/pkg/dbg"
|
|
"github.com/c9s/bbgo/pkg/fixedpoint"
|
|
indicatorv2 "github.com/c9s/bbgo/pkg/indicator/v2"
|
|
"github.com/c9s/bbgo/pkg/strategy/common"
|
|
"github.com/c9s/bbgo/pkg/types"
|
|
"github.com/c9s/bbgo/pkg/util"
|
|
"github.com/c9s/bbgo/pkg/util/tradingutil"
|
|
)
|
|
|
|
const ID = "liquiditymaker"
|
|
const IDAlias = "liqmaker"
|
|
|
|
func init() {
|
|
bbgo.RegisterStrategy(ID, &Strategy{})
|
|
bbgo.RegisterStrategy(IDAlias, &Strategy{})
|
|
}
|
|
|
|
// Strategy is the strategy struct of LiquidityMaker
|
|
// liquidity maker does not care about the current price, it tries to place liquidity orders (limit maker orders)
|
|
// around the current mid price
|
|
// liquidity maker's target:
|
|
// - place enough total liquidity amount on the order book, for example, 20k USDT value liquidity on both sell and buy
|
|
// - ensure the spread by placing the orders from the mid price (or the last trade price)
|
|
type Strategy struct {
|
|
*common.Strategy
|
|
|
|
Environment *bbgo.Environment
|
|
Market types.Market
|
|
|
|
Symbol string `json:"symbol"`
|
|
|
|
LiquidityUpdateInterval types.Interval `json:"liquidityUpdateInterval"`
|
|
|
|
AdjustmentUpdateInterval types.Interval `json:"adjustmentUpdateInterval"`
|
|
AdjustmentOrderMaxQuantity fixedpoint.Value `json:"adjustmentOrderMaxQuantity"`
|
|
AdjustmentOrderPriceType types.PriceType `json:"adjustmentOrderPriceType"`
|
|
|
|
NumOfLiquidityLayers int `json:"numOfLiquidityLayers"`
|
|
LiquiditySlideRule *bbgo.SlideRule `json:"liquidityScale"`
|
|
LiquidityPriceRange fixedpoint.Value `json:"liquidityPriceRange"`
|
|
AskLiquidityAmount fixedpoint.Value `json:"askLiquidityAmount"`
|
|
BidLiquidityAmount fixedpoint.Value `json:"bidLiquidityAmount"`
|
|
|
|
StopBidPrice fixedpoint.Value `json:"stopBidPrice"`
|
|
StopAskPrice fixedpoint.Value `json:"stopAskPrice"`
|
|
|
|
StopEMA *struct {
|
|
Enabled bool `json:"enabled"`
|
|
types.IntervalWindow
|
|
} `json:"stopEMA"`
|
|
|
|
stopEMA *indicatorv2.EWMAStream
|
|
|
|
UseProtectedPriceRange bool `json:"useProtectedPriceRange"`
|
|
|
|
UseLastTradePrice bool `json:"useLastTradePrice"`
|
|
Spread fixedpoint.Value `json:"spread"`
|
|
MaxPrice fixedpoint.Value `json:"maxPrice"`
|
|
MinPrice fixedpoint.Value `json:"minPrice"`
|
|
|
|
MaxPositionExposure fixedpoint.Value `json:"maxPositionExposure"`
|
|
|
|
MinProfit fixedpoint.Value `json:"minProfit"`
|
|
|
|
common.ProfitFixerBundle
|
|
|
|
liquidityOrderBook, adjustmentOrderBook *bbgo.ActiveOrderBook
|
|
|
|
liquidityScale bbgo.Scale
|
|
|
|
orderGenerator *LiquidityOrderGenerator
|
|
|
|
logger log.FieldLogger
|
|
metricsLabels prometheus.Labels
|
|
}
|
|
|
|
func (s *Strategy) ID() string {
|
|
return ID
|
|
}
|
|
|
|
func (s *Strategy) InstanceID() string {
|
|
return fmt.Sprintf("%s:%s", ID, s.Symbol)
|
|
}
|
|
|
|
func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
|
|
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.AdjustmentUpdateInterval})
|
|
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.LiquidityUpdateInterval})
|
|
|
|
if s.StopEMA != nil && s.StopEMA.Interval != "" {
|
|
session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.StopEMA.Interval})
|
|
}
|
|
}
|
|
|
|
func (s *Strategy) Defaults() error {
|
|
if s.AdjustmentOrderPriceType == "" {
|
|
s.AdjustmentOrderPriceType = types.PriceTypeMaker
|
|
}
|
|
|
|
if s.LiquidityUpdateInterval == "" {
|
|
s.LiquidityUpdateInterval = types.Interval1h
|
|
}
|
|
|
|
if s.AdjustmentUpdateInterval == "" {
|
|
s.AdjustmentUpdateInterval = types.Interval5m
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Strategy) Initialize() error {
|
|
if s.Strategy == nil {
|
|
s.Strategy = &common.Strategy{}
|
|
}
|
|
|
|
s.logger = log.WithFields(log.Fields{
|
|
"symbol": s.Symbol,
|
|
"strategy": ID,
|
|
"strategy_id": s.InstanceID(),
|
|
})
|
|
|
|
s.metricsLabels = prometheus.Labels{
|
|
"strategy_type": ID,
|
|
"strategy_id": s.InstanceID(),
|
|
"exchange": "", // FIXME
|
|
"symbol": s.Symbol,
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Strategy) updateMarketMetrics(ctx context.Context) error {
|
|
ticker, err := s.Session.Exchange.QueryTicker(ctx, s.Symbol)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
currentSpread := ticker.Sell.Sub(ticker.Buy)
|
|
|
|
tickerBidMetrics.With(s.metricsLabels).Set(ticker.Buy.Float64())
|
|
tickerAskMetrics.With(s.metricsLabels).Set(ticker.Sell.Float64())
|
|
spreadMetrics.With(s.metricsLabels).Set(currentSpread.Float64())
|
|
return nil
|
|
}
|
|
|
|
func (s *Strategy) liquidityWorker(ctx context.Context, interval types.Interval) {
|
|
metricsTicker := time.NewTicker(5 * time.Second)
|
|
defer metricsTicker.Stop()
|
|
|
|
ticker := time.NewTicker(interval.Duration())
|
|
defer ticker.Stop()
|
|
|
|
s.placeLiquidityOrders(ctx)
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
|
|
case <-metricsTicker.C:
|
|
if err := s.updateMarketMetrics(ctx); err != nil {
|
|
s.logger.WithError(err).Errorf("unable to update market metrics")
|
|
}
|
|
|
|
case <-ticker.C:
|
|
s.placeLiquidityOrders(ctx)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Strategy) Run(ctx context.Context, _ bbgo.OrderExecutor, session *bbgo.ExchangeSession) error {
|
|
if s.ProfitFixerBundle.ProfitFixerConfig != nil {
|
|
market, _ := session.Market(s.Symbol)
|
|
s.Position = types.NewPositionFromMarket(market)
|
|
s.ProfitStats = types.NewProfitStats(market)
|
|
|
|
if err := s.ProfitFixerBundle.Fix(ctx, s.Symbol, s.Position, s.ProfitStats, session); err != nil {
|
|
return err
|
|
}
|
|
|
|
bbgo.Notify("Fixed %s position", s.Symbol, s.Position)
|
|
bbgo.Notify("Fixed %s profitStats", s.Symbol, s.ProfitStats)
|
|
}
|
|
|
|
s.Strategy.Initialize(ctx, s.Environment, session, s.Market, ID, s.InstanceID())
|
|
|
|
if s.StopEMA != nil && s.StopEMA.Enabled {
|
|
s.stopEMA = session.Indicators(s.Symbol).EMA(s.StopEMA.IntervalWindow)
|
|
}
|
|
|
|
s.metricsLabels["exchange"] = session.ExchangeName.String()
|
|
|
|
s.orderGenerator = &LiquidityOrderGenerator{
|
|
Symbol: s.Symbol,
|
|
Market: s.Market,
|
|
logger: s.logger,
|
|
}
|
|
|
|
s.liquidityOrderBook = bbgo.NewActiveOrderBook(s.Symbol)
|
|
s.liquidityOrderBook.BindStream(session.UserDataStream)
|
|
|
|
s.adjustmentOrderBook = bbgo.NewActiveOrderBook(s.Symbol)
|
|
s.adjustmentOrderBook.BindStream(session.UserDataStream)
|
|
|
|
scale, err := s.LiquiditySlideRule.Scale()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := scale.Solve(); err != nil {
|
|
return err
|
|
}
|
|
|
|
s.liquidityScale = scale
|
|
|
|
if err := tradingutil.UniversalCancelAllOrders(ctx, session.Exchange, s.Symbol, nil); err != nil {
|
|
return err
|
|
}
|
|
|
|
session.MarketDataStream.OnKLineClosed(func(k types.KLine) {
|
|
if k.Interval == s.AdjustmentUpdateInterval {
|
|
s.placeAdjustmentOrders(ctx)
|
|
}
|
|
})
|
|
|
|
if intervalProvider, ok := session.Exchange.(types.CustomIntervalProvider); ok {
|
|
if intervalProvider.IsSupportedInterval(s.LiquidityUpdateInterval) {
|
|
session.UserDataStream.OnAuth(func() {
|
|
s.placeLiquidityOrders(ctx)
|
|
})
|
|
session.MarketDataStream.OnKLineClosed(func(k types.KLine) {
|
|
if k.Interval == s.LiquidityUpdateInterval {
|
|
s.placeLiquidityOrders(ctx)
|
|
}
|
|
})
|
|
} else {
|
|
session.UserDataStream.OnStart(func() {
|
|
go s.liquidityWorker(ctx, s.LiquidityUpdateInterval)
|
|
})
|
|
}
|
|
}
|
|
|
|
bbgo.OnShutdown(ctx, func(ctx context.Context, wg *sync.WaitGroup) {
|
|
defer wg.Done()
|
|
|
|
if err := s.liquidityOrderBook.GracefulCancel(ctx, s.Session.Exchange); err != nil {
|
|
util.LogErr(err, "unable to cancel liquidity orders")
|
|
}
|
|
|
|
if err := s.adjustmentOrderBook.GracefulCancel(ctx, s.Session.Exchange); err != nil {
|
|
util.LogErr(err, "unable to cancel adjustment orders")
|
|
}
|
|
|
|
if err := tradingutil.UniversalCancelAllOrders(ctx, s.Session.Exchange, s.Symbol, nil); err != nil {
|
|
util.LogErr(err, "unable to cancel all orders")
|
|
}
|
|
|
|
bbgo.Sync(ctx, s)
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Strategy) placeAdjustmentOrders(ctx context.Context) {
|
|
_ = s.adjustmentOrderBook.GracefulCancel(ctx, s.Session.Exchange)
|
|
|
|
if s.Position.IsDust() {
|
|
return
|
|
}
|
|
|
|
ticker, err := s.Session.Exchange.QueryTicker(ctx, s.Symbol)
|
|
if util.LogErr(err, "unable to query ticker") {
|
|
return
|
|
}
|
|
|
|
if _, err := s.Session.UpdateAccount(ctx); err != nil {
|
|
util.LogErr(err, "unable to update account")
|
|
return
|
|
}
|
|
|
|
baseBal, _ := s.Session.Account.Balance(s.Market.BaseCurrency)
|
|
quoteBal, _ := s.Session.Account.Balance(s.Market.QuoteCurrency)
|
|
|
|
var adjOrders []types.SubmitOrder
|
|
|
|
posSize := s.Position.Base.Abs()
|
|
|
|
if !s.AdjustmentOrderMaxQuantity.IsZero() {
|
|
posSize = fixedpoint.Min(posSize, s.AdjustmentOrderMaxQuantity)
|
|
}
|
|
|
|
tickSize := s.Market.TickSize
|
|
|
|
if s.Position.IsShort() {
|
|
price := s.AdjustmentOrderPriceType.GetPrice(ticker, types.SideTypeBuy)
|
|
price = profitProtectedPrice(types.SideTypeBuy, s.Position.AverageCost, price.Add(tickSize.Neg()), s.Session.MakerFeeRate, s.MinProfit)
|
|
quoteQuantity := fixedpoint.Min(price.Mul(posSize), quoteBal.Available)
|
|
bidQuantity := quoteQuantity.Div(price)
|
|
|
|
if s.Market.IsDustQuantity(bidQuantity, price) {
|
|
return
|
|
}
|
|
|
|
adjOrders = append(adjOrders, types.SubmitOrder{
|
|
Symbol: s.Symbol,
|
|
Type: types.OrderTypeLimitMaker,
|
|
Side: types.SideTypeBuy,
|
|
Price: price,
|
|
Quantity: bidQuantity,
|
|
Market: s.Market,
|
|
TimeInForce: types.TimeInForceGTC,
|
|
})
|
|
} else if s.Position.IsLong() {
|
|
price := s.AdjustmentOrderPriceType.GetPrice(ticker, types.SideTypeSell)
|
|
price = profitProtectedPrice(types.SideTypeSell, s.Position.AverageCost, price.Add(tickSize), s.Session.MakerFeeRate, s.MinProfit)
|
|
askQuantity := fixedpoint.Min(posSize, baseBal.Available)
|
|
|
|
if s.Market.IsDustQuantity(askQuantity, price) {
|
|
return
|
|
}
|
|
|
|
adjOrders = append(adjOrders, types.SubmitOrder{
|
|
Symbol: s.Symbol,
|
|
Type: types.OrderTypeLimitMaker,
|
|
Side: types.SideTypeSell,
|
|
Price: price,
|
|
Quantity: askQuantity,
|
|
Market: s.Market,
|
|
TimeInForce: types.TimeInForceGTC,
|
|
})
|
|
}
|
|
|
|
createdOrders, err := s.OrderExecutor.SubmitOrders(ctx, adjOrders...)
|
|
if util.LogErr(err, "unable to place liquidity orders") {
|
|
return
|
|
}
|
|
|
|
s.adjustmentOrderBook.Add(createdOrders...)
|
|
}
|
|
|
|
func (s *Strategy) placeLiquidityOrders(ctx context.Context) {
|
|
err := s.liquidityOrderBook.GracefulCancel(ctx, s.Session.Exchange)
|
|
if util.LogErr(err, "unable to cancel orders") {
|
|
return
|
|
}
|
|
|
|
ticker, err := s.Session.Exchange.QueryTicker(ctx, s.Symbol)
|
|
if util.LogErr(err, "unable to query ticker") {
|
|
return
|
|
}
|
|
|
|
if s.IsHalted(ticker.Time) {
|
|
s.logger.Warn("circuitBreakRiskControl: trading halted")
|
|
return
|
|
}
|
|
|
|
if _, err := s.Session.UpdateAccount(ctx); err != nil {
|
|
util.LogErr(err, "unable to update account")
|
|
return
|
|
}
|
|
|
|
baseBal, _ := s.Session.Account.Balance(s.Market.BaseCurrency)
|
|
quoteBal, _ := s.Session.Account.Balance(s.Market.QuoteCurrency)
|
|
|
|
if ticker.Buy.IsZero() && ticker.Sell.IsZero() {
|
|
ticker.Sell = ticker.Last.Add(s.Market.TickSize)
|
|
ticker.Buy = ticker.Last.Sub(s.Market.TickSize)
|
|
} else if ticker.Buy.IsZero() {
|
|
ticker.Buy = ticker.Sell.Sub(s.Market.TickSize)
|
|
} else if ticker.Sell.IsZero() {
|
|
ticker.Sell = ticker.Buy.Add(s.Market.TickSize)
|
|
}
|
|
|
|
s.logger.Infof("ticker: %+v", ticker)
|
|
|
|
lastTradedPrice := ticker.GetValidPrice()
|
|
midPrice := ticker.Sell.Add(ticker.Buy).Div(fixedpoint.Two)
|
|
currentSpread := ticker.Sell.Sub(ticker.Buy)
|
|
sideSpread := s.Spread.Div(fixedpoint.Two)
|
|
|
|
if !lastTradedPrice.IsZero() && (s.UseLastTradePrice || midPrice.IsZero()) {
|
|
midPrice = lastTradedPrice
|
|
}
|
|
|
|
s.logger.Infof("current spread: %f lastTradedPrice: %f midPrice: %f", currentSpread.Float64(), lastTradedPrice.Float64(), midPrice.Float64())
|
|
|
|
ask1Price := midPrice.Mul(fixedpoint.One.Add(sideSpread))
|
|
bid1Price := midPrice.Mul(fixedpoint.One.Sub(sideSpread))
|
|
|
|
askLastPrice := midPrice.Mul(fixedpoint.One.Add(s.LiquidityPriceRange))
|
|
bidLastPrice := midPrice.Mul(fixedpoint.One.Sub(s.LiquidityPriceRange))
|
|
s.logger.Infof("wanted side spread: %f askRange: %f ~ %f bidRange: %f ~ %f",
|
|
sideSpread.Float64(),
|
|
ask1Price.Float64(), askLastPrice.Float64(),
|
|
bid1Price.Float64(), bidLastPrice.Float64())
|
|
|
|
midPriceMetrics.With(s.metricsLabels).Set(midPrice.Float64())
|
|
|
|
placeBid := true
|
|
placeAsk := true
|
|
|
|
if s.StopBidPrice.Sign() > 0 && midPrice.Compare(s.StopBidPrice) > 0 {
|
|
s.logger.Infof("mid price %f > stop bid price %f, turning off bid orders", midPrice.Float64(), s.StopBidPrice.Float64())
|
|
placeBid = false
|
|
}
|
|
|
|
if s.StopAskPrice.Sign() > 0 && midPrice.Compare(s.StopAskPrice) < 0 {
|
|
s.logger.Infof("mid price %f < stop ask price %f, turning off ask orders", midPrice.Float64(), s.StopAskPrice.Float64())
|
|
placeAsk = false
|
|
}
|
|
|
|
if s.stopEMA != nil {
|
|
emaPrice := fixedpoint.NewFromFloat(s.stopEMA.Last(0))
|
|
if midPrice.Compare(emaPrice) > 0 {
|
|
s.logger.Infof("mid price %f > stop ema price %f, turning off bid orders", midPrice.Float64(), emaPrice.Float64())
|
|
placeBid = false
|
|
}
|
|
|
|
if midPrice.Compare(emaPrice) < 0 {
|
|
s.logger.Infof("mid price %f < stop ema price %f, turning off ask orders", midPrice.Float64(), emaPrice.Float64())
|
|
placeAsk = false
|
|
}
|
|
}
|
|
|
|
availableBase := baseBal.Available
|
|
availableQuote := quoteBal.Available
|
|
|
|
s.logger.Infof("balances before liq orders: %s, %s",
|
|
baseBal.String(),
|
|
quoteBal.String())
|
|
|
|
if !s.Position.IsDust() {
|
|
positionBase := s.Position.GetBase()
|
|
if s.Position.IsLong() {
|
|
availableBase = availableBase.Sub(positionBase)
|
|
availableBase = s.Market.RoundDownQuantityByPrecision(availableBase)
|
|
|
|
if s.UseProtectedPriceRange {
|
|
ask1Price = profitProtectedPrice(types.SideTypeSell, s.Position.AverageCost, ask1Price, s.Session.MakerFeeRate, s.MinProfit)
|
|
}
|
|
} else if s.Position.IsShort() {
|
|
posSizeInQuote := positionBase.Mul(ticker.Sell)
|
|
availableQuote = availableQuote.Sub(posSizeInQuote)
|
|
|
|
if s.UseProtectedPriceRange {
|
|
bid1Price = profitProtectedPrice(types.SideTypeBuy, s.Position.AverageCost, bid1Price, s.Session.MakerFeeRate, s.MinProfit)
|
|
}
|
|
}
|
|
|
|
if s.MaxPositionExposure.Sign() > 0 {
|
|
if positionBase.Abs().Compare(s.MaxPositionExposure) > 0 {
|
|
if s.Position.IsLong() {
|
|
s.logger.Infof("long position size %f exceeded max position exposure %f, turnning off bid orders",
|
|
positionBase.Float64(), s.MaxPositionExposure.Float64())
|
|
|
|
placeBid = false
|
|
}
|
|
if s.Position.IsShort() {
|
|
s.logger.Infof("short position size %f exceeded max position exposure %f, turnning off ask orders",
|
|
positionBase.Float64(), s.MaxPositionExposure.Float64())
|
|
|
|
placeAsk = false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
s.logger.Infof("place bid: %v, place ask: %v", placeBid, placeAsk)
|
|
|
|
s.logger.Infof("bid liquidity amount %f, ask liquidity amount %f", s.BidLiquidityAmount.Float64(), s.AskLiquidityAmount.Float64())
|
|
|
|
var bidExposureInUsd = fixedpoint.Zero
|
|
var askExposureInUsd = fixedpoint.Zero
|
|
var orderForms []types.SubmitOrder
|
|
|
|
orderPlacementStatusMetrics.With(extendLabels(s.metricsLabels, prometheus.Labels{
|
|
"side": "bid",
|
|
})).Set(bool2float(placeBid))
|
|
|
|
orderPlacementStatusMetrics.With(extendLabels(s.metricsLabels, prometheus.Labels{
|
|
"side": "ask",
|
|
})).Set(bool2float(placeAsk))
|
|
|
|
if placeAsk {
|
|
askOrders := s.orderGenerator.Generate(types.SideTypeSell,
|
|
s.AskLiquidityAmount,
|
|
ask1Price,
|
|
askLastPrice,
|
|
s.NumOfLiquidityLayers,
|
|
s.liquidityScale)
|
|
|
|
askOrders = filterAskOrders(askOrders, baseBal.Available)
|
|
|
|
if len(askOrders) > 0 {
|
|
askLiquidityPriceLowMetrics.With(s.metricsLabels).Set(askOrders[0].Price.Float64())
|
|
askLiquidityPriceHighMetrics.With(s.metricsLabels).Set(askOrders[len(askOrders)-1].Price.Float64())
|
|
}
|
|
|
|
askExposureInUsd = sumOrderQuoteQuantity(askOrders)
|
|
orderForms = append(orderForms, askOrders...)
|
|
}
|
|
|
|
bidLiquidityAmountMetrics.With(s.metricsLabels).Set(s.BidLiquidityAmount.Float64())
|
|
askLiquidityAmountMetrics.With(s.metricsLabels).Set(s.AskLiquidityAmount.Float64())
|
|
liquidityPriceRangeMetrics.With(s.metricsLabels).Set(s.LiquidityPriceRange.Float64())
|
|
|
|
if placeBid {
|
|
bidOrders := s.orderGenerator.Generate(types.SideTypeBuy,
|
|
fixedpoint.Min(s.BidLiquidityAmount, quoteBal.Available),
|
|
bid1Price,
|
|
bidLastPrice,
|
|
s.NumOfLiquidityLayers,
|
|
s.liquidityScale)
|
|
|
|
bidExposureInUsd = sumOrderQuoteQuantity(bidOrders)
|
|
|
|
if len(bidOrders) > 0 {
|
|
bidLiquidityPriceHighMetrics.With(s.metricsLabels).Set(bidOrders[0].Price.Float64())
|
|
bidLiquidityPriceLowMetrics.With(s.metricsLabels).Set(bidOrders[len(bidOrders)-1].Price.Float64())
|
|
}
|
|
|
|
orderForms = append(orderForms, bidOrders...)
|
|
}
|
|
|
|
dbg.DebugSubmitOrders(s.logger, orderForms)
|
|
|
|
createdOrders, err := s.OrderExecutor.SubmitOrders(ctx, orderForms...)
|
|
if util.LogErr(err, "unable to place liquidity orders") {
|
|
return
|
|
}
|
|
|
|
s.liquidityOrderBook.Add(createdOrders...)
|
|
|
|
openOrderBidExposureInUsdMetrics.With(s.metricsLabels).Set(bidExposureInUsd.Float64())
|
|
openOrderAskExposureInUsdMetrics.With(s.metricsLabels).Set(askExposureInUsd.Float64())
|
|
|
|
s.logger.Infof("%d liq orders are placed successfully", len(orderForms))
|
|
for _, o := range createdOrders {
|
|
s.logger.Infof("liq order: %+v", o)
|
|
}
|
|
}
|
|
|
|
func profitProtectedPrice(
|
|
side types.SideType, averageCost, price, feeRate, minProfit fixedpoint.Value,
|
|
) fixedpoint.Value {
|
|
switch side {
|
|
case types.SideTypeSell:
|
|
minProfitPrice := averageCost.Add(
|
|
averageCost.Mul(feeRate.Add(minProfit)))
|
|
return fixedpoint.Max(minProfitPrice, price)
|
|
|
|
case types.SideTypeBuy:
|
|
minProfitPrice := averageCost.Sub(
|
|
averageCost.Mul(feeRate.Add(minProfit)))
|
|
return fixedpoint.Min(minProfitPrice, price)
|
|
|
|
}
|
|
return price
|
|
}
|
|
|
|
func sumOrderQuoteQuantity(orders []types.SubmitOrder) fixedpoint.Value {
|
|
sum := fixedpoint.Zero
|
|
for _, order := range orders {
|
|
sum = sum.Add(order.Price.Mul(order.Quantity))
|
|
}
|
|
return sum
|
|
}
|
|
|
|
func filterAskOrders(askOrders []types.SubmitOrder, available fixedpoint.Value) (out []types.SubmitOrder) {
|
|
usedBase := fixedpoint.Zero
|
|
for _, askOrder := range askOrders {
|
|
if usedBase.Add(askOrder.Quantity).Compare(available) > 0 {
|
|
return out
|
|
}
|
|
|
|
usedBase = usedBase.Add(askOrder.Quantity)
|
|
out = append(out, askOrder)
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
func extendLabels(a, o prometheus.Labels) prometheus.Labels {
|
|
for k, v := range a {
|
|
if _, exists := o[k]; !exists {
|
|
o[k] = v
|
|
}
|
|
}
|
|
|
|
return o
|
|
}
|
|
|
|
func bool2float(b bool) float64 {
|
|
if b {
|
|
return 1.0
|
|
} else {
|
|
return -1.0
|
|
}
|
|
}
|