Rewrite trader service for V4 P0

2026-06-26 21:53:22 +08:00
parent 2fe4077164
commit 5d210053d0
184 changed files with 2780 additions and 6945 deletions
@@ -0,0 +1,130 @@
+package com.quantai.trader.domain;
+
+import static com.quantai.trader.util.TraderNumbers.*;
+
+import java.math.BigDecimal;
+
+public record TraderPmConfig(
+        String pmConfigVersion,
+        OpenRuleConfig open,
+        AddRuleConfig add,
+        ExitRuleConfig exit,
+        SizingConfig sizing
+) {
+    public TraderPmConfig {
+        pmConfigVersion = requiredText(pmConfigVersion, "pmConfigVersion");
+        open = java.util.Objects.requireNonNull(open, "open config is required");
+        add = java.util.Objects.requireNonNull(add, "add config is required");
+        exit = java.util.Objects.requireNonNull(exit, "exit config is required");
+        sizing = java.util.Objects.requireNonNull(sizing, "sizing config is required");
+    }
+
+    public record OpenRuleConfig(
+            BigDecimal longOpenProb,
+            BigDecimal shortOpenProb,
+            BigDecimal minLongEntryProb,
+            BigDecimal minShortEntryProb,
+            BigDecimal maxMarketRiskProb,
+            BigDecimal minExpectedEdgeBps,
+            BigDecimal minDirectionMargin,
+            BigDecimal minLiquidityCapacityRatio,
+            BigDecimal maxOodScore
+    ) {
+        public OpenRuleConfig {
+            longOpenProb = probability(longOpenProb, "open.longOpenProb");
+            shortOpenProb = probability(shortOpenProb, "open.shortOpenProb");
+            minLongEntryProb = probability(minLongEntryProb, "open.minLongEntryProb");
+            minShortEntryProb = probability(minShortEntryProb, "open.minShortEntryProb");
+            maxMarketRiskProb = probability(maxMarketRiskProb, "open.maxMarketRiskProb");
+            minExpectedEdgeBps = required(minExpectedEdgeBps, "open.minExpectedEdgeBps");
+            minDirectionMargin = nonNegative(minDirectionMargin, "open.minDirectionMargin");
+            minLiquidityCapacityRatio = nonNegative(minLiquidityCapacityRatio, "open.minLiquidityCapacityRatio");
+            maxOodScore = probability(maxOodScore, "open.maxOodScore");
+        }
+    }
+
+    public record AddRuleConfig(
+            BigDecimal minLongProb,
+            BigDecimal minShortProb,
+            BigDecimal minContinueProb,
+            BigDecimal minEntryProb,
+            BigDecimal maxExitProb,
+            BigDecimal maxMarketRiskProb,
+            BigDecimal maxPositionRiskProb,
+            BigDecimal minExpectedEdgeBps,
+            BigDecimal minContinueVsExitEdgeBps,
+            BigDecimal minLiquidityCapacityRatio,
+            BigDecimal minPostTradeLiquidationBufferBps,
+            int maxAddCount,
+            long cooldownMinutes
+    ) {
+        public AddRuleConfig {
+            minLongProb = probability(minLongProb, "add.minLongProb");
+            minShortProb = probability(minShortProb, "add.minShortProb");
+            minContinueProb = probability(minContinueProb, "add.minContinueProb");
+            minEntryProb = probability(minEntryProb, "add.minEntryProb");
+            maxExitProb = probability(maxExitProb, "add.maxExitProb");
+            maxMarketRiskProb = probability(maxMarketRiskProb, "add.maxMarketRiskProb");
+            maxPositionRiskProb = probability(maxPositionRiskProb, "add.maxPositionRiskProb");
+            minExpectedEdgeBps = required(minExpectedEdgeBps, "add.minExpectedEdgeBps");
+            minContinueVsExitEdgeBps = required(minContinueVsExitEdgeBps, "add.minContinueVsExitEdgeBps");
+            minLiquidityCapacityRatio = nonNegative(minLiquidityCapacityRatio, "add.minLiquidityCapacityRatio");
+            minPostTradeLiquidationBufferBps = nonNegative(minPostTradeLiquidationBufferBps, "add.minPostTradeLiquidationBufferBps");
+            if (maxAddCount < 0 || cooldownMinutes < 0) {
+                throw new IllegalArgumentException("add count and cooldown must be >= 0");
+            }
+        }
+    }
+
+    public record ExitRuleConfig(
+            BigDecimal closeExitProb,
+            BigDecimal closePositionRiskProb,
+            BigDecimal closeMarketRiskProb,
+            BigDecimal closeContinueMax,
+            BigDecimal reduceGivebackProb,
+            BigDecimal reduceContinueMin,
+            BigDecimal reduceContinueMax,
+            BigDecimal minProfitForReduceBps,
+            BigDecimal maxExpectedShortfallBps
+    ) {
+        public ExitRuleConfig {
+            closeExitProb = probability(closeExitProb, "exit.closeExitProb");
+            closePositionRiskProb = probability(closePositionRiskProb, "exit.closePositionRiskProb");
+            closeMarketRiskProb = probability(closeMarketRiskProb, "exit.closeMarketRiskProb");
+            closeContinueMax = probability(closeContinueMax, "exit.closeContinueMax");
+            reduceGivebackProb = probability(reduceGivebackProb, "exit.reduceGivebackProb");
+            reduceContinueMin = probability(reduceContinueMin, "exit.reduceContinueMin");
+            reduceContinueMax = probability(reduceContinueMax, "exit.reduceContinueMax");
+            minProfitForReduceBps = nonNegative(minProfitForReduceBps, "exit.minProfitForReduceBps");
+            maxExpectedShortfallBps = nonNegative(maxExpectedShortfallBps, "exit.maxExpectedShortfallBps");
+        }
+    }
+
+    public record SizingConfig(
+            BigDecimal baseRatio,
+            BigDecimal minInitialRatio,
+            BigDecimal maxSingleLegRatio,
+            BigDecimal minAddRatio,
+            BigDecimal maxAddRatio,
+            BigDecimal maxTotalPositionRatio,
+            BigDecimal minEdgeBps,
+            BigDecimal maxLossPerTradeBps,
+            BigDecimal maxLiquidityUsageRatio,
+            BigDecimal uncertaintyPenaltyMultiplier,
+            BigDecimal minPostTradeLiquidationBufferBps
+    ) {
+        public SizingConfig {
+            baseRatio = positive(baseRatio, "sizing.baseRatio");
+            minInitialRatio = nonNegative(minInitialRatio, "sizing.minInitialRatio");
+            maxSingleLegRatio = positive(maxSingleLegRatio, "sizing.maxSingleLegRatio");
+            minAddRatio = nonNegative(minAddRatio, "sizing.minAddRatio");
+            maxAddRatio = nonNegative(maxAddRatio, "sizing.maxAddRatio");
+            maxTotalPositionRatio = positive(maxTotalPositionRatio, "sizing.maxTotalPositionRatio");
+            minEdgeBps = required(minEdgeBps, "sizing.minEdgeBps");
+            maxLossPerTradeBps = positive(maxLossPerTradeBps, "sizing.maxLossPerTradeBps");
+            maxLiquidityUsageRatio = positive(maxLiquidityUsageRatio, "sizing.maxLiquidityUsageRatio");
+            uncertaintyPenaltyMultiplier = nonNegative(uncertaintyPenaltyMultiplier, "sizing.uncertaintyPenaltyMultiplier");
+            minPostTradeLiquidationBufferBps = nonNegative(minPostTradeLiquidationBufferBps, "sizing.minPostTradeLiquidationBufferBps");
+        }
+    }
+}