fix(gate-api): 修复网格交易重置策略中的竞态条件问题

Administrator

4 days ago 077472215c57a9b6bc4c2d10a2c316363905580b

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

@@ -3,9 +3,13 @@
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.xcong.excoin.utils.dingtalk.DingTalkUtils;
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
import com.google.gson.Gson;
import io.gate.gateapi.ApiClient;
import io.gate.gateapi.ApiException;
import io.gate.gateapi.GateApiException;
import io.gate.gateapi.JSON;
import io.gate.gateapi.api.AccountApi;
import io.gate.gateapi.api.FuturesApi;
import io.gate.gateapi.models.*;
@@ -15,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;

@@ -110,6 +115,11 @@
    private final FuturesApi futuresApi;
    private static final String SETTLE = "usdt";

    /** 手动市价平仓遭遇价格保护(MARKET_PRICE_TOO_DEVIATED)后的重试次数 */
    private static final int CLOSE_POSITION_RETRY_MAX_ATTEMPTS = 3;
    /** 手动市价平仓遭遇价格保护后的重试间隔（毫秒） */
    private static final long CLOSE_POSITION_RETRY_DELAY_MS = 800L;

    private volatile StrategyState state = StrategyState.WAITING_KLINE;

    /** 空仓价格队列，降序排列（大→小），容量 gridQueueSize */
@@ -152,6 +162,11 @@
    /** 自定义止损模式激活标记：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;
    private volatile BigDecimal cumulativePnl = BigDecimal.ZERO;
@@ -172,8 +187,50 @@
        ApiClient apiClient = new ApiClient();
        apiClient.setBasePath(config.getRestBasePath());
        apiClient.setApiKeySecret(config.getApiKey(), config.getApiSecret());
        // 修复 gate-api SDK finishAs 枚举不完整导致的反序列化失败（见 buildLenientJson）
        apiClient.setJSON(buildLenientJson());
        this.futuresApi = new FuturesApi(apiClient);
        this.executor = new GateTradeExecutor(apiClient, config.getContract());
    }

    /**
     * 构建容错的 JSON 序列化器，跳过部分枚举不完整字段的反序列化。
     *
     * <p>gate-api SDK 的枚举定义滞后于交易所实际返回值，反序列化未知枚举值时
     * {@code fromValue} 会抛 {@link IllegalArgumentException}，导致接口被误判为失败。
     * 已确认业务不使用以下字段，因此通过 Gson 排除策略直接跳过其解析：
     * <ul>
     *   <li>{@code finishAs}：{@code FuturesOrder.FinishAsEnum} 缺少
     *       {@code price_rate_protected}（价格保护）等值（如日志
     *       {@code Unexpected value 'price_rate_proteced'}）；</li>
     *   <li>{@code posMarginMode}：{@code FuturesPriceTriggeredOrder.PosMarginModeEnum}
     *       只定义 {@code cross}/{@code dual}，而 {@code cancelPriceTriggeredOrderList}
     *       会返回组合值 {@code cross|dual}（如日志 {@code Unexpected value 'cross|dual'}）。</li>
     * </ul>
     */
    private static JSON buildLenientJson() {
        JSON json = new JSON();
        Gson gson = json.getGson().newBuilder()
                .setExclusionStrategies(new ExclusionStrategy() {
                    @Override
                    public boolean shouldSkipField(FieldAttributes f) {
                        if ("finishAs".equals(f.getName())) {
                            return true;
                        }
                        // 仅跳过 FuturesPriceTriggeredOrder 的 posMarginMode，避免误伤
                        // FuturesOrder / Position 的同名字段（二者语义为 isolated/cross）
                        return "posMarginMode".equals(f.getName())
                                && FuturesPriceTriggeredOrder.class.equals(f.getDeclaringClass());
                    }

                    @Override
                    public boolean shouldSkipClass(Class<?> clazz) {
                        return false;
                    }
                })
                .create();
        json.setGson(gson);
        return json;
    }

    // ---- 初始化 ----
@@ -478,7 +535,7 @@
                config.isPriceDriveEnabled() &&
                longActive == false &&
                    longPositionSize.compareTo(BigDecimal.ZERO) == 0){
            processShortGrid(closePrice);
            processLongGrid(closePrice);
        }


@@ -486,7 +543,7 @@
                config.isPriceDriveEnabled() &&
                shortActive == false &&
                        shortPositionSize.compareTo(BigDecimal.ZERO) == 0){
            processLongGrid(closePrice);
            processShortGrid(closePrice);
        }
    }

@@ -552,14 +609,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;
@@ -735,9 +794,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);

@@ -761,8 +838,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())) {
@@ -770,6 +848,8 @@
                } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
                    placeDispersedTakeProfit(posSize, false, shortGridElement.getId());
                }
                // [Gate] 基础仓位止盈挂单：与超额止盈并行，独立于止盈模式
                placeBaseTakeProfit(posSize, false, shortGridElement.getId());
                log.info("[Gate] 空单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);


@@ -780,6 +860,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);

@@ -803,8 +889,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())) {
@@ -812,10 +899,239 @@
                } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
                    placeDispersedTakeProfit(posSize, true, longGridElement.getId());
                }
                // [Gate] 基础仓位止盈挂单：与超额止盈并行，独立于止盈模式
                placeBaseTakeProfit(posSize, true, longGridElement.getId());
                log.info("[Gate] 多单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);

            }
        }
    }


    /**
     * 多仓止盈单成交：清理止盈状态，并按配置在对向（空仓）挂开仓单。
     *
     * @param tpElem  触发止盈的网格元素
     * @param orderId 止盈单 ID
     */
    private void handleLongTakeProfitTriggered(GridElement tpElem, String orderId) {
        // 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
        boolean isLastTp = GridElement.getLongTakeProfitCount() <= 1;
        // 清理止盈单状态（移除已成交的这笔止盈单）
        longTakeProfitTraderIdParam(tpElem, orderId, 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, orderId, 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);
                }
        );
    }


@@ -897,12 +1213,6 @@
            generateShortQueue();
            generateLongQueue();
            updateGridElements();

            GridElement baseGridElement = GridElement.findById(0);
            baseGridElement.setLongOrderId(baseLongTraderParam.getEntryOrderId());
            baseGridElement.setHasLongOrder(true);
            baseGridElement.setShortOrderId(baseShortTraderParam.getEntryOrderId());
            baseGridElement.setHasShortOrder(true);

//            // 空仓止损对应的多仓止盈：多仓止盈挂在ID=3
//            int tpGridIdLong = 3;
@@ -1163,18 +1473,48 @@
            GridElement baseElement,String profitId, boolean flag
    ) {
        TraderParam tp = baseElement.getLongTraderParam();
        tp.setTakeProfitOrderId(profitId);
        tp.setTakeProfitPlaced(flag);
        baseElement.setLongTakeProfitOrderId(profitId);
        if (flag && profitId != null) {
            // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单）
            tp.setTakeProfitOrderId(profitId);
            tp.setTakeProfitPlaced(true);
            baseElement.addLongTakeProfitOrderId(profitId);
        } else {
            // 清理：profitId 非空移除指定止盈单，为空清空该网格全部止盈单
            tp.setTakeProfitPlaced(false);
            if (profitId != null) {
                baseElement.removeLongTakeProfitOrderId(profitId);
                if (!baseElement.hasLongTakeProfitOrders()) {
                    tp.setTakeProfitOrderId(null);
                }
            } else {
                baseElement.clearLongTakeProfitOrderIds();
                tp.setTakeProfitOrderId(null);
            }
        }
        GridElement.refreshIndices();
    }
    private void shortTakeProfitTraderIdParam(
            GridElement baseElement,String profitId, boolean flag
    ) {
        TraderParam tp = baseElement.getShortTraderParam();
        tp.setTakeProfitOrderId(profitId);
        tp.setTakeProfitPlaced(flag);
        baseElement.setShortTakeProfitOrderId(profitId);
        if (flag && profitId != null) {
            // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单）
            tp.setTakeProfitOrderId(profitId);
            tp.setTakeProfitPlaced(true);
            baseElement.addShortTakeProfitOrderId(profitId);
        } else {
            // 清理：profitId 非空移除指定止盈单，为空清空该网格全部止盈单
            tp.setTakeProfitPlaced(false);
            if (profitId != null) {
                baseElement.removeShortTakeProfitOrderId(profitId);
                if (!baseElement.hasShortTakeProfitOrders()) {
                    tp.setTakeProfitOrderId(null);
                }
            } else {
                baseElement.clearShortTakeProfitOrderIds();
                tp.setTakeProfitOrderId(null);
            }
        }
        GridElement.refreshIndices();
    }

@@ -1398,7 +1738,8 @@
    }


    private void processShortGrid(BigDecimal currentPrice) {
    /** 多仓仓位归零后，在当前价上方最近网格重新挂多单（遍历 totalLongPriceQueue 升序）。 */
    private void processLongGrid(BigDecimal currentPrice) {
        BigDecimal matched = BigDecimal.ZERO;
        synchronized (totalLongPriceQueue) {
            for (BigDecimal p : totalLongPriceQueue) {
@@ -1424,7 +1765,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());
@@ -1471,7 +1812,8 @@

    }

    private void processLongGrid(BigDecimal currentPrice) {
    /** 空仓仓位归零后，在当前价下方最近网格重新挂空单（遍历 totalShortPriceQueue 降序）。 */
    private void processShortGrid(BigDecimal currentPrice) {
        BigDecimal matched = BigDecimal.ZERO;
        synchronized (totalShortPriceQueue) {
            for (BigDecimal p : totalShortPriceQueue) {
@@ -1497,7 +1839,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());
@@ -1520,7 +1862,7 @@
                                    GridElement finalCancelCursor = cancelCursor;
                                    executor.cancelConditionalOrder(shortOrderId, oid -> {
                                        shortEntryTraderIdParam(finalCancelCursor, shortOrderId, false);
                                        log.info("[Gate] 空仓仓位归零, 取消gridId:{}的多单{}", finalCancelCursor.getId(), shortOrderId);
                                        log.info("[Gate] 空仓仓位归零, 取消gridId:{}的空单{}", finalCancelCursor.getId(), shortOrderId);
                                    });
                                }
                            }
@@ -1531,7 +1873,7 @@
                        if (!newEntryGrid.isHasShortOrder() && !hasShortOrderAbove){
                            BigDecimal triggerPrice = newEntryGrid.getGridPrice();
                            String size = quantity;
                            log.info("[Gate] 空仓仓位归零 gridId:{}, 挂{}基础张多单",
                            log.info("[Gate] 空仓仓位归零 gridId:{}, 挂{}基础张空单",
                                    newEntryGrid.getId(),  size);
                            newEntryGrid.getShortTraderParam().setQuantity(size);
                            placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
@@ -1565,19 +1907,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();
@@ -1594,8 +1944,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);
@@ -1634,12 +1998,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;
@@ -1693,12 +2061,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;
@@ -1868,11 +2240,13 @@
     */
    private void cancelAllLongTakeProfitsAndStopLosses() {
        for (GridElement e : config.getGridElements()) {
            String tpId = e.getLongTakeProfitOrderId();
            if (tpId != null) {
                e.getLongTraderParam().setTakeProfitPlaced(false);
                e.setLongTakeProfitOrderId(null);
            for (String tpId : new ArrayList<>(e.getLongTakeProfitOrderIds())) {
                executor.cancelConditionalOrder(tpId, oid -> {});
            }
            e.clearLongTakeProfitOrderIds();
            if (e.getLongTraderParam() != null) {
                e.getLongTraderParam().setTakeProfitPlaced(false);
                e.getLongTraderParam().setTakeProfitOrderId(null);
            }
            for (String slId : new ArrayList<>(e.getLongStopLossOrderIds())) {
                executor.cancelConditionalOrder(slId, oid -> {});
@@ -1888,11 +2262,13 @@
     */
    private void cancelAllShortTakeProfitsAndStopLosses() {
        for (GridElement e : config.getGridElements()) {
            String tpId = e.getShortTakeProfitOrderId();
            if (tpId != null) {
                e.getShortTraderParam().setTakeProfitPlaced(false);
                e.setShortTakeProfitOrderId(null);
            for (String tpId : new ArrayList<>(e.getShortTakeProfitOrderIds())) {
                executor.cancelConditionalOrder(tpId, oid -> {});
            }
            e.clearShortTakeProfitOrderIds();
            if (e.getShortTraderParam() != null) {
                e.getShortTraderParam().setTakeProfitPlaced(false);
                e.getShortTraderParam().setTakeProfitOrderId(null);
            }
            for (String slId : new ArrayList<>(e.getShortStopLossOrderIds())) {
                executor.cancelConditionalOrder(slId, oid -> {});
@@ -1907,20 +2283,28 @@
     * 首次挂单成交时，取消初始化阶段挂的所有止盈单（多+空），止损单保留不动。
     */
    private void cancelAllInitialTakeProfits() {


        GridElement tpElemLong = GridElement.findById(3);
        String longTpId = tpElemLong.getLongTakeProfitOrderId();
        if (longTpId != null) {
            longTakeProfitTraderIdParam(tpElemLong, null, false);
            executor.cancelConditionalOrder(longTpId, oid -> {});
        if (tpElemLong != null) {
            for (String tpId : new ArrayList<>(tpElemLong.getLongTakeProfitOrderIds())) {
                executor.cancelConditionalOrder(tpId, oid -> {});
            }
            tpElemLong.clearLongTakeProfitOrderIds();
            if (tpElemLong.getLongTraderParam() != null) {
                tpElemLong.getLongTraderParam().setTakeProfitPlaced(false);
                tpElemLong.getLongTraderParam().setTakeProfitOrderId(null);
            }
        }

        GridElement tpElemShort = GridElement.findById(-3);
        String shortTpId = tpElemShort.getShortTakeProfitOrderId();
        if (shortTpId != null) {
            shortTakeProfitTraderIdParam(tpElemShort, null, false);
            executor.cancelConditionalOrder(shortTpId, oid -> {});
        if (tpElemShort != null) {
            for (String tpId : new ArrayList<>(tpElemShort.getShortTakeProfitOrderIds())) {
                executor.cancelConditionalOrder(tpId, oid -> {});
            }
            tpElemShort.clearShortTakeProfitOrderIds();
            if (tpElemShort.getShortTraderParam() != null) {
                tpElemShort.getShortTraderParam().setTakeProfitPlaced(false);
                tpElemShort.getShortTraderParam().setTakeProfitOrderId(null);
            }
        }
        GridElement.refreshIndices();
        log.info("[Gate] 首次成交，取消所有初始化止盈单");
@@ -1943,6 +2327,7 @@
            return;
        }

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

@@ -2005,6 +2390,7 @@
            return;
        }

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

@@ -2306,6 +2692,7 @@
            } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
                placeDispersedTakeProfit(posSize, true, 0);
            }
            placeBaseTakeProfit(posSize, true, 0);
            log.info("[Gate] 生成多仓止盈止损完成, 仓位:{}张", posSize);
        });
    }
@@ -2328,6 +2715,7 @@
            } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
                placeDispersedTakeProfit(posSize, false, 0);
            }
            placeBaseTakeProfit(posSize, false, 0);
            log.info("[Gate] 生成空仓止盈止损完成, 仓位:{}张", posSize);
        });
    }
@@ -2366,7 +2754,7 @@
     */
    private void closePositionByMode(Position.ModeEnum mode, boolean isLong) {
        String sideLabel = isLong ? "多" : "空";
        // 1. 市价平掉对应方向仓位
        // 1. 市价平掉对应方向仓位（价格保护拒绝时重试）
        try {
            Position pos = queryPosition(mode);
            if (pos != null) {
@@ -2387,8 +2775,26 @@
                        closeOrder.setSize(size > 0 ? String.valueOf(-size) : String.valueOf(Math.abs(size)));
                    }
                    closeOrder.setText("t-grid-manual-close");
                    futuresApi.createFuturesOrder(SETTLE, closeOrder, null);
                    log.info("[Gate] 手动平{}仓, size:{}, mode:{}", sideLabel, sizeStr, posMode);
                    for (int attempt = 1; attempt <= CLOSE_POSITION_RETRY_MAX_ATTEMPTS; attempt++) {
                        try {
                            futuresApi.createFuturesOrder(SETTLE, closeOrder, null);
                            log.info("[Gate] 手动平{}仓, size:{}, mode:{}", sideLabel, sizeStr, posMode);
                            break;
                        } catch (Exception e) {
                            if (attempt < CLOSE_POSITION_RETRY_MAX_ATTEMPTS && isPriceProtectionRejected(e)) {
                                log.warn("[Gate] 手动平{}仓遭遇价格保护, 第{}次失败, {}ms后重试: {}",
                                        sideLabel, attempt, CLOSE_POSITION_RETRY_DELAY_MS, e.getMessage());
                                try {
                                    Thread.sleep(CLOSE_POSITION_RETRY_DELAY_MS);
                                } catch (InterruptedException ie) {
                                    Thread.currentThread().interrupt();
                                    break;
                                }
                            } else {
                                throw e;
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
@@ -2408,6 +2814,20 @@
            shortPositionSize = BigDecimal.ZERO;
        }
        log.info("[Gate] {}仓已平仓并清理挂单，交由价格驱动重新入场", sideLabel);
    }

    /**
     * 判断异常是否为市价单价格保护拒绝（{@code MARKET_PRICE_TOO_DEVIATED}）。
     *
     * <p>该错误是交易所对市价单的保护：当盘口价相对最新价偏离超过滑点比率时拒绝下单，
     * 属于瞬时行情错误，等待行情稳定后重试通常可成功。
     */
    private boolean isPriceProtectionRejected(Exception e) {
        if (e instanceof GateApiException) {
            String label = ((GateApiException) e).getErrorLabel();
            return label != null && label.contains("PRICE_TOO_DEVIATED");
        }
        return false;
    }

    /**
@@ -2523,9 +2943,11 @@
    }

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

        // 终点必须在起点前进方向上，否则退化为集中止盈（全部挂对手盘止损位）
        boolean valid = isLong ? (endId >= startId) : (endId <= startId);
@@ -2585,9 +3008,16 @@
        int remainder = excessQty % n;

        for (int i = 0; i < n; i++) {
            int qty = perGrid;
            if (i == n - 1) {
                qty += remainder;
            int qty;
            if (excessQty >= n) {
                // 超额仓位 ≥ 网格数：每格 perGrid，余数堆最后一格（即止损位的前一格）
                qty = perGrid;
                if (i == n - 1) {
                    qty += remainder;
                }
            } else {
                // 超额仓位 < 网格数：前 excessQty 个网格各挂 1 张，其余不挂（避免退化为合并止盈）
                qty = (i < excessQty) ? 1 : 0;
            }
            if (qty <= 0) {
                continue;
@@ -2614,6 +3044,83 @@
    }

    /**
     * 基础止盈：对基础仓位（baseQuantity）也挂止盈单，与超额止盈并行。
     *
     * <p>规则：从入场网格下一格（entryGridId ± 1）开始，每格 baseTakeProfitPerGrid 张，
     * 最多挂 baseTakeProfitGridCount 格，挂到止损位的前一格截止（与分散止盈同起点/同终点）。
     *
     * <p>边界：累计张数到 min(baseQuantity, 当前持仓) 即停（张数不足则最后一格挂剩余 = "挂几个算几个"）；
     * 网格不足时挂到停止位置结束。
     *
     * @param posSize     当前总持仓张数
     * @param isLong      true=多仓止盈，false=空仓止盈
     * @param entryGridId 入场网格 ID
     */
    private void placeBaseTakeProfit(int posSize, boolean isLong, int entryGridId) {
        BigDecimal perGrid = config.getBaseTakeProfitPerGrid();
        int gridCount = config.getBaseTakeProfitGridCount();
        if (perGrid == null || perGrid.compareTo(BigDecimal.ZERO) <= 0 || gridCount <= 0) {
            return;
        }
        int baseQty = Integer.parseInt(config.getBaseQuantity());
        if (baseQty <= 0) {
            return;
        }
        // 张数硬上限 = min(基础张数, 当前持仓)，避免持仓不足 baseQuantity 时超挂
        int maxQty = Math.min(baseQty, posSize);
        if (maxQty <= 0) {
            return;
        }

        GridElement endElem = isLong ? findFirstShortStopLossGrid() : findFirstLongStopLossGrid();
        if (endElem == null) {
            log.warn("[Gate] {}基础止盈失败：未找到对手盘止损位", isLong ? "多仓" : "空仓");
            return;
        }
        int dir = isLong ? 1 : -1;
        int startId = entryGridId + dir;
        // 分配范围到止损位的前一格截止（与分散止盈一致）
        int endId = endElem.getId() - dir;

        BigDecimal remaining = BigDecimal.valueOf(maxQty);
        int placed = 0;
        int id = startId;
        while (placed < gridCount && remaining.compareTo(BigDecimal.ZERO) > 0) {
            if (isLong ? id > endId : id < endId) {
                break;
            }
            GridElement elem = GridElement.findById(id);
            if (elem == null) {
                break;
            }
            BigDecimal qty = perGrid.min(remaining);
            final GridElement fe = elem;
            final int gid = id;
            final BigDecimal triggerPrice = elem.getGridPrice();
            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);
                        } else {
                            shortTakeProfitTraderIdParam(fe, profitId, true);
                        }
                        log.info("[Gate] 基础止盈 {} gridId:{}, 触发价:{}, 数量:{}, tpId:{}",
                                isLong ? "多仓" : "空仓", gid, triggerPrice, size, profitId);
                    }
            );
            remaining = remaining.subtract(qty);
            placed++;
            id += dir;
        }
        log.info("[Gate] 基础止盈 {} 挂单完成, 入场gridId:{}, 挂{}格, 剩余{}张",
                isLong ? "多仓" : "空仓", entryGridId, placed, remaining);
    }

    /**
     * 在指定网格挂一笔对手止盈单（非满仓超额止盈，挂在止损触发位的下一格）。
     */
    private void placeTakeProfitAtGrid(GridElement tpElem, boolean isLong, int qty, int times) {