exchange.git - Gitblit

			@@ -1,5 +1,8 @@
			package com.xcong.excoin.modules.gateApi;

			import cn.hutool.core.collection.CollUtil;
			import cn.hutool.core.util.StrUtil;
			import com.xcong.excoin.utils.dingtalk.DingTalkUtils;
			import io.gate.gateapi.ApiClient;
			import io.gate.gateapi.ApiException;
			import io.gate.gateapi.GateApiException;
			@@ -11,91 +14,70 @@
			import java.io.IOException;
			import java.math.BigDecimal;
			import java.math.RoundingMode;
			import java.util.ArrayList;
			import java.util.Collections;
			import java.util.Iterator;
			import java.util.LinkedHashMap;
			import java.util.List;
			import java.util.Map;
			import java.util.*;

			import com.xcong.excoin.modules.gateApi.wsHandler.handler.CandlestickChannelHandler;
			import com.xcong.excoin.modules.gateApi.wsHandler.handler.PositionClosesChannelHandler;
			import com.xcong.excoin.modules.gateApi.wsHandler.handler.PositionsChannelHandler;

			/**
			* Gate 网格交易服务 — 策略核心。
			* 网格交易策略引擎 — 多空对冲网格。
			*
			* <h3>策略概述</h3>
			* 多空双开基底 → 生成价格网格队列 → 条件单监控 → 触发成交后队列动态转移。
			* 每根 K 线更新未实现盈亏（unrealizedPnl），平仓后累加已实现盈亏（cumulativePnl）。
			* <h3>策略原理</h3>
			* 以空仓基底入场价（shortBaseEntryPrice）为价格基准，向上/向下各生成一个价格网格队列。
			* 价格触发网格层级时挂条件单，成交后自动挂止盈单。每笔止盈盈利 = step - minTick。
			*
			* <h3>核心机制</h3>
			* <ul>
			* <li><b>条件开仓单</b>：使用 Gate API {@code FuturesPriceTriggeredOrder}，服务器监控价格，
			* 达到触发价后以市价 IOC 开仓。相比限价单，条件单仅在触发价到达时才执行，避免提前成交。</li>
			* <li><b>条件单 ID 映射</b>（currentLongOrderIds / currentShortOrderIds）：
			* 用同步 Map 管理所有活跃的条件单（订单ID → 止盈价格）。挂条件单时通过回调存入，
			* 订单成交后通过 {@code futures.orders} 推送匹配止盈价并挂止盈单。</li>
			* <li><b>订单订阅（futures.orders）</b>：订单成交（status=finished, finish_as=filled）时，
			* 通过 {@link #onOrderUpdate(String, String, String)} 从 Map 中取出止盈价，
			* 调用 {@code executor.placeTakeProfit} 创建止盈条件单。</li>
			* <li><b>反向条件单</b>：当新网格首元素价格夹在多/空持仓均价之间，
			* 且反向持仓张数不超过 3 张时，额外挂一张反向市价单，通过订单订阅自动挂止盈。</li>
			* </ul>
			*
			* <h3>状态机</h3>
			* <h3>完整生命周期</h3>
			* <pre>
			* WAITING_KLINE → (首K线) → 异步双开基底
			*
			* 仓位推送(dual_long/dual_short) → 基底成交 → 记录入场价
			* → 双基底都成交 → 生成队列 + 初始条件单 + 止盈队列 → ACTIVE
			*
			* ACTIVE:
			* ├─ 每根K线 → 更新 unrealizedPnl → 方向判断
			* │ ├─ closePrice > longPriceQueue[0] → processLongGrid
			* │ └─ closePrice < shortPriceQueue[0] → processShortGrid
			* ├─ processShortGrid: 匹配空仓队列 → 本队补充 → 挂空仓+多仓条件单（止盈价存入Map）
			* ├─ processLongGrid: 匹配多仓队列 → 本队补充 → 挂多仓+空仓条件单（止盈价存入Map）
			* ├─ 订单推送(futures.orders) → onOrderUpdate → Map 匹配止盈价 → 挂止盈条件单
			* ├─ 仓位推送 → 更新均价/持仓量、仓位减少时处理反向单
			* ├─ 平仓推送 → 累加 cumulativePnl
			* ├─ 保证金安全阀 → 超限跳过挂单，队列照常更新
			* └─ cumulativePnl ≥ overallTp 或 ≤ -maxLoss → STOPPED
			* init() → startGrid() → WAITING_KLINE
			* ↓
			* onKline(首根K线) → OPENING → 异步市价双开基底（开多+开空）
			* ↓
			* onPositionUpdate() → 基底成交 → baseLongOpened && baseShortOpened
			* ↓
			* tryGenerateQueues()
			* ├── generateShortQueue() ← 空仓价格队列（降序，从 shortBaseEntryPrice-step 向下）
			* ├── generateLongQueue() ← 多仓价格队列（升序，从 shortBaseEntryPrice+step 向上）
			* ├── updateGridElements() ← 构建 GridElement 列表 + TraderParam + 全局索引
			* ├── 挂基座止盈单（ID=0 的 long/short takeProfit）
			* └── 挂初始条件单（up=-1 多单, down=1 空单）
			* ↓
			* state = ACTIVE（每根K线反复执行以下循环）
			* ↓
			* onKline() → processLongGrid() + processShortGrid()
			* ├── 匹配队列元素 → 队列补偿 → 保证金检查
			* ├── 首元素方向：挂条件开仓单 → 订单ID + GridElement状态同步
			* └── 反向守卫：在 downGrid 位置挂对向单（价格区间+trigger方向校验）
			* ↓
			* onOrderUpdate() ← futures.orders / futures.autoorders 推送
			* ├── 匹配止盈单ID → 清空止盈状态（已成交）
			* └── 匹配挂单ID → 挂止盈条件单 → 止盈ID + GridElement状态同步
			* ↓
			* onPositionClose() → cumulativePnl 累加
			* ├── ≥ overallTp → STOPPED
			* └── ≤ -maxLoss → STOPPED
			* </pre>
			*
			* <h3>队列转移规则</h3>
			* <ul>
			* <li><b>空仓队列触发</b>（processShortGrid）：matched 元素从空仓队列移除，
			* 尾部递减 step 补充新元素；多仓队列以首元素（最小价）递减 step 生成新元素加入。</li>
			* <li><b>多仓队列触发</b>（processLongGrid）：matched 元素从多仓队列移除，
			* 尾部递增 step 补充新元素；空仓队列以首元素（最高价）递增 step 生成新元素加入。</li>
			* <li>队列容量超限时截断尾部，保持固定容量。</li>
			* </ul>
			*
			* <h3>止盈机制</h3>
			* <ul>
			* <li>网格触发时，挂条件单的回调中将订单 ID 和止盈价存入 currentLongOrderIds / currentShortOrderIds Map。</li>
			* <li>条件单成交后，{@code futures.orders} 推送触发 {@link #onOrderUpdate}，
			* 通过订单 ID 取出止盈价，创建止盈条件单（plan-close-*-position）。</li>
			* <li>止盈条件单：以触发价监控（price_type=最新价，strategy_type=价格触发），
			* 到达后以市价 IOC 平仓（reduce_only=true，price="0"）。</li>
			* </ul>
			*
			* <h3>反向条件单条件</h3>
			* <h3>仓位线动态调整</h3>
			* <pre>
			* newFirstPrice > shortEntryPrice AND newFirstPrice < longEntryPrice
			* AND 反向持仓张数 < 3
			* onPositionUpdate() 中仓位均价变化后：
			* longEntryPrice ↑ → 取消高于 longEntryPrice 的空仓挂单（避免逆势空单）
			* shortEntryPrice ↓ → 取消低于 shortEntryPrice 的多仓挂单（避免逆势多单）
			* </pre>
			* 满足条件时以 newFirstPrice ± step 为止盈价直接挂市价单，通过订单订阅自动挂止盈。
			*
			* <h3>未实现盈亏公式（正向合约）</h3>
			* <h3>关键公式</h3>
			* <pre>
			* 多仓: 持仓量 × 合约乘数 × (计价价格 − 开仓均价)
			* 空仓: 持仓量 × 合约乘数 × (开仓均价 − 计价价格)
			* step = shortBaseEntryPrice × gridRate ← 网格绝对步长
			* minTick = 10^(-priceScale) ← 交易所最小价格单位
			* 多止盈 = gridPrice + (step - minTick) ← 多仓止盈价
			* 空止盈 = gridPrice - (step - minTick) ← 空仓止盈价
			* 单笔盈利 = (step - minTick) × contractMultiplier × quantity ← USDT
			* </pre>
			* 计价价格支持切换：{@link GateConfig.PnLPriceMode#LAST_PRICE 最新成交价} 或
			* {@link GateConfig.PnLPriceMode#MARK_PRICE 标记价格}（通过 {@link #setMarkPrice(BigDecimal)} 注入）。
			* 入场价和持仓量由 {@link #onPositionUpdate(String, Position.ModeEnum, BigDecimal, BigDecimal)} 实时更新。
			*
			* <h3>线程模型</h3>
			* 所有 WS 回调（onKline/onPositionUpdate/onOrderUpdate 等）在 WS 回调线程中串行执行。
			* 下单/撤单操作提交到 GateTradeExecutor 的单线程池异步执行，避免阻塞 WS 线程。
			* stopGrid() 会将 state 设为 STOPPED，后续所有 WS 回调直接返回不再处理。
			*
			* @author Administrator
			*/
			@@ -130,6 +112,8 @@
			private final List<BigDecimal> shortPriceQueue = Collections.synchronizedList(new ArrayList<>());
			/** 多仓价格队列，升序排列（小→大），容量 gridQueueSize */
			private final List<BigDecimal> longPriceQueue = Collections.synchronizedList(new ArrayList<>());
			private final List<BigDecimal> totalLongPriceQueue = Collections.synchronizedList(new ArrayList<>());
			private final List<BigDecimal> totalShortPriceQueue = Collections.synchronizedList(new ArrayList<>());

			/** 当前多仓条件单映射：订单ID → 止盈价格，订单成交后通过订单订阅推送匹配止盈 */
			private final Map<String, BigDecimal> currentLongOrderIds = Collections.synchronizedMap(new LinkedHashMap<>());
			@@ -160,6 +144,7 @@
			private volatile BigDecimal shortPositionSize = BigDecimal.ZERO;
			private Long userId;
			private volatile BigDecimal initialPrincipal = BigDecimal.ZERO;
			private volatile GateKlineWebSocketClient wsClient;

			public GateGridTradeService(GateConfig config) {
			this.config = config;
			@@ -319,7 +304,22 @@
			longPriceQueue.clear();
			currentLongOrderIds.clear();
			currentShortOrderIds.clear();
			log.info("[Gate] 网格策略已启动");
			// 每次重启重新获取当前本金
			refreshInitialPrincipal();

			log.info("[Gate] 网格策略已启动, 当前本金: {} USDT", initialPrincipal);
			}

			/**
			* 重新获取当前账户权益作为初始本金。
			*/
			private void refreshInitialPrincipal() {
			try {
			FuturesAccount account = futuresApi.listFuturesAccounts(SETTLE);
			this.initialPrincipal = new BigDecimal(account.getTotal());
			} catch (Exception e) {
			log.warn("[Gate] 获取初始化本金失败，使用旧值: {}", initialPrincipal);
			}
			}

			/**
			@@ -329,6 +329,7 @@
			public void stopGrid() {
			state = StrategyState.STOPPED;
			executor.cancelAllPriceTriggeredOrders();
			closeExistingPositions();
			executor.shutdown();
			log.info("[Gate] 策略已停止, 累计盈亏: {}", cumulativePnl);
			}
			@@ -355,36 +356,88 @@
			*/
			public void onKline(BigDecimal closePrice) {
			lastKlinePrice = closePrice;
			updateUnrealizedPnl();
			if (state == StrategyState.STOPPED) {
			return;
			}

			//初始化0位置的开仓，并且用空的开仓价格，作为价格基准来划分网格
			if (state == StrategyState.WAITING_KLINE) {
			if (wsClient == null \|\| !wsClient.areAllSubscribed()) {
			return;
			}

			state = StrategyState.OPENING;
			log.info("[Gate] 首根K线到达，开基底仓位...");
			executor.openLong(config.getQuantity(), (orderId) -> {

			String size = config.getBaseQuantity();
			log.info("[Gate] 首根K线到达，开基底仓位多空各{}张...", size);
			executor.openLong(size, (orderId) -> {
			TraderParam baseLongTp = TraderParam.builder()
			.entryOrderId(orderId)
			.build();
			config.setBaseLongTraderParam(baseLongTp);
			}, null);
			executor.openShort(negate(config.getQuantity()), (orderId) -> {
			executor.openShort(negate(size), (orderId) -> {
			TraderParam baseShortTp = TraderParam.builder()
			.entryOrderId(orderId)
			.build();
			config.setBaseShortTraderParam(baseShortTp);
			}, null);

			return;
			}

			if (state != StrategyState.ACTIVE) {
			return;

			// checkProfitAndReset();


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


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

			/** Gate 永续合约 taker 费率 0.05% */
			private static final BigDecimal TAKER_FEE_RATE = new BigDecimal("0.0005");
			private void checkProfitAndReset() {
			try {

			BigDecimal target = initialPrincipal.add(config.getExpectedProfit());

			FuturesAccount account = futuresApi.listFuturesAccounts(SETTLE);
			BigDecimal unrealisedPnl = new BigDecimal(account.getCrossUnrealisedPnl());
			BigDecimal available = new BigDecimal(account.getCrossAvailable());
			BigDecimal totalEquity = unrealisedPnl.add(available);

			// 估算平仓手续费：(多仓张数+空仓张数) × 合约面值 × 当前价 × taker费率
			BigDecimal totalSize = longPositionSize.abs().add(shortPositionSize.abs());
			BigDecimal closeContractValue =
			totalSize.multiply(config.getContractMultiplier()).multiply(lastKlinePrice != null ? lastKlinePrice : BigDecimal.ZERO);
			BigDecimal estimatedFee = closeContractValue.multiply(TAKER_FEE_RATE);
			BigDecimal netEquity = totalEquity.subtract(estimatedFee);
			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;
			try {
			futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
			} catch (ApiException e) {
			e.printStackTrace();
			}
			closeExistingPositions();
			// 提交到 executor 末尾：单线程FIFO保证前面所有平仓/取消任务完成后才重置
			executor.submitTask(() -> {
			try { Thread.sleep(3000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
			startGrid();
			});
			}
			} catch (Exception e) {
			log.warn("[Gate] 盈亏检查失败", e);
			}
			}

			// ---- 仓位推送回调 ----
			@@ -399,7 +452,6 @@
			* <li>首次开仓（基底）：标记 baseOpened=true，记录基底入场价，双基底都成交后生成网格队列</li>
			* <li>仓位净减少（size.abs() < 之前记录值）：止盈平仓后 → 检查反向条件单条件 →
			* 满足时以 entryPrice ± step 为止盈价挂反向市价单（订单ID + 止盈价存入 Map）</li>
			* <li>仓位净增加或不变：仅更新 positionSize，止盈由 {@link #onOrderUpdate} 通过订单订阅匹配处理</li>
			* </ul>
			* </li>
			* <li><b>无仓位 (size = 0)</b>：清空活跃标记和持仓量</li>
			@@ -419,41 +471,70 @@
			}

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

			if (Position.ModeEnum.DUAL_LONG == mode) {
			if (hasPosition) {
			if (state == StrategyState.OPENING){
			if (Position.ModeEnum.DUAL_LONG == mode && hasPosition && !baseLongOpened) {
			longActive = true;
			longPositionSize = size;
			longEntryPrice = entryPrice;
			if (!baseLongOpened) {
			longPositionSize = size;
			longBaseEntryPrice = entryPrice;
			baseLongOpened = true;
			log.info("[Gate] 基底多成交价: {}", longBaseEntryPrice);
			tryGenerateQueues();
			}else {
			longPositionSize = size;
			}
			} else {
			longActive = false;
			longPositionSize = BigDecimal.ZERO;
			}
			} else if (Position.ModeEnum.DUAL_SHORT == mode) {
			if (hasPosition) {
			longBaseEntryPrice = entryPrice;
			baseLongOpened = true;
			log.info("[Gate] 基底多成交价: {}", longBaseEntryPrice);
			tryGenerateQueues();
			} else if (Position.ModeEnum.DUAL_SHORT == mode && hasPosition && !baseShortOpened) {
			shortActive = true;
			shortPositionSize = size.abs();
			shortEntryPrice = entryPrice;
			if (!baseShortOpened) {
			shortPositionSize = size.abs();
			shortBaseEntryPrice = entryPrice;
			baseShortOpened = true;
			log.info("[Gate] 基底空成交价: {}", shortBaseEntryPrice);
			tryGenerateQueues();
			}else {
			shortPositionSize = size.abs();
			}
			} else {
			shortActive = false;
			shortPositionSize = BigDecimal.ZERO;
			shortBaseEntryPrice = entryPrice;
			baseShortOpened = true;
			log.info("[Gate] 基底空成交价: {}", shortBaseEntryPrice);
			tryGenerateQueues();
			}
			}

			if (state == StrategyState.ACTIVE){
			if (Position.ModeEnum.DUAL_LONG == mode) {
			if (hasPosition) {
			longActive = true;
			longPositionSize = size;
			longEntryPrice = entryPrice;
			} else {

			log.info("[Gate-0]多仓: {}", shortBaseEntryPrice);
			longActive = false;
			longPositionSize = BigDecimal.ZERO;
			longEntryPrice = BigDecimal.ZERO;
			}
			} else if (Position.ModeEnum.DUAL_SHORT == mode) {
			if (hasPosition) {
			shortActive = true;
			shortPositionSize = size.abs();
			shortEntryPrice = entryPrice;
			} else {

			log.info("[Gate-0]空仓: {}", shortBaseEntryPrice);
			shortActive = false;
			shortPositionSize = BigDecimal.ZERO;
			shortEntryPrice = BigDecimal.ZERO;
			}
			}
			}

			if (state == StrategyState.ACTIVE && shortActive == false && longActive == false) {
			try {
			futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
			} catch (ApiException e) {
			e.printStackTrace();
			}
			closeExistingPositions();

			state = StrategyState.STOPPED;
			// 提交到 executor 末尾：单线程FIFO保证前面所有平仓/取消任务完成后才重置
			executor.submitTask(() -> {
			try { Thread.sleep(3000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
			startGrid();
			});
			log.info("[Gate] 重置策略");
			return;
			}
			}

			@@ -475,115 +556,130 @@
			return;
			}
			cumulativePnl = cumulativePnl.add(pnl);
			log.info("[Gate] 盈亏累加:{}, 方向:{}, 累计:{}", pnl, side, cumulativePnl);
			updateUnrealizedPnl();
			BigDecimal totalPnl = cumulativePnl.add(unrealizedPnl);
			log.info("[Gate] 已实现:{}, 未实现:{}, 合计:{}",
			cumulativePnl, unrealizedPnl, totalPnl);
			if(totalPnl.compareTo(config.getMaxLoss().negate()) <= 0) {
			String logMessage = StrUtil.format("[Gate] 已达亏损风险值(合计{}), 已实现:{}, 未实现:{}",
			totalPnl, cumulativePnl, unrealizedPnl);
			log.info(logMessage);

			if (cumulativePnl.compareTo(config.getOverallTp()) >= 0) {
			log.info("[Gate] 已达止盈目标 {}→已停止", cumulativePnl);
			state = StrategyState.STOPPED;
			} else if (cumulativePnl.compareTo(config.getMaxLoss().negate()) <= 0) {
			log.info("[Gate] 已达亏损上限 {}→已停止", cumulativePnl);
			state = StrategyState.STOPPED;
			DingTalkUtils.getDefault().sendActionCard("风险提醒", logMessage, config.getApiKey(), "");
			}
			}

			// ---- 订单推送回调 ----

			/**
			* 订单推送回调。由 OrdersChannelHandler 在收到订单更新推送时调用。
			* 自动订单（条件单）状态变更回调。
			* 由 {@link com.xcong.excoin.modules.gateApi.wsHandler.handler.AutoOrdersChannelHandler}
			* 在收到 {@code futures.autoorders} 推送时调用。
			*
			* <h3>处理逻辑</h3>
			* 当订单状态为 finished 且 finish_as 为 filled 时，
			* 从 {@link #currentLongOrderIds} / {@link #currentShortOrderIds} 中匹配订单ID，
			* 取出止盈价格并挂止盈单。匹配成功后从 Map 中移除该条目，防止重复挂单。
			*
			* @param orderId 订单 ID
			* @param status 订单状态（open / finished）
			* @param finishAs 订单结束方式（filled / cancelled / ioc 等）
			* @param orderId 条件单 ID
			* @param status 订单状态（open / finished / cancelled）
			* @param reason 变更原因
			* @param orderType 订单类型（plan-close-long-position 等）
			*/
			public void onOrderUpdate(String orderId, String status, String finishAs) {
			if (!"finished".equals(status) \|\| !"filled".equals(finishAs)) {
			public void onAutoOrder(String orderId, String status, String reason, String orderType, String tradeId) {
			if (state == StrategyState.STOPPED) {
			return;
			}
			log.info("[Gate] 条件单状态变更, id:{}, status:{}, reason:{}, order_type:{}",
			orderId, status, reason, orderType);
			if (!"finished".equals(status)) {
			return;
			}

			/**
			* 匹配止盈单止盈
			*/
			GridElement byLongTakeProfitOrderId = GridElement.findByLongTakeProfitOrderId(orderId);
			if (byLongTakeProfitOrderId != null){
			longTakeProfitTraderIdParam(
			byLongTakeProfitOrderId,
			null,
			false
			);
			longEntryTraderIdParam(
			byLongTakeProfitOrderId,
			null,
			false
			);
			GridElement longStopLossElem = GridElement.findByLongStopLossOrderId(orderId);
			// if (longStopLossElem != null && longPositionSize.compareTo(BigDecimal.ZERO) > 0 && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
			if (longStopLossElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
			handleLongStopLossTriggered(longStopLossElem);
			return;
			}
			GridElement byShortTakeProfitOrderId = GridElement.findByShortTakeProfitOrderId(orderId);
			if (byShortTakeProfitOrderId != null){
			shortTakeProfitTraderIdParam(
			byShortTakeProfitOrderId,
			null,
			false
			);
			shortEntryTraderIdParam(
			byShortTakeProfitOrderId,
			null,
			false
			);
			GridElement shortStopLossElem = GridElement.findByShortStopLossOrderId(orderId);
			// if (shortStopLossElem != null && shortPositionSize.compareTo(BigDecimal.ZERO) > 0 && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
			if (shortStopLossElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
			handleShortStopLossTriggered(shortStopLossElem);
			return;
			}

			/**
			* 匹配挂单
			*/
			GridElement longGridElement = GridElement.findByLongOrderId(orderId);
			if (longGridElement != null) {
			if (longGridElement.isHasLongOrder()){
			if (longGridElement.getLongTakeProfitOrderId() == null){
			BigDecimal longTp = longGridElement.getLongTraderParam().getTakeProfitPrice();
			if (longTp != null) {
			executor.placeTakeProfit(longTp,
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			ORDER_TYPE_CLOSE_LONG,
			negate(config.getQuantity()),
			(profitId) -> {
			longTakeProfitTraderIdParam(
			longGridElement,
			profitId,
			true
			);
			});
			log.info("[Gate] 多单成交匹配止盈, orderId:{}, 止盈价:{}, size:{}", orderId, longTp, negate(config.getQuantity()));
			return;
			GridElement shortGridElement = GridElement.findByShortOrderId(orderId);
			if (shortGridElement != null) {
			if (shortGridElement.isHasShortOrder() && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0") ){
			int filledQty = Integer.parseInt(shortGridElement.getShortTraderParam().getQuantity());
			shortEntryTraderIdParam(shortGridElement, null, false);
			extendShortStopLoss(filledQty,shortGridElement.getId());
			log.info("[Gate] 空单成交 gridId:{}", filledQty);

			// 空仓持仓超过baseQuantity时，从gridId-2开始向外追挂止盈
			BigDecimal shortBaseQty = new BigDecimal(config.getBaseQuantity());
			BigDecimal shortGridQty = new BigDecimal(config.getQuantity());
			if (shortPositionSize.compareTo(shortBaseQty) > 0) {
			BigDecimal shortExcess = shortPositionSize.subtract(shortBaseQty);
			int shortExcessCount = shortExcess.divide(shortGridQty, 0, RoundingMode.DOWN).intValue();
			for (int i = 0; i < shortExcessCount; i++) {
			int tpGridId = shortGridElement.getId() - 2 - i;
			GridElement tpElem = GridElement.findById(tpGridId);
			if (tpElem == null \|\| tpElem.getShortTakeProfitOrderId() != null) {
			continue;
			}
			BigDecimal tpPrice = tpElem.getGridPrice();
			int finalTpGridId = tpGridId;
			executor.placeTakeProfit(
			tpPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			ORDER_TYPE_CLOSE_SHORT,
			config.getQuantity(),
			profitId -> {
			shortTakeProfitTraderIdParam(tpElem, profitId, true);
			log.info("[Gate] 空仓止盈挂单, gridId:{}, 触发价:{}, takeProfitId:{}",
			finalTpGridId, tpPrice, profitId);
			}
			);
			}
			}
			}
			}
			GridElement shortGridElement = GridElement.findByShortOrderId(orderId);
			if (shortGridElement != null) {
			if (shortGridElement.isHasShortOrder()){
			if (shortGridElement.getShortTakeProfitOrderId() == null){
			BigDecimal shortTp = shortGridElement.getShortTraderParam().getTakeProfitPrice();
			if (shortTp != null) {
			executor.placeTakeProfit(shortTp,
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			ORDER_TYPE_CLOSE_SHORT,
			config.getQuantity(),
			(profitId) -> {
			shortTakeProfitTraderIdParam(
			shortGridElement,
			profitId,
			true
			);
			});
			log.info("[Gate] 空单成交匹配止盈, orderId:{}, 止盈价:{}, size:{}", orderId, shortTp, config.getQuantity());
			GridElement longGridElement = GridElement.findByLongOrderId(orderId);
			if (longGridElement != null) {
			if (longGridElement.isHasLongOrder() && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")){

			int filledQty = Integer.parseInt(longGridElement.getLongTraderParam().getQuantity());
			longEntryTraderIdParam(longGridElement, null, false);
			extendLongStopLoss(filledQty,longGridElement.getId());
			log.info("[Gate] 多单成交 gridId:{}", filledQty);

			// 多仓持仓超过baseQuantity时，从gridId+2开始向外追挂止盈
			BigDecimal longBaseQty = new BigDecimal(config.getBaseQuantity());
			BigDecimal longGridQty = new BigDecimal(config.getQuantity());
			if (longPositionSize.compareTo(longBaseQty) > 0) {
			BigDecimal longExcess = longPositionSize.subtract(longBaseQty);
			int longExcessCount = longExcess.divide(longGridQty, 0, RoundingMode.DOWN).intValue();
			for (int i = 0; i < longExcessCount; i++) {
			int tpGridId = longGridElement.getId() + 2 + i;
			GridElement tpElem = GridElement.findById(tpGridId);
			if (tpElem == null \|\| tpElem.getLongTakeProfitOrderId() != null) {
			continue;
			}
			BigDecimal tpPrice = tpElem.getGridPrice();
			int finalTpGridId = tpGridId;
			executor.placeTakeProfit(
			tpPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			ORDER_TYPE_CLOSE_LONG,
			negate(config.getQuantity()),
			profitId -> {
			longTakeProfitTraderIdParam(tpElem, profitId, true);
			log.info("[Gate] 多仓止盈挂单, gridId:{}, 触发价:{}, takeProfitId:{}",
			finalTpGridId, tpPrice, profitId);
			}
			);
			}
			}
			}
			}
			}


			// ---- 网格队列处理 ----

			@@ -597,92 +693,104 @@
			* 止盈价 = 触发价 − step，通过 onSuccess 回调将 orderId → 止盈价存入 currentShortOrderIds</li>
			* <li>状态切换为 ACTIVE</li>
			* </ol>
			* 条件单成交后由 {@link #onOrderUpdate} 匹配止盈价并挂止盈条件单。
			*/
			private void tryGenerateQueues() {
			if (baseLongOpened && baseShortOpened) {
			//初始化空仓队列
			generateShortQueue();
			//初始化多仓队列
			generateLongQueue();
			//初始化网格数据
			updateGridElements();

			/**
			* 挂初始位置多空仓条件单
			* 0位置的多单止盈
			* 0位置的空单止盈
			*/
			GridElement baseGridElement = GridElement.findById(0);
			TraderParam baseLongTraderParam = config.getBaseLongTraderParam();
			baseGridElement.setLongOrderId(baseLongTraderParam.getEntryOrderId());
			//0位置的网格的多单止盈
			BigDecimal upTakeProfitPrice = baseGridElement.getLongTraderParam().getTakeProfitPrice();
			executor.placeTakeProfit(
			upTakeProfitPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			ORDER_TYPE_CLOSE_LONG,
			negate(config.getQuantity()),
			profitId -> {
			longTakeProfitTraderIdParam(
			baseGridElement,
			profitId,
			true
			);
			}
			);
			//0位置的网格的空单止盈
			baseGridElement.setHasLongOrder(true);
			TraderParam baseShortTraderParam = config.getBaseShortTraderParam();
			baseGridElement.setShortOrderId(baseShortTraderParam.getEntryOrderId());
			BigDecimal downTakeProfitPrice = baseGridElement.getShortTraderParam().getTakeProfitPrice();
			executor.placeTakeProfit(
			downTakeProfitPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			ORDER_TYPE_CLOSE_SHORT,
			config.getQuantity(),
			profitId -> {
			shortTakeProfitTraderIdParam(
			baseGridElement,
			profitId,
			true
			);
			}
			);
			baseGridElement.setHasShortOrder(true);

			/**
			* 挂初始位置的up位置的多单
			* 挂初始位置的down位置的空单
			*/
			Integer upId = baseGridElement.getUpId();
			GridElement upGridElementOne = GridElement.findById(upId);
			BigDecimal longTp = upGridElementOne.getGridPrice();
			executor.placeConditionalEntryOrder(
			longTp,
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			config.getQuantity(),
			orderId -> {
			longEntryTraderIdParam(
			upGridElementOne,
			orderId,
			true
			);
			},
			null);
			Integer downId = baseGridElement.getDownId();
			GridElement downGridElementOne = GridElement.findById(downId);
			BigDecimal shortTp = downGridElementOne.getGridPrice();
			executor.placeConditionalEntryOrder(
			shortTp,
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			negate(config.getQuantity()),
			orderId -> {
			shortEntryTraderIdParam(
			downGridElementOne,
			orderId,
			true
			);
			},
			null);
			// int shortTime = 2;
			// GridElement elemShort = GridElement.findById(shortTime);
			// if (elemShort != null) {
			// BigDecimal triggerPrice = elemShort.getGridPrice();
			// String size = config.getBaseQuantity();
			// executor.placeTakeProfit(
			// triggerPrice,
			// FuturesPriceTrigger.RuleEnum.NUMBER_1,
			// ORDER_TYPE_CLOSE_SHORT,
			// size,
			// profitId -> {
			// elemShort.setShortStopLossOrderId(profitId);
			// GridElement.refreshIndices();
			// log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", shortTime, triggerPrice, profitId);
			// }
			// );
			// }
			//
			//
			// int longTime = -2;
			// GridElement elemLong = GridElement.findById(longTime);
			// if (elemLong != null) {
			// BigDecimal triggerPrice = elemLong.getGridPrice();
			// String size = config.getBaseQuantity();
			// executor.placeTakeProfit(
			// triggerPrice,
			// FuturesPriceTrigger.RuleEnum.NUMBER_2,
			// ORDER_TYPE_CLOSE_LONG,
			// negate(size),
			// profitId -> {
			// elemLong.setLongStopLossOrderId(profitId);
			// GridElement.refreshIndices();
			// log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", longTime, triggerPrice, profitId);
			// }
			// );
			// }

			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.setShortStopLossOrderId(profitId);
			GridElement.refreshIndices();
			log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
			}
			);
			}


			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.setLongStopLossOrderId(profitId);
			GridElement.refreshIndices();
			log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
			}
			);
			}

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

			state = StrategyState.ACTIVE;
			}
			@@ -740,12 +848,16 @@
			*/
			private void generateShortQueue() {
			shortPriceQueue.clear();
			BigDecimal step = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
			int prec = config.getPriceScale();
			BigDecimal step = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(prec, RoundingMode.HALF_UP);
			config.setStep(step);
			BigDecimal elem = shortBaseEntryPrice.subtract(step).setScale(1, RoundingMode.HALF_UP);
			BigDecimal elem = shortBaseEntryPrice.subtract(step).setScale(prec, RoundingMode.HALF_UP);
			for (int i = 0; i < config.getGridQueueSize(); i++) {
			shortPriceQueue.add(elem);
			elem = elem.subtract(step).setScale(1, RoundingMode.HALF_UP);
			totalLongPriceQueue.add( elem);
			totalShortPriceQueue.add( elem);

			elem = elem.subtract(step).setScale(prec, RoundingMode.HALF_UP);
			if (elem.compareTo(BigDecimal.ZERO) <= 0) {
			break;
			}
			@@ -761,14 +873,21 @@
			*/
			private void generateLongQueue() {
			longPriceQueue.clear();
			int prec = config.getPriceScale();
			BigDecimal step = config.getStep();
			BigDecimal elem = shortBaseEntryPrice.add(step).setScale(1, RoundingMode.HALF_UP);
			BigDecimal elem = shortBaseEntryPrice.add(step).setScale(prec, RoundingMode.HALF_UP);
			for (int i = 0; i < config.getGridQueueSize(); i++) {
			longPriceQueue.add(elem);
			elem = elem.add(step).setScale(1, RoundingMode.HALF_UP);
			totalLongPriceQueue.add( elem);
			totalShortPriceQueue.add( elem);
			elem = elem.add(step).setScale(prec, RoundingMode.HALF_UP);
			}
			longPriceQueue.sort(BigDecimal::compareTo);
			log.info("[Gate] 多队列:{}", longPriceQueue);
			totalShortPriceQueue.sort((a, b) -> b.compareTo(a));
			log.info("[Gate] 队列从大到小:{}", totalShortPriceQueue);
			totalLongPriceQueue.sort(BigDecimal::compareTo);
			log.info("[Gate] 队列从小到大:{}", totalLongPriceQueue);
			}

			/**
			@@ -789,7 +908,10 @@
			List<GridElement> elements = new ArrayList<>();
			int shortSize = shortPriceQueue.size();
			int longSize = longPriceQueue.size();
			BigDecimal step = config.getStep().subtract(config.getContractMultiplier());
			//根据精度转换成小数
			int prec = config.getPriceScale();
			BigDecimal step = config.getStep();
			// String qty = config.getBaseQuantity();
			String qty = config.getQuantity();

			// 空仓队列：id 从 -1 自减, shortPriceQueue[i] → id=-(i+1)
			@@ -801,13 +923,13 @@
			TraderParam longParam = TraderParam.builder()
			.direction(TraderParam.Direction.LONG)
			.entryPrice(price)
			.takeProfitPrice(price.add(step).setScale(1, RoundingMode.HALF_UP))
			.takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
			.quantity(qty)
			.build();
			TraderParam shortParam = TraderParam.builder()
			.direction(TraderParam.Direction.SHORT)
			.entryPrice(price)
			.takeProfitPrice(price.subtract(step).setScale(1, RoundingMode.HALF_UP))
			.takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
			.quantity(qty)
			.build();
			elements.add(GridElement.builder()
			@@ -826,13 +948,13 @@
			TraderParam longParam = TraderParam.builder()
			.direction(TraderParam.Direction.LONG)
			.entryPrice(price)
			.takeProfitPrice(price.add(step).setScale(1, RoundingMode.HALF_UP))
			.takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
			.quantity(qty)
			.build();
			TraderParam shortParam = TraderParam.builder()
			.direction(TraderParam.Direction.SHORT)
			.entryPrice(price)
			.takeProfitPrice(price.subtract(step).setScale(1, RoundingMode.HALF_UP))
			.takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
			.quantity(qty)
			.build();
			elements.add(GridElement.builder()
			@@ -854,13 +976,13 @@
			TraderParam longParam = TraderParam.builder()
			.direction(TraderParam.Direction.LONG)
			.entryPrice(price)
			.takeProfitPrice(price.add(step).setScale(1, RoundingMode.HALF_UP))
			.takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
			.quantity(qty)
			.build();
			TraderParam shortParam = TraderParam.builder()
			.direction(TraderParam.Direction.SHORT)
			.entryPrice(price)
			.takeProfitPrice(price.subtract(step).setScale(1, RoundingMode.HALF_UP))
			.takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
			.quantity(qty)
			.build();
			elements.add(GridElement.builder()
			@@ -877,344 +999,284 @@
			log.info("[Gate] 网格元素列表已构建, 共{}个元素 (空仓:{} 位置:0 多仓:{})", elements.size(), shortSize, longSize);
			}

			/**
			* 空仓网格处理（当前价跌破空仓队列元素）。
			*
			* <h3>匹配规则</h3>
			* 遍历空仓队列（降序排列，大→小），收集所有大于当前价的元素为 matched。
			* 降序排列保证一旦遇到 price ≤ currentPrice 即可停止遍历。
			*
			* <h3>执行流程</h3>
			* <ol>
			* <li>匹配队列元素 → 为空则直接返回，不触发</li>
			* <li>空仓队列：移除 matched 元素，从尾部递减 step 补充等量新元素，重新降序排序</li>
			* <li>多仓队列：<b>不再更新</b>（队列转移逻辑已移除）</li>
			* <li>保证金检查 → 不安全则跳过挂单（队列照常更新），安全则继续</li>
			* <li>挂新空仓条件单（触发价 = newShortFirst，rule=NUMBER_2，止盈 = newShortFirst − step，
			* orderId → 止盈价存入 currentShortOrderIds）</li>
			* <li>多仓条件单守卫：newLongFirst = newShortFirst + step × 2，
			* 若 newLongFirst < longEntryPrice → 挂多仓条件单（止盈 = newLongFirst + step，
			* orderId → 止盈价存入 currentLongOrderIds）</li>
			* </ol>
			* 条件单成交后由 {@link #onOrderUpdate} 匹配止盈价并挂止盈条件单。
			* 反向条件单不再在此处理，改为在 {@link #onPositionUpdate} 仓位净减少时触发。
			*
			* @param currentPrice 当前 K 线收盘价（最新成交价）
			*/

			private void processShortGrid(BigDecimal currentPrice) {
			List<BigDecimal> matched = new ArrayList<>();
			synchronized (shortPriceQueue) {
			for (BigDecimal p : shortPriceQueue) {
			if (p.compareTo(currentPrice) > 0) {
			matched.add(p);
			} else {
			BigDecimal matched = BigDecimal.ZERO;
			synchronized (totalLongPriceQueue) {
			for (BigDecimal p : totalLongPriceQueue) {
			if (p.compareTo(currentPrice) >= 0) {
			matched = p;
			break;
			}
			}
			}
			if (matched.isEmpty()) {
			return;
			}
			log.info("[Gate] 空仓队列触发, 匹配{}个元素, 当前价:{}", matched.size(), 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(1, RoundingMode.HALF_UP);
			shortPriceQueue.add(min);
			// log.info("[Gate-1] 多仓仓位归零空仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
			if (BigDecimal.ZERO.compareTo( matched) == 0) {
			return;
			}
			shortPriceQueue.sort((a, b) -> b.compareTo(a));
			}

			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(1, RoundingMode.HALF_UP);
			longPriceQueue.add(elem);
			}
			longPriceQueue.sort(BigDecimal::compareTo);
			while (longPriceQueue.size() > config.getGridQueueSize()) {
			longPriceQueue.remove(longPriceQueue.size() - 1);
			}
			}
			GridElement matchedUpGridElement = GridElement.findByPrice(matched);
			if (matchedUpGridElement != null){
			if (!matchedUpGridElement.isHasLongOrder()){
			Integer upId = matchedUpGridElement.getUpId();
			GridElement newEntryGrid = GridElement.findById(upId);

			if (!isMarginSafe()) {
			log.warn("[Gate] 保证金超限，跳过挂条件单");
			} else {
			if (newEntryGrid != null) {
			// log.info("[Gate-2] 多仓仓位归零空仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
			if (!newEntryGrid.isHasLongOrder()) {
			BigDecimal triggerPrice = newEntryGrid.getGridPrice();
			String size = config.getBaseQuantity();
			log.info("[Gate] 多仓仓位归零 gridId:{}, 挂{}基础张多单",
			newEntryGrid.getId(), size);
			newEntryGrid.getLongTraderParam().setQuantity(size);
			placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
			}

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

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

			if (!UpGridElement.isHasShortOrder()) {

			//挂空仓条件单
			TraderParam upShortTraderParam = UpGridElement.getShortTraderParam();
			executor.placeConditionalEntryOrder(
			upShortTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			negate(upShortTraderParam.getQuantity()),
			orderId ->
			{
			shortEntryTraderIdParam(
			UpGridElement,
			orderId,
			true
			);
			},
			null
			);
			GridElement cancelGridElement = GridElement.findById(newEntryGrid.getUpId());
			if (cancelGridElement != null && cancelGridElement.isHasLongOrder()) {
			String longOrderId = cancelGridElement.getLongOrderId();
			executor.cancelConditionalOrder(longOrderId, oid -> {
			longEntryTraderIdParam(cancelGridElement, null, false);
			log.info("[Gate] 多仓仓位归零, 取消gridId:{}的多单,{}", cancelGridElement.getId(),longOrderId);
			});
			}
			}
			}
			}



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

			TraderParam downLongTraderParam = downGridElement.getLongTraderParam();
			if (!downGridElement.isHasShortOrder()){
			executor.placeConditionalEntryOrder(
			downLongTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			downLongTraderParam.getQuantity(),
			orderId ->
			{
			longEntryTraderIdParam(
			downGridElement,
			orderId,
			true
			);
			},
			null
			);
			}

			TraderParam downShortTraderParam = downGridElement.getShortTraderParam();
			BigDecimal downGridPrice = downGridElement.getGridPrice();
			if (
			!downGridElement.isHasShortOrder() &&
			downGridPrice.compareTo(longEntryPrice) <= 0 &&
			downGridPrice.compareTo(shortEntryPrice) >= 0
			){
			executor.placeConditionalEntryOrder(
			downShortTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			negate(downShortTraderParam.getQuantity()),
			orderId ->
			{
			shortEntryTraderIdParam(
			downGridElement,
			orderId,
			true
			);
			},
			null
			);

			}
			}

			}

			}

			/**
			* 多仓网格处理（当前价涨破多仓队列元素）。
			*
			* <h3>匹配规则</h3>
			* 遍历多仓队列（升序排列，小→大），收集所有小于当前价的元素为 matched。
			* 升序排列保证一旦遇到 price ≥ currentPrice 即可停止遍历。
			*
			* <h3>执行流程</h3>
			* <ol>
			* <li>匹配队列元素 → 为空则直接返回，不触发</li>
			* <li>多仓队列：移除 matched 元素，从尾部递增 step 补充等量新元素，重新升序排序</li>
			* <li>空仓队列：<b>不再更新</b>（队列转移逻辑已移除）</li>
			* <li>保证金检查 → 不安全则跳过挂单（队列照常更新），安全则继续</li>
			* <li>挂新多仓条件单（触发价 = newLongFirst，rule=NUMBER_1，止盈 = newLongFirst + step，
			* orderId → 止盈价存入 currentLongOrderIds）</li>
			* <li>空仓条件单守卫：newShortFirst = newLongFirst − step × 2，
			* 若 newShortFirst > shortEntryPrice → 挂空仓条件单（止盈 = newShortFirst − step，
			* orderId → 止盈价存入 currentShortOrderIds）</li>
			* </ol>
			* 条件单成交后由 {@link #onOrderUpdate} 匹配止盈价并挂止盈条件单。
			* 反向条件单不再在此处理，改为在 {@link #onPositionUpdate} 仓位净减少时触发。
			*
			* @param currentPrice 当前 K 线收盘价（最新成交价）
			*/
			private void processLongGrid(BigDecimal currentPrice) {
			List<BigDecimal> matched = new ArrayList<>();
			synchronized (longPriceQueue) {
			for (BigDecimal p : longPriceQueue) {
			if (p.compareTo(currentPrice) < 0) {
			matched.add(p);
			} else {
			BigDecimal matched = BigDecimal.ZERO;
			synchronized (totalShortPriceQueue) {
			for (BigDecimal p : totalShortPriceQueue) {
			if (p.compareTo(currentPrice) <= 0) {
			matched = p;
			break;
			}
			}
			// log.info("[Gate-3] 空仓仓位归零多仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
			if (BigDecimal.ZERO.compareTo( matched) == 0) {
			return;
			}

			GridElement matchedUpGridElement = GridElement.findByPrice(matched);
			if (matchedUpGridElement != null){
			if(!matchedUpGridElement.isHasShortOrder()){
			Integer downId = matchedUpGridElement.getDownId();
			GridElement newEntryGrid = GridElement.findById(downId);

			if (newEntryGrid != null) {
			// log.info("[Gate-4] 空仓仓位归零多仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
			if (!newEntryGrid.isHasShortOrder()){
			BigDecimal triggerPrice = newEntryGrid.getGridPrice();
			String size = config.getBaseQuantity();
			log.info("[Gate] 空仓仓位归零 gridId:{}, 挂{}基础张多单",
			newEntryGrid.getId(), size);
			newEntryGrid.getShortTraderParam().setQuantity(size);
			placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
			}

			GridElement cancelGridElement = GridElement.findById(newEntryGrid.getDownId());
			/**
			* 看是否有空仓挂单，有就取消
			*/
			if (cancelGridElement != null && cancelGridElement.isHasShortOrder()) {
			String shortOrderId = cancelGridElement.getShortOrderId();
			executor.cancelConditionalOrder(shortOrderId, oid -> {
			shortEntryTraderIdParam(cancelGridElement, null, false);
			log.info("[Gate] 空仓仓位归零, 取消gridId:{}的多单{}", cancelGridElement.getId(),shortOrderId);
			});
			}

			}
			}
			}
			}
			if (matched.isEmpty()) {
			}

			private void handleLongStopLossTriggered(GridElement gridElement) {
			gridElement.setLongStopLossOrderId(null);

			int gridId = gridElement.getId();
			log.info("[Gate] 多仓止损触发 gridId:{}, 开始追单", gridId);
			int newEntryGridId = gridId + 1;

			GridElement newEntryGrid = GridElement.findById(newEntryGridId);
			if (newEntryGrid == null) {
			log.warn("[Gate] 多仓止损触发 but gridId:{} 不存在", newEntryGridId);
			GridElement.refreshIndices();
			return;
			}

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

			/**
			* 匹配到元素后，
			* 多仓队列更新
			* 空仓队列更新
			*/
			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(1, RoundingMode.HALF_UP);
			longPriceQueue.add(max);
			}
			longPriceQueue.sort(BigDecimal::compareTo);
			BigDecimal baseQuantity = new BigDecimal(config.getBaseQuantity());
			BigDecimal subtract = baseQuantity.subtract(longPositionSize);
			String size = new BigDecimal(config.getQuantity()).add(new BigDecimal(config.getQuantity())).toString();
			if (subtract.compareTo(BigDecimal.ZERO) > 0){
			size = subtract.add(new BigDecimal(config.getQuantity())).toString();
			}
			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(1, RoundingMode.HALF_UP);
			shortPriceQueue.add(elem);
			}
			shortPriceQueue.sort((a, b) -> b.compareTo(a));
			while (shortPriceQueue.size() > config.getGridQueueSize()) {
			shortPriceQueue.remove(shortPriceQueue.size() - 1);
			}
			log.info("[Gate] 多仓止损触发 gridId:{}, 在gridId:{}挂{}基础张多单",
			gridId, newEntryGridId, size);

			newEntryGrid.getLongTraderParam().setQuantity(size);
			placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_1, size);


			int cancelGridId = gridId + 2;
			GridElement cancelGrid = GridElement.findById(cancelGridId);
			if (cancelGrid != null && cancelGrid.isHasLongOrder()) {
			executor.cancelConditionalOrder(cancelGrid.getLongOrderId(), oid -> {
			longEntryTraderIdParam(cancelGrid, null, false);
			log.info("[Gate] 多仓止损触发, 取消gridId:{}的多单", cancelGridId);
			});
			}

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

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

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

			if (!UpGridElement.isHasLongOrder()) {
			//挂多仓条件单
			TraderParam upLongTraderParam = UpGridElement.getLongTraderParam();
			executor.placeConditionalEntryOrder(
			upLongTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			config.getQuantity(),
			orderId ->
			{
			longEntryTraderIdParam(
			UpGridElement,
			orderId,
			true
			);
			},
			null
			);
			// 止损触发时，取消最远的多仓止盈订单
			GridElement farthestLongTp = null;
			for (GridElement e : config.getGridElements()) {
			if (e.getLongTakeProfitOrderId() != null) {
			if (farthestLongTp == null \|\| e.getGridPrice().compareTo(farthestLongTp.getGridPrice()) > 0) {
			farthestLongTp = e;
			}
			}



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

			TraderParam shortTraderParam = downGridElement.getShortTraderParam();
			if (!downGridElement.isHasShortOrder()){
			executor.placeConditionalEntryOrder(
			shortTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			negate(config.getQuantity()),
			orderId ->
			{
			shortEntryTraderIdParam(
			downGridElement,
			orderId,
			true
			);
			},
			null
			);
			}

			TraderParam downLongTraderParam = downGridElement.getLongTraderParam();
			BigDecimal downGridPrice = downGridElement.getGridPrice();
			if (
			!downGridElement.isHasLongOrder() &&
			downGridPrice.compareTo(longEntryPrice) <= 0 &&
			downGridPrice.compareTo(shortEntryPrice) >= 0
			){
			executor.placeConditionalEntryOrder(
			downLongTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			config.getQuantity(),
			orderId ->
			{
			longEntryTraderIdParam(
			downGridElement,
			orderId,
			true
			);
			},
			null
			);

			}
			}

			}

			if (farthestLongTp != null) {
			String tpOrderId = farthestLongTp.getLongTakeProfitOrderId();
			GridElement finalFarthestLongTp = farthestLongTp;
			executor.cancelConditionalOrder(tpOrderId, oid -> {
			longTakeProfitTraderIdParam(finalFarthestLongTp, null, false);
			log.info("[Gate] 多仓止损触发, 取消最远止盈 gridId:{}, orderId:{}", finalFarthestLongTp.getId(), tpOrderId);
			});
			}
			}

			// ---- 保证金安全阀 ----
			private void handleShortStopLossTriggered(GridElement gridElement) {
			gridElement.setShortStopLossOrderId(null);

			/**
			* 保证金安全阀检查。
			*
			* <p>实时查询当前保证金占用额（positionInitialMargin），计算其占初始本金的比例。
			* 比例 ≥ marginRatioLimit（默认 20%）时拒绝开仓，但仍照常更新队列。
			*
			* <p>查询失败时默认放行（返回 true），避免因 REST API 异常导致策略完全停滞。
			*
			* @return true=安全可开仓 / false=保证金超限跳过开仓
			*/
			private boolean isMarginSafe() {
			try {
			FuturesAccount account = futuresApi.listFuturesAccounts(SETTLE);
			BigDecimal margin = new BigDecimal(account.getPositionInitialMargin());
			BigDecimal ratio = margin.divide(initialPrincipal, 4, RoundingMode.HALF_UP);
			log.debug("[Gate] 保证金比例: {}/{}={}", margin, initialPrincipal, ratio);
			return ratio.compareTo(config.getMarginRatioLimit()) < 0;
			} catch (Exception e) {
			log.warn("[Gate] 查保证金失败，默认放行", e);
			return true;
			int gridId = gridElement.getId();
			log.info("[Gate] 空仓止损触发 gridId:{}, 开始追单", gridId);
			int newEntryGridId = gridId - 1;

			GridElement newEntryGrid = GridElement.findById(newEntryGridId);
			if (newEntryGrid == null) {
			log.warn("[Gate] 空仓止损触发 but gridId:{} 不存在", newEntryGridId);
			GridElement.refreshIndices();
			return;
			}

			BigDecimal triggerPrice = newEntryGrid.getGridPrice();

			BigDecimal baseQuantity = new BigDecimal(config.getBaseQuantity());
			BigDecimal subtract = baseQuantity.subtract(shortPositionSize);

			String size = new BigDecimal(config.getQuantity()).add(new BigDecimal(config.getQuantity())).toString();
			if (subtract.compareTo(BigDecimal.ZERO) > 0){
			size = subtract.add(new BigDecimal(config.getQuantity())).toString();
			}
			log.info("[Gate] 空仓止损触发 gridId:{}, 在gridId:{}挂{}基础张空单",
			gridId, newEntryGridId, size);
			newEntryGrid.getShortTraderParam().setQuantity(size);
			placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));


			int cancelGridId = gridId - 2;
			GridElement cancelGrid = GridElement.findById(cancelGridId);
			if (cancelGrid != null && cancelGrid.isHasShortOrder()) {
			executor.cancelConditionalOrder(cancelGrid.getShortOrderId(), oid -> {
			shortEntryTraderIdParam(cancelGrid, null, false);
			log.info("[Gate] 空仓止损触发, 取消gridId:{}的空单", cancelGridId);
			});
			}

			// 止损触发时，取消最远的空仓止盈订单
			GridElement farthestShortTp = null;
			for (GridElement e : config.getGridElements()) {
			if (e.getShortTakeProfitOrderId() != null) {
			if (farthestShortTp == null \|\| e.getGridPrice().compareTo(farthestShortTp.getGridPrice()) < 0) {
			farthestShortTp = e;
			}
			}
			}
			if (farthestShortTp != null) {
			String tpOrderId = farthestShortTp.getShortTakeProfitOrderId();
			GridElement finalFarthestShortTp = farthestShortTp;
			executor.cancelConditionalOrder(tpOrderId, oid -> {
			shortTakeProfitTraderIdParam(finalFarthestShortTp, null, false);
			log.info("[Gate] 空仓止损触发, 取消最远止盈 gridId:{}, orderId:{}", finalFarthestShortTp.getId(), tpOrderId);
			});
			}
			}

			private void extendLongStopLoss(int filledQty,int gridId) {
			int furthestSlId = 0;
			for (GridElement e : config.getGridElements()) {
			if (e.getLongStopLossOrderId() != null && e.getId() < furthestSlId) {
			furthestSlId = e.getId();
			}
			}
			if (furthestSlId == 0) {
			furthestSlId = gridId;
			}
			log.info("[Gate] 多仓追挂止损, 当前最远止损gridId:{}, 追加{}张", furthestSlId, filledQty);
			for (int i = 0; i < filledQty; i++) {
			int newSlId = furthestSlId - i - 1;
			GridElement elem = GridElement.findById(newSlId);
			if (elem == null) {
			continue;
			}
			BigDecimal triggerPrice = elem.getGridPrice();
			int finalSlId = newSlId;
			executor.placeTakeProfit(
			triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			ORDER_TYPE_CLOSE_LONG,
			negate(config.getQuantity()),
			profitId -> {
			elem.setLongStopLossOrderId(profitId);
			GridElement.refreshIndices();
			log.info("[Gate] 多仓止损追加, gridId:{}, 触发价:{}, stopLossId:{}", finalSlId, triggerPrice, profitId);
			}
			);
			}
			}

			private void extendShortStopLoss(int filledQty, int gridId) {
			int furthestSlId = 0;
			for (GridElement e : config.getGridElements()) {
			if (e.getShortStopLossOrderId() != null && e.getId() > furthestSlId) {
			furthestSlId = e.getId();
			}
			}
			if (furthestSlId == 0) {
			furthestSlId = gridId;
			}
			log.info("[Gate] 空仓追挂止损, 当前最远止损gridId:{}, 追加{}张", furthestSlId, filledQty);
			for (int i = 0; i < filledQty; i++) {
			int newSlId = furthestSlId + i + 1;
			GridElement elem = GridElement.findById(newSlId);
			if (elem == null) {
			continue;
			}
			BigDecimal triggerPrice = elem.getGridPrice();
			int finalSlId = newSlId;
			executor.placeTakeProfit(
			triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			ORDER_TYPE_CLOSE_SHORT,
			config.getQuantity(),
			profitId -> {
			elem.setShortStopLossOrderId(profitId);
			GridElement.refreshIndices();
			log.info("[Gate] 空仓止损追加, gridId:{}, 触发价:{}, stopLossId:{}", finalSlId, triggerPrice, profitId);
			}
			);
			}
			}

			@@ -1226,6 +1288,50 @@
			*/
			private String negate(String qty) {
			return qty.startsWith("-") ? qty.substring(1) : "-" + qty;
			}

			/**
			* 预设标志位后提交条件开仓单，防止异步回调导致的竞态重复挂单。
			*
			* <p>在调用 {@link GateTradeExecutor#placeConditionalEntryOrder} 之前同步设置
			* {@code isHasLongOrder / isHasShortOrder}，关闭 WS 线程与 Executor 线程之间的
			* 检查-下单时间窗口。API 失败时自动回滚标志位。
			*
			* @param gridElement 目标网格元素
			* @param isLong true=多仓下单，false=空仓下单
			* @param triggerPrice 触发价
			* @param rule 触发规则
			* @param size 开仓张数
			*/
			private void placeEntryOrderWithPreFlag(GridElement gridElement, boolean isLong,
			BigDecimal triggerPrice,
			FuturesPriceTrigger.RuleEnum rule,
			String size) {
			if (isLong) {
			gridElement.setHasLongOrder(true);
			} else {
			gridElement.setHasShortOrder(true);
			}
			executor.placeConditionalEntryOrder(triggerPrice, rule, size,
			orderId -> {
			if (isLong) {
			longEntryTraderIdParam(gridElement, orderId, true);
			} else {
			shortEntryTraderIdParam(gridElement, orderId, true);
			}
			},
			() -> {
			if (isLong) {
			gridElement.setHasLongOrder(false);
			gridElement.setLongOrderId(null);
			} else {
			gridElement.setHasShortOrder(false);
			gridElement.setShortOrderId(null);
			}
			GridElement.refreshIndices();
			log.warn("[Gate] 条件单创建失败，回滚标志位 gridId:{}, isLong:{}", gridElement.getId(), isLong);
			}
			);
			}

			/**
			@@ -1285,4 +1391,6 @@
			public Long getUserId() { return userId; }
			/** @return 当前策略状态 */
			public StrategyState getState() { return state; }
			/** 注入WS客户端，用于订阅状态检查 */
			public void setWsClient(GateKlineWebSocketClient wsClient) { this.wsClient = wsClient; }
			}