Merge pull request #698 from c9s/strategy/pivot

strategy pivotshort: refactor and add stop EMA

config/pivotshort-ETHUSDT.yaml

@@ -12,28 +12,51 @@ exchangeStrategies:
   pivotshort:
     symbol: ETHUSDT
     interval: 5m
+    pivotLength: 200
 
-    pivotLength:  120
+    # breakLow settings are used for shorting when the current price break the previous low
-
+    breakLow:
-    entry:
+      ratio: 0.1%
       quantity: 10.0
-      marginOrderSideEffect: borrow
+      stopEMARange: 5%
+      stopEMA:
+        interval: 1h
+        window: 99
+
+    bounceShort:
+      quantity: 10.0
+      # stopLossPercentage: 1%
+      numOfLayers: 10
+      layerSpread: 0.1%
+      pivotRatio: 0.1%
 
     exit:
-      takeProfitPercentage: 25%
+      # roiStopLossPercentage is the stop loss percentage of the position ROI (currently the price change)
-      stopLossPercentage: 1%
+      roiStopLossPercentage: 1%
-      lowerShadowRatio: 0.95
-      marginOrderSideEffect: repay
 
+      # roiTakeProfitPercentage is the take profit percentage of the position ROI (currently the price change)
+      # force to take the profit ROI exceeded the percentage.
+      roiTakeProfitPercentage: 25%
+
+      # lowerShadowRatio is used to force taking profit when the (lower shadow height / low price) > lowerShadowRatio
+      # you can grab a simple stats by the following SQL:
+      # SELECT ((close - low) / close) AS shadow_ratio FROM binance_klines WHERE symbol = 'ETHUSDT' AND `interval` = '5m' AND start_time > '2022-01-01' ORDER BY shadow_ratio DESC LIMIT 20;
+      lowerShadowRatio: 3%
+
+      cumulatedVolume:
+        minVolume: 50_000
+        window: 5
+
+      marginOrderSideEffect: repay
 
 backtest:
   sessions:
-    - binance
+  - binance
   startTime: "2022-04-01"
-  endTime: "2022-06-03"
+  endTime: "2022-06-08"
   symbols:
-    - ETHUSDT
+  - ETHUSDT
-  account:
+  accounts:
     binance:
       balances:
         ETH: 10.0

config/pivotshort-GMTBUSD.yaml

@@ -37,7 +37,7 @@ backtest:
   endTime: "2022-06-03"
   symbols:
     - GMTBUSD
-  account:
+  accounts:
     binance:
       balances:
         GMT: 3_000.0

config/pivotshort.yaml

@@ -14,27 +14,45 @@ exchangeStrategies:
     symbol: GMTUSDT
     interval: 5m
 
-    pivotLength:  120
+    pivotLength: 120
 
-    entry:
+    # breakLow settings are used for shorting when the current price break the previous low
-      quantity: 3000.0
+    breakLow:
-#      marginOrderSideEffect: borrow
+      ratio: 0.1%
+      quantity: 10.0
+      stopEMARange: 5%
+      stopEMA:
+        interval: 1h
+        window: 99
 
     exit:
-      takeProfitPercentage: 25%
+      # roiStopLossPercentage is the stop loss percentage of the position ROI (currently the price change)
-      stopLossPercentage: 1%
+      roiStopLossPercentage: 1%
-      lowerShadowRatio: 0.95
+
-#      marginOrderSideEffect: repay
+      # roiTakeProfitPercentage is the take profit percentage of the position ROI (currently the price change)
+      # force to take the profit ROI exceeded the percentage.
+      roiTakeProfitPercentage: 25%
+
+      # lowerShadowRatio is used to force taking profit when the (lower shadow height / low price) > lowerShadowRatio
+      # you can grab a simple stats by the following SQL:
+      # SELECT ((close - low) / close) AS shadow_ratio FROM binance_klines WHERE symbol = 'ETHUSDT' AND `interval` = '5m' AND start_time > '2022-01-01' ORDER BY shadow_ratio DESC LIMIT 20;
+      lowerShadowRatio: 3%
+
+      cumulatedVolume:
+        minVolume: 50_000
+        window: 5
+
+      marginOrderSideEffect: repay
 
 
 backtest:
   sessions:
-    - binance
+  - binance
   startTime: "2022-05-01"
   endTime: "2022-06-03"
   symbols:
-    - GMTUSDT
+  - GMTUSDT
-  account:
+  accounts:
     binance:
       balances:
         GMT: 3010.0

config/pivotshort_optimizer.yaml

@@ -0,0 +1,26 @@
+# usage:
+#
+#   go run ./cmd/bbgo optimize --config bollmaker_ethusdt.yaml  --optimizer-config optimizer.yaml --debug
+#
+---
+matrix:
+- type: iterate
+  label: interval
+  path: '/exchangeStrategies/0/pivotshort/interval'
+  values: [ "5m", "30m", "1h" ]
+
+- type: range
+  path: '/exchangeStrategies/0/pivotshort/pivotLength'
+  label: pivotLength
+  min: 20.0
+  max: 200.0
+  step: 10.0
+
+- type: range
+  path: '/exchangeStrategies/0/pivotshort/breakLow/stopEMARange'
+  label: pivotLength
+  min: 0%
+  max: 10%
+  step: 0.5%
+
+

pkg/backtest/exchange.go

@@ -323,12 +323,13 @@ func (e *Exchange) SubscribeMarketData(extraIntervals ...types.Interval) (chan t
 		loadedIntervals[it] = struct{}{}
 	}
 
+	// collect subscriptions
 	for _, sub := range e.marketDataStream.Subscriptions {
 		loadedSymbols[sub.Symbol] = struct{}{}
 
 		switch sub.Channel {
 		case types.KLineChannel:
-			loadedIntervals[types.Interval(sub.Options.Interval)] = struct{}{}
+			loadedIntervals[sub.Options.Interval] = struct{}{}
 
 		default:
 			// Since Environment is not yet been injected at this point, no hard error

pkg/bbgo/activeorderbook.go

@@ -10,7 +10,7 @@ import (
 	"github.com/c9s/bbgo/pkg/types"
 )
 
-const CancelOrderWaitTime = 20 * time.Millisecond
+const CancelOrderWaitTime = 10 * time.Millisecond
 
 // ActiveOrderBook manages the local active order books.
 //go:generate callbackgen -type ActiveOrderBook
@@ -69,6 +69,8 @@ func (b *ActiveOrderBook) waitAllClear(ctx context.Context, waitTime, timeout ti
 
 // GracefulCancel cancels the active orders gracefully
 func (b *ActiveOrderBook) GracefulCancel(ctx context.Context, ex types.Exchange) error {
+	waitTime := CancelOrderWaitTime
+
 	log.Debugf("[ActiveOrderBook] gracefully cancelling %s orders...", b.Symbol)
 
 	startTime := time.Now()
@@ -86,9 +88,9 @@ func (b *ActiveOrderBook) GracefulCancel(ctx context.Context, ex types.Exchange)
 			log.WithError(err).Errorf("[ActiveOrderBook] can not cancel %s orders", b.Symbol)
 		}
 
-		log.Debugf("[ActiveOrderBook] waiting %s for %s orders to be cancelled...", CancelOrderWaitTime, b.Symbol)
+		log.Debugf("[ActiveOrderBook] waiting %s for %s orders to be cancelled...", waitTime, b.Symbol)
 
-		clear, err := b.waitAllClear(ctx, CancelOrderWaitTime, 5*time.Second)
+		clear, err := b.waitAllClear(ctx, waitTime, 5*time.Second)
 		if clear || err != nil {
 			break
 		}

pkg/bbgo/notifier.go

@@ -1,6 +1,10 @@
 package bbgo
 
-import "github.com/sirupsen/logrus"
+import (
+	"github.com/sirupsen/logrus"
+
+	"github.com/c9s/bbgo/pkg/fixedpoint"
+)
 
 type Notifier interface {
 	NotifyTo(channel string, obj interface{}, args ...interface{})
@@ -69,7 +73,7 @@ func (m *Notifiability) NotifyTo(channel string, obj interface{}, args ...interf
 func filterSimpleArgs(args []interface{}) (simpleArgs []interface{}) {
 	for _, arg := range args {
 		switch arg.(type) {
-		case int, int64, int32, uint64, uint32, string, []byte, float64, float32:
+		case int, int64, int32, uint64, uint32, string, []byte, float64, float32, fixedpoint.Value:
 			simpleArgs = append(simpleArgs, arg)
 		}
 	}

pkg/bbgo/smart_stops.go

@@ -128,7 +128,7 @@ func (c *TrailingStopController) Run(ctx context.Context, session *ExchangeSessi
 
 			log.Infof("current %s position: %s", c.Symbol, c.position.String())
 
-			marketOrder := c.position.NewClosePositionOrder(c.ClosePosition)
+			marketOrder := c.position.NewMarketCloseOrder(c.ClosePosition)
 			if marketOrder != nil {
 				log.Infof("submitting %s market order to stop: %+v", c.Symbol, marketOrder)
 

pkg/cmd/backtest.go

@@ -127,7 +127,6 @@ var BacktestCmd = &cobra.Command{
 			return err
 		}
 
-
 		if userConfig.Backtest == nil {
 			return errors.New("backtest config is not defined")
 		}

pkg/cmd/root.go

@@ -4,6 +4,7 @@ import (
 	"net/http"
 	"os"
 	"path"
+	"runtime/pprof"
 	"strings"
 	"time"
 
@@ -22,6 +23,8 @@ import (
 	_ "github.com/go-sql-driver/mysql"
 )
 
+var cpuProfileFile *os.File
+
 var userConfig *bbgo.Config
 
 var RootCmd = &cobra.Command{
@@ -32,7 +35,7 @@ var RootCmd = &cobra.Command{
 	SilenceUsage: true,
 
 	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-		if err := cobraLoadDotenv(cmd, args) ; err != nil {
+		if err := cobraLoadDotenv(cmd, args); err != nil {
 			return err
 		}
 
@@ -53,8 +56,34 @@ var RootCmd = &cobra.Command{
 			}()
 		}
 
+		cpuProfile, err := cmd.Flags().GetString("cpu-profile")
+		if err != nil {
+			return err
+		}
+
+		if cpuProfile != "" {
+			log.Infof("starting cpu profiler...")
+
+			cpuProfileFile, err = os.Create(cpuProfile)
+			if err != nil {
+				log.Fatal("could not create CPU profile: ", err)
+			}
+
+			if err := pprof.StartCPUProfile(cpuProfileFile); err != nil {
+				log.Fatal("could not start CPU profile: ", err)
+			}
+		}
+
 		return cobraLoadConfig(cmd, args)
 	},
+	PersistentPostRunE: func(cmd *cobra.Command, args []string) error {
+		pprof.StopCPUProfile()
+		if cpuProfileFile != nil {
+			return cpuProfileFile.Close() // error handling omitted for example
+		}
+
+		return nil
+	},
 	RunE: func(cmd *cobra.Command, args []string) error {
 		return nil
 	},
@@ -139,6 +168,7 @@ func init() {
 	RootCmd.PersistentFlags().String("ftx-api-key", "", "ftx api key")
 	RootCmd.PersistentFlags().String("ftx-api-secret", "", "ftx api secret")
 	RootCmd.PersistentFlags().String("ftx-subaccount", "", "subaccount name. Specify it if the credential is for subaccount.")
+	RootCmd.PersistentFlags().String("cpu-profile", "", "cpu profile")
 
 	viper.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
 

pkg/cmd/run.go

@@ -34,7 +34,6 @@ func init() {
 	RunCmd.Flags().Bool("enable-grpc", false, "enable grpc server")
 	RunCmd.Flags().String("grpc-bind", ":50051", "grpc server binding")
 
-	RunCmd.Flags().String("cpu-profile", "", "cpu profile")
 	RunCmd.Flags().Bool("setup", false, "use setup mode")
 	RootCmd.AddCommand(RunCmd)
 }

pkg/fixedpoint/convert.go

@@ -98,7 +98,7 @@ func (v Value) String() string {
 func (v Value) FormatString(prec int) string {
 	pow := math.Pow10(prec)
 	return strconv.FormatFloat(
-		math.Trunc(float64(v)/DefaultPow * pow) / pow, 'f', prec, 64)
+		math.Trunc(float64(v)/DefaultPow*pow)/pow, 'f', prec, 64)
 }
 
 func (v Value) Percentage() string {
@@ -114,7 +114,7 @@ func (v Value) FormatPercentage(prec int) string {
 	}
 	pow := math.Pow10(prec)
 	result := strconv.FormatFloat(
-		math.Trunc(float64(v)/DefaultPow * pow * 100.) / pow, 'f', prec, 64)
+		math.Trunc(float64(v)/DefaultPow*pow*100.)/pow, 'f', prec, 64)
 	return result + "%"
 }
 
@@ -222,6 +222,10 @@ func (v *Value) UnmarshalYAML(unmarshal func(a interface{}) error) (err error) {
 	return err
 }
 
+func (v Value) MarshalYAML() (interface{}, error) {
+	return v.FormatString(DefaultPrecision), nil
+}
+
 func (v Value) MarshalJSON() ([]byte, error) {
 	return []byte(v.FormatString(DefaultPrecision)), nil
 }
@@ -326,7 +330,7 @@ func NewFromString(input string) (Value, error) {
 	// if is decimal, we don't need this
 	hasScientificNotion := false
 	scIndex := -1
-	for i, c := range(input) {
+	for i, c := range input {
 		if hasDecimal {
 			if c <= '9' && c >= '0' {
 				decimalCount++
@@ -345,7 +349,7 @@ func NewFromString(input string) (Value, error) {
 		}
 	}
 	if hasDecimal {
-		after := input[dotIndex+1:len(input)]
+		after := input[dotIndex+1 : len(input)]
 		if decimalCount >= 8 {
 			after = after[0:8] + "." + after[8:len(after)]
 		} else {
@@ -368,7 +372,7 @@ func NewFromString(input string) (Value, error) {
 		if err != nil {
 			return 0, err
 		}
-		v, err := strconv.ParseFloat(input[0:scIndex+1] + strconv.FormatInt(exp + 8, 10), 64)
+		v, err := strconv.ParseFloat(input[0:scIndex+1]+strconv.FormatInt(exp+8, 10), 64)
 		if err != nil {
 			return 0, err
 		}
@@ -385,7 +389,6 @@ func NewFromString(input string) (Value, error) {
 		}
 		return Value(v), nil
 	}
-
 }
 
 func MustNewFromString(input string) Value {

pkg/service/backtest.go

@@ -188,21 +188,27 @@ func (s *BacktestService) QueryKLinesBackward(exchange types.ExchangeName, symbo
 }
 
 func (s *BacktestService) QueryKLinesCh(since, until time.Time, exchange types.Exchange, symbols []string, intervals []types.Interval) (chan types.KLine, chan error) {
-
 	if len(symbols) == 0 {
 		return returnError(errors.Errorf("symbols is empty when querying kline, plesae check your strategy setting. "))
 	}
 
 	tableName := targetKlineTable(exchange.Name())
-	sql := "SELECT * FROM `binance_klines` WHERE `end_time` BETWEEN :since AND :until AND `symbol` IN (:symbols) AND `interval` IN (:intervals)  and exchange = :exchange  ORDER BY end_time ASC"
+	var query string
-	sql = strings.ReplaceAll(sql, "binance_klines", tableName)
 
-	sql, args, err := sqlx.Named(sql, map[string]interface{}{
+	if len(symbols) == 1 {
+		query = "SELECT * FROM `binance_klines` WHERE `end_time` BETWEEN :since AND :until AND `symbol` = :symbols AND `interval` IN (:intervals) ORDER BY end_time ASC"
+	} else {
+		query = "SELECT * FROM `binance_klines` WHERE `end_time` BETWEEN :since AND :until AND `symbol` IN (:symbols) AND `interval` IN (:intervals) ORDER BY end_time ASC"
+	}
+
+	query = strings.ReplaceAll(query, "binance_klines", tableName)
+
+	sql, args, err := sqlx.Named(query, map[string]interface{}{
 		"since":     since,
 		"until":     until,
+		"symbol":    symbols[0],
 		"symbols":   symbols,
 		"intervals": types.IntervalSlice(intervals),
-		"exchange":  exchange.Name().String(),
 	})
 
 	sql, args, err = sqlx.In(sql, args...)

pkg/strategy/ewoDgtrd/strategy.go

@@ -613,13 +613,13 @@ func (s *Strategy) PlaceSellOrder(ctx context.Context, price fixedpoint.Value) (
 }
 
 // ClosePosition(context.Context) -> (closeOrder *types.Order, ok bool)
-// this will decorate the generated order from NewClosePositionOrder
+// this will decorate the generated order from NewMarketCloseOrder
 // add do necessary checks
 // if available quantity is zero, will return (nil, true)
 // if any of the checks failed, will return (nil, false)
 // otherwise, return the created close order and true
 func (s *Strategy) ClosePosition(ctx context.Context) (*types.Order, bool) {
-	order := s.Position.NewClosePositionOrder(fixedpoint.One)
+	order := s.Position.NewMarketCloseOrder(fixedpoint.One)
 	// no position exists
 	if order == nil {
 		// no base

pkg/strategy/pivotshort/strategy.go

@@ -3,8 +3,10 @@ package pivotshort
 import (
 	"context"
 	"fmt"
+	"sync"
 
 	"github.com/sirupsen/logrus"
+	"gopkg.in/yaml.v3"
 
 	"github.com/c9s/bbgo/pkg/bbgo"
 	"github.com/c9s/bbgo/pkg/fixedpoint"
@@ -12,6 +14,39 @@ import (
 	"github.com/c9s/bbgo/pkg/types"
 )
 
+type TradeStats struct {
+	WinningRatio        fixedpoint.Value   `json:"winningRatio" yaml:"winningRatio"`
+	NumOfLossTrade      int                `json:"numOfLossTrade" yaml:"numOfLossTrade"`
+	NumOfProfitTrade    int                `json:"numOfProfitTrade" yaml:"numOfProfitTrade"`
+	GrossProfit         fixedpoint.Value   `json:"grossProfit" yaml:"grossProfit"`
+	GrossLoss           fixedpoint.Value   `json:"grossLoss" yaml:"grossLoss"`
+	Profits             []fixedpoint.Value `json:"profits" yaml:"profits"`
+	Losses              []fixedpoint.Value `json:"losses" yaml:"losses"`
+	MostProfitableTrade fixedpoint.Value   `json:"mostProfitableTrade" yaml:"mostProfitableTrade"`
+	MostLossTrade       fixedpoint.Value   `json:"mostLossTrade" yaml:"mostLossTrade"`
+}
+
+func (s *TradeStats) Add(pnl fixedpoint.Value) {
+	if pnl.Sign() > 0 {
+		s.NumOfProfitTrade++
+		s.Profits = append(s.Profits, pnl)
+		s.GrossProfit = s.GrossProfit.Add(pnl)
+		s.MostProfitableTrade = fixedpoint.Max(s.MostProfitableTrade, pnl)
+	} else {
+		s.NumOfLossTrade++
+		s.Losses = append(s.Losses, pnl)
+		s.GrossLoss = s.GrossLoss.Add(pnl)
+		s.MostLossTrade = fixedpoint.Min(s.MostLossTrade, pnl)
+	}
+
+	s.WinningRatio = fixedpoint.NewFromFloat(float64(s.NumOfProfitTrade) / float64(s.NumOfLossTrade))
+}
+
+func (s *TradeStats) String() string {
+	out, _ := yaml.Marshal(s)
+	return string(out)
+}
+
 const ID = "pivotshort"
 
 var log = logrus.WithField("strategy", ID)
@@ -24,8 +59,15 @@ type IntervalWindowSetting struct {
 	types.IntervalWindow
 }
 
+// BreakLow -- when price breaks the previous pivot low, we set a trade entry
+type BreakLow struct {
+	Ratio        fixedpoint.Value      `json:"ratio"`
+	Quantity     fixedpoint.Value      `json:"quantity"`
+	StopEMARange fixedpoint.Value      `json:"stopEMARange"`
+	StopEMA      *types.IntervalWindow `json:"stopEMA"`
+}
+
 type Entry struct {
-	Immediate      bool             `json:"immediate"`
 	CatBounceRatio fixedpoint.Value `json:"catBounceRatio"`
 	NumLayers      int              `json:"numLayers"`
 	TotalQuantity  fixedpoint.Value `json:"totalQuantity"`
@@ -35,10 +77,12 @@ type Entry struct {
 }
 
 type Exit struct {
-	TakeProfitPercentage fixedpoint.Value                `json:"takeProfitPercentage"`
+	RoiStopLossPercentage   fixedpoint.Value `json:"roiStopLossPercentage"`
-	StopLossPercentage   fixedpoint.Value                `json:"stopLossPercentage"`
+	RoiTakeProfitPercentage fixedpoint.Value `json:"roiTakeProfitPercentage"`
-	LowerShadowRatio     fixedpoint.Value                `json:"lowerShadowRatio"`
+
-	MarginSideEffect     types.MarginOrderSideEffectType `json:"marginOrderSideEffect"`
+	LowerShadowRatio fixedpoint.Value `json:"lowerShadowRatio"`
+
+	MarginSideEffect types.MarginOrderSideEffectType `json:"marginOrderSideEffect"`
 }
 
 type Strategy struct {
@@ -54,12 +98,13 @@ type Strategy struct {
 	// persistence fields
 	Position    *types.Position    `json:"position,omitempty" persistence:"position"`
 	ProfitStats *types.ProfitStats `json:"profitStats,omitempty" persistence:"profit_stats"`
+	TradeStats  *TradeStats        `persistence:"trade_stats"`
 
 	PivotLength int `json:"pivotLength"`
-	LastLow     fixedpoint.Value
 
-	Entry Entry
+	BreakLow BreakLow `json:"breakLow"`
-	Exit  Exit
+	Entry    Entry    `json:"entry"`
+	Exit     Exit     `json:"exit"`
 
 	activeMakerOrders *bbgo.ActiveOrderBook
 	orderStore        *bbgo.OrderStore
@@ -67,7 +112,9 @@ type Strategy struct {
 
 	session *bbgo.ExchangeSession
 
+	lastLow        fixedpoint.Value
 	pivot          *indicator.Pivot
+	ewma           *indicator.EWMA
 	pivotLowPrices []fixedpoint.Value
 
 	// StrategyController
@@ -95,8 +142,7 @@ func (s *Strategy) submitOrders(ctx context.Context, orderExecutor bbgo.OrderExe
 	s.tradeCollector.Process()
 }
 
-func (s *Strategy) placeMarketSell(ctx context.Context, orderExecutor bbgo.OrderExecutor) {
+func (s *Strategy) placeMarketSell(ctx context.Context, orderExecutor bbgo.OrderExecutor, quantity fixedpoint.Value) {
-	quantity := s.Entry.Quantity
 	if quantity.IsZero() {
 		if balance, ok := s.session.Account.Balance(s.Market.BaseCurrency); ok {
 			s.Notify("sell quantity is not set, submitting sell with all base balance: %s", balance.Available.String())
@@ -109,29 +155,19 @@ func (s *Strategy) placeMarketSell(ctx context.Context, orderExecutor bbgo.Order
 		return
 	}
 
-	sideEffect := s.Entry.MarginSideEffect
-	if len(sideEffect) == 0 {
-		sideEffect = types.SideEffectTypeMarginBuy
-	}
-
 	submitOrder := types.SubmitOrder{
 		Symbol:           s.Symbol,
 		Side:             types.SideTypeSell,
 		Type:             types.OrderTypeMarket,
 		Quantity:         quantity,
-		MarginSideEffect: sideEffect,
+		MarginSideEffect: types.SideEffectTypeMarginBuy,
 	}
 
 	s.submitOrders(ctx, orderExecutor, submitOrder)
 }
 
-// check if position can be close or not
-func canClosePosition(position *types.Position, price fixedpoint.Value) bool {
-	return position.IsShort() && !(position.IsClosed() || position.IsDust(price))
-}
-
 func (s *Strategy) ClosePosition(ctx context.Context, percentage fixedpoint.Value) error {
-	submitOrder := s.Position.NewClosePositionOrder(percentage) // types.SubmitOrder{
+	submitOrder := s.Position.NewMarketCloseOrder(percentage) // types.SubmitOrder{
 	if submitOrder == nil {
 		return nil
 	}
@@ -140,7 +176,7 @@ func (s *Strategy) ClosePosition(ctx context.Context, percentage fixedpoint.Valu
 		submitOrder.MarginSideEffect = s.Exit.MarginSideEffect
 	}
 
-	s.Notify("Submitting %s buy order to close position by %v", s.Symbol, percentage)
+	s.Notify("Closing %s position by %f", s.Symbol, percentage.Float64())
 
 	createdOrders, err := s.session.Exchange.SubmitOrders(ctx, *submitOrder)
 	if err != nil {
@@ -152,6 +188,7 @@ func (s *Strategy) ClosePosition(ctx context.Context, percentage fixedpoint.Valu
 	s.tradeCollector.Process()
 	return err
 }
+
 func (s *Strategy) InstanceID() string {
 	return fmt.Sprintf("%s:%s", ID, s.Symbol)
 }
@@ -174,6 +211,10 @@ func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, se
 		s.ProfitStats = types.NewProfitStats(s.Market)
 	}
 
+	if s.TradeStats == nil {
+		s.TradeStats = &TradeStats{}
+	}
+
 	instanceID := s.InstanceID()
 
 	// Always update the position fields
@@ -189,6 +230,7 @@ func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, se
 			s.Environment.RecordPosition(s.Position, trade, nil)
 		} else {
 			log.Infof("%s generated profit: %v", s.Symbol, profit)
+
 			p := s.Position.NewProfit(trade, profit, netProfit)
 			p.Strategy = ID
 			p.StrategyInstanceID = instanceID
@@ -197,6 +239,8 @@ func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, se
 			s.ProfitStats.AddProfit(p)
 			s.Notify(&s.ProfitStats)
 
+			s.TradeStats.Add(profit)
+
 			s.Environment.RecordPosition(s.Position, trade, &p)
 		}
 	})
@@ -212,7 +256,12 @@ func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, se
 	s.pivot = &indicator.Pivot{IntervalWindow: iw}
 	s.pivot.Bind(store)
 
-	s.LastLow = fixedpoint.Zero
+	standardIndicator, _ := session.StandardIndicatorSet(s.Symbol)
+	if s.BreakLow.StopEMA != nil {
+		s.ewma = standardIndicator.EWMA(*s.BreakLow.StopEMA)
+	}
+
+	s.lastLow = fixedpoint.Zero
 
 	session.UserDataStream.OnStart(func() {
 		/*
@@ -231,44 +280,87 @@ func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, se
 			return
 		}
 
-		// TODO: handle stop loss here, faster than closed kline
+		isPositionOpened := !s.Position.IsClosed() && !s.Position.IsDust(kline.Close)
-		if canClosePosition(s.Position, kline.Close) {
-			if err := s.activeMakerOrders.GracefulCancel(ctx, s.session.Exchange); err != nil {
-				log.WithError(err).Errorf("graceful cancel order error")
-			}
 
+		if isPositionOpened && s.Position.IsShort() {
 			// calculate return rate
-			R := kline.Close.Sub(s.Position.AverageCost).Div(s.Position.AverageCost)
+			// TODO: apply quantity to this formula
-			if R.Compare(s.Exit.StopLossPercentage) > 0 {
+			roi := s.Position.AverageCost.Sub(kline.Close).Div(s.Position.AverageCost)
+			if roi.Compare(s.Exit.RoiStopLossPercentage.Neg()) < 0 {
 				// SL
-				s.Notify("%s SL triggered at price %f", s.Symbol, kline.Close.Float64())
+				s.Notify("%s ROI StopLoss triggered at price %f, ROI = %s", s.Symbol, kline.Close.Float64(), roi.Percentage())
-				s.ClosePosition(ctx, fixedpoint.One)
-				return
-			} else if R.Compare(s.Exit.TakeProfitPercentage.Neg()) < 0 && kline.GetLowerShadowRatio().Compare(s.Exit.LowerShadowRatio) > 0 {
-				// TP
-				s.Notify("%s TP triggered at price %f", s.Symbol, kline.Close.Float64())
-				s.ClosePosition(ctx, fixedpoint.One)
-				return
-			}
-		}
-
-		if len(s.pivotLowPrices) > 0 {
-			lastLow := s.pivotLowPrices[len(s.pivotLowPrices)-1]
-			if kline.Close.Compare(lastLow) < 0 {
-				s.Notify("%s price %f breaks the previous low %f, submitting market sell to open a short position", s.Symbol, kline.Close.Float64(), lastLow.Float64())
-
-				if !s.Position.IsClosed() && !s.Position.IsDust(kline.Close) {
-					s.Notify("skip opening %s position, which is not closed", s.Symbol, s.Position)
-					return
-				}
-
 				if err := s.activeMakerOrders.GracefulCancel(ctx, s.session.Exchange); err != nil {
 					log.WithError(err).Errorf("graceful cancel order error")
 				}
 
-				s.placeMarketSell(ctx, orderExecutor)
+				if err := s.ClosePosition(ctx, fixedpoint.One); err != nil {
+					log.WithError(err).Errorf("close position error")
+				}
+
+				return
+			} else if roi.Compare(s.Exit.RoiTakeProfitPercentage) > 0 { // disable this condition temporarily
+				s.Notify("%s TakeProfit triggered at price %f, ROI take profit percentage by %s", s.Symbol, kline.Close.Float64(), roi.Percentage(), kline)
+				if err := s.activeMakerOrders.GracefulCancel(ctx, s.session.Exchange); err != nil {
+					log.WithError(err).Errorf("graceful cancel order error")
+				}
+
+				if err := s.ClosePosition(ctx, fixedpoint.One); err != nil {
+					log.WithError(err).Errorf("close position error")
+				}
+			} else if !s.Exit.LowerShadowRatio.IsZero() && kline.GetLowerShadowHeight().Div(kline.Close).Compare(s.Exit.LowerShadowRatio) > 0 {
+				s.Notify("%s TakeProfit triggered at price %f: shadow ratio %f", s.Symbol, kline.Close.Float64(), kline.GetLowerShadowRatio().Float64(), kline)
+				if err := s.activeMakerOrders.GracefulCancel(ctx, s.session.Exchange); err != nil {
+					log.WithError(err).Errorf("graceful cancel order error")
+				}
+
+				if err := s.ClosePosition(ctx, fixedpoint.One); err != nil {
+					log.WithError(err).Errorf("close position error")
+				}
+				return
 			}
 		}
+
+		if len(s.pivotLowPrices) == 0 {
+			return
+		}
+
+		previousLow := s.pivotLowPrices[len(s.pivotLowPrices)-1]
+
+		// truncate the pivot low prices
+		if len(s.pivotLowPrices) > 10 {
+			s.pivotLowPrices = s.pivotLowPrices[len(s.pivotLowPrices)-10:]
+		}
+
+		if s.ewma != nil && !s.BreakLow.StopEMARange.IsZero() {
+			ema := fixedpoint.NewFromFloat(s.ewma.Last())
+			if ema.IsZero() {
+				return
+			}
+
+			emaStopShortPrice := ema.Mul(fixedpoint.One.Sub(s.BreakLow.StopEMARange))
+			if kline.Close.Compare(emaStopShortPrice) < 0 {
+				return
+			}
+		}
+
+		ratio := fixedpoint.One.Sub(s.BreakLow.Ratio)
+		breakPrice := previousLow.Mul(ratio)
+		if kline.Close.Compare(breakPrice) > 0 {
+			return
+		}
+
+		if !s.Position.IsClosed() && !s.Position.IsDust(kline.Close) {
+			// s.Notify("skip opening %s position, which is not closed", s.Symbol, s.Position)
+			return
+		}
+
+		s.Notify("%s price %f breaks the previous low %f with ratio %f, submitting market sell to open a short position", s.Symbol, kline.Close.Float64(), previousLow.Float64(), s.BreakLow.Ratio.Float64())
+
+		if err := s.activeMakerOrders.GracefulCancel(ctx, s.session.Exchange); err != nil {
+			log.WithError(err).Errorf("graceful cancel order error")
+		}
+
+		s.placeMarketSell(ctx, orderExecutor, s.BreakLow.Quantity)
 	})
 
 	session.MarketDataStream.OnKLineClosed(func(kline types.KLine) {
@@ -277,12 +369,20 @@ func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, se
 		}
 
 		if s.pivot.LastLow() > 0.0 {
-			log.Infof("pivot low signal detected: %f %s", s.pivot.LastLow(), kline.EndTime.Time())
+			log.Infof("pivot low detected: %f %s", s.pivot.LastLow(), kline.EndTime.Time())
-			s.LastLow = fixedpoint.NewFromFloat(s.pivot.LastLow())
+			lastLow := fixedpoint.NewFromFloat(s.pivot.LastLow())
-			s.pivotLowPrices = append(s.pivotLowPrices, s.LastLow)
+			if lastLow.Compare(s.lastLow) != 0 {
+				s.lastLow = lastLow
+				s.pivotLowPrices = append(s.pivotLowPrices, s.lastLow)
+			}
 		}
 	})
 
+	s.Graceful.OnShutdown(func(ctx context.Context, wg *sync.WaitGroup) {
+		log.Info(s.TradeStats.String())
+		wg.Done()
+	})
+
 	return nil
 }
 
@@ -337,13 +437,9 @@ func (s *Strategy) placeOrder(ctx context.Context, lastLow fixedpoint.Value, lim
 		Quantity: qty,
 	}
 
-	if !lastLow.IsZero() && s.Entry.Immediate && lastLow.Compare(currentPrice) <= 0 {
+	if !lastLow.IsZero() && lastLow.Compare(currentPrice) <= 0 {
 		submitOrder.Type = types.OrderTypeMarket
 	}
 
-	if s.session.Margin {
-		submitOrder.MarginSideEffect = s.Entry.MarginSideEffect
-	}
-
 	s.submitOrders(ctx, orderExecutor, submitOrder)
 }

pkg/strategy/xmaker/strategy.go

@@ -807,8 +807,7 @@ func (s *Strategy) CrossRun(ctx context.Context, orderExecutionRouter bbgo.Order
 		defer tradeScanTicker.Stop()
 
 		defer func() {
-			if err := s.activeMakerOrders.GracefulCancel(context.Background(),
+			if err := s.activeMakerOrders.GracefulCancel(context.Background(), s.makerSession.Exchange); err != nil {
-				s.makerSession.Exchange); err != nil {
 				log.WithError(err).Errorf("can not cancel %s orders", s.Symbol)
 			}
 		}()

pkg/types/position.go

@@ -120,7 +120,7 @@ func (p *Position) NewProfit(trade Trade, profit, netProfit fixedpoint.Value) Pr
 	}
 }
 
-func (p *Position) NewClosePositionOrder(percentage fixedpoint.Value) *SubmitOrder {
+func (p *Position) NewMarketCloseOrder(percentage fixedpoint.Value) *SubmitOrder {
 	base := p.GetBase()
 
 	quantity := base.Abs()