fix(gateApi): 解决市价单价格保护错误和枚举反序列化问题

Administrator

2026-09-21 6fd0d871d28dbdbea6bca0cbd3360cd8d8d6f5cb

 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.*;
@@ -110,6 +114,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 */
@@ -150,7 +159,7 @@
    /** 最近触发止损的空头网格ID */
    private volatile int lastShortStopLossGridId = Integer.MAX_VALUE;
    /** 自定义止损模式激活标记：true=尚未发生第一次止损触发，第一次触发后置 false（触发未触发侧重挂默认） */
    private final AtomicBoolean customStopLossModeActive = new AtomicBoolean(false);
    private final AtomicBoolean dualStopLossModeActive = new AtomicBoolean(false);

    private volatile BigDecimal lastKlinePrice;
    private volatile BigDecimal markPrice = BigDecimal.ZERO;
@@ -172,8 +181,38 @@
        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 序列化器，跳过 {@code finishAs} 字段的反序列化。
     *
     * <p>gate-api SDK 的 {@code FuturesOrder.FinishAsEnum} 枚举不完整，缺少
     * {@code price_rate_proteced}（价格保护）等 Gate 实际会返回的值。反序列化未知
     * 枚举值时 {@code fromValue} 会抛 {@link IllegalArgumentException}，导致已成功
     * 提交的订单被误判为失败（如日志 {@code Unexpected value 'price_rate_proteced'}）。
     * 业务不使用 finishAs 字段，因此通过 Gson 排除策略直接跳过其解析。
     */
    private static JSON buildLenientJson() {
        JSON json = new JSON();
        Gson gson = json.getGson().newBuilder()
                .setExclusionStrategies(new ExclusionStrategy() {
                    @Override
                    public boolean shouldSkipField(FieldAttributes f) {
                        return "finishAs".equals(f.getName());
                    }

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

    // ---- 初始化 ----
@@ -365,7 +404,7 @@
        accumulatedShortLossCount = 0;
        lastLongStopLossGridId = Integer.MAX_VALUE;
        lastShortStopLossGridId = Integer.MAX_VALUE;
        customStopLossModeActive.set(false);
        dualStopLossModeActive.set(false);
        shortPriceQueue.clear();
        longPriceQueue.clear();
        totalShortPriceQueue.clear();
@@ -978,7 +1017,7 @@
//                );
//            }

            if (config.isCustomStopLossEnabled()) {
            if (config.isDualStopLossEnabled()) {
                placeCustomStopLosses();
            } else {
                placeDefaultStopLossLadders();
@@ -995,10 +1034,10 @@
     * 多仓止损：NUMBER_2（价格 ≤ 触发价平多），空仓止损：NUMBER_1（价格 ≥ 触发价平空）。
     */
    private void placeCustomStopLosses() {
        customStopLossModeActive.set(true);
        dualStopLossModeActive.set(true);
        String baseQty = config.getBaseQuantity();
        BigDecimal longPrice = config.getLongCustomStopLossPrice();
        BigDecimal shortPrice = config.getShortCustomStopLossPrice();
        BigDecimal longPrice = config.getLongStopLossPrice();
        BigDecimal shortPrice = config.getShortStopLossPrice();

        if (longPrice != null && longPrice.compareTo(BigDecimal.ZERO) > 0) {
            GridElement longElem = findNearestGridElementByPrice(longPrice);
@@ -1654,7 +1693,7 @@
        }

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

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

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

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

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

        if (gridCount == 1) {
@@ -2272,6 +2313,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] 已提交取消所有空仓入场单");
    }

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

    /** 找到第一个有多仓止损单的网格（首个匹配即返回） */