From f228ca79620b445c553fa0cba9663827725ba179 Mon Sep 17 00:00:00 2001 From: c9s Date: Wed, 7 Aug 2024 17:44:42 +0800 Subject: [PATCH 1/8] core: add OrderConverter --- pkg/core/tradecollector.go | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/pkg/core/tradecollector.go b/pkg/core/tradecollector.go index 6069d2c266..ab2b540179 100644 --- a/pkg/core/tradecollector.go +++ b/pkg/core/tradecollector.go @@ -12,8 +12,12 @@ import ( "github.com/c9s/bbgo/pkg/types" ) +type OrderConverter interface { + ConvertOrder(order types.Order) (types.Order, error) +} + type TradeConverter interface { - Convert(trade types.Trade) (types.Trade, error) + ConvertTrade(trade types.Trade) (types.Trade, error) } //go:generate callbackgen -type TradeCollector @@ -65,7 +69,7 @@ func (c *TradeCollector) convertTrade(trade types.Trade) types.Trade { } for _, converter := range c.tradeConverters { - convTrade, err := converter.Convert(trade) + convTrade, err := converter.ConvertTrade(trade) if err != nil { logrus.WithError(err).Errorf("trade %+v converter error, trade: %s", converter, trade.String()) continue From f277b191d23724a8edb312c7b1ddf2c58470c1db Mon Sep 17 00:00:00 2001 From: c9s Date: Thu, 8 Aug 2024 17:00:45 +0800 Subject: [PATCH 2/8] core: add ConverterManager --- pkg/core/converter.go | 43 +++++++++++++++++++++ pkg/core/tradecollector.go | 76 ++++++++++++++++++++++---------------- 2 files changed, 88 insertions(+), 31 deletions(-) create mode 100644 pkg/core/converter.go diff --git a/pkg/core/converter.go b/pkg/core/converter.go new file mode 100644 index 0000000000..2a2f24d625 --- /dev/null +++ b/pkg/core/converter.go @@ -0,0 +1,43 @@ +package core + +import "github.com/c9s/bbgo/pkg/types" + +type Converter interface { + OrderConverter + TradeConverter +} + +// OrderConverter converts the order to another order +type OrderConverter interface { + ConvertOrder(order types.Order) (types.Order, error) +} + +// TradeConverter converts the trade to another trade +type TradeConverter interface { + ConvertTrade(trade types.Trade) (types.Trade, error) +} + +// SymbolConverter converts the symbol to another symbol +type SymbolConverter struct { + fromSymbol, toSymbol string +} + +func NewSymbolConverter(fromSymbol, toSymbol string) *SymbolConverter { + return &SymbolConverter{fromSymbol: fromSymbol, toSymbol: toSymbol} +} + +func (c *SymbolConverter) ConvertOrder(order types.Order) (types.Order, error) { + if order.Symbol == c.fromSymbol { + order.Symbol = c.toSymbol + } + + return order, nil +} + +func (c *SymbolConverter) ConvertTrade(trade types.Trade) (types.Trade, error) { + if trade.Symbol == c.fromSymbol { + trade.Symbol = c.toSymbol + } + + return trade, nil +} diff --git a/pkg/core/tradecollector.go b/pkg/core/tradecollector.go index ab2b540179..e9245b49bf 100644 --- a/pkg/core/tradecollector.go +++ b/pkg/core/tradecollector.go @@ -12,12 +12,48 @@ import ( "github.com/c9s/bbgo/pkg/types" ) -type OrderConverter interface { - ConvertOrder(order types.Order) (types.Order, error) +type ConverterManager struct { + converters []Converter } -type TradeConverter interface { - ConvertTrade(trade types.Trade) (types.Trade, error) +func (c *ConverterManager) AddConverter(converter Converter) { + c.converters = append(c.converters, converter) +} + +func (c *ConverterManager) ConvertOrder(order types.Order) types.Order { + if len(c.converters) == 0 { + return order + } + + for _, converter := range c.converters { + convOrder, err := converter.ConvertOrder(order) + if err != nil { + logrus.WithError(err).Errorf("converter %+v error, order: %s", converter, order.String()) + continue + } + + order = convOrder + } + + return order +} + +func (c *ConverterManager) ConvertTrade(trade types.Trade) types.Trade { + if len(c.converters) == 0 { + return trade + } + + for _, converter := range c.converters { + convTrade, err := converter.ConvertTrade(trade) + if err != nil { + logrus.WithError(err).Errorf("converter %+v error, trade: %s", converter, trade.String()) + continue + } + + trade = convTrade + } + + return trade } //go:generate callbackgen -type TradeCollector @@ -33,14 +69,14 @@ type TradeCollector struct { mu sync.Mutex - tradeConverters []TradeConverter - recoverCallbacks []func(trade types.Trade) tradeCallbacks []func(trade types.Trade, profit, netProfit fixedpoint.Value) positionUpdateCallbacks []func(position *types.Position) profitCallbacks []func(trade types.Trade, profit *types.Profit) + + ConverterManager } func NewTradeCollector(symbol string, position *types.Position, orderStore *OrderStore) *TradeCollector { @@ -59,28 +95,6 @@ func NewTradeCollector(symbol string, position *types.Position, orderStore *Orde } } -func (c *TradeCollector) AddTradeConverter(converter TradeConverter) { - c.tradeConverters = append(c.tradeConverters, converter) -} - -func (c *TradeCollector) convertTrade(trade types.Trade) types.Trade { - if len(c.tradeConverters) == 0 { - return trade - } - - for _, converter := range c.tradeConverters { - convTrade, err := converter.ConvertTrade(trade) - if err != nil { - logrus.WithError(err).Errorf("trade %+v converter error, trade: %s", converter, trade.String()) - continue - } - - trade = convTrade - } - - return trade -} - // OrderStore returns the order store used by the trade collector func (c *TradeCollector) OrderStore() *OrderStore { return c.orderStore @@ -148,7 +162,7 @@ func (c *TradeCollector) Recover( } func (c *TradeCollector) RecoverTrade(td types.Trade) bool { - td = c.convertTrade(td) + td = c.ConvertTrade(td) logrus.Debugf("checking trade: %s", td.String()) if c.processTrade(td) { @@ -264,7 +278,7 @@ func (c *TradeCollector) processTrade(trade types.Trade) bool { // return true when the given trade is added // return false when the given trade is not added func (c *TradeCollector) ProcessTrade(trade types.Trade) bool { - return c.processTrade(c.convertTrade(trade)) + return c.processTrade(c.ConvertTrade(trade)) } // Run is a goroutine executed in the background @@ -283,7 +297,7 @@ func (c *TradeCollector) Run(ctx context.Context) { c.Process() case trade := <-c.tradeC: - c.processTrade(c.convertTrade(trade)) + c.processTrade(c.ConvertTrade(trade)) } } From 00e860df266de4dd4c901f426439a5bd80e0a871 Mon Sep 17 00:00:00 2001 From: c9s Date: Thu, 8 Aug 2024 17:18:17 +0800 Subject: [PATCH 3/8] core: add dynamic converter --- pkg/core/converter.go | 33 +++++++++++++++++++++++++++------ pkg/core/tradecollector.go | 20 ++++++++++++++------ 2 files changed, 41 insertions(+), 12 deletions(-) diff --git a/pkg/core/converter.go b/pkg/core/converter.go index 2a2f24d625..c29ccff8b2 100644 --- a/pkg/core/converter.go +++ b/pkg/core/converter.go @@ -17,26 +17,47 @@ type TradeConverter interface { ConvertTrade(trade types.Trade) (types.Trade, error) } +type OrderConvertFunc func(order types.Order) (types.Order, error) +type TradeConvertFunc func(trade types.Trade) (types.Trade, error) + +type DynamicConverter struct { + orderConverter OrderConvertFunc + tradeConverter TradeConvertFunc +} + +func NewDynamicConverter(orderConverter OrderConvertFunc, tradeConverter TradeConvertFunc) *DynamicConverter { + return &DynamicConverter{orderConverter: orderConverter, tradeConverter: tradeConverter} +} + +func (c *DynamicConverter) ConvertOrder(order types.Order) (types.Order, error) { + return c.orderConverter(order) +} + +func (c *DynamicConverter) ConvertTrade(trade types.Trade) (types.Trade, error) { + return c.tradeConverter(trade) +} + // SymbolConverter converts the symbol to another symbol type SymbolConverter struct { - fromSymbol, toSymbol string + FromSymbol string `json:"from"` + ToSymbol string `json:"to"` } func NewSymbolConverter(fromSymbol, toSymbol string) *SymbolConverter { - return &SymbolConverter{fromSymbol: fromSymbol, toSymbol: toSymbol} + return &SymbolConverter{FromSymbol: fromSymbol, ToSymbol: toSymbol} } func (c *SymbolConverter) ConvertOrder(order types.Order) (types.Order, error) { - if order.Symbol == c.fromSymbol { - order.Symbol = c.toSymbol + if order.Symbol == c.FromSymbol { + order.Symbol = c.ToSymbol } return order, nil } func (c *SymbolConverter) ConvertTrade(trade types.Trade) (types.Trade, error) { - if trade.Symbol == c.fromSymbol { - trade.Symbol = c.toSymbol + if trade.Symbol == c.FromSymbol { + trade.Symbol = c.ToSymbol } return trade, nil diff --git a/pkg/core/tradecollector.go b/pkg/core/tradecollector.go index e9245b49bf..d961890af8 100644 --- a/pkg/core/tradecollector.go +++ b/pkg/core/tradecollector.go @@ -13,19 +13,27 @@ import ( ) type ConverterManager struct { - converters []Converter + Converters []Converter `json:"converters,omitempty" yaml:"converters,omitempty"` +} + +func (c *ConverterManager) Initialize() error { + for _, converter := range c.Converters { + _ = converter + } + + return nil } func (c *ConverterManager) AddConverter(converter Converter) { - c.converters = append(c.converters, converter) + c.Converters = append(c.Converters, converter) } func (c *ConverterManager) ConvertOrder(order types.Order) types.Order { - if len(c.converters) == 0 { + if len(c.Converters) == 0 { return order } - for _, converter := range c.converters { + for _, converter := range c.Converters { convOrder, err := converter.ConvertOrder(order) if err != nil { logrus.WithError(err).Errorf("converter %+v error, order: %s", converter, order.String()) @@ -39,11 +47,11 @@ func (c *ConverterManager) ConvertOrder(order types.Order) types.Order { } func (c *ConverterManager) ConvertTrade(trade types.Trade) types.Trade { - if len(c.converters) == 0 { + if len(c.Converters) == 0 { return trade } - for _, converter := range c.converters { + for _, converter := range c.Converters { convTrade, err := converter.ConvertTrade(trade) if err != nil { logrus.WithError(err).Errorf("converter %+v error, trade: %s", converter, trade.String()) From df8d52adda071801adaf464d9c245694c5b8b90e Mon Sep 17 00:00:00 2001 From: c9s Date: Thu, 8 Aug 2024 17:33:35 +0800 Subject: [PATCH 4/8] core: add TestSymbolConverter --- pkg/core/converter_test.go | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 pkg/core/converter_test.go diff --git a/pkg/core/converter_test.go b/pkg/core/converter_test.go new file mode 100644 index 0000000000..4718eca2ba --- /dev/null +++ b/pkg/core/converter_test.go @@ -0,0 +1,31 @@ +package core + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/c9s/bbgo/pkg/types" +) + +func TestSymbolConverter(t *testing.T) { + converter := NewSymbolConverter("MAXEXCHANGEUSDT", "MAXUSDT") + trade, err := converter.ConvertTrade(types.Trade{ + Symbol: "MAXEXCHANGEUSDT", + }) + + if assert.NoError(t, err) { + assert.Equal(t, "MAXUSDT", trade.Symbol) + } + + order, err := converter.ConvertOrder(types.Order{ + SubmitOrder: types.SubmitOrder{ + Symbol: "MAXEXCHANGEUSDT", + }, + }) + + if assert.NoError(t, err) { + assert.Equal(t, "MAXUSDT", order.Symbol) + } + +} From 1ad2bc5f340a48c464555001421dc385cf4d67ae Mon Sep 17 00:00:00 2001 From: c9s Date: Thu, 8 Aug 2024 17:37:58 +0800 Subject: [PATCH 5/8] core: add Initialize() method to the converter interface --- pkg/core/converter.go | 9 +++++++++ pkg/strategy/xdepthmaker/strategy.go | 3 +++ 2 files changed, 12 insertions(+) diff --git a/pkg/core/converter.go b/pkg/core/converter.go index c29ccff8b2..6f6578b089 100644 --- a/pkg/core/converter.go +++ b/pkg/core/converter.go @@ -5,6 +5,7 @@ import "github.com/c9s/bbgo/pkg/types" type Converter interface { OrderConverter TradeConverter + Initialize() error } // OrderConverter converts the order to another order @@ -29,6 +30,10 @@ func NewDynamicConverter(orderConverter OrderConvertFunc, tradeConverter TradeCo return &DynamicConverter{orderConverter: orderConverter, tradeConverter: tradeConverter} } +func (c *DynamicConverter) Initialize() error { + return nil +} + func (c *DynamicConverter) ConvertOrder(order types.Order) (types.Order, error) { return c.orderConverter(order) } @@ -47,6 +52,10 @@ func NewSymbolConverter(fromSymbol, toSymbol string) *SymbolConverter { return &SymbolConverter{FromSymbol: fromSymbol, ToSymbol: toSymbol} } +func (c *SymbolConverter) Initialize() error { + return nil +} + func (c *SymbolConverter) ConvertOrder(order types.Order) (types.Order, error) { if order.Symbol == c.FromSymbol { order.Symbol = c.ToSymbol diff --git a/pkg/strategy/xdepthmaker/strategy.go b/pkg/strategy/xdepthmaker/strategy.go index 4a2623c4b9..855de24cee 100644 --- a/pkg/strategy/xdepthmaker/strategy.go +++ b/pkg/strategy/xdepthmaker/strategy.go @@ -12,6 +12,7 @@ import ( "golang.org/x/time/rate" "github.com/c9s/bbgo/pkg/bbgo" + "github.com/c9s/bbgo/pkg/core" "github.com/c9s/bbgo/pkg/exchange/retry" "github.com/c9s/bbgo/pkg/fixedpoint" "github.com/c9s/bbgo/pkg/strategy/common" @@ -147,6 +148,8 @@ func (s *CrossExchangeMarketMakingStrategy) Initialize( type Strategy struct { *CrossExchangeMarketMakingStrategy + *core.ConverterManager + Environment *bbgo.Environment Symbol string `json:"symbol"` From 473a6bc10896ac75ea17454ac7e69b87a4548d43 Mon Sep 17 00:00:00 2001 From: c9s Date: Sat, 10 Aug 2024 15:50:20 +0800 Subject: [PATCH 6/8] xdepthmaker: set converter manager --- pkg/strategy/xdepthmaker/strategy.go | 14 +++++++++++--- pkg/types/position.go | 17 +++++++++++++---- 2 files changed, 24 insertions(+), 7 deletions(-) diff --git a/pkg/strategy/xdepthmaker/strategy.go b/pkg/strategy/xdepthmaker/strategy.go index 855de24cee..7a8d80c4c4 100644 --- a/pkg/strategy/xdepthmaker/strategy.go +++ b/pkg/strategy/xdepthmaker/strategy.go @@ -49,7 +49,10 @@ type CrossExchangeMarketMakingStrategy struct { Position *types.Position `json:"position,omitempty" persistence:"position"` ProfitStats *types.ProfitStats `json:"profitStats,omitempty" persistence:"profit_stats"` CoveredPosition fixedpoint.Value `json:"coveredPosition,omitempty" persistence:"covered_position"` - mu sync.Mutex + + core.ConverterManager + + mu sync.Mutex MakerOrderExecutor, HedgeOrderExecutor *bbgo.GeneralOrderExecutor } @@ -107,6 +110,10 @@ func (s *CrossExchangeMarketMakingStrategy) Initialize( s.makerMarket.Symbol, strategyID, instanceID, s.Position) + + // update converter manager + s.MakerOrderExecutor.TradeCollector().ConverterManager = s.ConverterManager + s.MakerOrderExecutor.BindEnvironment(environ) s.MakerOrderExecutor.BindProfitStats(s.ProfitStats) s.MakerOrderExecutor.Bind() @@ -122,6 +129,9 @@ func (s *CrossExchangeMarketMakingStrategy) Initialize( s.HedgeOrderExecutor.BindEnvironment(environ) s.HedgeOrderExecutor.BindProfitStats(s.ProfitStats) s.HedgeOrderExecutor.Bind() + + s.HedgeOrderExecutor.TradeCollector().ConverterManager = s.ConverterManager + s.HedgeOrderExecutor.TradeCollector().OnPositionUpdate(func(position *types.Position) { // bbgo.Sync(ctx, s) }) @@ -148,8 +158,6 @@ func (s *CrossExchangeMarketMakingStrategy) Initialize( type Strategy struct { *CrossExchangeMarketMakingStrategy - *core.ConverterManager - Environment *bbgo.Environment Symbol string `json:"symbol"` diff --git a/pkg/types/position.go b/pkg/types/position.go index 589fa2a2be..d0b37f031a 100644 --- a/pkg/types/position.go +++ b/pkg/types/position.go @@ -19,16 +19,19 @@ const ( PositionClosed = PositionType("Closed") ) +// ExchangeFee stores the exchange fee rate type ExchangeFee struct { MakerFeeRate fixedpoint.Value TakerFeeRate fixedpoint.Value } +// PositionRisk stores the position risk data type PositionRisk struct { - Leverage fixedpoint.Value `json:"leverage"` - LiquidationPrice fixedpoint.Value `json:"liquidationPrice"` + Leverage fixedpoint.Value `json:"leverage,omitempty"` + LiquidationPrice fixedpoint.Value `json:"liquidationPrice,omitempty"` } +// Position stores the position data type Position struct { Symbol string `json:"symbol" db:"symbol"` BaseCurrency string `json:"baseCurrency" db:"base"` @@ -281,8 +284,14 @@ type FuturesPosition struct { ExchangeFeeRates map[ExchangeName]ExchangeFee `json:"exchangeFeeRates"` // Futures data fields - Isolated bool `json:"isolated"` - UpdateTime int64 `json:"updateTime"` + // ------------------- + // Isolated margin mode + Isolated bool `json:"isolated"` + + // UpdateTime is the time when the position is updated + UpdateTime int64 `json:"updateTime"` + + // PositionRisk stores the position risk data PositionRisk *PositionRisk } From 1b0d4599e2e130fd454685d1189fb68a8c694320 Mon Sep 17 00:00:00 2001 From: c9s Date: Mon, 12 Aug 2024 15:02:02 +0800 Subject: [PATCH 7/8] all: add trade converter to trade pnl fixer --- pkg/core/tradecollector.go | 2 +- pkg/strategy/common/profit_fixer.go | 5 +++++ pkg/strategy/xdepthmaker/strategy.go | 4 ++++ 3 files changed, 10 insertions(+), 1 deletion(-) diff --git a/pkg/core/tradecollector.go b/pkg/core/tradecollector.go index d961890af8..7dda8b6862 100644 --- a/pkg/core/tradecollector.go +++ b/pkg/core/tradecollector.go @@ -134,7 +134,7 @@ func (c *TradeCollector) BindStreamForBackground(stream types.Stream) { func (c *TradeCollector) BindStream(stream types.Stream) { stream.OnTradeUpdate(func(trade types.Trade) { - c.processTrade(trade) + c.ProcessTrade(trade) }) } diff --git a/pkg/strategy/common/profit_fixer.go b/pkg/strategy/common/profit_fixer.go index 44817acdf5..9aebcf6178 100644 --- a/pkg/strategy/common/profit_fixer.go +++ b/pkg/strategy/common/profit_fixer.go @@ -10,6 +10,7 @@ import ( "golang.org/x/sync/errgroup" "github.com/c9s/bbgo/pkg/bbgo" + "github.com/c9s/bbgo/pkg/core" "github.com/c9s/bbgo/pkg/exchange/batch" "github.com/c9s/bbgo/pkg/types" ) @@ -22,6 +23,8 @@ type ProfitFixerConfig struct { // ProfitFixer implements a trade-history-based profit fixer type ProfitFixer struct { sessions map[string]types.ExchangeTradeHistoryService + + core.ConverterManager } func NewProfitFixer() *ProfitFixer { @@ -106,6 +109,8 @@ func (f *ProfitFixer) Fix( func (f *ProfitFixer) FixFromTrades(allTrades []types.Trade, stats *types.ProfitStats, position *types.Position) error { for _, trade := range allTrades { + trade = f.ConverterManager.ConvertTrade(trade) + profit, netProfit, madeProfit := position.AddTrade(trade) if madeProfit { p := position.NewProfit(trade, profit, netProfit) diff --git a/pkg/strategy/xdepthmaker/strategy.go b/pkg/strategy/xdepthmaker/strategy.go index 7a8d80c4c4..9e35997aae 100644 --- a/pkg/strategy/xdepthmaker/strategy.go +++ b/pkg/strategy/xdepthmaker/strategy.go @@ -160,6 +160,7 @@ type Strategy struct { Environment *bbgo.Environment + // Symbol is the maker exchange symbol Symbol string `json:"symbol"` // HedgeSymbol is the symbol for the hedge exchange @@ -262,6 +263,7 @@ func (s *Strategy) CrossSubscribe(sessions map[string]*bbgo.ExchangeSession) { }) hedgeSession.Subscribe(types.KLineChannel, s.HedgeSymbol, types.SubscribeOptions{Interval: "1m"}) + makerSession.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: "1m"}) } @@ -355,6 +357,8 @@ func (s *Strategy) CrossRun( s.CrossExchangeMarketMakingStrategy.ProfitStats = types.NewProfitStats(makerMarket) fixer := common.NewProfitFixer() + fixer.ConverterManager = s.ConverterManager + if ss, ok := makerSession.Exchange.(types.ExchangeTradeHistoryService); ok { log.Infof("adding makerSession %s to profitFixer", makerSession.Name) fixer.AddExchange(makerSession.Name, ss) From 9911a4f711daf4bbe649c7bf4bd1ff569c74e430 Mon Sep 17 00:00:00 2001 From: c9s Date: Mon, 12 Aug 2024 15:56:24 +0800 Subject: [PATCH 8/8] all: fix converter initialization --- pkg/core/converter.go | 14 ++++++++- pkg/core/tradecollector.go | 47 +++++++++++++++++++++++----- pkg/strategy/xdepthmaker/strategy.go | 4 +++ 3 files changed, 56 insertions(+), 9 deletions(-) diff --git a/pkg/core/converter.go b/pkg/core/converter.go index 6f6578b089..a154e2758a 100644 --- a/pkg/core/converter.go +++ b/pkg/core/converter.go @@ -1,6 +1,10 @@ package core -import "github.com/c9s/bbgo/pkg/types" +import ( + "errors" + + "github.com/c9s/bbgo/pkg/types" +) type Converter interface { OrderConverter @@ -53,6 +57,14 @@ func NewSymbolConverter(fromSymbol, toSymbol string) *SymbolConverter { } func (c *SymbolConverter) Initialize() error { + if c.ToSymbol == "" { + return errors.New("toSymbol can not be empty") + } + + if c.FromSymbol == "" { + return errors.New("fromSymbol can not be empty") + } + return nil } diff --git a/pkg/core/tradecollector.go b/pkg/core/tradecollector.go index 7dda8b6862..9622e912c1 100644 --- a/pkg/core/tradecollector.go +++ b/pkg/core/tradecollector.go @@ -12,28 +12,59 @@ import ( "github.com/c9s/bbgo/pkg/types" ) +type ConverterSetting struct { + SymbolConverter *SymbolConverter `json:"symbolConverter" yaml:"symbolConverter"` +} + +func (s *ConverterSetting) getConverter() Converter { + if s.SymbolConverter != nil { + return s.SymbolConverter + } + + return nil +} + +func (s *ConverterSetting) InitializeConverter() (Converter, error) { + converter := s.getConverter() + if converter == nil { + return nil, nil + } + + logrus.Infof("initializing converter %T ...", converter) + err := converter.Initialize() + return nil, err +} + type ConverterManager struct { - Converters []Converter `json:"converters,omitempty" yaml:"converters,omitempty"` + ConverterSettings []ConverterSetting `json:"converters,omitempty" yaml:"converters,omitempty"` + + converters []Converter } func (c *ConverterManager) Initialize() error { - for _, converter := range c.Converters { - _ = converter + for _, setting := range c.ConverterSettings { + + converter, err := setting.InitializeConverter() + if err != nil { + return err + } + + c.AddConverter(converter) } return nil } func (c *ConverterManager) AddConverter(converter Converter) { - c.Converters = append(c.Converters, converter) + c.converters = append(c.converters, converter) } func (c *ConverterManager) ConvertOrder(order types.Order) types.Order { - if len(c.Converters) == 0 { + if len(c.converters) == 0 { return order } - for _, converter := range c.Converters { + for _, converter := range c.converters { convOrder, err := converter.ConvertOrder(order) if err != nil { logrus.WithError(err).Errorf("converter %+v error, order: %s", converter, order.String()) @@ -47,11 +78,11 @@ func (c *ConverterManager) ConvertOrder(order types.Order) types.Order { } func (c *ConverterManager) ConvertTrade(trade types.Trade) types.Trade { - if len(c.Converters) == 0 { + if len(c.converters) == 0 { return trade } - for _, converter := range c.Converters { + for _, converter := range c.converters { convTrade, err := converter.ConvertTrade(trade) if err != nil { logrus.WithError(err).Errorf("converter %+v error, trade: %s", converter, trade.String()) diff --git a/pkg/strategy/xdepthmaker/strategy.go b/pkg/strategy/xdepthmaker/strategy.go index 9e35997aae..103c50bf49 100644 --- a/pkg/strategy/xdepthmaker/strategy.go +++ b/pkg/strategy/xdepthmaker/strategy.go @@ -82,6 +82,10 @@ func (s *CrossExchangeMarketMakingStrategy) Initialize( return fmt.Errorf("maker session market %s is not defined", symbol) } + if err := s.ConverterManager.Initialize(); err != nil { + return err + } + if s.ProfitStats == nil { s.ProfitStats = types.NewProfitStats(s.makerMarket) }