feat(gate): 实现仓位止盈补仓功能

Administrator

5 days ago 8cadc2c947d541bd2621892b5764d2d3e7697cad

 src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java

@@ -155,6 +155,10 @@
    private volatile int accumulatedLongLossCount = 0;
    /** 空头累计止损次数（始终递增，加仓订单成交后归零） */
    private volatile int accumulatedShortLossCount = 0;
    /** 多头加仓执行次数（每次真正产生额外加仓量 addMultiplier>0 的多仓止损追单 +1，用于加仓停止阈值判断） */
    private volatile int accumulatedLongAddCount = 0;
    /** 空头加仓执行次数（每次真正产生额外加仓量 addMultiplier>0 的空仓止损追单 +1，用于加仓停止阈值判断） */
    private volatile int accumulatedShortAddCount = 0;
    /** 最近触发止损的多头网格ID */
    private volatile int lastLongStopLossGridId = Integer.MAX_VALUE;
    /** 最近触发止损的空头网格ID */
@@ -420,6 +424,8 @@
        shortActive = false;
        accumulatedLongLossCount = 0;
        accumulatedShortLossCount = 0;
        accumulatedLongAddCount = 0;
        accumulatedShortAddCount = 0;
        lastLongStopLossGridId = Integer.MAX_VALUE;
        lastShortStopLossGridId = Integer.MAX_VALUE;
        dualStopLossModeActive.set(false);
@@ -609,14 +615,16 @@

                log.info("[Gate] 重置策略，开始第{}轮...", currentRound);
                state = StrategyState.STOPPED;
                try {
                    futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
                } catch (ApiException e) {
                    e.printStackTrace();
                }
                closeExistingPositions();
                // 提交到 executor 末尾：单线程FIFO保证前面所有平仓/取消任务完成后才重置
                // 关键修复：取消+平仓+延时+重启必须整体放进 executor 队列末尾，让上一轮排队的
                // 挂单任务先执行完（挂到交易所），随后的 cancel 才能取消到它们。若 cancel 仍留在
                // WS 线程同步执行，会早于上一轮挂单任务，取消不到"尚未挂出"的单（竞态）。
                executor.submitTask(() -> {
                    try {
                        futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
                    } catch (ApiException e) {
                        e.printStackTrace();
                    }
                    closeExistingPositions();
                    try { Thread.sleep(3000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
                    // 注意：startGrid() 会将 currentRound 归零，这里需要保留
                    int savedRound = currentRound;
@@ -836,8 +844,9 @@
                lastShortStopLossGridId = Integer.MAX_VALUE;
                // [Gate-需求2] 加仓后先撤空仓所有止盈+止损，再查交易所持仓后重挂
                cancelAllShortTakeProfitsAndStopLosses();
                // REST 查询可能因交易所延迟返回旧值，与 WS 本地缓存取最大值兜底
                int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue());
                // REST/WS 持仓可能因交易所延迟返回旧值（仓位归零后重开甚至为 0），
                // 与本次成交张数 filledQty 取最大值兜底，避免 posSize=0 导致止盈止损全部跳过
                int posSize = Math.max(Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()), filledQty);
                extendShortStopLoss(posSize, shortGridElement.getId());
                // [Gate] 止盈挂单：超出基础仓位的部分，挂在多仓第一止损位
                if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
@@ -886,8 +895,9 @@
                lastLongStopLossGridId = Integer.MAX_VALUE;
                // [Gate-需求2] 加仓后先撤多仓所有止盈+止损，再查交易所持仓后重挂
                cancelAllLongTakeProfitsAndStopLosses();
                // REST 查询可能因交易所延迟返回旧值，与 WS 本地缓存取最大值兜底
                int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue());
                // REST/WS 持仓可能因交易所延迟返回旧值（仓位归零后重开甚至为 0），
                // 与本次成交张数 filledQty 取最大值兜底，避免 posSize=0 导致止盈止损全部跳过
                int posSize = Math.max(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()), filledQty);
                extendLongStopLoss(posSize, longGridElement.getId());
                // [Gate] 止盈挂单：超出基础仓位的部分，挂在空仓第一止损位
                if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
@@ -911,6 +921,8 @@
     * @param orderId 止盈单 ID
     */
    private void handleLongTakeProfitTriggered(GridElement tpElem, String orderId) {
        // 清理前读取本次止盈单张数（仓位止盈补仓用；清理后该记录会被移除）
        Integer tpSize = tpElem.getLongTakeProfitOrderSize(orderId);
        // 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
        boolean isLastTp = GridElement.getLongTakeProfitCount() <= 1;
        // 清理止盈单状态（移除已成交的这笔止盈单）
@@ -920,6 +932,11 @@

        // 止盈依次上移：先取消之前挂的对向空开仓单，再挂新单
        cancelTpOppositeShortEntries();

        // 仓位止盈补仓：在对侧（空仓）止损位挂同方向（多仓）开仓单，张数 = 本次止盈单张数
        if (config.isTpPositionReplenishEnabled()) {
            replenishAfterTp(true, tpSize);
        }

        if (!config.isTpTriggerOppositeAddEnabled()) {
            return;
@@ -949,6 +966,8 @@
     * @param orderId 止盈单 ID
     */
    private void handleShortTakeProfitTriggered(GridElement tpElem, String orderId) {
        // 清理前读取本次止盈单张数（仓位止盈补仓用；清理后该记录会被移除）
        Integer tpSize = tpElem.getShortTakeProfitOrderSize(orderId);
        // 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
        boolean isLastTp = GridElement.getShortTakeProfitCount() <= 1;
        // 清理止盈单状态（移除已成交的这笔止盈单）
@@ -958,6 +977,11 @@

        // 止盈依次下移：先取消之前挂的对向多开仓单，再挂新单
        cancelTpOppositeLongEntries();

        // 仓位止盈补仓：在对侧（多仓）止损位挂同方向（空仓）开仓单，张数 = 本次止盈单张数
        if (config.isTpPositionReplenishEnabled()) {
            replenishAfterTp(false, tpSize);
        }

        if (!config.isTpTriggerOppositeAddEnabled()) {
            return;
@@ -978,6 +1002,41 @@
            return;
        }
        placeOppositeAddLongEntry(target, tpElem, qty);
    }

    /**
     * 仓位止盈补仓：任意方向止盈触发时，在对侧止损位挂与止盈方向一致、张数 = 本次止盈单张数的条件开仓单。
     * <p>开仓单走标准入场流程（placeEntryOrderWithPreFlag 预置标记），成交后进入 ENTRY_FILLED 常规分支，
     * extend 会按最新全持仓重挂止损，保证补仓仓位有完整止损覆盖。</p>
     *
     * @param isLong true=多仓止盈（挂多仓开仓单），false=空仓止盈（挂空仓开仓单）
     * @param tpSize 本次触发止盈单的张数（null 或 <=0 则跳过）
     */
    private void replenishAfterTp(boolean isLong, Integer tpSize) {
        if (tpSize == null || tpSize <= 0) {
            log.warn("[Gate] 仓位止盈补仓跳过: 止盈单张数无效, isLong:{}, tpSize:{}", isLong, tpSize);
            return;
        }
        // 对侧止损位：多仓止盈 → 空仓第一止损位；空仓止盈 → 多仓第一止损位
        GridElement slElem = isLong ? findFirstShortStopLossGrid() : findFirstLongStopLossGrid();
        if (slElem == null) {
            log.warn("[Gate] 仓位止盈补仓: 未找到对侧止损位, isLong:{}", isLong);
            return;
        }
        BigDecimal triggerPrice = slElem.getGridPrice();
        // 方向与止盈方向一致：多仓止盈 → 多开仓（价格≥触发价 NUMBER_1）；空仓止盈 → 空开仓（价格≤触发价 NUMBER_2）
        FuturesPriceTrigger.RuleEnum rule = isLong ? FuturesPriceTrigger.RuleEnum.NUMBER_1
                : FuturesPriceTrigger.RuleEnum.NUMBER_2;
        String size = isLong ? String.valueOf(tpSize) : negate(String.valueOf(tpSize));
        // 记录本网格该方向的开仓张数（供 ENTRY_FILLED 分支读取成交张数）
        if (isLong) {
            slElem.getLongTraderParam().setQuantity(String.valueOf(tpSize));
        } else {
            slElem.getShortTraderParam().setQuantity(String.valueOf(tpSize));
        }
        placeEntryOrderWithPreFlag(slElem, isLong, triggerPrice, rule, size);
        log.info("[Gate] 仓位止盈补仓: {}止盈触发, 对侧止损位 gridId:{}, 挂{}开仓{}张",
                isLong ? "多仓" : "空仓", slElem.getId(), isLong ? "多" : "空", tpSize);
    }

    /**
@@ -1094,7 +1153,7 @@
                ORDER_TYPE_CLOSE_SHORT,
                String.valueOf(qty),
                profitId -> {
                    slElem.addShortStopLossOrderId(profitId);
                    slElem.addShortStopLossOrderId(profitId, qty);
                    GridElement.refreshIndices();
                    log.info("[Gate] 对向加仓空仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
                            oppositeGridId, stopLossGridId, qty, profitId);
@@ -1122,7 +1181,7 @@
                ORDER_TYPE_CLOSE_LONG,
                negate(String.valueOf(qty)),
                profitId -> {
                    slElem.addLongStopLossOrderId(profitId);
                    slElem.addLongStopLossOrderId(profitId, qty);
                    GridElement.refreshIndices();
                    log.info("[Gate] 对向加仓多仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
                            oppositeGridId, stopLossGridId, qty, profitId);
@@ -1316,7 +1375,7 @@
                        ORDER_TYPE_CLOSE_LONG,
                        negate(baseQty),
                        profitId -> {
                            longElem.addLongStopLossOrderId(profitId);
                            longElem.addLongStopLossOrderId(profitId, Integer.parseInt(baseQty));
                            GridElement.refreshIndices();
                            log.info("[Gate] 自定义多仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
                                    longPrice, longElem.getId(), triggerPrice, profitId);
@@ -1337,7 +1396,7 @@
                        ORDER_TYPE_CLOSE_SHORT,
                        baseQty,
                        profitId -> {
                            shortElem.addShortStopLossOrderId(profitId);
                            shortElem.addShortStopLossOrderId(profitId, Integer.parseInt(baseQty));
                            GridElement.refreshIndices();
                            log.info("[Gate] 自定义空仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
                                    shortPrice, shortElem.getId(), triggerPrice, profitId);
@@ -1380,7 +1439,7 @@
                    ORDER_TYPE_CLOSE_SHORT,
                    size,
                    profitId -> {
                        elem.addShortStopLossOrderId(profitId);
                        elem.addShortStopLossOrderId(profitId, Integer.parseInt(size));
                        GridElement.refreshIndices();
                        log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                    }
@@ -1407,7 +1466,7 @@
                    ORDER_TYPE_CLOSE_LONG,
                    negate(size),
                    profitId -> {
                        elem.addLongStopLossOrderId(profitId);
                        elem.addLongStopLossOrderId(profitId, Integer.parseInt(size));
                        GridElement.refreshIndices();
                        log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                    }
@@ -1468,12 +1527,17 @@
    private void longTakeProfitTraderIdParam(
            GridElement baseElement,String profitId, boolean flag
    ) {
        longTakeProfitTraderIdParam(baseElement, profitId, flag, 0);
    }
    private void longTakeProfitTraderIdParam(
            GridElement baseElement,String profitId, boolean flag, int size
    ) {
        TraderParam tp = baseElement.getLongTraderParam();
        if (flag && profitId != null) {
            // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单）
            // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单），并记录该单张数
            tp.setTakeProfitOrderId(profitId);
            tp.setTakeProfitPlaced(true);
            baseElement.addLongTakeProfitOrderId(profitId);
            baseElement.addLongTakeProfitOrderId(profitId, size);
        } else {
            // 清理：profitId 非空移除指定止盈单，为空清空该网格全部止盈单
            tp.setTakeProfitPlaced(false);
@@ -1492,12 +1556,17 @@
    private void shortTakeProfitTraderIdParam(
            GridElement baseElement,String profitId, boolean flag
    ) {
        shortTakeProfitTraderIdParam(baseElement, profitId, flag, 0);
    }
    private void shortTakeProfitTraderIdParam(
            GridElement baseElement,String profitId, boolean flag, int size
    ) {
        TraderParam tp = baseElement.getShortTraderParam();
        if (flag && profitId != null) {
            // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单）
            // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单），并记录该单张数
            tp.setTakeProfitOrderId(profitId);
            tp.setTakeProfitPlaced(true);
            baseElement.addShortTakeProfitOrderId(profitId);
            baseElement.addShortTakeProfitOrderId(profitId, size);
        } else {
            // 清理：profitId 非空移除指定止盈单，为空清空该网格全部止盈单
            tp.setTakeProfitPlaced(false);
@@ -1761,7 +1830,7 @@
//                        String quantity = String.valueOf(config.getBaseQuantity());


                        String quantity = calculateEntryQuantity(true, false);
                        String quantity = calculateEntryQuantity(true, false, 0);
                        // 向下检查是否已有多单挂在更低价格网格，有则跳过（防止价格回升后重复挂单）
                        boolean hasLongOrderBelow = false;
                        GridElement checkDownCursor = GridElement.findById(newEntryGrid.getDownId());
@@ -1835,7 +1904,7 @@
//                        String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()) + Integer.parseInt(config.getQuantity()));
//                        String quantity = String.valueOf(config.getBaseQuantity());

                        String quantity = calculateEntryQuantity(false, false);
                        String quantity = calculateEntryQuantity(false, false, 0);
                        // 向上检查是否已有空单挂在更高价格网格，有则跳过（防止价格回落后重复挂单）
                        boolean hasShortOrderAbove = false;
                        GridElement checkUpCursor = GridElement.findById(newEntryGrid.getUpId());
@@ -1903,6 +1972,75 @@
    }

    /**
     * 根据 {@code stopLossCountMode} 计算当前有效的加仓执行次数（与止损次数的统计口径一致）。
     * <p>加仓执行次数 = 真正产生额外加仓量（addMultiplier &gt; 0）的止损追单累计次数，
     * 用于加仓停止阈值判断。</p>
     *
     * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
     * @return 有效加仓执行次数
     */
    private int getEffectiveAddCount(boolean isLong) {
        if ("single".equals(config.getStopLossCountMode())) {
            return isLong ? accumulatedLongAddCount : accumulatedShortAddCount;
        }
        // "dual" — 双向总次数
        return accumulatedLongAddCount + accumulatedShortAddCount;
    }

    /**
     * 记录一次加仓执行（用于加仓停止阈值判断）。
     * <p>仅当本次追单的加仓公式<b>真正产生了额外加仓量</b>（addMultiplier &gt; 0，即 addQty &gt; 0）时计数；
     * 只挂基础张数的追单不计入。判断依据 {@link #computeAddQty(boolean)} 与
     * {@link #calculateEntryQuantity(boolean, boolean, int)} 共用同一套计数状态，
     * 同一处理器内止损次数不变，二者结果一致。</p>
     *
     * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
     */
    private void recordAddExecution(boolean isLong) {
        if (computeAddQty(isLong) <= 0) {
            // 本次未产生额外加仓量（addMultiplier = 0），不计入执行次数
            return;
        }
        if (isLong) {
            accumulatedLongAddCount++;
        } else {
            accumulatedShortAddCount++;
        }
    }

    /**
     * 计算本次追单的额外加仓量（addQty），供 {@link #calculateEntryQuantity(boolean, boolean, int)}
     * 与 {@link #recordAddExecution(boolean)} 共用，保证「加仓执行」判定与下单计算同源。
     * <pre>
     * effectiveCount = max(0, 累计止损次数 - addPositionStartThreshold)   ← 启动阈值
     * divisor        = addPositionInterval + 1
     * addMultiplier  = floor(effectiveCount / divisor)
     * addQty         = addMultiplier × addPositionQuantity
     * </pre>
     * 加仓停止阈值：加仓执行次数达到 {@code addPositionStopThreshold} 后 addMultiplier 强制归零
     * （addQty = 0），回到基础张数；0 = 不限制。
     *
     * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
     * @return 额外加仓张数（0 表示本次不加仓）
     */
    private int computeAddQty(boolean isLong) {
        int effectiveCount = getEffectiveStopLossCount(isLong);
        int startThreshold = config.getAddPositionStartThreshold();
        if (startThreshold > 0) {
            effectiveCount = Math.max(0, effectiveCount - startThreshold);
        }
        // 加仓停止阈值：按「加仓执行次数」（真正产生额外加仓量的执行）计数，
        // 已达到停止阈值则加仓量归零，回到基础张数
        int stopThreshold = config.getAddPositionStopThreshold();
        boolean addStopped = stopThreshold > 0 && getEffectiveAddCount(isLong) >= stopThreshold;
        // divisor = interval + 1：interval=0→每次加仓, interval=1→每2次加仓(2,4,6...), interval=3→每4次加仓(4,8,12...)
        int interval = config.getAddPositionInterval();
        int divisor = interval + 1;
        int addMultiplier = (!addStopped && interval >= 0) ? effectiveCount / divisor : 0;
        return addMultiplier * config.getAddPositionQuantity();
    }

    /**
     * 根据加仓配置计算入场/追单时的实际下单量。
     * <p>公式：</p>
     * <pre>
@@ -1918,37 +2056,37 @@
     *   <li>{@code respectCurrentPosition=true}：{@code upperLimit = maxPositionPerSide - 当前持仓}
     *       （止损追单，保证单边总持仓 ≤ maxPositionPerSide）</li>
     * </ul>
     * <p>加仓停止阈值 {@code addPositionStopThreshold}：</p>
     * <ul>
     *   <li>{@code 0} = 不限制；</li>
     *   <li>{@code > 0} 时按「加仓执行次数」（真正产生额外加仓量 addMultiplier &gt; 0 的执行）计数，
     *       达到该次数后不再追加加仓量 {@code addQty}，下单量回到 {@code baseQuantity}。</li>
     * </ul>
     *
     * @param isLong                 {@code true}=多仓方向，{@code false}=空仓方向
     * @param respectCurrentPosition {@code true}=按「单边总持仓 ≤ maxPositionPerSide」扣减当前持仓；{@code false}=仅限制单次下单量
     * @param stopLossSize           本次触发网格的全部止损单张数（仅止损追单场景传入，用于修正 REST 持仓时序竞态；其余场景传 0）
     * @return 实际下单张数（字符串）
     */
    private String calculateEntryQuantity(boolean isLong, boolean respectCurrentPosition) {
    private String calculateEntryQuantity(boolean isLong, boolean respectCurrentPosition, int stopLossSize) {
        int baseQty = Integer.parseInt(config.getBaseQuantity());
        int interval = config.getAddPositionInterval();
        int addQtyPerUnit = config.getAddPositionQuantity();
        int maxPerSide = config.getMaxPositionPerSide();

        int effectiveCount = getEffectiveStopLossCount(isLong);
        int startThreshold = config.getAddPositionStartThreshold();
        if (startThreshold > 0) {
            effectiveCount = Math.max(0, effectiveCount - startThreshold);
        }
        // divisor = interval + 1：interval=0→每次加仓, interval=1→每2次加仓(2,4,6...), interval=3→每4次加仓(4,8,12...)
        int divisor = interval + 1;
        int addMultiplier = interval >= 0 ? effectiveCount / divisor : 0;
        int addQty = addMultiplier * addQtyPerUnit;
        // 额外加仓量由 computeAddQty 统一计算（含启动/停止阈值与间隔公式）
        int addQty = computeAddQty(isLong);
        int totalQty = baseQty + addQty;

        if (maxPerSide > 0) {
            int upperLimit = maxPerSide;
            if (respectCurrentPosition) {
                // 止损追单：单边总持仓不得超过 maxPerSide，追单量 = maxPerSide - 当前持仓。
                // 止损单刚成交、WS 持仓推送尚未到达，必须用 REST 实时查询绕过 WS 缓存时序竞态，
                // 否则会取到滞后的旧持仓（如止损前仍为 10），把追单量错误扣减。
                // 止损单刚成交、REST 查询可能仍返回止损前持仓（时序竞态），
                // 减去本网格全部止损张数得到止损后的真实持仓，避免追单量被错误扣减。
                int currentPos = isLong
                        ? queryPositionSize(Position.ModeEnum.DUAL_LONG)
                        : queryPositionSize(Position.ModeEnum.DUAL_SHORT);
                if (stopLossSize > 0) {
                    currentPos = Math.max(0, currentPos - stopLossSize);
                }
                upperLimit = maxPerSide - currentPos;
            }
            if (upperLimit <= 0) {
@@ -1962,6 +2100,8 @@
    }

    private void handleLongStopLossTriggered(GridElement gridElement, String orderId) {
        // 本网格全部止损单覆盖张数（含刚触发的这一单），用于追单时修正 REST 持仓的时序竞态
        int gridStopLossSize = gridElement.getLongStopLossTotalSize();
        gridElement.removeLongStopLossOrderId(orderId);

        int gridId = gridElement.getId();
@@ -1994,15 +2134,18 @@

        // 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(true, true);
        log.info("[Gate] 多仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(true), config.getBaseQuantity(), size, config.getStopLossCountMode());
        String size = calculateEntryQuantity(true, true, gridStopLossSize);
        log.info("[Gate] 多仓止损追单 有效次数:{}, 加仓执行:{}, 停止阈值:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(true), getEffectiveAddCount(true), config.getAddPositionStopThreshold(),
                config.getBaseQuantity(), size, config.getStopLossCountMode());
        if (Integer.parseInt(size) <= 0) {
            log.warn("[Gate] 多仓止损追单 当前持仓已达单边上限({}), 跳过挂单", config.getMaxPositionPerSide());
        } else {
            newEntryGrid.getLongTraderParam().setQuantity(size);
            placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
            // 记录加仓执行次数：仅当本次真正产生了额外加仓量（addMultiplier > 0）时计数
            recordAddExecution(true);
        }

        // 取消 gridId+2 位置的所有多单
@@ -2027,6 +2170,8 @@
    }

    private void handleShortStopLossTriggered(GridElement gridElement, String orderId) {
        // 本网格全部止损单覆盖张数（含刚触发的这一单），用于追单时修正 REST 持仓的时序竞态
        int gridStopLossSize = gridElement.getShortStopLossTotalSize();
        gridElement.removeShortStopLossOrderId(orderId);

        int gridId = gridElement.getId();
@@ -2057,15 +2202,18 @@

        // 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(false, true);
        log.info("[Gate] 空仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(false), config.getBaseQuantity(), size, config.getStopLossCountMode());
        String size = calculateEntryQuantity(false, true, gridStopLossSize);
        log.info("[Gate] 空仓止损追单 有效次数:{}, 加仓执行:{}, 停止阈值:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(false), getEffectiveAddCount(false), config.getAddPositionStopThreshold(),
                config.getBaseQuantity(), size, config.getStopLossCountMode());
        if (Integer.parseInt(size) <= 0) {
            log.warn("[Gate] 空仓止损追单 当前持仓已达单边上限({}), 跳过挂单", config.getMaxPositionPerSide());
        } else {
            newEntryGrid.getShortTraderParam().setQuantity(size);
            placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
            // 记录加仓执行次数：仅当本次真正产生了额外加仓量（addMultiplier > 0）时计数
            recordAddExecution(false);
        }

        // 取消 gridId-2 位置的所有空单
@@ -2309,22 +2457,27 @@
    // ========== 止损追单（新逻辑：3 个固定位置，每个位置挂多个 1 张止损单） ==========

    /**
     * 多仓止损追单 — 网格数量 = baseQuantity/quantity，从近到远分配。
     * aCount<0跳过, aCount=0→主=2, aCount=1→主=2,辅0=1, aCount>=2→主=aCount,辅依次填1
     * 多仓止损追单 — 把当前多头持仓<b>全量</b>拆分为多笔止损单，挂在靠近入场的连续网格上。
     * 网格数 gridCount = baseQuantity / quantity；最近网格挂大部分张数、其余网格各挂 1 笔 quantity 张，
     * 不足一格的余数单独在更远一网格挂一笔。所有异步挂单完成后通过计数器重置防重入标记；
     * 期间若有入场单成交则打 pendingStopLossReExtend 待重挂。
     */
    private void extendLongStopLoss(int filledQty, int gridId) {
        int qty = Integer.parseInt(config.getQuantity());
        int baseQty = Integer.parseInt(config.getBaseQuantity());
        int gridCount = baseQty / qty;
        GridElement entryElem = GridElement.findById(gridId);
        if (gridCount <= 0 || filledQty < qty) {
        if (gridCount <= 0 || filledQty <= 0) {
            // 早期返回需重置防重入标记
            if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
            return;
        }

        // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈
        int totalOrders = filledQty / qty;
        // [Gate] 止损覆盖全持仓：加仓部分同样受止损保护，不再只保初始仓位。
        // 取 max 是为了在 REST 时序竞态导致 filledQty 偏小时，至少保住 baseQuantity 的基础仓位
        int slSize = Math.max(filledQty, baseQty);
        int totalOrders = slSize / qty;
        int remainder = slSize % qty;
        int[] orders = new int[gridCount];

        if (gridCount == 1) {
@@ -2348,6 +2501,7 @@
        for (int i = 0; i < gridCount; i++) {
            if (orders[i] > 0) { totalOrdersToPlace += orders[i]; }
        }
        if (remainder > 0) { totalOrdersToPlace += 1; }
        if (totalOrdersToPlace == 0) {
            if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
            return;
@@ -2358,7 +2512,7 @@
        for (int i = 0; i < gridCount; i++) {
            if (orders[i] > 0) {
                int sgId = gridId - 2 - i;
                placeStopLossOrders(sgId, orders[i], qty, FuturesPriceTrigger.RuleEnum.NUMBER_2,
                placeStopLossOrders(sgId, orders[i], String.valueOf(qty), FuturesPriceTrigger.RuleEnum.NUMBER_2,
                        ORDER_TYPE_CLOSE_LONG, true, remainCount, entryElem);
                if (detail.length() > 0) {
                    detail.append("  ");
@@ -2366,28 +2520,43 @@
                detail.append(sgId).append("x").append(orders[i]);
            }
        }
        // 不足一个网格量的余数：单独挂一张止损
        if (remainder > 0) {
            int sgId = gridId - 2 - totalOrders;
            placeStopLossOrders(sgId, 1, String.valueOf(remainder), FuturesPriceTrigger.RuleEnum.NUMBER_2,
                    ORDER_TYPE_CLOSE_LONG, true, remainCount, entryElem);
            if (detail.length() > 0) {
                detail.append("  ");
            }
            detail.append(sgId).append("x").append(remainder);
        }

        log.info("[Gate] 多仓追挂止损, 成交{}张, gridId:{}, 网格数:{}, 分配:{}",
                filledQty, gridId, gridCount, detail);
    }

    /**
     * 空仓止损追单 — 网格数量 = baseQuantity/quantity，从近到远分配。
     * aCount<0跳过, aCount=0→主=2, aCount=1→主=2,辅0=1, aCount>=2→主=aCount,辅依次填1
     * 空仓止损追单 — 把当前空头持仓<b>全量</b>拆分为多笔止损单，挂在靠近入场的连续网格上。
     * 网格数 gridCount = baseQuantity / quantity；最近网格挂大部分张数、其余网格各挂 1 笔 quantity 张，
     * 不足一格的余数单独在更远一网格挂一笔。所有异步挂单完成后通过计数器重置防重入标记；
     * 期间若有入场单成交则打 pendingStopLossReExtend 待重挂。
     */
    private void extendShortStopLoss(int filledQty, int gridId) {
        int qty = Integer.parseInt(config.getQuantity());
        int baseQty = Integer.parseInt(config.getBaseQuantity());
        int gridCount = baseQty / qty;
        GridElement entryElem = GridElement.findById(gridId);
        if (gridCount <= 0 || filledQty < qty) {
        if (gridCount <= 0 || filledQty <= 0) {
            // 早期返回需重置防重入标记
            if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
            return;
        }

        // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈
        int totalOrders = filledQty / qty;
        // [Gate] 止损覆盖全持仓：加仓部分同样受止损保护，不再只保初始仓位。
        // 取 max 是为了在 REST 时序竞态导致 filledQty 偏小时，至少保住 baseQuantity 的基础仓位
        int slSize = Math.max(filledQty, baseQty);
        int totalOrders = slSize / qty;
        int remainder = slSize % qty;
        int[] orders = new int[gridCount];

        if (gridCount == 1) {
@@ -2411,6 +2580,7 @@
        for (int i = 0; i < gridCount; i++) {
            if (orders[i] > 0) { totalOrdersToPlace += orders[i]; }
        }
        if (remainder > 0) { totalOrdersToPlace += 1; }
        if (totalOrdersToPlace == 0) {
            if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
            return;
@@ -2421,13 +2591,23 @@
        for (int i = 0; i < gridCount; i++) {
            if (orders[i] > 0) {
                int sgId = gridId + 2 + i;
                placeStopLossOrders(sgId, orders[i], qty, FuturesPriceTrigger.RuleEnum.NUMBER_1,
                placeStopLossOrders(sgId, orders[i], String.valueOf(qty), FuturesPriceTrigger.RuleEnum.NUMBER_1,
                        ORDER_TYPE_CLOSE_SHORT, false, remainCount, entryElem);
                if (detail.length() > 0) {
                    detail.append("  ");
                }
                detail.append(sgId).append("x").append(orders[i]);
            }
        }
        // 不足一个网格量的余数：单独挂一张止损
        if (remainder > 0) {
            int sgId = gridId + 2 + totalOrders;
            placeStopLossOrders(sgId, 1, String.valueOf(remainder), FuturesPriceTrigger.RuleEnum.NUMBER_1,
                    ORDER_TYPE_CLOSE_SHORT, false, remainCount, entryElem);
            if (detail.length() > 0) {
                detail.append("  ");
            }
            detail.append(sgId).append("x").append(remainder);
        }

        log.info("[Gate] 空仓追挂止损, 成交{}张, gridId:{}, 网格数:{}, 分配:{}",
@@ -2465,7 +2645,7 @@
    /**
     * 在指定网格位置挂 count 个独立止损单，每个 size 张。
     */
    private void placeStopLossOrders(int gridId, int count, int qty,
    private void placeStopLossOrders(int gridId, int count, String qtyStr,
                                      FuturesPriceTrigger.RuleEnum rule,
                                      String orderType, boolean isLong,
                                      AtomicInteger remainCount,
@@ -2498,17 +2678,17 @@
            return;
        }
        BigDecimal triggerPrice = elem.getGridPrice();
        String size = isLong ? negate(qtyStr) : qtyStr;
        for (int i = 0; i < count; i++) {
            String size = isLong ? negate(String.valueOf(qty)) : String.valueOf(qty);
            int finalGridId = gridId;
            int finalI = i;
            executor.placeTakeProfit(
                    triggerPrice, rule, orderType, size,
                    profitId -> {
                        if (isLong) {
                            elem.addLongStopLossOrderId(profitId);
                            elem.addLongStopLossOrderId(profitId, Integer.parseInt(qtyStr));
                        } else {
                            elem.addShortStopLossOrderId(profitId);
                            elem.addShortStopLossOrderId(profitId, Integer.parseInt(qtyStr));
                        }
                        GridElement.refreshIndices();
                        log.info("[Gate] {}止损追加, gridId:{}, 触发价:{}, 第{}单, stopLossId:{}",
@@ -2928,9 +3108,9 @@
        executor.placeTakeProfit(triggerPrice, rule, orderType, size,
                profitId -> {
                    if (isLong) {
                        longTakeProfitTraderIdParam(tpElem, profitId, true);
                        longTakeProfitTraderIdParam(tpElem, profitId, true, excessQty);
                    } else {
                        shortTakeProfitTraderIdParam(tpElem, profitId, true);
                        shortTakeProfitTraderIdParam(tpElem, profitId, true, excessQty);
                    }
                    log.info("[Gate] {}止盈挂单, gridId:{}, 触发价:{}, 数量:{}, takeProfitId:{}",
                            isLong ? "多仓" : "空仓", finalTpGridId, triggerPrice, finalSize, profitId);
@@ -2940,10 +3120,10 @@

    /**
     * 分散止盈：把超出基础仓位的部分，从入场网格下一格开始逐格挂止盈单，
     * 一直挂到对手盘止损位的前一格（不含止损位那一格）。
     * 一直挂到对手盘止损位（包含止损位那一格）。
     *
     * <p>数量分配：每个网格至少挂 1 张；当 excessQty &lt; 网格数时，张数不够则从起点逐格各挂 1 张、
     * 挂满 excessQty 张即停止；当 excessQty ≥ 网格数时，每格 excessQty÷n，余数堆最后一格（即止损位的前一格）。
     * 挂满 excessQty 张即停止；当 excessQty ≥ 网格数时，每格 excessQty÷n，余数堆最后一格（即止损位那一格）。
     *
     * <p>方向：多仓成交向价格更高方向（id 递增）铺到空仓第一止损位；
     * 空仓成交向价格更低方向（id 递减）铺到多仓第一止损位。
@@ -2966,8 +3146,8 @@
        }
        int dir = isLong ? 1 : -1;
        int startId = entryGridId + dir;
        // 分配范围到止损位的前一格截止（不含止损位那一格）
        int endId = endElem.getId() - dir;
        // 分配范围到止损位那一格截止（包含止损位）
        int endId = endElem.getId();

        // 终点必须在起点前进方向上，否则退化为集中止盈（全部挂对手盘止损位）
        boolean valid = isLong ? (endId >= startId) : (endId <= startId);
@@ -3006,7 +3186,7 @@
        for (int i = 0; i < n; i++) {
            int qty;
            if (excessQty >= n) {
                // 超额仓位 ≥ 网格数：每格 perGrid，余数堆最后一格（即止损位的前一格）
                // 超额仓位 ≥ 网格数：每格 perGrid，余数堆最后一格（即止损位那一格）
                qty = perGrid;
                if (i == n - 1) {
                    qty += remainder;
@@ -3018,6 +3198,7 @@
            if (qty <= 0) {
                continue;
            }
            final int fqty = qty;
            final GridElement elem = gridList.get(i);
            final int gid = elem.getId();
            final BigDecimal triggerPrice = elem.getGridPrice();
@@ -3028,9 +3209,9 @@
            executor.placeTakeProfit(triggerPrice, rule, orderType, size,
                    profitId -> {
                        if (isLong) {
                            longTakeProfitTraderIdParam(elem, profitId, true);
                            longTakeProfitTraderIdParam(elem, profitId, true, fqty);
                        } else {
                            shortTakeProfitTraderIdParam(elem, profitId, true);
                            shortTakeProfitTraderIdParam(elem, profitId, true, fqty);
                        }
                        log.info("[Gate] 分散止盈 {} gridId:{}, 触发价:{}, 数量:{}, tpId:{}",
                                isLong ? "多仓" : "空仓", gid, triggerPrice, size, profitId);
@@ -3043,7 +3224,7 @@
     * 基础止盈：对基础仓位（baseQuantity）也挂止盈单，与超额止盈并行。
     *
     * <p>规则：从入场网格下一格（entryGridId ± 1）开始，每格 baseTakeProfitPerGrid 张，
     * 最多挂 baseTakeProfitGridCount 格，挂到止损位的前一格截止（与分散止盈同起点/同终点）。
     * 最多挂 baseTakeProfitGridCount 格，挂到止损位前 2 格截止（即对手盘仓位线）。
     *
     * <p>边界：累计张数到 min(baseQuantity, 当前持仓) 即停（张数不足则最后一格挂剩余 = "挂几个算几个"）；
     * 网格不足时挂到停止位置结束。
@@ -3053,9 +3234,9 @@
     * @param entryGridId 入场网格 ID
     */
    private void placeBaseTakeProfit(int posSize, boolean isLong, int entryGridId) {
        int perGrid = config.getBaseTakeProfitPerGrid();
        BigDecimal perGrid = config.getBaseTakeProfitPerGrid();
        int gridCount = config.getBaseTakeProfitGridCount();
        if (perGrid <= 0 || gridCount <= 0) {
        if (perGrid == null || perGrid.compareTo(BigDecimal.ZERO) <= 0 || gridCount <= 0) {
            return;
        }
        int baseQty = Integer.parseInt(config.getBaseQuantity());
@@ -3075,13 +3256,13 @@
        }
        int dir = isLong ? 1 : -1;
        int startId = entryGridId + dir;
        // 分配范围到止损位的前一格截止（与分散止盈一致）
        int endId = endElem.getId() - dir;
        // 分配范围到止损位前 2 格截止（即对手盘仓位线）
        int endId = endElem.getId() - 2 * dir;

        int remaining = maxQty;
        BigDecimal remaining = BigDecimal.valueOf(maxQty);
        int placed = 0;
        int id = startId;
        while (placed < gridCount && remaining > 0) {
        while (placed < gridCount && remaining.compareTo(BigDecimal.ZERO) > 0) {
            if (isLong ? id > endId : id < endId) {
                break;
            }
@@ -3089,26 +3270,27 @@
            if (elem == null) {
                break;
            }
            int qty = Math.min(perGrid, remaining);
            BigDecimal qty = perGrid.min(remaining);
            final int fqty = qty.intValue();
            final GridElement fe = elem;
            final int gid = id;
            final BigDecimal triggerPrice = elem.getGridPrice();
            final String size = isLong ? negate(String.valueOf(qty)) : String.valueOf(qty);
            final String size = isLong ? negate(qty.toPlainString()) : qty.toPlainString();
            final String orderType = isLong ? ORDER_TYPE_CLOSE_LONG : ORDER_TYPE_CLOSE_SHORT;
            final FuturesPriceTrigger.RuleEnum rule = isLong ? FuturesPriceTrigger.RuleEnum.NUMBER_1
                    : FuturesPriceTrigger.RuleEnum.NUMBER_2;
            executor.placeTakeProfit(triggerPrice, rule, orderType, size,
                    profitId -> {
                        if (isLong) {
                            longTakeProfitTraderIdParam(fe, profitId, true);
                            longTakeProfitTraderIdParam(fe, profitId, true, fqty);
                        } else {
                            shortTakeProfitTraderIdParam(fe, profitId, true);
                            shortTakeProfitTraderIdParam(fe, profitId, true, fqty);
                        }
                        log.info("[Gate] 基础止盈 {} gridId:{}, 触发价:{}, 数量:{}, tpId:{}",
                                isLong ? "多仓" : "空仓", gid, triggerPrice, size, profitId);
                    }
            );
            remaining -= qty;
            remaining = remaining.subtract(qty);
            placed++;
            id += dir;
        }
@@ -3129,9 +3311,9 @@
        executor.placeTakeProfit(triggerPrice, rule, orderType, size,
                profitId -> {
                    if (isLong) {
                        longTakeProfitTraderIdParam(tpElem, profitId, true);
                        longTakeProfitTraderIdParam(tpElem, profitId, true, qty);
                    } else {
                        shortTakeProfitTraderIdParam(tpElem, profitId, true);
                        shortTakeProfitTraderIdParam(tpElem, profitId, true, qty);
                    }
                    log.info("[Gate] 止损{}→对手超额止盈 gridId:{}, 量:{}, tpId:{}", times, gridId, qty, profitId);
                }
@@ -3156,8 +3338,8 @@
        String size = isLong ? negate(String.valueOf(tpQty)) : String.valueOf(tpQty);
        executor.placeTakeProfit(triggerPrice, rule, orderType, size,
                profitId -> {
                    if (isLong) longTakeProfitTraderIdParam(tpElem, profitId, true);
                    else        shortTakeProfitTraderIdParam(tpElem, profitId, true);
                    if (isLong) longTakeProfitTraderIdParam(tpElem, profitId, true, tpQty);
                    else        shortTakeProfitTraderIdParam(tpElem, profitId, true, tpQty);
                    log.info("[Gate] 止损次数{}→对手{}止盈 gridId:{}, 量:{}, tpId:{}",
                            times, isLong ? "多仓" : "空仓", tpGridId, size, profitId);
                }