You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
293 lines
8.7 KiB
293 lines
8.7 KiB
package trading |
|
|
|
import ( |
|
"context" |
|
"fmt" |
|
"io" |
|
"sig-pub/api/pb" |
|
"sig-pub/pkg/client" |
|
"sig-pub/pkg/data" |
|
"sig-pub/pkg/data/entity" |
|
"sig-pub/pkg/indicator" |
|
"sig-pub/pkg/publish" |
|
"sig-pub/pkg/strategy" |
|
"sig-pub/pkg/types" |
|
"sig-pub/pkg/utils/collect" |
|
"sig-pub/pkg/utils/lang" |
|
"sig-pub/pkg/utils/times" |
|
"sig-pub/pkg/zlog" |
|
|
|
"sig-pub/internal/trading/backtest" |
|
"sig-pub/internal/trading/sig" |
|
|
|
"github.com/bytedance/sonic" |
|
"google.golang.org/grpc" |
|
) |
|
|
|
type TradingService struct { |
|
marketClientAside *client.TradeInstanceAside |
|
exchangeClient pb.ExchangeServiceClient |
|
tradingDataPersist *TradingDataPersist |
|
|
|
klineSeriesStore *KlineSeriesStore |
|
indicatorReg *indicator.IndicatorRegistry // 注册窗口指标 |
|
strategyReg *strategy.SigStrategyRegistry // 注册信号策略 |
|
signalPublisher *publish.Publisher[int64, strategy.StrategyType] // planId -> strategyType |
|
tradingPlans *collect.SyncMap[int64, *sig.TradingPlan] // 运行中交易计划 |
|
} |
|
|
|
func NewTradingService( |
|
marketClientAside *client.TradeInstanceAside, |
|
exchangeClient pb.ExchangeServiceClient, |
|
tradingDataPersist *TradingDataPersist, |
|
) *TradingService { |
|
return &TradingService{ |
|
marketClientAside: marketClientAside, |
|
exchangeClient: exchangeClient, |
|
tradingDataPersist: tradingDataPersist, |
|
klineSeriesStore: NewKlineSeriesStore(exchangeClient), |
|
indicatorReg: indicator.NewIndicatorRegistry(), |
|
strategyReg: strategy.NewSigStrategyRegistry(), |
|
signalPublisher: publish.NewPublisher[int64, strategy.StrategyType](16), |
|
tradingPlans: collect.NewSyncMap[int64, *sig.TradingPlan](), |
|
} |
|
} |
|
|
|
// 初始化历史k线, 订阅实时k线 |
|
func (svc *TradingService) Init() (err error) { |
|
if err = svc.indicatorReg.Init(); err != nil { |
|
return |
|
} |
|
if err = svc.strategyReg.Init(); err != nil { |
|
return |
|
} |
|
|
|
if err = svc.klineSeriesStore.Init(); err != nil { |
|
return |
|
} |
|
|
|
go svc.consumerKlineSignal() |
|
|
|
// todo loading trading plan |
|
return |
|
} |
|
|
|
// consumerKlineSignal 订阅k线更新 |
|
func (svc *TradingService) consumerKlineSignal() { |
|
c := svc.klineSeriesStore.ConsumerKlineSignel() |
|
for { |
|
signalKey := <-c |
|
zlog.Debugf("signal: %s", signalKey) |
|
planIds, strategyTypes := svc.signalPublisher.Publisher(signalKey) |
|
for i, strategyType := range strategyTypes { |
|
planId := planIds[i] |
|
plan, ok := svc.tradingPlans.Load(planId) |
|
if !ok { |
|
zlog.Warningf("plan not running: id=%d", planId) |
|
continue |
|
} |
|
if plan.Status.Load() == int32(data.StatusOk) { |
|
plan.Update(strategyType) |
|
} |
|
} |
|
} |
|
} |
|
|
|
// getTradingPlan 获取交易计划 |
|
// todo 止盈止损策略, 下单策略... |
|
func (svc *TradingService) getTradingPlan(plan *entity.TradePlan, sigKlineSeries *sig.KlineSeries) (tradingPlan *sig.TradingPlan, err error) { |
|
exchange := pb.ExchangeType(plan.Exchange) |
|
interval := types.Interval(plan.Interval) |
|
instId := plan.InstId |
|
if !types.IsSupportExchange(exchange) { |
|
err = fmt.Errorf("unsupport exchange %d", plan.Exchange) |
|
return |
|
} |
|
if _, ok := types.SupportedIntervals[interval]; !ok { |
|
err = fmt.Errorf("unsupport interval %d", plan.Exchange) |
|
return |
|
} |
|
|
|
// sigStrategy |
|
sigStrategyParam := make(strategy.StrategyParam) |
|
if err = sonic.UnmarshalString(plan.SigStrategyParam, &sigStrategyParam); err != nil { |
|
return |
|
} |
|
sigStrategyType, sigStrategy, ok := svc.strategyReg.NewSigStrategy(plan.SigStrategy) |
|
if !ok { |
|
err = fmt.Errorf("strategy %s not exists", plan.SigStrategy) |
|
return |
|
} |
|
|
|
if sigKlineSeries == nil { |
|
sigKlineSeries, err = svc.klineSeriesStore.GetKlineSeires(exchange, instId, interval) |
|
if err != nil { |
|
return |
|
} |
|
} |
|
|
|
tradingPlan = sig.NewTradingPlan(*plan, svc.indicatorReg) |
|
if err = tradingPlan.Init(); err != nil { |
|
return |
|
} |
|
sigIndicatorCtx := sig.NewIndicatorContext(sigKlineSeries) |
|
sigStrategyCtx := sig.NewStrategyContext(sigIndicatorCtx, svc.indicatorReg) |
|
if err = tradingPlan.InitSigStrategy(sigStrategyType, sigStrategy, sigStrategyParam, sigStrategyCtx); err != nil { |
|
return |
|
} |
|
return |
|
|
|
// if _, load := svc.tradingPlans.LoadOrStore(planId, tradingPlan); load { |
|
// err = fmt.Errorf("plan already running: planId=%d", planId) |
|
// return |
|
// } |
|
// tradingPlan.Status.Store(int32(data.StatusProcessing)) |
|
|
|
// defer func() { |
|
// if err != nil { |
|
// svc.tradingPlans.Delete(planId) |
|
// } else { |
|
// // 订阅交易信号策略k线周期 |
|
// sigSubKey := strategy.DriverIntervalKey(instId, exchange, false, sigInterval) |
|
// svc.signalPublisher.Subscribe(sigSubKey, planId, strategy.StrategyTypeSig) |
|
|
|
// tradingPlan.Status.Store(int32(data.StatusOk)) |
|
// } |
|
// }() |
|
} |
|
|
|
// fetchHistoryKlineSeries 请求k线数据流式处理 |
|
func (svc *TradingService) fetchHistoryKlineSeries(ctx context.Context, sr *pb.SeriesRange, recvFn func(k *types.Kline) error) (err error) { |
|
// fetch history klines via stream |
|
req := &pb.ReqHistoryKlineStream{Series: sr} |
|
stream, err := svc.exchangeClient.HistoryKlineStream(ctx, req, grpc.UseCompressor("snappy")) |
|
if err != nil { |
|
return |
|
} |
|
var msg *pb.RspHistoryKlineStream |
|
recvTimes, recvTotal := 0, 0 |
|
watch := times.NewWatch() |
|
for { |
|
select { |
|
case <-ctx.Done(): |
|
err = ctx.Err() |
|
return |
|
default: |
|
} |
|
msg, err = stream.Recv() |
|
if err == io.EOF { |
|
err = nil |
|
break |
|
} |
|
if err != nil { |
|
return |
|
} |
|
recvTimes++ |
|
recvTotal += len(msg.Klines) |
|
for _, k := range msg.Klines { |
|
kline := new(types.Kline) |
|
kline.ParsePBKline(sr.Exchange, k) |
|
if err = recvFn(kline); err != nil { |
|
return |
|
} |
|
} |
|
} |
|
zlog.Debugf("fetch history kline series: inst=%s(%s), interval=%s, recv=%d, total=%d, use %s", sr.InstId, sr.Exchange, sr.Interval, recvTimes, recvTotal, watch.ElapsedFmt(".")) |
|
return |
|
} |
|
|
|
// IndicatorSeries 获取指标实时或历史序列数据, 闭区间 |
|
func (svc *TradingService) IndicatorSeries(ctx context.Context, indicatorName string, window uint32, sr *pb.SeriesRange) (matrix []float64, times []int64, err error) { |
|
// indicatorName string, exchange pb.ExchangeType, instId string, interval types.Interval, window int |
|
indicator, ok := svc.indicatorReg.IndicatorW(indicatorName) |
|
if !ok { |
|
err = fmt.Errorf("indicator %s not exists", indicatorName) |
|
return |
|
} |
|
interval := types.Interval(sr.Interval) |
|
_, ok = types.SupportedIntervals[interval] |
|
if !ok { |
|
err = fmt.Errorf("unsupport interval %s", interval) |
|
return |
|
} |
|
|
|
// 查询历史指标数据 |
|
requiredSeries := int(indicator.RequiredSeries(int16(window))) |
|
sr.WindowExtra = uint32(max(0, requiredSeries-1)) |
|
kSeries := sig.NewKlineSeries(sr.Exchange, sr.InstId, types.Interval(sr.Interval)) |
|
indicatorContext := sig.NewIndicatorContext(kSeries) |
|
|
|
matrix = make([]float64, 0, 200) |
|
times = make([]int64, 0, 200) |
|
err = svc.fetchHistoryKlineSeries(ctx, sr, func(k *types.Kline) (err error) { |
|
if lastTs, serial := kSeries.Update(k); !serial { |
|
err = fmt.Errorf("kline not series: %s(%s), interval=%s, lastTs=%d", sr.InstId, sr.Exchange, interval, lastTs) |
|
return |
|
} |
|
if kSeries.Length() < requiredSeries { |
|
return |
|
} |
|
vector := indicator.Calculate(indicatorContext, int16(window)) |
|
matrix = append(matrix, vector) |
|
times = append(times, indicatorContext.Get(0).Ts) |
|
return |
|
}) |
|
if err != nil { |
|
return |
|
} |
|
return |
|
} |
|
|
|
// StrategySeries 信号策略回测 |
|
func (svc *TradingService) StrategySeries(ctx context.Context, req *pb.ReqStrategySeries, rsp *pb.RspStrategySeries) (err error) { |
|
// sigStrategy |
|
sigStrategyType, sigStrategy, ok := svc.strategyReg.NewSigStrategy(req.SigStrategy) |
|
if !ok { |
|
err = fmt.Errorf("strategy %s not exists", req.SigStrategy) |
|
return |
|
} |
|
// init sigStrategy |
|
if err = sigStrategy.Init(req.SigParam); err != nil { |
|
return |
|
} |
|
|
|
interval := types.Interval(req.Series.Interval) |
|
_, ok = types.SupportedIntervals[interval] |
|
if !ok { |
|
err = fmt.Errorf("unsupport interval %s", interval) |
|
return |
|
} |
|
|
|
// 使用回测器回测信号 |
|
backtester := backtest.NewSigStrategyBacktester(sigStrategyType, sigStrategy, svc.indicatorReg, svc.exchangeClient) |
|
err = backtester.Backtest(ctx, req.Series, func(sigSide types.Side, k types.Kline) (err error) { |
|
side := lang.Ternary(sigSide == types.SideLong, pb.Side_BUY, pb.Side_SELL) |
|
rsp.Signal = append(rsp.Signal, side) |
|
rsp.Times = append(rsp.Times, k.Ts) |
|
return |
|
}) |
|
return |
|
} |
|
|
|
// Backtest 回测交易计划 |
|
func (svc *TradingService) Backtest(planId, stime, etime int64) (err error) { |
|
plan, err := svc.tradingDataPersist.GetTradePlanById(planId) |
|
if err != nil { |
|
return |
|
} |
|
exchange := pb.ExchangeType(plan.Exchange) |
|
interval := types.Interval(plan.Interval) |
|
|
|
sigKlineSeries := sig.NewKlineSeries(exchange, plan.InstId, interval) |
|
tradingPlan, err := svc.getTradingPlan(plan, sigKlineSeries) |
|
if err != nil { |
|
return |
|
} |
|
|
|
test := backtest.NewTradingPlanBacktester(svc.exchangeClient, svc.indicatorReg, svc.strategyReg) |
|
err = test.RunTradingPlan(context.Background(), tradingPlan, stime, etime, sigKlineSeries) |
|
if err != nil { |
|
return |
|
} |
|
return |
|
}
|
|
|