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

@@ -136,6 +136,10 @@
    private final BigDecimal longStopLossPrice;
    /** 空仓自定义止损触发价（价格涨至该值触发平空），null/0=未设置 */
    private final BigDecimal shortStopLossPrice;
    /** 止盈成交触发对向加仓开关：true=启用，false=禁用。默认 false */
    private final boolean tpTriggerOppositeAddEnabled;
    /** 对向加仓挂单数量：止盈成交后在对向挂出的开仓张数，0=不启用。默认 0 */
    private final int tpTriggerOppositeAddQuantity;
    /** 网格绝对步长（shortBaseEntryPrice × gridRate），运行时由队列生成逻辑设置 */
    private BigDecimal step;
    /** 网格元素列表，由队列初始化时同步填充，包含完整的多空仓挂单状态 */
@@ -180,6 +184,8 @@
        this.dualStopLossEnabled = builder.dualStopLossEnabled;
        this.longStopLossPrice = builder.longStopLossPrice;
        this.shortStopLossPrice = builder.shortStopLossPrice;
        this.tpTriggerOppositeAddEnabled = builder.tpTriggerOppositeAddEnabled;
        this.tpTriggerOppositeAddQuantity = builder.tpTriggerOppositeAddQuantity;
    }

    // ==================== REST/WS 地址 ====================
@@ -293,6 +299,10 @@
    public BigDecimal getLongStopLossPrice() { return longStopLossPrice; }
    /** @return 空仓自定义止损触发价，null/0=未设置 */
    public BigDecimal getShortStopLossPrice() { return shortStopLossPrice; }
    /** @return 止盈成交触发对向加仓开关：true=启用，false=禁用 */
    public boolean isTpTriggerOppositeAddEnabled() { return tpTriggerOppositeAddEnabled; }
    /** @return 对向加仓挂单数量：止盈成交后在对向挂出的开仓张数 */
    public int getTpTriggerOppositeAddQuantity() { return tpTriggerOppositeAddQuantity; }

    // ==================== 运行时参数 ====================

@@ -411,6 +421,10 @@
        private BigDecimal longStopLossPrice;
        /** 空仓自定义止损触发价，null=未设置 */
        private BigDecimal shortStopLossPrice;
        /** 止盈成交触发对向加仓开关：true=启用，false=禁用。默认 false */
        private boolean tpTriggerOppositeAddEnabled = false;
        /** 对向加仓挂单数量：止盈成交后在对向挂出的开仓张数，默认 0 */
        private int tpTriggerOppositeAddQuantity = 0;

        /** 设置 API Key */
        public Builder apiKey(String apiKey) { this.apiKey = apiKey; return this; }
@@ -480,6 +494,10 @@
        public Builder longStopLossPrice(BigDecimal longStopLossPrice) { this.longStopLossPrice = longStopLossPrice; return this; }
        /** 设置空仓自定义止损触发价 */
        public Builder shortStopLossPrice(BigDecimal shortStopLossPrice) { this.shortStopLossPrice = shortStopLossPrice; return this; }
        /** 设置止盈成交触发对向加仓开关：true=启用，false=禁用 */
        public Builder tpTriggerOppositeAddEnabled(boolean tpTriggerOppositeAddEnabled) { this.tpTriggerOppositeAddEnabled = tpTriggerOppositeAddEnabled; return this; }
        /** 设置对向加仓挂单数量：止盈成交后在对向挂出的开仓张数 */
        public Builder tpTriggerOppositeAddQuantity(int tpTriggerOppositeAddQuantity) { this.tpTriggerOppositeAddQuantity = tpTriggerOppositeAddQuantity; return this; }

        public GateConfig build() {
            return new GateConfig(this);

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

@@ -77,6 +77,10 @@
    private BigDecimal longStopLossPrice;
    /** 空仓自定义止损触发价（价格涨至该值触发平空），null=未设置 */
    private BigDecimal shortStopLossPrice;
    /** 止盈成交触发对向加仓开关：true=启用，false=禁用。null=未设置(默认false) */
    private Boolean tpTriggerOppositeAddEnabled;
    /** 对向加仓挂单数量：止盈成交后在对向挂出的开仓张数，0=不启用 */
    private Integer tpTriggerOppositeAddQuantity;

    /**
     * 从 GateConfig 构建 DTO（不暴露 apiSecret）。
@@ -113,6 +117,8 @@
                .dualStopLossEnabled(config.isDualStopLossEnabled())
                .longStopLossPrice(config.getLongStopLossPrice())
                .shortStopLossPrice(config.getShortStopLossPrice())
                .tpTriggerOppositeAddEnabled(config.isTpTriggerOppositeAddEnabled())
                .tpTriggerOppositeAddQuantity(config.getTpTriggerOppositeAddQuantity())
                .build();
    }

@@ -143,6 +149,8 @@
        m.put("dualStopLossEnabled", dualStopLossEnabled);
        m.put("longStopLossPrice", longStopLossPrice);
        m.put("shortStopLossPrice", shortStopLossPrice);
        m.put("tpTriggerOppositeAddEnabled", tpTriggerOppositeAddEnabled);
        m.put("tpTriggerOppositeAddQuantity", tpTriggerOppositeAddQuantity);
        return m;
    }

@@ -180,6 +188,8 @@
                .dualStopLossEnabled(false)
                .longStopLossPrice(null)
                .shortStopLossPrice(null)
                .tpTriggerOppositeAddEnabled(false)
                .tpTriggerOppositeAddQuantity(0)
                .build();
    }
}

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

@@ -115,6 +115,8 @@
                .dualStopLossEnabled(nvl(dto.getDualStopLossEnabled(), false))
                .longStopLossPrice(dto.getLongStopLossPrice())
                .shortStopLossPrice(dto.getShortStopLossPrice())
                .tpTriggerOppositeAddEnabled(nvl(dto.getTpTriggerOppositeAddEnabled(), false))
                .tpTriggerOppositeAddQuantity(dto.getTpTriggerOppositeAddQuantity() != null && dto.getTpTriggerOppositeAddQuantity() > 0 ? dto.getTpTriggerOppositeAddQuantity() : 0)
                .build();
    }


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

@@ -19,6 +19,7 @@
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

@@ -160,6 +161,11 @@
    private volatile int lastShortStopLossGridId = Integer.MAX_VALUE;
    /** 自定义止损模式激活标记：true=尚未发生第一次止损触发，第一次触发后置 false（触发未触发侧重挂默认） */
    private final AtomicBoolean dualStopLossModeActive = new AtomicBoolean(false);

    /** 止盈触发对向加仓：多仓止盈→空仓开仓单ID → 网格ID（成交后在该网格+1挂空仓止损） */
    private final Map<String, Integer> tpOppositeShortOrderGridMap = new ConcurrentHashMap<>();
    /** 止盈触发对向加仓：空仓止盈→多仓开仓单ID → 网格ID（成交后在该网格-1挂多仓止损） */
    private final Map<String, Integer> tpOppositeLongOrderGridMap = new ConcurrentHashMap<>();

    private volatile BigDecimal lastKlinePrice;
    private volatile BigDecimal markPrice = BigDecimal.ZERO;
@@ -786,9 +792,27 @@
            return;
        }

        // 止盈单成交 → 清理止盈状态，并按配置触发对向加仓
        GridElement longTpElem = GridElement.findByLongTakeProfitOrderId(orderId);
        if (longTpElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
            handleLongTakeProfitTriggered(longTpElem, orderId);
            return;
        }
        GridElement shortTpElem = GridElement.findByShortTakeProfitOrderId(orderId);
        if (shortTpElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
            handleShortTakeProfitTriggered(shortTpElem, orderId);
            return;
        }

        GridElement shortGridElement = GridElement.findByShortOrderId(orderId);
        if (shortGridElement != null) {
            if (StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0") ){
                // 止盈触发的对向加仓空仓开仓单成交 → 在网格+1挂空仓止损
                Integer tpOppositeGridId = tpOppositeShortOrderGridMap.remove(orderId);
                if (tpOppositeGridId != null) {
                    handleTpOppositeShortAddFilled(shortGridElement, tpOppositeGridId);
                    return;
                }
                int filledQty = Integer.parseInt(shortGridElement.getShortTraderParam().getQuantity());
                shortEntryTraderIdParam(shortGridElement, orderId, false);

@@ -831,6 +855,12 @@
        if (longGridElement != null) {
            if (StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")){

                // 止盈触发的对向加仓多仓开仓单成交 → 在网格-1挂多仓止损
                Integer tpOppositeGridId = tpOppositeLongOrderGridMap.remove(orderId);
                if (tpOppositeGridId != null) {
                    handleTpOppositeLongAddFilled(longGridElement, tpOppositeGridId);
                    return;
                }
                int filledQty = Integer.parseInt(longGridElement.getLongTraderParam().getQuantity());
                longEntryTraderIdParam(longGridElement, orderId, false);

@@ -867,6 +897,233 @@

            }
        }
    }


    /**
     * 多仓止盈单成交：清理止盈状态，并按配置在对向（空仓）挂开仓单。
     *
     * @param tpElem  触发止盈的网格元素
     * @param orderId 止盈单 ID
     */
    private void handleLongTakeProfitTriggered(GridElement tpElem, String orderId) {
        // 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
        boolean isLastTp = GridElement.getLongTakeProfitCount() <= 1;
        // 清理止盈单状态（已成交）
        longTakeProfitTraderIdParam(tpElem, null, false);
        log.info("[Gate] 多仓止盈触发 gridId:{}, orderId:{}, 剩余止盈:{}", tpElem.getId(), orderId,
                GridElement.getLongTakeProfitCount());

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

        if (!config.isTpTriggerOppositeAddEnabled()) {
            return;
        }
        if (isLastTp) {
            log.info("[Gate] 多仓止盈为最后一个, 不触发对向加仓, gridId:{}", tpElem.getId());
            return;
        }
        int qty = config.getTpTriggerOppositeAddQuantity();
        if (qty <= 0) {
            return;
        }
        // 多仓止盈在 gridId=N 成交，对向空仓开仓单挂在 gridId=N-1
        int targetGridId = tpElem.getId() - 1;
        GridElement target = GridElement.findById(targetGridId);
        if (target == null) {
            log.warn("[Gate] 止盈触发对向加仓: 目标网格不存在, 止盈gridId:{}, 目标gridId:{}", tpElem.getId(), targetGridId);
            return;
        }
        placeOppositeAddShortEntry(target, tpElem, qty);
    }

    /**
     * 空仓止盈单成交：清理止盈状态，并按配置在对向（多仓）挂开仓单。
     *
     * @param tpElem  触发止盈的网格元素
     * @param orderId 止盈单 ID
     */
    private void handleShortTakeProfitTriggered(GridElement tpElem, String orderId) {
        // 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
        boolean isLastTp = GridElement.getShortTakeProfitCount() <= 1;
        // 清理止盈单状态（已成交）
        shortTakeProfitTraderIdParam(tpElem, null, false);
        log.info("[Gate] 空仓止盈触发 gridId:{}, orderId:{}, 剩余止盈:{}", tpElem.getId(), orderId,
                GridElement.getShortTakeProfitCount());

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

        if (!config.isTpTriggerOppositeAddEnabled()) {
            return;
        }
        if (isLastTp) {
            log.info("[Gate] 空仓止盈为最后一个, 不触发对向加仓, gridId:{}", tpElem.getId());
            return;
        }
        int qty = config.getTpTriggerOppositeAddQuantity();
        if (qty <= 0) {
            return;
        }
        // 空仓止盈在 gridId=N 成交，对向多仓开仓单挂在 gridId=N+1
        int targetGridId = tpElem.getId() + 1;
        GridElement target = GridElement.findById(targetGridId);
        if (target == null) {
            log.warn("[Gate] 止盈触发对向加仓: 目标网格不存在, 止盈gridId:{}, 目标gridId:{}", tpElem.getId(), targetGridId);
            return;
        }
        placeOppositeAddLongEntry(target, tpElem, qty);
    }

    /**
     * 取消所有已挂未成交的对向空仓开仓单（止盈依次上移时，取消旧位置的开仓单）。
     */
    private void cancelTpOppositeShortEntries() {
        if (tpOppositeShortOrderGridMap.isEmpty()) {
            return;
        }
        List<String> orderIds = new ArrayList<>(tpOppositeShortOrderGridMap.keySet());
        tpOppositeShortOrderGridMap.clear();
        for (String oid : orderIds) {
            GridElement elem = GridElement.findByShortOrderId(oid);
            if (elem != null) {
                elem.removeShortOrderId(oid);
                elem.setHasShortOrder(elem.hasShortOrderIds());
            }
            executor.cancelConditionalOrder(oid, o -> {});
            log.info("[Gate] 取消对向空开仓单, orderId:{}", oid);
        }
        GridElement.refreshIndices();
    }

    /**
     * 取消所有已挂未成交的对向多仓开仓单（止盈依次下移时，取消旧位置的开仓单）。
     */
    private void cancelTpOppositeLongEntries() {
        if (tpOppositeLongOrderGridMap.isEmpty()) {
            return;
        }
        List<String> orderIds = new ArrayList<>(tpOppositeLongOrderGridMap.keySet());
        tpOppositeLongOrderGridMap.clear();
        for (String oid : orderIds) {
            GridElement elem = GridElement.findByLongOrderId(oid);
            if (elem != null) {
                elem.removeLongOrderId(oid);
                elem.setHasLongOrder(elem.hasLongOrderIds());
            }
            executor.cancelConditionalOrder(oid, o -> {});
            log.info("[Gate] 取消对向多开仓单, orderId:{}", oid);
        }
        GridElement.refreshIndices();
    }

    /**
     * 在目标网格挂空仓对向开仓单，并记录订单ID→网格ID映射，供成交后挂止损。
     */
    private void placeOppositeAddShortEntry(GridElement target, GridElement tpElem, int qty) {
        target.setHasShortOrder(true);
        executor.placeConditionalEntryOrder(
                target.getGridPrice(),
                FuturesPriceTrigger.RuleEnum.NUMBER_2,
                negate(String.valueOf(qty)),
                orderId -> {
                    tpOppositeShortOrderGridMap.put(orderId, target.getId());
                    shortEntryTraderIdParam(target, orderId, true);
                    log.info("[Gate] 多仓止盈触发对向加仓, 止盈gridId:{}, 空仓开仓gridId:{}, 数量:{}张, orderId:{}",
                            tpElem.getId(), target.getId(), qty, orderId);
                },
                () -> {
                    if (!target.hasShortOrderIds()) {
                        target.setHasShortOrder(false);
                    }
                    GridElement.refreshIndices();
                    log.warn("[Gate] 多仓止盈触发对向加仓挂单失败, 止盈gridId:{}, 目标gridId:{}",
                            tpElem.getId(), target.getId());
                }
        );
    }

    /**
     * 在目标网格挂多仓对向开仓单，并记录订单ID→网格ID映射，供成交后挂止损。
     */
    private void placeOppositeAddLongEntry(GridElement target, GridElement tpElem, int qty) {
        target.setHasLongOrder(true);
        executor.placeConditionalEntryOrder(
                target.getGridPrice(),
                FuturesPriceTrigger.RuleEnum.NUMBER_1,
                String.valueOf(qty),
                orderId -> {
                    tpOppositeLongOrderGridMap.put(orderId, target.getId());
                    longEntryTraderIdParam(target, orderId, true);
                    log.info("[Gate] 空仓止盈触发对向加仓, 止盈gridId:{}, 多仓开仓gridId:{}, 数量:{}张, orderId:{}",
                            tpElem.getId(), target.getId(), qty, orderId);
                },
                () -> {
                    if (!target.hasLongOrderIds()) {
                        target.setHasLongOrder(false);
                    }
                    GridElement.refreshIndices();
                    log.warn("[Gate] 空仓止盈触发对向加仓挂单失败, 止盈gridId:{}, 目标gridId:{}",
                            tpElem.getId(), target.getId());
                }
        );
    }

    /**
     * 对向加仓空仓开仓单成交：在网格+1 挂空仓止损。
     *
     * @param elem           开仓单成交的网格元素
     * @param oppositeGridId 记录的对向开仓网格ID
     */
    private void handleTpOppositeShortAddFilled(GridElement elem, int oppositeGridId) {
        int qty = Integer.parseInt(elem.getShortTraderParam().getQuantity());
        int stopLossGridId = oppositeGridId + 1;
        GridElement slElem = GridElement.findById(stopLossGridId);
        if (slElem == null) {
            log.warn("[Gate] 对向加仓止损位置不存在, 开仓gridId:{}, 止损gridId:{}", oppositeGridId, stopLossGridId);
            return;
        }
        executor.placeTakeProfit(
                slElem.getGridPrice(),
                FuturesPriceTrigger.RuleEnum.NUMBER_1,
                ORDER_TYPE_CLOSE_SHORT,
                String.valueOf(qty),
                profitId -> {
                    slElem.addShortStopLossOrderId(profitId);
                    GridElement.refreshIndices();
                    log.info("[Gate] 对向加仓空仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
                            oppositeGridId, stopLossGridId, qty, profitId);
                }
        );
    }

    /**
     * 对向加仓多仓开仓单成交：在网格-1 挂多仓止损。
     *
     * @param elem           开仓单成交的网格元素
     * @param oppositeGridId 记录的对向开仓网格ID
     */
    private void handleTpOppositeLongAddFilled(GridElement elem, int oppositeGridId) {
        int qty = Integer.parseInt(elem.getLongTraderParam().getQuantity());
        int stopLossGridId = oppositeGridId - 1;
        GridElement slElem = GridElement.findById(stopLossGridId);
        if (slElem == null) {
            log.warn("[Gate] 对向加仓止损位置不存在, 开仓gridId:{}, 止损gridId:{}", oppositeGridId, stopLossGridId);
            return;
        }
        executor.placeTakeProfit(
                slElem.getGridPrice(),
                FuturesPriceTrigger.RuleEnum.NUMBER_2,
                ORDER_TYPE_CLOSE_LONG,
                negate(String.valueOf(qty)),
                profitId -> {
                    slElem.addLongStopLossOrderId(profitId);
                    GridElement.refreshIndices();
                    log.info("[Gate] 对向加仓多仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
                            oppositeGridId, stopLossGridId, qty, profitId);
                }
        );
    }


@@ -1470,7 +1727,7 @@
//                        String quantity = String.valueOf(config.getBaseQuantity());


                        String quantity = calculateEntryQuantity(true);
                        String quantity = calculateEntryQuantity(true, false);
                        // 向下检查是否已有多单挂在更低价格网格，有则跳过（防止价格回升后重复挂单）
                        boolean hasLongOrderBelow = false;
                        GridElement checkDownCursor = GridElement.findById(newEntryGrid.getDownId());
@@ -1544,7 +1801,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);
                        String quantity = calculateEntryQuantity(false, false);
                        // 向上检查是否已有空单挂在更高价格网格，有则跳过（防止价格回落后重复挂单）
                        boolean hasShortOrderAbove = false;
                        GridElement checkUpCursor = GridElement.findById(newEntryGrid.getUpId());
@@ -1612,19 +1869,27 @@
    }

    /**
     * 根据加仓配置计算止损追单时的实际下单量。
     * 根据加仓配置计算入场/追单时的实际下单量。
     * <p>公式：</p>
     * <pre>
     * divisor = addPositionInterval + 1
     * addMultiplier = floor(effectiveStopLossCount / divisor)
     * addQty = addMultiplier × addPositionQuantity
     * finalQty = min(baseQuantity + addQty, maxPositionPerSide > 0 ? maxPositionPerSide : ∞)
     * finalQty = min(baseQuantity + addQty, upperLimit)
     * </pre>
     * <p>上限 upperLimit：</p>
     * <ul>
     *   <li>{@code respectCurrentPosition=false}：{@code upperLimit = maxPositionPerSide}
     *       （仓位归零重新入场，仅限制单次下单量）</li>
     *   <li>{@code respectCurrentPosition=true}：{@code upperLimit = maxPositionPerSide - 当前持仓}
     *       （止损追单，保证单边总持仓 ≤ maxPositionPerSide）</li>
     * </ul>
     *
     * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
     * @param isLong                 {@code true}=多仓方向，{@code false}=空仓方向
     * @param respectCurrentPosition {@code true}=按「单边总持仓 ≤ maxPositionPerSide」扣减当前持仓；{@code false}=仅限制单次下单量
     * @return 实际下单张数（字符串）
     */
    private String calculateEntryQuantity(boolean isLong) {
    private String calculateEntryQuantity(boolean isLong, boolean respectCurrentPosition) {
        int baseQty = Integer.parseInt(config.getBaseQuantity());
        int interval = config.getAddPositionInterval();
        int addQtyPerUnit = config.getAddPositionQuantity();
@@ -1641,8 +1906,22 @@
        int addQty = addMultiplier * addQtyPerUnit;
        int totalQty = baseQty + addQty;

        if (maxPerSide > 0 && totalQty > maxPerSide) {
            totalQty = maxPerSide;
        if (maxPerSide > 0) {
            int upperLimit = maxPerSide;
            if (respectCurrentPosition) {
                // 止损追单：单边总持仓不得超过 maxPerSide，追单量 = maxPerSide - 当前持仓。
                // 止损单刚成交、WS 持仓推送尚未到达，必须用 REST 实时查询绕过 WS 缓存时序竞态，
                // 否则会取到滞后的旧持仓（如止损前仍为 10），把追单量错误扣减。
                int currentPos = isLong
                        ? queryPositionSize(Position.ModeEnum.DUAL_LONG)
                        : queryPositionSize(Position.ModeEnum.DUAL_SHORT);
                upperLimit = maxPerSide - currentPos;
            }
            if (upperLimit <= 0) {
                totalQty = 0;
            } else if (totalQty > upperLimit) {
                totalQty = upperLimit;
            }
        }

        return String.valueOf(totalQty);
@@ -1681,12 +1960,16 @@

        // 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(true);
        String size = calculateEntryQuantity(true, true);
        log.info("[Gate] 多仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(true), config.getBaseQuantity(), size, config.getStopLossCountMode());
        newEntryGrid.getLongTraderParam().setQuantity(size);
        placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
                FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
        if (Integer.parseInt(size) <= 0) {
            log.warn("[Gate] 多仓止损追单 当前持仓已达单边上限({}), 跳过挂单", config.getMaxPositionPerSide());
        } else {
            newEntryGrid.getLongTraderParam().setQuantity(size);
            placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
        }

        // 取消 gridId+2 位置的所有多单
        int cancelGridId = gridId + 2;
@@ -1740,12 +2023,16 @@

        // 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(false);
        String size = calculateEntryQuantity(false, true);
        log.info("[Gate] 空仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(false), config.getBaseQuantity(), size, config.getStopLossCountMode());
        newEntryGrid.getShortTraderParam().setQuantity(size);
        placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
                FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
        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));
        }

        // 取消 gridId-2 位置的所有空单
        int cancelGridId = gridId - 2;
@@ -1991,7 +2278,7 @@
        }

        // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈
        int totalOrders = baseQty / qty;
        int totalOrders = filledQty / qty;
        int[] orders = new int[gridCount];

        if (gridCount == 1) {
@@ -2054,7 +2341,7 @@
        }

        // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈
        int totalOrders = baseQty / qty;
        int totalOrders = filledQty / qty;
        int[] orders = new int[gridCount];

        if (gridCount == 1) {