@backtest-kit/ui 12.8.0 → 13.3.0

package/build/index.cjs

@@ -108,6 +108,7 @@ const mockServices$1 = {
     environmentMockService: Symbol("environmentMockService"),
     setupMockService: Symbol("setupMockService"),
     runtimeMockService: Symbol("runtimeMockService"),
+    controlMockService: Symbol("controlMockService"),
 };
 const viewServices$1 = {
     notificationViewService: Symbol("notificationViewService"),
@@ -123,6 +124,7 @@ const viewServices$1 = {
     environmentViewService: Symbol("environmentViewService"),
     setupViewService: Symbol("setupViewService"),
     runtimeViewService: Symbol("runtimeViewService"),
+    controlViewService: Symbol("controlViewService"),
 };
 const TYPES = {
     ...baseServices$1,
@@ -2197,6 +2199,237 @@ class RuntimeViewService {
     }
 }
 
+const MOCK_STRATEGY_PATH = "./mock/strategy.json";
+const MOCK_STRATEGY_INFO_PATH = "./mock/strategy-info.json";
+const READ_STRATEGY_FN = functoolsKit.singleshot(async () => {
+    const data = await fs.readFile(MOCK_STRATEGY_PATH, "utf-8");
+    return JSON.parse(data);
+});
+const READ_STRATEGY_INFO_FN = functoolsKit.singleshot(async () => {
+    const data = await fs.readFile(MOCK_STRATEGY_INFO_PATH, "utf-8");
+    return JSON.parse(data);
+});
+class ControlMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getStatus = async (symbol, context) => {
+            this.loggerService.log("controlMockService getStatus", {
+                symbol,
+                context,
+            });
+            const strategyInfo = await READ_STRATEGY_INFO_FN();
+            const pendingSignal = await READ_STRATEGY_FN();
+            const currentPrice = pendingSignal?.pnl?.priceClose ?? pendingSignal?.priceOpen ?? 0;
+            return { strategyInfo, pendingSignal, currentPrice };
+        };
+        this.getAveragePrice = async (symbol, context) => {
+            this.loggerService.log("controlMockService getAveragePrice", {
+                symbol,
+                context,
+            });
+            const pendingSignal = await READ_STRATEGY_FN();
+            return pendingSignal?.pnl?.priceClose ?? pendingSignal?.priceOpen ?? 0;
+        };
+        this.commitOpenPending = async (symbol, context, dto) => {
+            this.loggerService.log("controlMockService commitOpenPending", {
+                symbol,
+                context,
+                dto,
+            });
+        };
+        this.commitAverageBuy = async (symbol, context, dto) => {
+            this.loggerService.log("controlMockService commitAverageBuy", {
+                symbol,
+                context,
+                dto,
+            });
+        };
+        this.commitClosePending = async (symbol, context, dto) => {
+            this.loggerService.log("controlMockService commitClosePending", {
+                symbol,
+                context,
+                dto,
+            });
+        };
+        this.commitBreakeven = async (symbol, context) => {
+            this.loggerService.log("controlMockService commitBreakeven", {
+                symbol,
+                context,
+            });
+        };
+    }
+}
+
+/** Grid step (percent) the hard stop-loss distance snaps to. */
+const HARD_STOP_STEP_PERCENT = 2.5;
+/**
+ * Computes the hard stop-loss distance percent for an opened position.
+ *
+ * Snaps the configured max stop-loss distance to a {@link HARD_STOP_STEP_PERCENT} grid
+ * (rounded to the nearest step), then steps one notch down so the result stays strictly
+ * below CC_MAX_STOPLOSS_DISTANCE_PERCENT — which the signal validator rejects at the
+ * boundary (e.g. 20% config yields 20.008% after price rounding).
+ *
+ * @param maxDistance - CC_MAX_STOPLOSS_DISTANCE_PERCENT
+ * @returns Hard stop-loss distance in percent (e.g. 11 -> 7.5, 10 -> 7.5, 20 -> 17.5)
+ */
+const COMPUTE_HARD_STOP_FN = (maxDistance) => Math.round(maxDistance / HARD_STOP_STEP_PERCENT) * HARD_STOP_STEP_PERCENT - HARD_STOP_STEP_PERCENT;
+class ControlViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.controlMockService = inject(TYPES.controlMockService);
+        this.getStatus = async (symbol, context) => {
+            this.loggerService.log("controlViewService getStatus", {
+                symbol,
+                context,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.controlMockService.getStatus(symbol, context);
+            }
+            const liveList = await BacktestKit.Live.list();
+            const liveTarget = liveList.find((live) => live.symbol === symbol);
+            if (liveTarget) {
+                const currentPrice = await BacktestKit.Exchange.getAveragePrice(symbol, {
+                    exchangeName: liveTarget.exchangeName,
+                });
+                const strategy = await BacktestKit.Live.getStrategyStatus(symbol, context);
+                const pending = await BacktestKit.Live.getPendingSignal(symbol, currentPrice, context);
+                return { strategyInfo: strategy, pendingSignal: pending, currentPrice };
+            }
+            throw new Error("ControlViewService getStatus live target not found");
+        };
+        this.getAveragePrice = async (symbol, context) => {
+            this.loggerService.log("controlViewService getAveragePrice", {
+                symbol,
+                context,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.controlMockService.getAveragePrice(symbol, context);
+            }
+            const liveList = await BacktestKit.Live.list();
+            const liveTarget = liveList.find((live) => live.symbol === symbol);
+            if (liveTarget) {
+                return await BacktestKit.Exchange.getAveragePrice(symbol, {
+                    exchangeName: liveTarget.exchangeName,
+                });
+            }
+            throw new Error("ControlViewService getAveragePrice live target not found");
+        };
+        this.commitOpenPending = async (symbol, context, dto) => {
+            this.loggerService.log("controlViewService commitOpenPending", {
+                symbol,
+                context,
+                dto,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.controlMockService.commitOpenPending(symbol, context, dto);
+            }
+            const liveList = await BacktestKit.Live.list();
+            const liveTarget = liveList.find((live) => live.symbol === symbol);
+            if (liveTarget) {
+                const currentPrice = await BacktestKit.Exchange.getAveragePrice(symbol, {
+                    exchangeName: liveTarget.exchangeName,
+                });
+                const pending = await BacktestKit.Live.getPendingSignal(symbol, currentPrice, context);
+                const config = BacktestKit.getConfig();
+                if (pending) {
+                    throw new Error("ControlViewService commitOpenPending already have pending signal");
+                }
+                const percentStopLoss = COMPUTE_HARD_STOP_FN(config.CC_MAX_STOPLOSS_DISTANCE_PERCENT);
+                return await BacktestKit.Live.commitCreateSignal(symbol, context, {
+                    ...BacktestKit.Position.moonbag({
+                        position: dto.position,
+                        currentPrice,
+                        percentStopLoss,
+                    }),
+                    cost: dto.cost,
+                    note: dto.note,
+                });
+            }
+            throw new Error("ControlViewService commitOpenPending live target not found");
+        };
+        this.commitAverageBuy = async (symbol, context, dto) => {
+            this.loggerService.log("controlViewService commitAverageBuy", {
+                symbol,
+                context,
+                dto,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.controlMockService.commitAverageBuy(symbol, context, dto);
+            }
+            const liveList = await BacktestKit.Live.list();
+            const liveTarget = liveList.find((live) => live.symbol === symbol);
+            if (liveTarget) {
+                const currentPrice = await BacktestKit.Exchange.getAveragePrice(symbol, {
+                    exchangeName: liveTarget.exchangeName,
+                });
+                const pending = await BacktestKit.Live.getPendingSignal(symbol, currentPrice, context);
+                if (!pending) {
+                    throw new Error("ControlViewService commitAverageBuy has no pending signal");
+                }
+                const isOk = await BacktestKit.Live.commitAverageBuy(symbol, currentPrice, context, dto.cost);
+                if (!isOk) {
+                    throw new Error("ControlViewService commitAverageBuy failed");
+                }
+                return;
+            }
+            throw new Error("ControlViewService commitAverageBuy live target not found");
+        };
+        this.commitClosePending = async (symbol, context, dto) => {
+            this.loggerService.log("controlViewService commitClosePending", {
+                symbol,
+                context,
+                dto,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.controlMockService.commitClosePending(symbol, context, dto);
+            }
+            const liveList = await BacktestKit.Live.list();
+            const liveTarget = liveList.find((live) => live.symbol === symbol);
+            if (liveTarget) {
+                const currentPrice = await BacktestKit.Exchange.getAveragePrice(symbol, {
+                    exchangeName: liveTarget.exchangeName,
+                });
+                const pending = await BacktestKit.Live.getPendingSignal(symbol, currentPrice, context);
+                if (!pending) {
+                    throw new Error("ControlViewService commitClosePending has no pending signal");
+                }
+                return await BacktestKit.Live.commitClosePending(symbol, context, {
+                    id: pending.id,
+                    note: dto.note,
+                });
+            }
+            throw new Error("ControlViewService commitClosePending live target not found");
+        };
+        this.commitBreakeven = async (symbol, context) => {
+            this.loggerService.log("controlViewService commitBreakeven", {
+                symbol,
+                context,
+            });
+            if (CC_ENABLE_MOCK) {
+                return await this.controlMockService.commitBreakeven(symbol, context);
+            }
+            const liveList = await BacktestKit.Live.list();
+            const liveTarget = liveList.find((live) => live.symbol === symbol);
+            if (liveTarget) {
+                const currentPrice = await BacktestKit.Exchange.getAveragePrice(symbol, {
+                    exchangeName: liveTarget.exchangeName,
+                });
+                const pending = await BacktestKit.Live.getPendingSignal(symbol, currentPrice, context);
+                if (!pending) {
+                    throw new Error("ControlViewService commitBreakeven has no pending signal");
+                }
+                const isOk = await BacktestKit.Live.commitBreakeven(symbol, currentPrice, context);
+                if (!isOk) {
+                    throw new Error("ControlViewService commitBreakeven failed");
+                }
+                return;
+            }
+            throw new Error("ControlViewService commitBreakeven live target not found");
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
     provide(TYPES.exchangeService, () => new ExchangeService());
@@ -2224,6 +2457,7 @@ class RuntimeViewService {
     provide(TYPES.environmentMockService, () => new EnvironmentMockService());
     provide(TYPES.setupMockService, () => new SetupMockService());
     provide(TYPES.runtimeMockService, () => new RuntimeMockService());
+    provide(TYPES.controlMockService, () => new ControlMockService());
 }
 {
     provide(TYPES.notificationViewService, () => new NotificationViewService());
@@ -2239,6 +2473,7 @@ class RuntimeViewService {
     provide(TYPES.environmentViewService, () => new EnvironmentViewService());
     provide(TYPES.setupViewService, () => new SetupViewService());
     provide(TYPES.runtimeViewService, () => new RuntimeViewService());
+    provide(TYPES.controlViewService, () => new ControlViewService());
 }
 
 const baseServices = {
@@ -2268,6 +2503,7 @@ const mockServices = {
     environmentMockService: inject(TYPES.environmentMockService),
     setupMockService: inject(TYPES.setupMockService),
     runtimeMockService: inject(TYPES.runtimeMockService),
+    controlMockService: inject(TYPES.controlMockService),
 };
 const viewServices = {
     notificationViewService: inject(TYPES.notificationViewService),
@@ -2283,6 +2519,7 @@ const viewServices = {
     environmentViewService: inject(TYPES.environmentViewService),
     setupViewService: inject(TYPES.setupViewService),
     runtimeViewService: inject(TYPES.runtimeViewService),
+    controlViewService: inject(TYPES.controlViewService),
 };
 const ioc = {
     ...baseServices,
@@ -2851,6 +3088,175 @@ router$b.post("/api/v1/mock/status_one/:id", async (req, res) => {
         });
     }
 });
+// ControlMockService endpoints
+router$b.post("/api/v1/mock/control_status", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, requestId, serviceName } = request;
+        const data = await ioc.controlMockService.getStatus(symbol, context);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/control_status ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/control_status error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$b.post("/api/v1/mock/control_average_price", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, requestId, serviceName } = request;
+        const data = await ioc.controlMockService.getAveragePrice(symbol, context);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/control_average_price ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/control_average_price error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$b.post("/api/v1/mock/control_open_pending", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, dto, requestId, serviceName } = request;
+        const data = await ioc.controlMockService.commitOpenPending(symbol, context, dto);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/control_open_pending ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/control_open_pending error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$b.post("/api/v1/mock/control_average_buy", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, dto, requestId, serviceName } = request;
+        const data = await ioc.controlMockService.commitAverageBuy(symbol, context, dto);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/control_average_buy ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/control_average_buy error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$b.post("/api/v1/mock/control_close_pending", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, dto, requestId, serviceName } = request;
+        const data = await ioc.controlMockService.commitClosePending(symbol, context, dto);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/control_close_pending ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/control_close_pending error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$b.post("/api/v1/mock/control_breakeven", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, requestId, serviceName } = request;
+        const data = await ioc.controlMockService.commitBreakeven(symbol, context);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/mock/control_breakeven ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/mock/control_breakeven error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 // HeatMockService endpoints
 router$b.post("/api/v1/mock/heat_data", async (req, res) => {
     try {
@@ -3610,6 +4016,175 @@ router$a.post("/api/v1/view/status_one/:id", async (req, res) => {
         });
     }
 });
+// ControlViewService endpoints
+router$a.post("/api/v1/view/control_status", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, requestId, serviceName } = request;
+        const data = await ioc.controlViewService.getStatus(symbol, context);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/control_status ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/control_status error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$a.post("/api/v1/view/control_average_price", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, requestId, serviceName } = request;
+        const data = await ioc.controlViewService.getAveragePrice(symbol, context);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/control_average_price ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/control_average_price error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$a.post("/api/v1/view/control_open_pending", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, dto, requestId, serviceName } = request;
+        const data = await ioc.controlViewService.commitOpenPending(symbol, context, dto);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/control_open_pending ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/control_open_pending error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$a.post("/api/v1/view/control_average_buy", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, dto, requestId, serviceName } = request;
+        const data = await ioc.controlViewService.commitAverageBuy(symbol, context, dto);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/control_average_buy ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/control_average_buy error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$a.post("/api/v1/view/control_close_pending", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, dto, requestId, serviceName } = request;
+        const data = await ioc.controlViewService.commitClosePending(symbol, context, dto);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/control_close_pending ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/control_close_pending error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
+router$a.post("/api/v1/view/control_breakeven", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { symbol, context, requestId, serviceName } = request;
+        const data = await ioc.controlViewService.commitBreakeven(symbol, context);
+        const result = {
+            data,
+            status: "ok",
+            error: "",
+            requestId,
+            serviceName,
+        };
+        ioc.loggerService.log("/api/v1/view/control_breakeven ok", {
+            request,
+            result: omit(result, "data"),
+        });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/view/control_breakeven error", {
+            error: functoolsKit.errorData(error),
+        });
+        return await micro.send(res, 200, {
+            status: "error",
+            error: functoolsKit.getErrorMessage(error),
+        });
+    }
+});
 // HeatViewService endpoints
 router$a.post("/api/v1/view/heat_data", async (req, res) => {
     try {