refactor(gateApi): 优化网格交易逻辑和条件单管理

Administrator

4 hours ago 935856d1a80bacaccad4154d99e7e7c949523011

refactor(gateApi): 优化网格交易逻辑和条件单管理

- 更新文档描述多仓和空仓止盈队列的处理方式
- 修改价格处理逻辑移除条件判断直接执行长短网格处理
- 添加反向仓位逻辑支持当价格在特定范围内且仓位数量未达上限时开反向单
- 优化多仓和空仓止盈队列的更新策略确保队列按规则排序
- 移除多余的价格队列同步代码简化并发处理
- 调整条件单守卫逻辑确保只有满足条件时才更新订单状态
- 修复保证金检查逻辑确保队列和止盈队列正常更新
- 重构反向条件单挂单逻辑避免重复执行和资源浪费

 src/main/java/com/xcong/excoin/modules/okxApi/OkxConfig.java

@@ -58,6 +58,8 @@
    private final BigDecimal marginRatioLimit;
    private final BigDecimal contractMultiplier;
    private final PnLPriceMode unrealizedPnlPriceMode;
    private final BigDecimal maxPosSize;
    private BigDecimal step;

    private OkxConfig(Builder builder) {
        this.apiKey = builder.apiKey;
@@ -76,6 +78,7 @@
        this.marginRatioLimit = builder.marginRatioLimit;
        this.contractMultiplier = builder.contractMultiplier;
        this.unrealizedPnlPriceMode = builder.unrealizedPnlPriceMode;
        this.maxPosSize = builder.maxPosSize;
    }

    // ==================== WS 地址 ====================
@@ -122,6 +125,7 @@
    public BigDecimal getOverallTp() { return overallTp; }
    public BigDecimal getMaxLoss() { return maxLoss; }
    public String getQuantity() { return quantity; }
    public BigDecimal getMaxPosSize() { return maxPosSize; }
    public int getGridQueueSize() { return gridQueueSize; }

    // ==================== 风险控制 ====================
@@ -132,6 +136,9 @@

    public BigDecimal getContractMultiplier() { return contractMultiplier; }
    public PnLPriceMode getUnrealizedPnlPriceMode() { return unrealizedPnlPriceMode; }

    public BigDecimal getStep() { return step; }
    public void setStep(BigDecimal step) { this.step = step; }

    // ==================== 环境 ====================

@@ -158,6 +165,7 @@
        private BigDecimal marginRatioLimit = new BigDecimal("0.2");
        private BigDecimal contractMultiplier = new BigDecimal("1");
        private PnLPriceMode unrealizedPnlPriceMode = PnLPriceMode.LAST_PRICE;
        private BigDecimal maxPosSize = new BigDecimal("10");

        public Builder apiKey(String apiKey) { this.apiKey = apiKey; return this; }
        public Builder secretKey(String secretKey) { this.secretKey = secretKey; return this; }
@@ -173,6 +181,7 @@
        public Builder isProduction(boolean isProduction) { this.isProduction = isProduction; return this; }
        public Builder contractMultiplier(BigDecimal contractMultiplier) { this.contractMultiplier = contractMultiplier; return this; }
        public Builder unrealizedPnlPriceMode(PnLPriceMode mode) { this.unrealizedPnlPriceMode = mode; return this; }
        public Builder maxPosSize(BigDecimal maxPosSize) { this.maxPosSize = maxPosSize; return this; }

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

 src/main/java/com/xcong/excoin/modules/okxApi/OkxGridTradeService.java

@@ -37,6 +37,8 @@
    private volatile BigDecimal lastKlinePrice;
    private volatile BigDecimal cumulativePnl = BigDecimal.ZERO;
    private volatile BigDecimal unrealizedPnl = BigDecimal.ZERO;
    private volatile BigDecimal longRealizedPnl = BigDecimal.ZERO;
    private volatile BigDecimal shortRealizedPnl = BigDecimal.ZERO;
    private volatile BigDecimal longEntryPrice = BigDecimal.ZERO;
    private volatile BigDecimal shortEntryPrice = BigDecimal.ZERO;
    private volatile BigDecimal longPositionSize = BigDecimal.ZERO;
@@ -60,6 +62,8 @@
        state = StrategyState.WAITING_KLINE;
        cumulativePnl = BigDecimal.ZERO;
        unrealizedPnl = BigDecimal.ZERO;
        longRealizedPnl = BigDecimal.ZERO;
        shortRealizedPnl = BigDecimal.ZERO;
        longEntryPrice = BigDecimal.ZERO;
        shortEntryPrice = BigDecimal.ZERO;
        longPositionSize = BigDecimal.ZERO;
@@ -70,6 +74,7 @@
        shortActive = false;
        shortPriceQueue.clear();
        longPriceQueue.clear();
        config.setStep(null);
        log.info("[{}] 网格策略已启动", config.getContract());
    }

@@ -106,74 +111,44 @@
        processLongGrid(closePrice);
    }

    public void onPositionUpdate(String posSide, BigDecimal size, BigDecimal entryPrice) {
        if (state == StrategyState.STOPPED || state == StrategyState.WAITING_KLINE) {
    public void onPositionUpdate(String posSide, BigDecimal size, BigDecimal entryPrice, BigDecimal realizedPnl) {
        if (state == StrategyState.STOPPED) {
            return;
        }

        boolean hasPosition = size.compareTo(BigDecimal.ZERO) > 0;

        if (OkxEnums.POSSIDE_LONG.equals(posSide)) {
            longRealizedPnl = realizedPnl;
            if (hasPosition) {
                longActive = true;
                longEntryPrice = entryPrice;
                if (!baseLongOpened) {
                    longPositionSize = size;
                    longBaseEntryPrice = entryPrice;
                    baseLongOpened = true;
                    log.info("[{}] 基底多成交价: {}", config.getContract(), longBaseEntryPrice);
                    tryGenerateQueues();
                } else if (size.compareTo(longPositionSize) > 0) {
                    longPositionSize = size;
                    if (longPriceQueue.isEmpty()) {
                        log.warn("[{}] 多仓队列为空，无法设止盈", config.getContract());
                    } else {
                        BigDecimal tpPrice = longPriceQueue.get(0);
                        executor.placeTakeProfit(tpPrice, OkxEnums.ORDER_TYPE_CLOSE_LONG, config.getQuantity());
                        log.info("[{}] 多单止盈已设, entry:{}, tp:{}, size:{}", config.getContract(), entryPrice, tpPrice, config.getQuantity());
                    }
                } else {
                    longPositionSize = size;
                }
                longPositionSize = size;
            } else {
                longActive = false;
                longPositionSize = BigDecimal.ZERO;
                longRealizedPnl = BigDecimal.ZERO;
            }
        } else if (OkxEnums.POSSIDE_SHORT.equals(posSide)) {
            shortRealizedPnl = realizedPnl;
            if (hasPosition) {
                shortActive = true;
                shortEntryPrice = entryPrice;
                if (!baseShortOpened) {
                    shortPositionSize = size;
                    shortBaseEntryPrice = entryPrice;
                    baseShortOpened = true;
                    log.info("[{}] 基底空成交价: {}", config.getContract(), shortBaseEntryPrice);
                    tryGenerateQueues();
                } else if (size.compareTo(shortPositionSize) > 0) {
                    shortPositionSize = size;
                    if (shortPriceQueue.isEmpty()) {
                        log.warn("[{}] 空仓队列为空，无法设止盈", config.getContract());
                    } else {
                        BigDecimal tpPrice = shortPriceQueue.get(0);
                        executor.placeTakeProfit(tpPrice, OkxEnums.ORDER_TYPE_CLOSE_SHORT, config.getQuantity());
                        log.info("[{}] 空单止盈已设, entry:{}, tp:{}, size:{}", config.getContract(), entryPrice, tpPrice, config.getQuantity());
                    }
                } else {
                    shortPositionSize = size;
                }
                shortPositionSize = size;
            } else {
                shortActive = false;
                shortPositionSize = BigDecimal.ZERO;
                shortRealizedPnl = BigDecimal.ZERO;
            }
        }
    }

    public void onOrderFilled(String posSide, BigDecimal fillSz, BigDecimal pnl) {
        if (state == StrategyState.STOPPED) {
        cumulativePnl = longRealizedPnl.add(shortRealizedPnl);
        log.info("[{}] 持仓更新, 多已实现盈亏:{}, 空已实现盈亏:{}, 累计:{}",
                config.getContract(), longRealizedPnl, shortRealizedPnl, cumulativePnl);

        if (state == StrategyState.WAITING_KLINE) {
            return;
        }
        cumulativePnl = cumulativePnl.add(pnl);
        log.info("[{}] 订单成交盈亏: {}, 方向:{}, 累计:{}", config.getContract(), pnl, posSide, cumulativePnl);

        if (cumulativePnl.compareTo(config.getOverallTp()) >= 0) {
            log.info("[{}] 已达止盈目标 {}→已停止", config.getContract(), cumulativePnl);
@@ -184,13 +159,58 @@
        }
    }

    public void onOrderFilled(String posSide, BigDecimal fillSz, BigDecimal avgPx, BigDecimal pnl) {
        if (state == StrategyState.STOPPED || state == StrategyState.WAITING_KLINE) {
            return;
        }

        log.info("[{}] 订单成交, 方向:{}, 数量:{}, 成交价:{}, 盈亏:{}",
                config.getContract(), posSide, fillSz, avgPx, pnl);

        if (OkxEnums.POSSIDE_LONG.equals(posSide)) {
            if (!baseLongOpened) {
                longBaseEntryPrice = avgPx;
                baseLongOpened = true;
                log.info("[{}] 基底多成交价: {}", config.getContract(), longBaseEntryPrice);
                tryGenerateQueues();
            } else if (fillSz.compareTo(BigDecimal.ZERO) > 0) {
                if (longPriceQueue.isEmpty()) {
                    log.warn("[{}] 多仓队列为空，无法设止盈", config.getContract());
                } else {
                    BigDecimal tpPrice = longPriceQueue.get(0);
                    executor.placeTakeProfit(tpPrice, OkxEnums.ORDER_TYPE_CLOSE_LONG, config.getQuantity());
                    log.info("[{}] 多单止盈已设, 成交价:{}, tp:{}, size:{}",
                            config.getContract(), avgPx, tpPrice, config.getQuantity());
                }
            }
        } else if (OkxEnums.POSSIDE_SHORT.equals(posSide)) {
            if (!baseShortOpened) {
                shortBaseEntryPrice = avgPx;
                baseShortOpened = true;
                log.info("[{}] 基底空成交价: {}", config.getContract(), shortBaseEntryPrice);
                tryGenerateQueues();
            } else if (fillSz.compareTo(BigDecimal.ZERO) > 0) {
                if (shortPriceQueue.isEmpty()) {
                    log.warn("[{}] 空仓队列为空，无法设止盈", config.getContract());
                } else {
                    BigDecimal tpPrice = shortPriceQueue.get(0);
                    executor.placeTakeProfit(tpPrice, OkxEnums.ORDER_TYPE_CLOSE_SHORT, config.getQuantity());
                    log.info("[{}] 空单止盈已设, 成交价:{}, tp:{}, size:{}",
                            config.getContract(), avgPx, tpPrice, config.getQuantity());
                }
            }
        }
    }

    private void tryGenerateQueues() {
        if (baseLongOpened && baseShortOpened) {
            BigDecimal step = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
            config.setStep(step);
            generateShortQueue();
            generateLongQueue();
            state = StrategyState.ACTIVE;
            log.info("[{}] 网格队列已生成, 空队首:{} → 尾:{}, 多队首:{} → 尾:{}, 已激活",
                    config.getContract(),
            log.info("[{}] 网格队列已生成, 步长:{}, 空队首:{} → 尾:{}, 多队首:{} → 尾:{}, 已激活",
                    config.getContract(), step,
                    shortPriceQueue.isEmpty() ? "N/A" : shortPriceQueue.get(0),
                    shortPriceQueue.isEmpty() ? "N/A" : shortPriceQueue.get(shortPriceQueue.size() - 1),
                    longPriceQueue.isEmpty() ? "N/A" : longPriceQueue.get(0),
@@ -200,26 +220,26 @@

    private void generateShortQueue() {
        shortPriceQueue.clear();
        BigDecimal fixedStep = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        BigDecimal step = config.getStep();
        BigDecimal prev = shortBaseEntryPrice;
        for (int i = 0; i < config.getGridQueueSize(); i++) {
            prev = prev.subtract(fixedStep).setScale(1, RoundingMode.HALF_UP);
            prev = prev.subtract(step).setScale(1, RoundingMode.HALF_UP);
            shortPriceQueue.add(prev);
        }
        shortPriceQueue.sort((a, b) -> b.compareTo(a));
        log.info("[{}] 空队列:{} 步长:{}", config.getContract(), shortPriceQueue, fixedStep);
        log.info("[{}] 空队列:{} 步长:{}", config.getContract(), shortPriceQueue, step);
    }

    private void generateLongQueue() {
        longPriceQueue.clear();
        BigDecimal fixedStep = longBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        BigDecimal step = config.getStep();
        BigDecimal prev = longBaseEntryPrice;
        for (int i = 0; i < config.getGridQueueSize(); i++) {
            prev = prev.add(fixedStep).setScale(1, RoundingMode.HALF_UP);
            prev = prev.add(step).setScale(1, RoundingMode.HALF_UP);
            longPriceQueue.add(prev);
        }
        Collections.sort(longPriceQueue);
        log.info("[{}] 多队列:{} 步长:{}", config.getContract(), longPriceQueue, fixedStep);
        log.info("[{}] 多队列:{} 步长:{}", config.getContract(), longPriceQueue, step);
    }

    /**
@@ -259,22 +279,21 @@
        }
        log.info("[{}] 空仓队列触发, 匹配{}个元素, 当前价:{}", config.getContract(), matched.size(), currentPrice);

        BigDecimal shortFixedStep = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        BigDecimal longFixedStep = longBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        replenishOwnQueue(shortPriceQueue, matched, shortFixedStep, true, "空");
        BigDecimal step = config.getStep();
        replenishOwnQueue(shortPriceQueue, matched, step, true, "空");

        transferBetweenQueues(longPriceQueue, matched, matched.get(matched.size() - 1),
                longFixedStep, false, longEntryPrice, BigDecimal::compareTo, "多", currentPrice);
                step, false, longEntryPrice, BigDecimal::compareTo, "多", currentPrice);

        if (!isMarginSafe()) {
            log.warn("[{}] 保证金超限，跳过空单开仓", config.getContract());
        } else {
            executor.openShort(config.getQuantity(), null, null);
            if (shortEntryPrice.compareTo(BigDecimal.ZERO) > 0
                    && longEntryPrice.compareTo(BigDecimal.ZERO) > 0
                    && longEntryPrice.compareTo(shortEntryPrice) > 0
                    && currentPrice.compareTo(shortEntryPrice) > 0
                    && currentPrice.compareTo(longEntryPrice.subtract(longFixedStep)) < 0) {
            if (shortPositionSize.compareTo(config.getMaxPosSize()) < 0){
                executor.openShort(config.getQuantity(), null, null);
            }
            if (currentPrice.compareTo(shortEntryPrice) > 0
                    && currentPrice.compareTo(longEntryPrice) < 0
            && shortPositionSize.compareTo(config.getMaxPosSize()) < 0) {
                executor.openLong(config.getQuantity(), null, null);
                log.info("[{}] 触发价在多/空持仓价之间且多>空且远离多仓均价, 额外开多一次, 当前价:{}", config.getContract(), currentPrice);
            }
@@ -318,22 +337,24 @@
        }
        log.info("[{}] 多仓队列触发, 匹配{}个元素, 当前价:{}", config.getContract(), matched.size(), currentPrice);

        BigDecimal longFixedStep = longBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        BigDecimal shortFixedStep = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        replenishOwnQueue(longPriceQueue, matched, longFixedStep, false, "多");
        BigDecimal step = config.getStep();
        replenishOwnQueue(longPriceQueue, matched, step, false, "多");

        transferBetweenQueues(shortPriceQueue, matched, matched.get(0),
                shortFixedStep, true, shortEntryPrice, (a, b) -> b.compareTo(a), "空", currentPrice);
                step, true, shortEntryPrice, (a, b) -> b.compareTo(a), "空", currentPrice);

        if (!isMarginSafe()) {
            log.warn("[{}] 保证金超限，跳过多单开仓", config.getContract());
        } else {
            executor.openLong(config.getQuantity(), null, null);
            if (longPositionSize.compareTo(config.getMaxPosSize()) < 0) {
                executor.openLong(config.getQuantity(), null, null);
            }
            if (shortEntryPrice.compareTo(BigDecimal.ZERO) > 0
                    && longEntryPrice.compareTo(BigDecimal.ZERO) > 0
                    && longEntryPrice.compareTo(shortEntryPrice) > 0
                    && currentPrice.compareTo(shortEntryPrice.add(shortFixedStep)) > 0
                    && currentPrice.compareTo(longEntryPrice) < 0) {
                    && currentPrice.compareTo(shortEntryPrice.add(step)) > 0
                    && currentPrice.compareTo(longEntryPrice) < 0
                    && shortPositionSize.compareTo(config.getMaxPosSize()) < 0) {
                executor.openShort(config.getQuantity(), null, null);
                log.info("[{}] 触发价在多/空持仓价之间且多>空且远离空仓均价, 额外开空一次, 当前价:{}", config.getContract(), currentPrice);
            }

 src/main/java/com/xcong/excoin/modules/okxApi/OkxWebSocketClientManager.java

@@ -29,14 +29,14 @@
                    .apiKey("d90ca272391992b8e74f8f92cedb21ec")
                    .secretKey("1861e4f52de4bb53369ea3208d9ede38ece4777368030f96c77d27934c46c274")
                    .passphrase("Aa123123@")
                    .contract("BTC-USDT-SWAP")
                    .contract("ETH-USDT-SWAP")
                    .leverage("100")
                    .marginMode("cross")
                    .posMode("long_short_mode")
                    .gridRate(new BigDecimal("0.0015"))
                    .overallTp(new BigDecimal("5"))
                    .maxLoss(new BigDecimal("15"))
                    .quantity("1")
                    .maxLoss(new BigDecimal("20"))
                    .quantity("0.1")
                    .contractMultiplier(new BigDecimal("1"))
                    .unrealizedPnlPriceMode(OkxConfig.PnLPriceMode.LAST_PRICE)
                    .isProduction(false)

 src/main/java/com/xcong/excoin/modules/okxApi/wsHandler/handler/OkxOrderInfoChannelHandler.java

@@ -98,18 +98,20 @@
                }
                String state = detail.getString("state");
                String accFillSz = detail.getString("accFillSz");
                String fillPx = detail.getString("fillPx");
                String pnl = detail.getString("pnl");
                String posSide = detail.getString("posSide");
                String avgPx = detail.getString("avgPx");
                String clOrdId = detail.getString("clOrdId");

                log.info("[{}] 订单, 方向:{}, 状态:{}, 成交量:{}, 均价:{}, 盈亏:{}, 编号:{}",
                        CHANNEL_NAME, posSide, state, accFillSz, avgPx, pnl, clOrdId);
                log.info("[{}] 订单, 方向:{}, 状态:{}, 成交量:{}, 末笔成交价:{}, 均价:{}, 盈亏:{}, 编号:{}",
                        CHANNEL_NAME, posSide, state, accFillSz, fillPx, avgPx, pnl, clOrdId);

                if ("filled".equals(state) && accFillSz != null && new BigDecimal(accFillSz).compareTo(BigDecimal.ZERO) > 0) {
                    if (gridTradeService != null) {
                        BigDecimal avgPxVal = avgPx != null && !avgPx.isEmpty() ? new BigDecimal(avgPx) : BigDecimal.ZERO;
                        BigDecimal pnlVal = pnl != null ? new BigDecimal(pnl) : BigDecimal.ZERO;
                        gridTradeService.onOrderFilled(posSide, new BigDecimal(accFillSz), pnlVal);
                        gridTradeService.onOrderFilled(posSide, new BigDecimal(accFillSz), avgPxVal, pnlVal);
                    }
                }
            }

 src/main/java/com/xcong/excoin/modules/okxApi/wsHandler/handler/OkxPositionsChannelHandler.java

@@ -80,13 +80,15 @@
                BigDecimal size = new BigDecimal(pos.getString("pos"));
                BigDecimal avgPx = pos.containsKey("avgPx") && pos.getString("avgPx") != null
                        ? new BigDecimal(pos.getString("avgPx")) : BigDecimal.ZERO;
                BigDecimal realizedPnl = pos.containsKey("realizedPnl") && pos.getString("realizedPnl") != null
                        ? new BigDecimal(pos.getString("realizedPnl")) : BigDecimal.ZERO;

                log.info("[{}] 持仓更新, 方向:{}, 数量:{}, 均价:{}, 未实现盈亏:{}, 保证金:{}",
                log.info("[{}] 持仓更新, 方向:{}, 数量:{}, 均价:{}, 未实现盈亏:{}, 已实现盈亏:{}, 保证金:{}",
                        OkxEnums.CHANNEL_POSITIONS, posSide, size, avgPx,
                        pos.get("upl"), pos.get("imr"));
                        pos.get("upl"), realizedPnl, pos.get("imr"));

                if (gridTradeService != null) {
                    gridTradeService.onPositionUpdate(posSide, size, avgPx);
                    gridTradeService.onPositionUpdate(posSide, size, avgPx, realizedPnl);
                }
            }
        } catch (Exception e) {