fix(gateApi): 解决枚举定义不完整导致的反序列化异常

Administrator

2026-09-21 c05affd8ed0d5391c6dff6084c55e6050f9bb6aa

 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.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

import com.xcong.excoin.modules.gateApi.wsHandler.handler.CandlestickChannelHandler;
@@ -37,8 +42,8 @@
 *   onPositionUpdate() → 基底成交 → baseLongOpened && baseShortOpened
 *     ↓
 *   tryGenerateQueues()
 *     ├── generateShortQueue()   ← 空仓价格队列（降序，从 shortBaseEntryPrice-step 向下）
 *     ├── generateLongQueue()    ← 多仓价格队列（升序，从 shortBaseEntryPrice+step 向上）
 *     ├── generateShortQueue()   ← 空仓价格队列（降序，基价×(1−gridRate) 等比向下）
 *     ├── generateLongQueue()    ← 多仓价格队列（升序，基价×(1+gridRate) 等比向上）
 *     ├── updateGridElements()   ← 构建 GridElement 列表 + TraderParam + 全局索引
 *     ├── 挂基座止盈单（ID=0 的 long/short takeProfit）
 *     └── 挂初始条件单（up=-1 多单, down=1 空单）
@@ -68,11 +73,11 @@
 *
 * <h3>关键公式</h3>
 * <pre>
 *   step  = shortBaseEntryPrice × gridRate                      ← 网格绝对步长
 *   step  = shortBaseEntryPrice × gridRate                      ← 首档间距（0档与±1档的距离度量）
 *   minTick = 10^(-priceScale)                                  ← 交易所最小价格单位
 *   多止盈 = gridPrice + (step - minTick)                       ← 多仓止盈价
 *   空止盈 = gridPrice - (step - minTick)                       ← 空仓止盈价
 *   单笔盈利 = (step - minTick) × contractMultiplier × quantity  ← USDT
 *   等比网格: 下一档 = 本档 × (1 ± gridRate)                     ← 向下×(1−r)，向上×(1+r)
 *   止盈价 = 本档价 × (1 ± gridRate)（与相邻网格价联动）         ← 多仓向上，空仓向下
 *   单笔盈利 ≈ 档价 × gridRate × contractMultiplier × quantity（随网格位置浮动）
 * </pre>
 *
 * <h3>线程模型</h3>
@@ -108,6 +113,11 @@
    private final GateTradeExecutor executor;
    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;

@@ -148,6 +158,8 @@
    private volatile int lastLongStopLossGridId = Integer.MAX_VALUE;
    /** 最近触发止损的空头网格ID */
    private volatile int lastShortStopLossGridId = Integer.MAX_VALUE;
    /** 自定义止损模式激活标记：true=尚未发生第一次止损触发，第一次触发后置 false（触发未触发侧重挂默认） */
    private final AtomicBoolean dualStopLossModeActive = new AtomicBoolean(false);

    private volatile BigDecimal lastKlinePrice;
    private volatile BigDecimal markPrice = BigDecimal.ZERO;
@@ -169,8 +181,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;
    }

    // ---- 初始化 ----
@@ -354,12 +408,15 @@
        shortPositionSize = BigDecimal.ZERO;
        baseLongOpened = false;
        baseShortOpened = false;
        config.setBaseLongTraderParam(null);
        config.setBaseShortTraderParam(null);
        longActive = false;
        shortActive = false;
        accumulatedLongLossCount = 0;
        accumulatedShortLossCount = 0;
        lastLongStopLossGridId = Integer.MAX_VALUE;
        lastShortStopLossGridId = Integer.MAX_VALUE;
        dualStopLossModeActive.set(false);
        shortPriceQueue.clear();
        longPriceQueue.clear();
        totalShortPriceQueue.clear();
@@ -453,12 +510,14 @@
                        .entryOrderId(orderId)
                        .build();
                config.setBaseLongTraderParam(baseLongTp);
                tryGenerateQueues();
            }, null);
            executor.openShort(negate(size), (orderId) -> {
                TraderParam baseShortTp = TraderParam.builder()
                        .entryOrderId(orderId)
                        .build();
                config.setBaseShortTraderParam(baseShortTp);
                tryGenerateQueues();
            }, null);
            return;
        }
@@ -757,8 +816,10 @@
                int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue());
                extendShortStopLoss(posSize, shortGridElement.getId());
                // [Gate] 止盈挂单：超出基础仓位的部分，挂在多仓第一止损位
                if (config.isPlaceExcessTakeProfit()) {
                if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
                    placeExcessTakeProfit(posSize, false);
                } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
                    placeDispersedTakeProfit(posSize, false, shortGridElement.getId());
                }
                log.info("[Gate] 空单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);

@@ -797,8 +858,10 @@
                int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue());
                extendLongStopLoss(posSize, longGridElement.getId());
                // [Gate] 止盈挂单：超出基础仓位的部分，挂在空仓第一止损位
                if (config.isPlaceExcessTakeProfit()) {
                if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
                    placeExcessTakeProfit(posSize, true);
                } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
                    placeDispersedTakeProfit(posSize, true, longGridElement.getId());
                }
                log.info("[Gate] 多单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);

@@ -868,17 +931,27 @@
     *   <li>状态切换为 ACTIVE</li>
     * </ol>
     */
    private void tryGenerateQueues() {
        if (baseLongOpened && baseShortOpened) {
    private synchronized void tryGenerateQueues() {
        // 幂等保护：生成队列后 state 切换为 ACTIVE，避免多线程重复执行
        if (state != StrategyState.OPENING) {
            return;
        }
        TraderParam baseLongTraderParam = config.getBaseLongTraderParam();
        TraderParam baseShortTraderParam = config.getBaseShortTraderParam();
        // 需同时满足：多空基底均已成交，且两个下单参数(orderId)均已通过下单成功回调拿到。
        // IOC 市价单成交后 WS 持仓推送可能先于 REST 下单响应返回，必须等参数就绪再生成队列。
        if (!(baseLongOpened && baseShortOpened)
                || baseLongTraderParam == null || baseShortTraderParam == null) {
            return;
        }
        {
            generateShortQueue();
            generateLongQueue();
            updateGridElements();

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

@@ -956,56 +1029,182 @@
//                );
//            }

            int shortTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
            for (int id = 2; id <= shortTime; id++) {
                GridElement elem = GridElement.findById(id);
                if (elem == null) {
                    continue;
                }
                BigDecimal triggerPrice = elem.getGridPrice();
                String size = config.getQuantity();
                int finalId = id;
                executor.placeTakeProfit(
                        triggerPrice,
                        FuturesPriceTrigger.RuleEnum.NUMBER_1,
                        ORDER_TYPE_CLOSE_SHORT,
                        size,
                        profitId -> {
                            elem.addShortStopLossOrderId(profitId);
                            GridElement.refreshIndices();
                            log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                        }
                );
            if (config.isDualStopLossEnabled()) {
                placeCustomStopLosses();
            } else {
                placeDefaultStopLossLadders();
            }

            state = StrategyState.ACTIVE;
        }
    }

    // ========== 自定义止损（按触发价各挂一单） ==========

            int longTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
            for (int id = -2; id >= -longTime; id--) {
                GridElement elem = GridElement.findById(id);
                if (elem == null) {
                    continue;
                }
                BigDecimal triggerPrice = elem.getGridPrice();
                String size = config.getQuantity();
                int finalId = id;
    /**
     * 自定义止损初始化：按多空止损触发价匹配最近网格，各挂一张覆盖全仓位（baseQuantity）的止损单。
     * 多仓止损：NUMBER_2（价格 ≤ 触发价平多），空仓止损：NUMBER_1（价格 ≥ 触发价平空）。
     */
    private void placeCustomStopLosses() {
        dualStopLossModeActive.set(true);
        String baseQty = config.getBaseQuantity();
        BigDecimal longPrice = config.getLongStopLossPrice();
        BigDecimal shortPrice = config.getShortStopLossPrice();

        if (longPrice != null && longPrice.compareTo(BigDecimal.ZERO) > 0) {
            GridElement longElem = findNearestGridElementByPrice(longPrice);
            if (longElem != null) {
                BigDecimal triggerPrice = longElem.getGridPrice();
                executor.placeTakeProfit(
                        triggerPrice,
                        FuturesPriceTrigger.RuleEnum.NUMBER_2,
                        ORDER_TYPE_CLOSE_LONG,
                        negate(size),
                        negate(baseQty),
                        profitId -> {
                            elem.addLongStopLossOrderId(profitId);
                            longElem.addLongStopLossOrderId(profitId);
                            GridElement.refreshIndices();
                            log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                            log.info("[Gate] 自定义多仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
                                    longPrice, longElem.getId(), triggerPrice, profitId);
                        }
                );
            } else {
                log.warn("[Gate] 自定义多仓止损价:{} 未匹配到任何网格", longPrice);
            }

            log.info("[Gate] 止损止盈单已全部挂完, 空仓止损:2~{}, 多仓止损:-2~-{}", shortTime, longTime);

            state = StrategyState.ACTIVE;
        }

        if (shortPrice != null && shortPrice.compareTo(BigDecimal.ZERO) > 0) {
            GridElement shortElem = findNearestGridElementByPrice(shortPrice);
            if (shortElem != null) {
                BigDecimal triggerPrice = shortElem.getGridPrice();
                executor.placeTakeProfit(
                        triggerPrice,
                        FuturesPriceTrigger.RuleEnum.NUMBER_1,
                        ORDER_TYPE_CLOSE_SHORT,
                        baseQty,
                        profitId -> {
                            shortElem.addShortStopLossOrderId(profitId);
                            GridElement.refreshIndices();
                            log.info("[Gate] 自定义空仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
                                    shortPrice, shortElem.getId(), triggerPrice, profitId);
                        }
                );
            } else {
                log.warn("[Gate] 自定义空仓止损价:{} 未匹配到任何网格", shortPrice);
            }
        }
        log.info("[Gate] 自定义止损初始化完成, 多仓止损价:{}, 空仓止损价:{}", longPrice, shortPrice);
    }

    /**
     * 默认止损阶梯（原有逻辑）：空仓从 ID=2 向上、多仓从 ID=-2 向下，各挂 baseQuantity/quantity 格、每格 quantity 张。
     */
    private void placeDefaultStopLossLadders() {
        placeDefaultShortStopLossLadder();
        placeDefaultLongStopLossLadder();
        int shortTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
        int longTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
        log.info("[Gate] 止损止盈单已全部挂完, 空仓止损:2~{}, 多仓止损:-2~-{}", shortTime, longTime);
    }

    /**
     * 默认空仓止损阶梯：从 ID=2 向上挂，每格 quantity 张，NUMBER_1（价格 ≥ 触发价平空）。
     */
    private void placeDefaultShortStopLossLadder() {
        int shortTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
        for (int id = 2; id <= shortTime; id++) {
            GridElement elem = GridElement.findById(id);
            if (elem == null) {
                continue;
            }
            BigDecimal triggerPrice = elem.getGridPrice();
            String size = config.getQuantity();
            int finalId = id;
            executor.placeTakeProfit(
                    triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_1,
                    ORDER_TYPE_CLOSE_SHORT,
                    size,
                    profitId -> {
                        elem.addShortStopLossOrderId(profitId);
                        GridElement.refreshIndices();
                        log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                    }
            );
        }
    }

    /**
     * 默认多仓止损阶梯：从 ID=-2 向下挂，每格 quantity 张，NUMBER_2（价格 ≤ 触发价平多）。
     */
    private void placeDefaultLongStopLossLadder() {
        int longTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
        for (int id = -2; id >= -longTime; id--) {
            GridElement elem = GridElement.findById(id);
            if (elem == null) {
                continue;
            }
            BigDecimal triggerPrice = elem.getGridPrice();
            String size = config.getQuantity();
            int finalId = id;
            executor.placeTakeProfit(
                    triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_2,
                    ORDER_TYPE_CLOSE_LONG,
                    negate(size),
                    profitId -> {
                        elem.addLongStopLossOrderId(profitId);
                        GridElement.refreshIndices();
                        log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                    }
            );
        }
    }

    /**
     * 按「价格 → 最近网格」匹配：返回 gridPrice 与目标价绝对值差最小的网格元素。
     */
    private GridElement findNearestGridElementByPrice(BigDecimal price) {
        if (price == null || price.compareTo(BigDecimal.ZERO) <= 0) {
            return null;
        }
        GridElement nearest = null;
        BigDecimal minDiff = null;
        for (GridElement e : config.getGridElements()) {
            BigDecimal diff = e.getGridPrice().subtract(price).abs();
            if (minDiff == null || diff.compareTo(minDiff) < 0) {
                minDiff = diff;
                nearest = e;
            }
        }
        return nearest;
    }

    /**
     * 只取消空仓止损单（保留空仓止盈），用于自定义止损首次触发时重挂未触发侧。
     */
    private void cancelAllShortStopLossesOnly() {
        for (GridElement e : config.getGridElements()) {
            for (String slId : new ArrayList<>(e.getShortStopLossOrderIds())) {
                executor.cancelConditionalOrder(slId, oid -> {});
            }
            e.clearShortStopLossOrderIds();
        }
        GridElement.refreshIndices();
        log.info("[Gate] 已提交取消所有空仓止损（保留止盈）");
    }

    /**
     * 只取消多仓止损单（保留多仓止盈），用于自定义止损首次触发时重挂未触发侧。
     */
    private void cancelAllLongStopLossesOnly() {
        for (GridElement e : config.getGridElements()) {
            for (String slId : new ArrayList<>(e.getLongStopLossOrderIds())) {
                executor.cancelConditionalOrder(slId, oid -> {});
            }
            e.clearLongStopLossOrderIds();
        }
        GridElement.refreshIndices();
        log.info("[Gate] 已提交取消所有多仓止损（保留止盈）");
    }

    /**
@@ -1065,51 +1264,73 @@
    }

    /**
     * 生成空仓价格队列。
     * 以 shortBaseEntryPrice × gridRate 作为绝对步长 step，存到 config。
     * 第1个元素 = shortBaseEntryPrice − step，后续依次递减 step，共 gridQueueSize 个。
     * 队列降序排列（大→小），方便 processShortGrid 中从头遍历。
     * 生成空仓价格队列（等比 / 复合百分比网格）。
     *
     * <p>每个网格价 = 上一档 × (1 − gridRate)，即自 shortBaseEntryPrice 向下等比递减：
     * <pre>
     *   第1档 = shortBaseEntryPrice × (1 − gridRate)
     *   第2档 = 第1档 × (1 − gridRate)
     *   ...
     * </pre>
     * 档间距 = 该档价格 × gridRate，随价格下降而收窄。
     *
     * <p>同时将 step（= shortBaseEntryPrice × gridRate，即 0档 与 ±1档 的间距）注入 config，
     * 供跨度重启等需要固定距离度量的功能使用。
     *
     * <p>队列降序排列（大→小），方便 processShortGrid 中从头遍历。
     */
    private void generateShortQueue() {
        shortPriceQueue.clear();
        totalShortPriceQueue.clear();
        totalLongPriceQueue.clear();
        int prec = config.getPriceScale();
        BigDecimal step = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(prec, RoundingMode.HALF_UP);
        BigDecimal gridRate = config.getGridRate();
        // 首档间距 = 基价 × gridRate（0档与±1档的间距），保留作跨度等固定距离度量
        BigDecimal step = shortBaseEntryPrice.multiply(gridRate).setScale(prec, RoundingMode.HALF_UP);
        config.setStep(step);
        BigDecimal elem = shortBaseEntryPrice.subtract(step).setScale(prec, RoundingMode.HALF_UP);
            for (int i = 0; i < config.getGridQueueSize(); i++) {
                shortPriceQueue.add(elem);
                totalLongPriceQueue.add( elem);
                totalShortPriceQueue.add( elem);
        BigDecimal factor = BigDecimal.ONE.subtract(gridRate);
        BigDecimal elem = shortBaseEntryPrice.multiply(factor).setScale(prec, RoundingMode.HALF_UP);
        for (int i = 0; i < config.getGridQueueSize(); i++) {
            shortPriceQueue.add(elem);
            totalLongPriceQueue.add(elem);
            totalShortPriceQueue.add(elem);

                elem = elem.subtract(step).setScale(prec, RoundingMode.HALF_UP);
                if (elem.compareTo(BigDecimal.ZERO) <= 0) {
                    break;
                }
            elem = elem.multiply(factor).setScale(prec, RoundingMode.HALF_UP);
            if (elem.compareTo(BigDecimal.ZERO) <= 0) {
                break;
            }
        }
        shortPriceQueue.sort((a, b) -> b.compareTo(a));
        log.info("[Gate] 空队列:{}", shortPriceQueue);
        log.info("[Gate] 空队列(等比):{}", shortPriceQueue);
    }

    /**
     * 生成多仓价格队列。
     * 以 shortBaseEntryPrice + step 为首元素，后续依次递增 step，共 gridQueueSize 个。
     * 队列升序排列（小→大），方便 processLongGrid 中从头遍历。
     * 生成多仓价格队列（等比 / 复合百分比网格）。
     *
     * <p>每个网格价 = 上一档 × (1 + gridRate)，即自 shortBaseEntryPrice 向上等比递增：
     * <pre>
     *   第1档 = shortBaseEntryPrice × (1 + gridRate)
     *   第2档 = 第1档 × (1 + gridRate)
     *   ...
     * </pre>
     * 档间距 = 该档价格 × gridRate，随价格上升而放大；
     * 与空仓队列（下方 ×(1−gridRate)）关于基价对称，保证上下网格连续一致。
     *
     * <p>队列升序排列（小→大），方便 processLongGrid 中从头遍历。
     */
    private void generateLongQueue() {
        longPriceQueue.clear();
        int prec = config.getPriceScale();
        BigDecimal step = config.getStep();
        BigDecimal elem = shortBaseEntryPrice.add(step).setScale(prec, RoundingMode.HALF_UP);
        BigDecimal factor = BigDecimal.ONE.add(config.getGridRate());
        BigDecimal elem = shortBaseEntryPrice.multiply(factor).setScale(prec, RoundingMode.HALF_UP);
        for (int i = 0; i < config.getGridQueueSize(); i++) {
            longPriceQueue.add(elem);
            totalLongPriceQueue.add( elem);
            totalShortPriceQueue.add( elem);
            elem = elem.add(step).setScale(prec, RoundingMode.HALF_UP);
            totalLongPriceQueue.add(elem);
            totalShortPriceQueue.add(elem);
            elem = elem.multiply(factor).setScale(prec, RoundingMode.HALF_UP);
        }
        longPriceQueue.sort(BigDecimal::compareTo);
        log.info("[Gate] 多队列:{}", longPriceQueue);
        log.info("[Gate] 多队列(等比):{}", longPriceQueue);
        totalShortPriceQueue.sort((a, b) -> b.compareTo(a));
        log.info("[Gate] 队列从大到小:{}", totalShortPriceQueue);
        totalLongPriceQueue.sort(BigDecimal::compareTo);
@@ -1136,7 +1357,9 @@
        int longSize = longPriceQueue.size();
        //根据精度转换成小数
        int prec = config.getPriceScale();
        BigDecimal step = config.getStep();
        // 等比网格：止盈价与本档相邻网格价联动 = 本档价 × (1 ± gridRate)
        BigDecimal tpUpFactor = BigDecimal.ONE.add(config.getGridRate());
        BigDecimal tpDownFactor = BigDecimal.ONE.subtract(config.getGridRate());
//        String qty = config.getBaseQuantity();
        String qty = config.getQuantity();

@@ -1149,13 +1372,13 @@
            TraderParam longParam = TraderParam.builder()
                    .direction(TraderParam.Direction.LONG)
                    .entryPrice(price)
                    .takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
                    .takeProfitPrice(price.multiply(tpUpFactor).setScale(prec, RoundingMode.HALF_UP))
                    .quantity(qty)
                    .build();
            TraderParam shortParam = TraderParam.builder()
                    .direction(TraderParam.Direction.SHORT)
                    .entryPrice(price)
                    .takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
                    .takeProfitPrice(price.multiply(tpDownFactor).setScale(prec, RoundingMode.HALF_UP))
                    .quantity(qty)
                    .build();
            elements.add(GridElement.builder()
@@ -1174,13 +1397,13 @@
            TraderParam longParam = TraderParam.builder()
                    .direction(TraderParam.Direction.LONG)
                    .entryPrice(price)
                    .takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
                    .takeProfitPrice(price.multiply(tpUpFactor).setScale(prec, RoundingMode.HALF_UP))
                    .quantity(qty)
                    .build();
            TraderParam shortParam = TraderParam.builder()
                    .direction(TraderParam.Direction.SHORT)
                    .entryPrice(price)
                    .takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
                    .takeProfitPrice(price.multiply(tpDownFactor).setScale(prec, RoundingMode.HALF_UP))
                    .quantity(qty)
                    .build();
            elements.add(GridElement.builder()
@@ -1202,13 +1425,13 @@
            TraderParam longParam = TraderParam.builder()
                    .direction(TraderParam.Direction.LONG)
                    .entryPrice(price)
                    .takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
                    .takeProfitPrice(price.multiply(tpUpFactor).setScale(prec, RoundingMode.HALF_UP))
                    .quantity(qty)
                    .build();
            TraderParam shortParam = TraderParam.builder()
                    .direction(TraderParam.Direction.SHORT)
                    .entryPrice(price)
                    .takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
                    .takeProfitPrice(price.multiply(tpDownFactor).setScale(prec, RoundingMode.HALF_UP))
                    .quantity(qty)
                    .build();
            elements.add(GridElement.builder()
@@ -1249,7 +1472,10 @@
                    if (newEntryGrid != null) {

//                        String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()) + Integer.parseInt(config.getQuantity()));
                        String quantity = String.valueOf(config.getBaseQuantity());
//                        String quantity = String.valueOf(config.getBaseQuantity());


                        String quantity = calculateEntryQuantity(true);
                        // 向下检查是否已有多单挂在更低价格网格，有则跳过（防止价格回升后重复挂单）
                        boolean hasLongOrderBelow = false;
                        GridElement checkDownCursor = GridElement.findById(newEntryGrid.getDownId());
@@ -1320,7 +1546,9 @@

//                        String quantity = String.valueOf((accumulatedShortLossCount + 1) * Integer.parseInt(config.getQuantity()));
//                        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 = String.valueOf(config.getBaseQuantity());

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

        // 自定义止损模式：第一次止损触发时，取消未触发侧（空仓）自定义止损单并重挂默认阶梯
        if (config.isDualStopLossEnabled() && dualStopLossModeActive.compareAndSet(true, false)) {
            cancelAllShortStopLossesOnly();
            placeDefaultShortStopLossLadder();
            log.info("[Gate] 自定义止损首次触发(多仓), 已取消空仓自定义止损并重挂默认阶梯");
        }

    }

    private void handleShortStopLossTriggered(GridElement gridElement, String orderId) {
@@ -1526,6 +1761,13 @@
                    log.info("[Gate] 空仓止损触发, 取消gridId:{}的空单,{}", cancelGridId, cancelOrderId);
                });
            }
        }

        // 自定义止损模式：第一次止损触发时，取消未触发侧（多仓）自定义止损单并重挂默认阶梯
        if (config.isDualStopLossEnabled() && dualStopLossModeActive.compareAndSet(true, false)) {
            cancelAllLongStopLossesOnly();
            placeDefaultLongStopLossLadder();
            log.info("[Gate] 自定义止损首次触发(空仓), 已取消多仓自定义止损并重挂默认阶梯");
        }
    }

@@ -1752,7 +1994,8 @@
            return;
        }

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

        if (gridCount == 1) {
@@ -1814,7 +2057,8 @@
            return;
        }

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

        if (gridCount == 1) {
@@ -2081,6 +2325,210 @@
    /** 注入WS客户端，用于订阅状态检查 */
    public void setWsClient(GateKlineWebSocketClient wsClient) { this.wsClient = wsClient; }

    // ========== 手动控制（Station 指令） ==========

    /**
     * 手动取消多仓止盈 + 止损挂单，并同步清理对应 GridElement 的挂单记录。
     */
    public void cancelLongTakeProfitAndStopLoss() {
        submitManualTask(this::cancelAllLongTakeProfitsAndStopLosses);
    }

    /**
     * 手动取消空仓止盈 + 止损挂单，并同步清理对应 GridElement 的挂单记录。
     */
    public void cancelShortTakeProfitAndStopLoss() {
        submitManualTask(this::cancelAllShortTakeProfitsAndStopLosses);
    }

    /**
     * 手动重新生成多仓止盈 + 止损挂单，逻辑与挂单成交（onAutoOrder）一致：
     * 先撤多仓所有止盈止损，再按交易所最新持仓重挂止损阶梯，超额部分挂止盈到空仓第一止损位。
     */
    public void rebuildLongTakeProfitAndStopLoss() {
        submitManualTask(() -> {
            cancelAllLongTakeProfitsAndStopLosses();
            int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue());
            if (posSize <= 0) {
                log.warn("[Gate] 生成多仓止盈止损失败：无多仓持仓");
                return;
            }
            extendLongStopLoss(posSize, 0);
            if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
                placeExcessTakeProfit(posSize, true);
            } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
                placeDispersedTakeProfit(posSize, true, 0);
            }
            log.info("[Gate] 生成多仓止盈止损完成, 仓位:{}张", posSize);
        });
    }

    /**
     * 手动重新生成空仓止盈 + 止损挂单，逻辑与挂单成交（onAutoOrder）一致：
     * 先撤空仓所有止盈止损，再按交易所最新持仓重挂止损阶梯，超额部分挂止盈到多仓第一止损位。
     */
    public void rebuildShortTakeProfitAndStopLoss() {
        submitManualTask(() -> {
            cancelAllShortTakeProfitsAndStopLosses();
            int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue());
            if (posSize <= 0) {
                log.warn("[Gate] 生成空仓止盈止损失败：无空仓持仓");
                return;
            }
            extendShortStopLoss(posSize, 0);
            if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
                placeExcessTakeProfit(posSize, false);
            } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
                placeDispersedTakeProfit(posSize, false, 0);
            }
            log.info("[Gate] 生成空仓止盈止损完成, 仓位:{}张", posSize);
        });
    }

    /**
     * 多单平仓：市价平掉多仓 → 撤多仓所有挂单并更新 GridElement → 交由价格驱动（onKline→processGrid）重新入场。
     */
    public void closeLongPosition() {
        submitManualTask(() -> closePositionByMode(Position.ModeEnum.DUAL_LONG, true));
    }

    /**
     * 空单平仓：市价平掉空仓 → 撤空仓所有挂单并更新 GridElement → 交由价格驱动（onKline→processGrid）重新入场。
     */
    public void closeShortPosition() {
        submitManualTask(() -> closePositionByMode(Position.ModeEnum.DUAL_SHORT, false));
    }

    /**
     * 统一提交手动操作任务。策略停止（executor 已关闭）时直接忽略，避免 RejectedExecutionException。
     */
    private void submitManualTask(Runnable task) {
        if (state == StrategyState.STOPPED) {
            log.warn("[Gate] 策略已停止，忽略手动操作");
            return;
        }
        executor.submitTask(task);
    }

    /**
     * 按持仓模式市价平仓（reduceOnly + IOC），随后撤该方向所有挂单（止盈/止损/入场单）、
     * 更新 GridElement，并清空 active 与持仓量标记，让价格驱动在下一根 K 线重新挂入场单。
     *
     * @param mode   持仓模式（DUAL_LONG / DUAL_SHORT）
     * @param isLong true=多仓，false=空仓
     */
    private void closePositionByMode(Position.ModeEnum mode, boolean isLong) {
        String sideLabel = isLong ? "多" : "空";
        // 1. 市价平掉对应方向仓位（价格保护拒绝时重试）
        try {
            Position pos = queryPosition(mode);
            if (pos != null) {
                String sizeStr = pos.getSize();
                long size = Long.parseLong(sizeStr);
                if (size != 0) {
                    Position.ModeEnum posMode = pos.getMode();
                    FuturesOrder closeOrder = new FuturesOrder();
                    closeOrder.setContract(config.getContract());
                    closeOrder.setPrice("0");
                    closeOrder.setTif(FuturesOrder.TifEnum.IOC);
                    closeOrder.setReduceOnly(true);
                    if (posMode != null && posMode.getValue() != null && posMode.getValue().contains("dual")) {
                        closeOrder.setSize("0");
                        closeOrder.setClose(false);
                        closeOrder.setAutoSize(size > 0 ? FuturesOrder.AutoSizeEnum.LONG : FuturesOrder.AutoSizeEnum.SHORT);
                    } else {
                        closeOrder.setSize(size > 0 ? String.valueOf(-size) : String.valueOf(Math.abs(size)));
                    }
                    closeOrder.setText("t-grid-manual-close");
                    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) {
            log.warn("[Gate] 手动平{}仓失败", sideLabel, e);
        }

        // 2. 撤该方向所有挂单 + 更新 GridElement
        if (isLong) {
            cancelAllLongTakeProfitsAndStopLosses();
            cancelAllLongEntryOrders();
            longActive = false;
            longPositionSize = BigDecimal.ZERO;
        } else {
            cancelAllShortTakeProfitsAndStopLosses();
            cancelAllShortEntryOrders();
            shortActive = false;
            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;
    }

    /**
     * 取消所有多仓入场单（条件开仓单），并清空 GridElement 的多仓挂单记录。
     */
    private void cancelAllLongEntryOrders() {
        for (GridElement e : config.getGridElements()) {
            for (String oid : new ArrayList<>(e.getLongOrderIds())) {
                executor.cancelConditionalOrder(oid, o -> {});
            }
            e.getLongTraderParam().setEntryOrderId(null);
            e.getLongTraderParam().setEntryOrderPlaced(false);
            e.setHasLongOrder(false);
            e.clearLongOrderIds();
        }
        GridElement.refreshIndices();
        log.info("[Gate] 已提交取消所有多仓入场单");
    }

    /**
     * 取消所有空仓入场单（条件开仓单），并清空 GridElement 的空仓挂单记录。
     */
    private void cancelAllShortEntryOrders() {
        for (GridElement e : config.getGridElements()) {
            for (String oid : new ArrayList<>(e.getShortOrderIds())) {
                executor.cancelConditionalOrder(oid, o -> {});
            }
            e.getShortTraderParam().setEntryOrderId(null);
            e.getShortTraderParam().setEntryOrderPlaced(false);
            e.setHasShortOrder(false);
            e.clearShortOrderIds();
        }
        GridElement.refreshIndices();
        log.info("[Gate] 已提交取消所有空仓入场单");
    }

    // ========== 止损查表辅助方法 ==========

    /** 找到第一个有多仓止损单的网格（首个匹配即返回） */
@@ -2160,6 +2608,97 @@
    }

    /**
     * 分散止盈：把超出基础仓位的部分，从入场网格下一格开始逐格挂止盈单，一直挂到对手盘止损位。
     *
     * <p>数量分配：excessQty ÷ 网格数向下取整，余数全部挂在最后一个止盈网格（对手盘止损位）。
     *
     * <p>方向：多仓成交向价格更高方向（id 递增）铺到空仓第一止损位；
     * 空仓成交向价格更低方向（id 递减）铺到多仓第一止损位。
     *
     * @param posSize      当前总持仓张数
     * @param isLong       true=多仓成交，false=空仓成交
     * @param entryGridId  入场网格 ID
     */
    private void placeDispersedTakeProfit(int posSize, boolean isLong, int entryGridId) {
        int baseQty = Integer.parseInt(config.getBaseQuantity());
        int excessQty = posSize - baseQty;
        if (excessQty <= 0) {
            return;
        }

        GridElement endElem = isLong ? findFirstShortStopLossGrid() : findFirstLongStopLossGrid();
        if (endElem == null) {
            log.warn("[Gate] {}分散止盈失败：未找到对手盘止损位", isLong ? "多仓" : "空仓");
            return;
        }
        int endId = endElem.getId();
        int dir = isLong ? 1 : -1;
        int startId = entryGridId + dir;

        // 终点必须在起点前进方向上，否则退化为集中止盈（全部挂对手盘止损位）
        boolean valid = isLong ? (endId >= startId) : (endId <= startId);
        if (!valid) {
            placeExcessTakeProfit(posSize, isLong);
            return;
        }

        // 收集区间内全部网格（含两端）
        List<GridElement> gridList = new ArrayList<>();
        int id = startId;
        while (true) {
            GridElement e = GridElement.findById(id);
            if (e == null) {
                break;
            }
            gridList.add(e);
            if (id == endId) {
                break;
            }
            id += dir;
            if (gridList.size() > config.getGridQueueSize() * 2 + 4) {
                break;
            }
        }
        if (gridList.isEmpty() || gridList.get(gridList.size() - 1).getId() != endId) {
            // 未能铺满到终点（网格缺失），退化为集中止盈
            placeExcessTakeProfit(posSize, isLong);
            return;
        }

        int n = gridList.size();
        int perGrid = excessQty / n;
        int remainder = excessQty % n;

        for (int i = 0; i < n; i++) {
            int qty = perGrid;
            if (i == n - 1) {
                qty += remainder;
            }
            if (qty <= 0) {
                continue;
            }
            final GridElement elem = gridList.get(i);
            final int gid = elem.getId();
            final BigDecimal triggerPrice = elem.getGridPrice();
            final String size = isLong ? negate(String.valueOf(qty)) : String.valueOf(qty);
            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(elem, profitId, true);
                        } else {
                            shortTakeProfitTraderIdParam(elem, profitId, true);
                        }
                        log.info("[Gate] 分散止盈 {} gridId:{}, 触发价:{}, 数量:{}, tpId:{}",
                                isLong ? "多仓" : "空仓", gid, triggerPrice, size, profitId);
                    }
            );
        }
    }

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