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

Administrator

3 days ago 664b83f528c0fa690e2900a8a260137393ca5225

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

@@ -170,6 +170,10 @@
    private final Map<String, Integer> tpOppositeShortOrderGridMap = new ConcurrentHashMap<>();
    /** 止盈触发对向加仓：空仓止盈→多仓开仓单ID → 网格ID（成交后在该网格-1挂多仓止损） */
    private final Map<String, Integer> tpOppositeLongOrderGridMap = new ConcurrentHashMap<>();
    /** 仓位止盈补仓：多仓止盈→多仓开仓单ID → 张数（成交后按原多仓止损位重挂全持仓止损） */
    private final Map<String, Integer> tpReplenishLongOrderMap = new ConcurrentHashMap<>();
    /** 仓位止盈补仓：空仓止盈→空仓开仓单ID → 张数（成交后按原空仓止损位重挂全持仓止损） */
    private final Map<String, Integer> tpReplenishShortOrderMap = new ConcurrentHashMap<>();

    private volatile BigDecimal lastKlinePrice;
    private volatile BigDecimal markPrice = BigDecimal.ZERO;
@@ -429,6 +433,8 @@
        lastLongStopLossGridId = Integer.MAX_VALUE;
        lastShortStopLossGridId = Integer.MAX_VALUE;
        dualStopLossModeActive.set(false);
        tpReplenishLongOrderMap.clear();
        tpReplenishShortOrderMap.clear();
        shortPriceQueue.clear();
        longPriceQueue.clear();
        totalShortPriceQueue.clear();
@@ -821,6 +827,12 @@
                    handleTpOppositeShortAddFilled(shortGridElement, tpOppositeGridId);
                    return;
                }
                // 仓位止盈补仓的空仓开仓单成交 → 取消原空仓止损并在原位置按最新持仓重挂
                Integer replenishQty = tpReplenishShortOrderMap.remove(orderId);
                if (replenishQty != null) {
                    handleReplenishShortAddFilled(shortGridElement, orderId, replenishQty);
                    return;
                }
                int filledQty = Integer.parseInt(shortGridElement.getShortTraderParam().getQuantity());
                shortEntryTraderIdParam(shortGridElement, orderId, false);

@@ -872,6 +884,12 @@
                    handleTpOppositeLongAddFilled(longGridElement, tpOppositeGridId);
                    return;
                }
                // 仓位止盈补仓的多仓开仓单成交 → 取消原多仓止损并在原位置按最新持仓重挂
                Integer replenishQty = tpReplenishLongOrderMap.remove(orderId);
                if (replenishQty != null) {
                    handleReplenishLongAddFilled(longGridElement, orderId, replenishQty);
                    return;
                }
                int filledQty = Integer.parseInt(longGridElement.getLongTraderParam().getQuantity());
                longEntryTraderIdParam(longGridElement, orderId, false);

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

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

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

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

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

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

        if (!config.isTpTriggerOppositeAddEnabled()) {
            return;
@@ -988,6 +1020,192 @@
            return;
        }
        placeOppositeAddLongEntry(target, tpElem, qty);
    }

    /**
     * 仓位止盈补仓：任意方向止盈触发时，在对侧止损位挂与止盈方向一致、张数 = 本次止盈单张数的条件开仓单。
     * <p>开仓单走<b>专用分支</b>：成交后取消补仓方向原有的止损单，并在与原来相同的位置
     * 按最新总持仓重挂止损（不动止盈），详见 {@link #handleReplenishLongAddFilled} /
     * {@link #handleReplenishShortAddFilled}。</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;
        }
        // 方向与止盈方向一致：多仓止盈 → 多开仓（价格≥触发价 NUMBER_1）；空仓止盈 → 空开仓（价格≤触发价 NUMBER_2）
        if (isLong) {
            placeReplenishLongEntry(slElem, tpSize);
        } else {
            placeReplenishShortEntry(slElem, tpSize);
        }
        log.info("[Gate] 仓位止盈补仓: {}止盈触发, 对侧止损位 gridId:{}, 挂{}开仓{}张",
                isLong ? "多仓" : "空仓", slElem.getId(), isLong ? "多" : "空", tpSize);
    }

    /**
     * 仓位止盈补仓：在对侧止损位挂多仓条件开仓单（价格≥触发价），成交走专用分支 {@link #handleReplenishLongAddFilled}。
     */
    private void placeReplenishLongEntry(GridElement target, int qty) {
        target.setHasLongOrder(true);
        executor.placeConditionalEntryOrder(
                target.getGridPrice(),
                FuturesPriceTrigger.RuleEnum.NUMBER_1,
                String.valueOf(qty),
                orderId -> {
                    tpReplenishLongOrderMap.put(orderId, qty);
                    target.getLongTraderParam().setQuantity(String.valueOf(qty));
                    longEntryTraderIdParam(target, orderId, true);
                    log.info("[Gate] 仓位止盈补仓多开仓单已挂, 目标gridId:{}, 数量:{}张, orderId:{}",
                            target.getId(), qty, orderId);
                },
                () -> {
                    if (!target.hasLongOrderIds()) {
                        target.setHasLongOrder(false);
                    }
                    GridElement.refreshIndices();
                    log.warn("[Gate] 仓位止盈补仓多开仓单挂单失败, 目标gridId:{}", target.getId());
                }
        );
    }

    /**
     * 仓位止盈补仓：在对侧止损位挂空仓条件开仓单（价格≤触发价），成交走专用分支 {@link #handleReplenishShortAddFilled}。
     */
    private void placeReplenishShortEntry(GridElement target, int qty) {
        target.setHasShortOrder(true);
        executor.placeConditionalEntryOrder(
                target.getGridPrice(),
                FuturesPriceTrigger.RuleEnum.NUMBER_2,
                negate(String.valueOf(qty)),
                orderId -> {
                    tpReplenishShortOrderMap.put(orderId, qty);
                    target.getShortTraderParam().setQuantity(String.valueOf(qty));
                    shortEntryTraderIdParam(target, orderId, true);
                    log.info("[Gate] 仓位止盈补仓空开仓单已挂, 目标gridId:{}, 数量:{}张, orderId:{}",
                            target.getId(), qty, orderId);
                },
                () -> {
                    if (!target.hasShortOrderIds()) {
                        target.setHasShortOrder(false);
                    }
                    GridElement.refreshIndices();
                    log.warn("[Gate] 仓位止盈补仓空开仓单挂单失败, 目标gridId:{}", target.getId());
                }
        );
    }

    /**
     * 仓位止盈补仓：多仓开仓单成交（专用分支）。
     * 先取消多仓原有全部止损单（保留止盈），再在与原来相同的位置按最新总持仓重挂止损。
     *
     * @param elem      补仓开仓单所在的网格元素
     * @param orderId   已成交的开仓单 ID
     * @param filledQty 本次成交张数（挂单时记录）
     */
    private void handleReplenishLongAddFilled(GridElement elem, String orderId, int filledQty) {
        longEntryTraderIdParam(elem, orderId, false);

        // 最新总持仓：REST/本地/本次成交取最大，规避时序竞态
        int posSize = Math.max(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()), filledQty);
        // 原多仓止损位（最靠近入场的那个）
        GridElement anchorSl = findNearestLongStopLossGrid();
        if (anchorSl == null) {
            log.warn("[Gate] 仓位止盈补仓: 未找到原多仓止损位, 跳过重挂, 当前持仓:{}张", posSize);
            return;
        }
        // 反推原入场网格：止损挂在 entry-2-i，最近止损位 = entry-2 → entry = 最近止损位 + 2
        int anchorEntryGridId = anchorSl.getId() + 2;
        // 取消原多仓止损（保留止盈），并在原位置重挂全持仓止损
        cancelAllLongStopLossesOnly();
        lastLongStopLossGridId = Integer.MAX_VALUE;
        extendLongStopLoss(posSize, anchorEntryGridId);

        // 埋点: ENTRY_FILLED（补仓成交）
        emitStats("ENTRY_FILLED", mapOf(
                "direction", "long",
                "gridId", elem.getId(),
                "filledQty", filledQty,
                "source", "tp_replenish"
        ));
        log.info("[Gate] 仓位止盈补仓多开仓成交, gridId:{}, 当前持仓:{}张, 止损按原位置gridId:{}重挂",
                elem.getId(), posSize, anchorSl.getId());
    }

    /**
     * 仓位止盈补仓：空仓开仓单成交（专用分支）。
     * 先取消空仓原有全部止损单（保留止盈），再在与原来相同的位置按最新总持仓重挂止损。
     *
     * @param elem      补仓开仓单所在的网格元素
     * @param orderId   已成交的开仓单 ID
     * @param filledQty 本次成交张数（挂单时记录）
     */
    private void handleReplenishShortAddFilled(GridElement elem, String orderId, int filledQty) {
        shortEntryTraderIdParam(elem, orderId, false);

        // 最新总持仓：REST/本地/本次成交取最大，规避时序竞态
        int posSize = Math.max(Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()), filledQty);
        // 原空仓止损位（最靠近入场的那个）
        GridElement anchorSl = findNearestShortStopLossGrid();
        if (anchorSl == null) {
            log.warn("[Gate] 仓位止盈补仓: 未找到原空仓止损位, 跳过重挂, 当前持仓:{}张", posSize);
            return;
        }
        // 反推原入场网格：止损挂在 entry+2+i，最近止损位 = entry+2 → entry = 最近止损位 - 2
        int anchorEntryGridId = anchorSl.getId() - 2;
        // 取消原空仓止损（保留止盈），并在原位置重挂全持仓止损
        cancelAllShortStopLossesOnly();
        lastShortStopLossGridId = Integer.MAX_VALUE;
        extendShortStopLoss(posSize, anchorEntryGridId);

        // 埋点: ENTRY_FILLED（补仓成交）
        emitStats("ENTRY_FILLED", mapOf(
                "direction", "short",
                "gridId", elem.getId(),
                "filledQty", filledQty,
                "source", "tp_replenish"
        ));
        log.info("[Gate] 仓位止盈补仓空开仓成交, gridId:{}, 当前持仓:{}张, 止损按原位置gridId:{}重挂",
                elem.getId(), posSize, anchorSl.getId());
    }

    /**
     * 找到最靠近入场方向的多仓止损网格（ID 最大者）。
     */
    private GridElement findNearestLongStopLossGrid() {
        GridElement nearest = null;
        for (GridElement e : config.getGridElements()) {
            if (e.hasLongStopLossOrders()) {
                if (nearest == null || e.getId() > nearest.getId()) {
                    nearest = e;
                }
            }
        }
        return nearest;
    }

    /**
     * 找到最靠近入场方向的空仓止损网格（ID 最小者）。
     */
    private GridElement findNearestShortStopLossGrid() {
        GridElement nearest = null;
        for (GridElement e : config.getGridElements()) {
            if (e.hasShortStopLossOrders()) {
                if (nearest == null || e.getId() < nearest.getId()) {
                    nearest = e;
                }
            }
        }
        return nearest;
    }

    /**
@@ -1104,7 +1322,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);
@@ -1132,7 +1350,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);
@@ -1326,7 +1544,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);
@@ -1347,7 +1565,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);
@@ -1390,7 +1608,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);
                    }
@@ -1417,7 +1635,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);
                    }
@@ -1478,12 +1696,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);
@@ -1502,12 +1725,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);
@@ -2006,7 +2234,7 @@
     *
     * @param isLong                 {@code true}=多仓方向，{@code false}=空仓方向
     * @param respectCurrentPosition {@code true}=按「单边总持仓 ≤ maxPositionPerSide」扣减当前持仓；{@code false}=仅限制单次下单量
     * @param stopLossSize           本次止损单张数（仅止损追单场景传入，用于修正 REST 时序竞态；其余场景传 0）
     * @param stopLossSize           本次触发网格的全部止损单张数（仅止损追单场景传入，用于修正 REST 持仓时序竞态；其余场景传 0）
     * @return 实际下单张数（字符串）
     */
    private String calculateEntryQuantity(boolean isLong, boolean respectCurrentPosition, int stopLossSize) {
@@ -2021,7 +2249,7 @@
            if (respectCurrentPosition) {
                // 止损追单：单边总持仓不得超过 maxPerSide，追单量 = maxPerSide - 当前持仓。
                // 止损单刚成交、REST 查询可能仍返回止损前持仓（时序竞态），
                // 减去本次止损单张数得到止损后的真实持仓，避免追单量被错误扣减。
                // 减去本网格全部止损张数得到止损后的真实持仓，避免追单量被错误扣减。
                int currentPos = isLong
                        ? queryPositionSize(Position.ModeEnum.DUAL_LONG)
                        : queryPositionSize(Position.ModeEnum.DUAL_SHORT);
@@ -2041,6 +2269,8 @@
    }

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

        int gridId = gridElement.getId();
@@ -2073,7 +2303,7 @@

        // 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(true, true, Integer.parseInt(config.getQuantity()));
        String size = calculateEntryQuantity(true, true, gridStopLossSize);
        log.info("[Gate] 多仓止损追单 有效次数:{}, 加仓执行:{}, 停止阈值:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(true), getEffectiveAddCount(true), config.getAddPositionStopThreshold(),
                config.getBaseQuantity(), size, config.getStopLossCountMode());
@@ -2109,6 +2339,8 @@
    }

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

        int gridId = gridElement.getId();
@@ -2139,7 +2371,7 @@

        // 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(false, true, Integer.parseInt(config.getQuantity()));
        String size = calculateEntryQuantity(false, true, gridStopLossSize);
        log.info("[Gate] 空仓止损追单 有效次数:{}, 加仓执行:{}, 停止阈值:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(false), getEffectiveAddCount(false), config.getAddPositionStopThreshold(),
                config.getBaseQuantity(), size, config.getStopLossCountMode());
@@ -2623,9 +2855,9 @@
                    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:{}",
@@ -3045,9 +3277,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);
@@ -3135,6 +3367,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();
@@ -3145,9 +3378,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);
@@ -3207,6 +3440,7 @@
                break;
            }
            BigDecimal qty = perGrid.min(remaining);
            final int fqty = qty.intValue();
            final GridElement fe = elem;
            final int gid = id;
            final BigDecimal triggerPrice = elem.getGridPrice();
@@ -3217,9 +3451,9 @@
            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);
@@ -3246,9 +3480,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);
                }
@@ -3273,8 +3507,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);
                }