fix(gateApi): 修复网格交易策略状态检查逻辑

Administrator

2026-06-08 1deaa332168ed37fc20d4960fa960a58db6ff452

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

@@ -409,6 +409,20 @@
            return;
        }
        checkProfitAndReset();


        if (state == StrategyState.ACTIVE &&
                longActive == false &&
                        longPositionSize.compareTo(BigDecimal.ZERO) == 0){
            processShortGrid(closePrice);
        }


        if (state == StrategyState.ACTIVE &&
                shortActive == false &&
                        shortPositionSize.compareTo(BigDecimal.ZERO) == 0){
            processLongGrid(closePrice);
        }
    }

    // ---- 仓位推送回调 ----
@@ -461,8 +475,8 @@
                }
            } else {
                if (longActive && state == StrategyState.ACTIVE) {
                    log.info("[Gate] 多仓持仓归零，重置策略");
                    handlePositionZeroAndReset("多仓");
//                    log.info("[Gate] 多仓持仓归零，重置策略");
//                    handlePositionZeroAndReset("多仓");
                }
                longActive = false;
                longPositionSize = BigDecimal.ZERO;
@@ -484,8 +498,8 @@
                }
            } else {
                if (shortActive && state == StrategyState.ACTIVE) {
                    log.info("[Gate] 空仓持仓归零，重置策略");
                    handlePositionZeroAndReset("空仓");
//                    log.info("[Gate] 空仓持仓归零，重置策略");
//                    handlePositionZeroAndReset("空仓");
                }
                shortActive = false;
                shortPositionSize = BigDecimal.ZERO;
@@ -793,7 +807,7 @@
                shortEntryQty = 1;
                extendShortStopLoss(filledQty);
                log.info("[Gate] 空单成交 gridId:{}, qty:{}, 追挂止损", shortGridElement.getId(), filledQty);
                checkMaxPositionAndPlaceTakeProfit(false, shortGridElement.getId());
//                checkMaxPositionAndPlaceTakeProfit(false, shortGridElement.getId());
            }
        }
        GridElement longGridElement = GridElement.findByLongOrderId(orderId);
@@ -804,7 +818,7 @@
                longEntryQty = 1;
                extendLongStopLoss(filledQty);
                log.info("[Gate] 多单成交 gridId:{}, qty:{}, 追挂止损", longGridElement.getId(), filledQty);
                checkMaxPositionAndPlaceTakeProfit(true, longGridElement.getId());
//                checkMaxPositionAndPlaceTakeProfit(true, longGridElement.getId());
            }
        }
    }
@@ -928,7 +942,8 @@
            baseGridElement.setShortOrderId(baseShortTraderParam.getEntryOrderId());
            baseGridElement.setHasShortOrder(true);

            for (int id = 2; id <= 11; id++) {
            int shortTime = Integer.parseInt(config.getBaseQuantity()) + 1;
            for (int id = 2; id <= shortTime; id++) {
                GridElement elem = GridElement.findById(id);
                if (elem == null) {
                    continue;
@@ -948,7 +963,9 @@
                );
            }

            for (int id = -2; id >= -11; id--) {

            int longTime = Integer.parseInt(config.getBaseQuantity()) + 1;
            for (int id = -2; id >= -longTime; id--) {
                GridElement elem = GridElement.findById(id);
                if (elem == null) {
                    continue;
@@ -968,7 +985,7 @@
                );
            }

            log.info("[Gate] 止损单已全部挂完, 空仓止损: 2~11, 多仓止损: -2~-11");
            log.info("[Gate] 止损单已全部挂完, 空仓止损: 2~{}, 多仓止损: -2~-{}", shortTime, longTime);
            state = StrategyState.ACTIVE;
        }
    }
@@ -1169,210 +1186,97 @@
    }

    private void processShortGrid(BigDecimal currentPrice) {
        int prec = config.getPriceScale();
        List<BigDecimal> matched = new ArrayList<>();
        BigDecimal matched = BigDecimal.ZERO;
        synchronized (shortPriceQueue) {
            for (BigDecimal p : shortPriceQueue) {
                if (p.compareTo(currentPrice) >= 0) {
                    matched.add(p);
                    matched =  p;
                } else {
                    break;
                }
            }
        }
        if (matched.isEmpty()) {
        if (BigDecimal.ZERO.compareTo( matched) == 0) {
            return;
        }
        log.info("[Gate] 空仓队列触发, 匹配{}个元素, 当前价:{}", matched.size(), currentPrice);
        log.info("[Gate] 空仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);

        synchronized (shortPriceQueue) {
            shortPriceQueue.removeAll(matched);
            BigDecimal min = shortPriceQueue.isEmpty() ? matched.get(matched.size() - 1) : shortPriceQueue.get(shortPriceQueue.size() - 1);
            BigDecimal gridStep = config.getStep();
            for (int i = 0; i < matched.size(); i++) {
                min = min.subtract(gridStep).setScale(prec, RoundingMode.HALF_UP);
                shortPriceQueue.add(min);
            }
            shortPriceQueue.sort((a, b) -> b.compareTo(a));
        }
        GridElement matchedUpGridElement = GridElement.findByPrice(matched);

        synchronized (longPriceQueue) {
            BigDecimal first = longPriceQueue.isEmpty() ? matched.get(matched.size() - 1) : longPriceQueue.get(0);
            BigDecimal gridStep = config.getStep();
            for (int i = 1; i <= matched.size(); i++) {
                BigDecimal elem = first.subtract(gridStep.multiply(BigDecimal.valueOf(i))).setScale(prec, RoundingMode.HALF_UP);
                longPriceQueue.add(elem);
            }
            longPriceQueue.sort(BigDecimal::compareTo);
            while (longPriceQueue.size() > config.getGridQueueSize()) {
                longPriceQueue.remove(longPriceQueue.size() - 1);
            }
        }
        Integer upId = matchedUpGridElement.getUpId();
        GridElement newEntryGrid = GridElement.findById(upId);

        if (!isMarginSafe()) {
            log.warn("[Gate] 保证金超限，跳过挂条件单");
        } else {
        if (newEntryGrid != null) {
            GridElement cancelGridElement = GridElement.findById(newEntryGrid.getUpId());

            /**
             * 下一个开仓位置
             *      获取队列第一个元素的价格对应的网格
             *      判断网格是否能开空仓，如果不能则跳过
             *      前进方向挂空仓条件单
             *      后置方向挂多空条件单
             */
            //下一个开仓位置
            BigDecimal newLongFirst = shortPriceQueue.get(0);
            GridElement UpGridElement = GridElement.findByPrice(newLongFirst);
            if (cancelGridElement != null) {
                BigDecimal triggerPrice = newEntryGrid.getGridPrice();
                String size = cancelGridElement.getLongTraderParam().getQuantity();
                log.info("[Gate] 多仓仓位归零 gridId:{}, 挂{}基础张多单",
                        newEntryGrid.getId(),  size);
                newEntryGrid.getLongTraderParam().setQuantity(size);
                placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
                        FuturesPriceTrigger.RuleEnum.NUMBER_1, size);

            // 判断网格是否能开空仓，如果不能则跳过
            if (UpGridElement != null) {

//                if (!UpGridElement.isHasShortOrder() && shortEntryPrice.compareTo(newLongFirst) > 0) {
//
//                    TraderParam upShortTraderParam = UpGridElement.getShortTraderParam();
//                    placeEntryOrderWithPreFlag(UpGridElement, false,
//                            upShortTraderParam.getEntryPrice(),
//                            FuturesPriceTrigger.RuleEnum.NUMBER_2,
//                            negate(upShortTraderParam.getQuantity()));
//                }
                int i = UpGridElement.getId() + 2;
                GridElement downGridElement = GridElement.findById(i);
                if (downGridElement != null){

                    BigDecimal downGridPrice = downGridElement.getGridPrice();

//                    TraderParam downShortTraderParam = downGridElement.getShortTraderParam();
//                    if (
//                            !downGridElement.isHasShortOrder() &&
//                                    downGridPrice.compareTo(longEntryPrice) <= 0 &&
//                                    downGridPrice.compareTo(shortEntryPrice) >= 0
//                    ){
//                        placeEntryOrderWithPreFlag(downGridElement, false,
//                                downShortTraderParam.getEntryPrice(),
//                                FuturesPriceTrigger.RuleEnum.NUMBER_1,
//                                negate(downShortTraderParam.getQuantity()));
//
//                    }

                    TraderParam downLongTraderParam = downGridElement.getLongTraderParam();
                    if (
                            !downGridElement.isHasLongOrder() &&
                                    downGridPrice.compareTo(longEntryPrice) <= 0
                    ){
                        placeEntryOrderWithPreFlag(downGridElement, true,
                                downLongTraderParam.getEntryPrice(),
                                FuturesPriceTrigger.RuleEnum.NUMBER_1,
                                downLongTraderParam.getQuantity());
                    }
                /**
                 * 看是否有多仓挂单，有就取消
                 */
                if (cancelGridElement != null && cancelGridElement.isHasLongOrder()) {
                    executor.cancelConditionalOrder(cancelGridElement.getLongOrderId(), oid -> {
                        longEntryTraderIdParam(cancelGridElement, null, false);
                        log.info("[Gate] 多仓仓位归零, 取消gridId:{}的多单", cancelGridElement);
                    });
                }
            }
        }
    }

    private void processLongGrid(BigDecimal currentPrice) {
        int prec = config.getPriceScale();
        List<BigDecimal> matched = new ArrayList<>();
        BigDecimal matched = BigDecimal.ZERO;
        synchronized (longPriceQueue) {
            for (BigDecimal p : longPriceQueue) {
                if (p.compareTo(currentPrice) <= 0) {
                    matched.add(p);
                    matched = p;
                } else {
                    break;
                }
            }
        }
        if (matched.isEmpty()) {
        if (BigDecimal.ZERO.compareTo( matched) == 0) {
            return;
        }

        log.info("[Gate] 多仓队列触发, 匹配{}个元素, 当前价:{}", matched.size(), currentPrice);
        log.info("[Gate] 多仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);

        /**
         * 匹配到元素后，
         *  多仓队列更新
         *  空仓队列更新
         */
        synchronized (longPriceQueue) {
            longPriceQueue.removeAll(matched);
            BigDecimal max = longPriceQueue.isEmpty() ? matched.get(matched.size() - 1) : longPriceQueue.get(longPriceQueue.size() - 1);
            BigDecimal gridStep = config.getStep();
            for (int i = 0; i < matched.size(); i++) {
                max = max.add(gridStep).setScale(prec, RoundingMode.HALF_UP);
                longPriceQueue.add(max);
            }
            longPriceQueue.sort(BigDecimal::compareTo);
        }
        synchronized (shortPriceQueue) {
            BigDecimal first = shortPriceQueue.isEmpty() ? matched.get(0) : shortPriceQueue.get(0);
            BigDecimal gridStep = config.getStep();
            for (int i = 1; i <= matched.size(); i++) {
                BigDecimal elem = first.add(gridStep.multiply(BigDecimal.valueOf(i))).setScale(prec, RoundingMode.HALF_UP);
                shortPriceQueue.add(elem);
            }
            shortPriceQueue.sort((a, b) -> b.compareTo(a));
            while (shortPriceQueue.size() > config.getGridQueueSize()) {
                shortPriceQueue.remove(shortPriceQueue.size() - 1);
            }
        }
        GridElement matchedUpGridElement = GridElement.findByPrice(matched);

        if (!isMarginSafe()) {
            log.warn("[Gate] 保证金超限，跳过挂条件单");
        } else {
        Integer downId = matchedUpGridElement.getDownId();
        GridElement newEntryGrid = GridElement.findById(downId);

            /**
             * 下一个开仓位置
             *      获取队列第一个元素的价格对应的网格
             *      判断网格是否能开多仓，如果不能则跳过
             *      前进方向挂多仓条件单
             *      后置方向挂多空条件单
             */
            //下一个开仓位置
            BigDecimal newLongFirst = longPriceQueue.get(0);
            GridElement UpGridElement = GridElement.findByPrice(newLongFirst);
        if (newEntryGrid != null) {
            GridElement cancelGridElement = GridElement.findById(newEntryGrid.getDownId());

            // 判断网格是否能开多仓，如果不能则跳过
            if (UpGridElement != null) {
            if (cancelGridElement != null) {
                BigDecimal triggerPrice = newEntryGrid.getGridPrice();
                String size = cancelGridElement.getShortTraderParam().getQuantity();
                log.info("[Gate] 空仓仓位归零 gridId:{}, 挂{}基础张多单",
                        newEntryGrid.getId(),  size);
                newEntryGrid.getShortTraderParam().setQuantity(size);
                placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
                        FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));

//                if (!UpGridElement.isHasLongOrder() && longEntryPrice.compareTo(newLongFirst) < 0) {
//                    TraderParam upLongTraderParam = UpGridElement.getLongTraderParam();
//                    placeEntryOrderWithPreFlag(UpGridElement, true,
//                            upLongTraderParam.getEntryPrice(),
//                            FuturesPriceTrigger.RuleEnum.NUMBER_1,
//                            config.getQuantity());
//                }

                int i = UpGridElement.getId() - 2;
                GridElement downGridElement = GridElement.findById(i);
                if (downGridElement != null){

                    BigDecimal downGridPrice = downGridElement.getGridPrice();

//                    TraderParam downLongTraderParam = downGridElement.getLongTraderParam();
//                    if (
//                            !downGridElement.isHasLongOrder() &&
//                                    downGridPrice.compareTo(shortEntryPrice) >= 0 &&
//                                    downGridPrice.compareTo(longEntryPrice) <= 0
//                    ){
//                        placeEntryOrderWithPreFlag(downGridElement, true,
//                                downLongTraderParam.getEntryPrice(),
//                                FuturesPriceTrigger.RuleEnum.NUMBER_2,
//                                config.getQuantity());
//
//                    }

                    TraderParam shortTraderParam = downGridElement.getShortTraderParam();
                    if (
                            !downGridElement.isHasShortOrder() &&
                                    downGridPrice.compareTo(shortEntryPrice) >= 0
                    ){

                        placeEntryOrderWithPreFlag(downGridElement, false,
                                shortTraderParam.getEntryPrice(),
                                FuturesPriceTrigger.RuleEnum.NUMBER_2,
                                negate(config.getQuantity()));
                    }
                /**
                 * 看是否有空仓挂单，有就取消
                 */
                if (cancelGridElement != null && cancelGridElement.isHasShortOrder()) {
                    executor.cancelConditionalOrder(cancelGridElement.getShortOrderId(), oid -> {
                        shortEntryTraderIdParam(cancelGridElement, null, false);
                        log.info("[Gate] 空仓仓位归零, 取消gridId:{}的多单", cancelGridElement);
                    });
                }
            }

        }
    }

@@ -1595,14 +1499,15 @@
            BigDecimal totalEquity = unrealisedPnl.add(available);

            // 估算平仓手续费：(多仓张数+空仓张数) × 合约面值 × 当前价 × taker费率
            BigDecimal closeContractValue = longPositionSize.add(shortPositionSize)
                    .multiply(CT_VAL).multiply(lastKlinePrice != null ? lastKlinePrice : BigDecimal.ZERO);
            BigDecimal totalSize = longPositionSize.abs().add(shortPositionSize.abs());
            BigDecimal closeContractValue =
                    totalSize.multiply(CT_VAL).multiply(lastKlinePrice != null ? lastKlinePrice : BigDecimal.ZERO);
            BigDecimal estimatedFee = closeContractValue.multiply(TAKER_FEE_RATE);
            BigDecimal netEquity = totalEquity.subtract(estimatedFee);

            BigDecimal target = initialPrincipal.add(config.getExpectedProfit());
            log.info("[Gate] 盈亏检查 upl:{}, avail:{}, 合计:{}, 估手续费:{}, 净权益:{}, 目标:{}",
                    unrealisedPnl, available, totalEquity, estimatedFee, netEquity, target);
            log.info("[Gate] 盈亏检查,总张数：{}, upl:{}, avail:{}, 合计:{}, 估手续费:{}, 净权益:{}, 目标:{}",
                    totalSize,unrealisedPnl, available, totalEquity, estimatedFee, netEquity, target);
            if (netEquity.compareTo(target) > 0) {
                log.info("[Gate] 盈亏达标(净权益{}>目标{})，重置策略", netEquity, target);
                state = StrategyState.STOPPED;