exchange.git - Gitblit

			@@ -1,6 +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;
			@@ -12,12 +14,8 @@
			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 java.util.concurrent.atomic.AtomicInteger;

			import com.xcong.excoin.modules.gateApi.wsHandler.handler.CandlestickChannelHandler;
			import com.xcong.excoin.modules.gateApi.wsHandler.handler.PositionClosesChannelHandler;
			@@ -105,6 +103,8 @@
			private static final String ORDER_TYPE_CLOSE_SHORT = "plan-close-short-position";

			private final GateConfig config;
			private final StatsEventProducer statsProducer;
			private String apiKeyMd5;
			private final GateTradeExecutor executor;
			private final FuturesApi futuresApi;
			private static final String SETTLE = "usdt";
			@@ -115,6 +115,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<>());
			@@ -135,6 +137,18 @@
			/** 多头是否活跃（有仓位） */
			private volatile boolean longActive = false;

			/** 当前已完成轮数，每次盈利重启时+1 */
			private volatile int currentRound = 0;

			/** 多头累计止损次数（始终递增，加仓订单成交后归零） */
			private volatile int accumulatedLongLossCount = 0;
			/** 空头累计止损次数（始终递增，加仓订单成交后归零） */
			private volatile int accumulatedShortLossCount = 0;
			/** 最近触发止损的多头网格ID */
			private volatile int lastLongStopLossGridId = Integer.MAX_VALUE;
			/** 最近触发止损的空头网格ID */
			private volatile int lastShortStopLossGridId = Integer.MAX_VALUE;

			private volatile BigDecimal lastKlinePrice;
			private volatile BigDecimal markPrice = BigDecimal.ZERO;
			private volatile BigDecimal cumulativePnl = BigDecimal.ZERO;
			@@ -145,9 +159,13 @@
			private volatile BigDecimal shortPositionSize = BigDecimal.ZERO;
			private Long userId;
			private volatile BigDecimal initialPrincipal = BigDecimal.ZERO;
			/** 上次 PNL 快照时间（毫秒），用于控制 PNL_SNAPSHOT 埋点频率 */
			private volatile long lastPnlSnapshotTime = 0;
			private volatile GateKlineWebSocketClient wsClient;

			public GateGridTradeService(GateConfig config) {
			public GateGridTradeService(GateConfig config, StatsEventProducer statsProducer) {
			this.config = config;
			this.statsProducer = statsProducer;
			ApiClient apiClient = new ApiClient();
			apiClient.setBasePath(config.getRestBasePath());
			apiClient.setApiKeySecret(config.getApiKey(), config.getApiSecret());
			@@ -277,6 +295,44 @@
			}
			}

			// ---- 埋点 ----

			private String apiKeyMd5() {
			if (apiKeyMd5 == null) {
			try {
			java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
			byte[] digest = md.digest(config.getApiKey().getBytes(java.nio.charset.StandardCharsets.UTF_8));
			StringBuilder sb = new StringBuilder();
			for (byte b : digest) sb.append(String.format("%02x", b));
			apiKeyMd5 = sb.toString();
			} catch (Exception e) {
			apiKeyMd5 = Integer.toHexString(config.getApiKey().hashCode());
			}
			}
			return apiKeyMd5;
			}

			private void emitStats(String type, Object payload) {
			if (statsProducer == null) return;
			try {
			statsProducer.sendStats(statsProducer.newStats(type, apiKeyMd5(), payload));
			} catch (Exception e) {
			log.warn("[Gate] 埋点发送失败, type={}", type, e);
			}
			}

			/**
			* Java 8 兼容的 Map 构造工具（Map.of 为 Java 9 API，此处手动实现）。
			* 接受偶数个参数：key1, value1, key2, value2, ...
			*/
			private static Map<String, Object> mapOf(Object... kv) {
			Map<String, Object> m = new LinkedHashMap<>();
			for (int i = 0; i < kv.length; i += 2) {
			m.put((String) kv[i], kv[i + 1]);
			}
			return m;
			}

			// ---- 启动/停止 ----

			/**
			@@ -300,11 +356,40 @@
			baseShortOpened = false;
			longActive = false;
			shortActive = false;
			accumulatedLongLossCount = 0;
			accumulatedShortLossCount = 0;
			lastLongStopLossGridId = Integer.MAX_VALUE;
			lastShortStopLossGridId = Integer.MAX_VALUE;
			shortPriceQueue.clear();
			longPriceQueue.clear();
			totalShortPriceQueue.clear();
			totalLongPriceQueue.clear();
			currentLongOrderIds.clear();
			currentShortOrderIds.clear();
			log.info("[Gate] 网格策略已启动");
			// 每次重启重新获取当前本金
			refreshInitialPrincipal();
			currentRound = 0;

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

			// 埋点: STRATEGY_START — 附全量配置快照
			GateConfigDTO snapshot = GateConfigDTO.from(config);
			Map<String, Object> params = snapshot.toParamsMap();
			params.put("principal", initialPrincipal.toPlainString());
			params.put("contract", config.getContract());
			emitStats("STRATEGY_START", params);
			}

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

			/**
			@@ -313,7 +398,16 @@
			*/
			public void stopGrid() {
			state = StrategyState.STOPPED;

			// 埋点: STRATEGY_STOP
			emitStats("STRATEGY_STOP", mapOf(
			"reason", "manual",
			"rounds", currentRound,
			"pnl", cumulativePnl.toPlainString()
			));

			executor.cancelAllPriceTriggeredOrders();
			closeExistingPositions();
			executor.shutdown();
			log.info("[Gate] 策略已停止, 累计盈亏: {}", cumulativePnl);
			}
			@@ -339,37 +433,135 @@
			* @param closePrice K 线收盘价（即当前最新成交价）
			*/
			public void onKline(BigDecimal closePrice) {

			// log.info("当前价：{}", 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) {
			// 异步检查盈亏，避免 REST 调用阻塞 WS 心跳导致 Socket closed
			executor.submitTask(this::checkProfitAndReset);

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


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

			/** Gate 永续合约 taker 费率 0.05% */
			private static final BigDecimal TAKER_FEE_RATE = new BigDecimal("0.001");
			private void checkProfitAndReset() {
			if (state == StrategyState.STOPPED \|\| state == StrategyState.WAITING_KLINE) {
			return;
			}
			processLongGrid(closePrice);
			processShortGrid(closePrice);
			try {

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

			FuturesAccount account = futuresApi.listFuturesAccounts(SETTLE);
			// 预估平仓手续费 = 持仓量 × 合约乘数 × 入场价 × taker费率
			BigDecimal multiplier = config.getContractMultiplier();
			BigDecimal longCloseFee = BigDecimal.ZERO;
			if (longPositionSize.compareTo(BigDecimal.ZERO) > 0 && longEntryPrice.compareTo(BigDecimal.ZERO) > 0) {
			longCloseFee = longPositionSize.multiply(multiplier).multiply(longEntryPrice).multiply(TAKER_FEE_RATE);
			}
			BigDecimal shortCloseFee = BigDecimal.ZERO;
			if (shortPositionSize.compareTo(BigDecimal.ZERO) > 0 && shortEntryPrice.compareTo(BigDecimal.ZERO) > 0) {
			shortCloseFee = shortPositionSize.multiply(multiplier).multiply(shortEntryPrice).multiply(TAKER_FEE_RATE);
			}
			BigDecimal estimatedCloseFee = longCloseFee.add(shortCloseFee);

			BigDecimal totalEquity = new BigDecimal(account.getTotal())
			.add(new BigDecimal(account.getUnrealisedPnl()))
			.subtract(estimatedCloseFee);

			// 埋点: PNL_SNAPSHOT — 每60秒发射一次
			long now = System.currentTimeMillis();
			if (now - lastPnlSnapshotTime >= 60_000) {
			lastPnlSnapshotTime = now;
			BigDecimal total = new BigDecimal(account.getTotal());
			emitStats("PNL_SNAPSHOT", mapOf(
			"cumulativePnl", cumulativePnl.toPlainString(),
			"unrealizedPnl", new BigDecimal(account.getUnrealisedPnl()).toPlainString(),
			"totalEquity", total.toPlainString(),
			"markPrice", markPrice.toPlainString()
			));
			}

			if (totalEquity.compareTo(target) > 0) {
			currentRound++;

			// 埋点: ROUND_COMPLETE
			emitStats("ROUND_COMPLETE", mapOf(
			"roundNum", currentRound,
			"totalEquity", totalEquity.toPlainString()
			));

			int maxRounds = config.getRounds();
			log.info("[Gate] 盈亏达标(净权益{}→含手续费-{}=实际{}>目标{})，第{}轮完成",
			new BigDecimal(account.getTotal()).add(new BigDecimal(account.getUnrealisedPnl())),
			estimatedCloseFee, totalEquity, target, currentRound);

			if (maxRounds > 0 && currentRound >= maxRounds) {
			log.info("[Gate] 已达到运行轮数上限({})，策略停止", maxRounds);
			stopGrid();
			return;
			}

			log.info("[Gate] 重置策略，开始第{}轮...", currentRound);
			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() 会将 currentRound 归零，这里需要保留
			int savedRound = currentRound;
			startGrid();
			currentRound = savedRound;
			});
			}
			} catch (Exception e) {
			log.warn("[Gate] 盈亏检查失败", e);
			}
			}

			// ---- 仓位推送回调 ----
			@@ -384,7 +576,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>
			@@ -404,73 +595,72 @@
			}

			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;
			//取消多仓位线以上的开空仓挂单
			List<GridElement> allShortOrders = GridElement.findAllShortOrders(longEntryPrice);
			if (CollUtil.isNotEmpty(allShortOrders)){
			for (GridElement e : allShortOrders) {
			executor.cancelOrder(
			e.getShortOrderId(),
			orderId -> {
			shortEntryTraderIdParam(
			e,
			null,
			false
			);
			}
			);
			}
			}
			}
			} 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();
			//取消空仓仓位线以下的开多仓挂单
			List<GridElement> allLongOrders = GridElement.findAllLongOrders(shortEntryPrice);
			if (CollUtil.isNotEmpty(allLongOrders)){
			for (GridElement e : allLongOrders) {
			executor.cancelOrder(
			e.getLongOrderId(),
			orderId -> {
			shortEntryTraderIdParam(
			e,
			null,
			false
			);
			}
			);
			}
			}
			}
			} 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(); }
			int savedRound = currentRound;
			startGrid();
			currentRound = savedRound;
			});
			log.info("[Gate] 重置策略");
			return;
			}
			}

			@@ -492,134 +682,19 @@
			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 在收到订单更新推送时调用。
			*
			* <h3>处理逻辑</h3>
			* 当订单状态为 finished 且 finish_as 为 filled 时，
			* 从 {@link #currentLongOrderIds} / {@link #currentShortOrderIds} 中匹配订单ID，
			* 取出止盈价格并挂止盈单。匹配成功后从 Map 中移除该条目，防止重复挂单。
			*
			* @param orderId 订单 ID
			* @param status 订单状态（open / finished）
			* @param finishAs 订单结束方式（filled / cancelled / ioc 等）
			*/
			public void onOrderUpdate(String orderId, String status, String finishAs) {
			if (!"finished".equals(status) \|\| !"filled".equals(finishAs)) {
			return;
			}

			/**
			* 匹配止盈单止盈
			*/
			GridElement byLongTakeProfitOrderId = GridElement.findByLongTakeProfitOrderId(orderId);
			if (byLongTakeProfitOrderId != null){
			longTakeProfitTraderIdParam(
			byLongTakeProfitOrderId,
			null,
			false
			);
			longEntryTraderIdParam(
			byLongTakeProfitOrderId,
			null,
			false
			);
			}
			GridElement byShortTakeProfitOrderId = GridElement.findByShortTakeProfitOrderId(orderId);
			if (byShortTakeProfitOrderId != null){
			shortTakeProfitTraderIdParam(
			byShortTakeProfitOrderId,
			null,
			false
			);
			shortEntryTraderIdParam(
			byShortTakeProfitOrderId,
			null,
			false
			);
			}

			/**
			* 匹配挂单
			*/
			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()){
			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());
			}
			}
			}
			}
			}

			/**
			* 用户私有成交回调。由 {@link com.xcong.excoin.modules.gateApi.wsHandler.handler.UserTradesChannelHandler}
			* 在收到 {@code futures.usertrades} 推送时调用。
			*
			* @param contract 合约名称
			* @param orderId 订单 ID
			* @param price 成交价格
			* @param size 成交数量
			* @param role 用户角色（maker / taker）
			* @param fee 手续费
			*/
			public void onUserTrade(String contract, String orderId, BigDecimal price, String size, String role, BigDecimal fee) {
			if (state == StrategyState.STOPPED) {
			return;
			}
			log.info("[Gate] 成交明细, 合约:{}, 订单ID:{}, 价格:{}, 数量:{}, 角色:{}, 手续费:{}",
			contract, orderId, price, size, role, fee);
			}

			/**
			* 自动订单（条件单）状态变更回调。
			@@ -631,7 +706,7 @@
			* @param reason 变更原因
			* @param orderType 订单类型（plan-close-long-position 等）
			*/
			public void onAutoOrder(String orderId, String status, String reason, String orderType) {
			public void onAutoOrder(String orderId, String status, String reason, String orderType, String tradeId) {
			if (state == StrategyState.STOPPED) {
			return;
			}
			@@ -641,84 +716,143 @@
			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 && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
			handleLongStopLossTriggered(longStopLossElem, orderId);
			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 && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
			handleShortStopLossTriggered(shortStopLossElem, orderId);
			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()){
			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());
			if (StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0") ){
			int filledQty = Integer.parseInt(shortGridElement.getShortTraderParam().getQuantity());
			shortEntryTraderIdParam(shortGridElement, orderId, false);

			// 埋点: ENTRY_FILLED — 空仓加仓成交
			emitStats("ENTRY_FILLED", mapOf(
			"direction", "short",
			"gridId", shortGridElement.getId(),
			"filledQty", filledQty
			));

			// 防重入：同一网格存在多个入场单且相近时间成交时，只处理第一次 extend，
			// 后续成交打标 pendingReExtend，延展完成后自动用最新仓位重挂一次。
			if (shortGridElement.isExtendStopLossInProgress()) {
			shortGridElement.setPendingStopLossReExtend(true);
			log.info("[Gate] 空单成交 gridId:{}, 止损追单已在进行中，标记待重挂, orderId:{}",
			shortGridElement.getId(), orderId);
			return;
			}
			shortGridElement.setExtendStopLossInProgress(true);

			lastShortStopLossGridId = Integer.MAX_VALUE;
			// [Gate-需求2] 加仓后先撤空仓所有止盈+止损，再查交易所持仓后重挂
			cancelAllShortTakeProfitsAndStopLosses();
			// REST 查询可能因交易所延迟返回旧值，与 WS 本地缓存取最大值兜底
			int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue());
			extendShortStopLoss(posSize, shortGridElement.getId());
			// [Gate] 止盈挂单：超出基础仓位的部分，挂在多仓第一止损位
			if (config.isPlaceExcessTakeProfit()) {
			placeExcessTakeProfit(posSize, false);
			}
			log.info("[Gate] 空单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);



			}
			}
			GridElement longGridElement = GridElement.findByLongOrderId(orderId);
			if (longGridElement != null) {
			if (StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")){

			int filledQty = Integer.parseInt(longGridElement.getLongTraderParam().getQuantity());
			longEntryTraderIdParam(longGridElement, orderId, false);

			// 埋点: ENTRY_FILLED — 多仓加仓成交
			emitStats("ENTRY_FILLED", mapOf(
			"direction", "long",
			"gridId", longGridElement.getId(),
			"filledQty", filledQty
			));

			// 防重入：同一网格存在多个入场单且相近时间成交时，只处理第一次 extend，
			// 后续成交打标 pendingReExtend，延展完成后自动用最新仓位重挂一次。
			if (longGridElement.isExtendStopLossInProgress()) {
			longGridElement.setPendingStopLossReExtend(true);
			log.info("[Gate] 多单成交 gridId:{}, 止损追单已在进行中，标记待重挂, orderId:{}",
			longGridElement.getId(), orderId);
			return;
			}
			longGridElement.setExtendStopLossInProgress(true);

			lastLongStopLossGridId = Integer.MAX_VALUE;
			// [Gate-需求2] 加仓后先撤多仓所有止盈+止损，再查交易所持仓后重挂
			cancelAllLongTakeProfitsAndStopLosses();
			// REST 查询可能因交易所延迟返回旧值，与 WS 本地缓存取最大值兜底
			int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue());
			extendLongStopLoss(posSize, longGridElement.getId());
			// [Gate] 止盈挂单：超出基础仓位的部分，挂在空仓第一止损位
			if (config.isPlaceExcessTakeProfit()) {
			placeExcessTakeProfit(posSize, true);
			}
			log.info("[Gate] 多单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);

			}
			}
			}


			/**
			* 查询交易所当前持仓张数（绝对值）。加仓/开仓后重挂止盈止损时调用，
			* 绕过本地 WS 推送缓存避免时序竞态，直接拿到交易所权威数据。
			*
			* @param mode 持仓模式（DUAL_LONG / DUAL_SHORT）
			* @return 持仓张数（绝对值），查询失败返回 0
			*/
			private int queryPositionSize(Position.ModeEnum mode) {
			Position p = queryPosition(mode);
			if (p != null) {
			return new BigDecimal(p.getSize()).abs().intValue();
			}
			return 0;
			}

			/**
			* 查询交易所当前持仓均价，绕过本地 WS 推送缓存避免时序竞态。
			*
			* @param mode 持仓模式（DUAL_LONG / DUAL_SHORT）
			* @return 持仓均价，无持仓或查询失败返回 BigDecimal.ZERO
			*/
			private BigDecimal queryEntryPrice(Position.ModeEnum mode) {
			Position p = queryPosition(mode);
			if (p != null && p.getEntryPrice() != null) {
			return new BigDecimal(p.getEntryPrice());
			}
			return BigDecimal.ZERO;
			}

			/**
			* 查询指定模式的持仓对象。
			*/
			private Position queryPosition(Position.ModeEnum mode) {
			try {
			List<Position> positions = futuresApi.listPositions(SETTLE).execute();
			if (positions != null) {
			for (Position p : positions) {
			if (mode == p.getMode() && config.getContract().equals(p.getContract())) {
			return p;
			}
			}
			}
			} catch (Exception e) {
			log.warn("[Gate] 查询{}持仓失败", mode, e);
			}
			return null;
			}

			// ---- 网格队列处理 ----
			@@ -733,94 +867,142 @@
			* 止盈价 = 触发价 − 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());
			baseGridElement.setHasLongOrder(true);
			//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位置的网格的空单止盈
			TraderParam baseShortTraderParam = config.getBaseShortTraderParam();
			baseGridElement.setShortOrderId(baseShortTraderParam.getEntryOrderId());
			baseGridElement.setHasShortOrder(true);
			BigDecimal downTakeProfitPrice = baseGridElement.getShortTraderParam().getTakeProfitPrice();
			executor.placeTakeProfit(
			downTakeProfitPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			ORDER_TYPE_CLOSE_SHORT,
			config.getQuantity(),
			profitId -> {
			shortTakeProfitTraderIdParam(
			baseGridElement,
			profitId,
			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);
			// // 空仓止损对应的多仓止盈：多仓止盈挂在ID=3
			// int tpGridIdLong = 3;
			// GridElement tpElemLong = GridElement.findById(tpGridIdLong);
			// BigDecimal triggerPriceLong = tpElemLong.getGridPrice();
			// String sizeLong = config.getBaseQuantity();
			// executor.placeTakeProfit(
			// triggerPriceLong,
			// FuturesPriceTrigger.RuleEnum.NUMBER_1,
			// ORDER_TYPE_CLOSE_LONG,
			// negate(sizeLong),
			// profitId -> {
			// tpElemLong.setLongTakeProfitOrderId(profitId);
			// GridElement.refreshIndices();
			// log.info("[Gate] 多仓止盈已挂(gridId:{}多止盈), 触发价:{}, takeProfitId:{}",
			// tpGridIdLong, triggerPriceLong, profitId);
			// }
			// );
			//
			//
			// // 多仓止损对应的空仓止盈：空仓止盈挂在ID=-3
			// int tpGridIdShort = -3;
			// GridElement tpElemShort = GridElement.findById(tpGridIdShort);
			// BigDecimal triggerPriceShort = tpElemShort.getGridPrice();
			// String sizeShort = config.getBaseQuantity();
			// executor.placeTakeProfit(
			// triggerPriceShort,
			// FuturesPriceTrigger.RuleEnum.NUMBER_2,
			// ORDER_TYPE_CLOSE_SHORT,
			// sizeShort,
			// profitId -> {
			// tpElemShort.setShortTakeProfitOrderId(profitId);
			// GridElement.refreshIndices();
			// log.info("[Gate] 空仓止盈已挂(gridId:{}空止盈), 触发价:{}, takeProfitId:{}",
			// tpGridIdShort, triggerPriceShort, profitId);
			// }
			// );

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

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

			state = StrategyState.ACTIVE;
			}
			@@ -854,8 +1036,14 @@
			TraderParam tp = baseElement.getLongTraderParam();
			tp.setEntryOrderId(entryId);
			tp.setEntryOrderPlaced(flag);
			baseElement.setHasLongOrder(flag);
			baseElement.setLongOrderId(entryId);
			if (flag && entryId != null) {
			baseElement.addLongOrderId(entryId);
			baseElement.setHasLongOrder(true);
			} else if (!flag && entryId != null) {
			baseElement.removeLongOrderId(entryId);
			// 只有列表全部清空才关闭预置标志，避免还有未成交挂单时被 processGrid 误判
			baseElement.setHasLongOrder(baseElement.hasLongOrderIds());
			}
			GridElement.refreshIndices();
			}

			@@ -865,8 +1053,14 @@
			TraderParam tp = baseElement.getShortTraderParam();
			tp.setEntryOrderId(entryId);
			tp.setEntryOrderPlaced(flag);
			baseElement.setHasShortOrder(flag);
			baseElement.setShortOrderId(entryId);
			if (flag && entryId != null) {
			baseElement.addShortOrderId(entryId);
			baseElement.setHasShortOrder(true);
			} else if (!flag && entryId != null) {
			baseElement.removeShortOrderId(entryId);
			// 只有列表全部清空才关闭预置标志，避免还有未成交挂单时被 processGrid 误判
			baseElement.setHasShortOrder(baseElement.hasShortOrderIds());
			}
			GridElement.refreshIndices();
			}

			@@ -878,12 +1072,17 @@
			*/
			private void generateShortQueue() {
			shortPriceQueue.clear();
			totalShortPriceQueue.clear();
			totalLongPriceQueue.clear();
			int prec = config.getPriceScale();
			BigDecimal step = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(prec, RoundingMode.HALF_UP);
			config.setStep(step);
			BigDecimal elem = shortBaseEntryPrice.subtract(step).setScale(prec, RoundingMode.HALF_UP);
			for (int i = 0; i < config.getGridQueueSize(); i++) {
			shortPriceQueue.add(elem);
			totalLongPriceQueue.add( elem);
			totalShortPriceQueue.add( elem);

			elem = elem.subtract(step).setScale(prec, RoundingMode.HALF_UP);
			if (elem.compareTo(BigDecimal.ZERO) <= 0) {
			break;
			@@ -905,10 +1104,16 @@
			BigDecimal elem = shortBaseEntryPrice.add(step).setScale(prec, RoundingMode.HALF_UP);
			for (int i = 0; i < config.getGridQueueSize(); i++) {
			longPriceQueue.add(elem);
			totalLongPriceQueue.add( elem);
			totalShortPriceQueue.add( elem);
			elem = elem.add(step).setScale(prec, RoundingMode.HALF_UP);
			}
			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);
			}

			/**
			@@ -931,8 +1136,8 @@
			int longSize = longPriceQueue.size();
			//根据精度转换成小数
			int prec = config.getPriceScale();
			BigDecimal minTick = BigDecimal.ONE.scaleByPowerOfTen(-prec);
			BigDecimal step = config.getStep().subtract(minTick);
			BigDecimal step = config.getStep();
			// String qty = config.getBaseQuantity();
			String qty = config.getQuantity();

			// 空仓队列：id 从 -1 自减, shortPriceQueue[i] → id=-(i+1)
			@@ -981,8 +1186,8 @@
			elements.add(GridElement.builder()
			.id(0)
			.gridPrice(price)
			.upId(shortSize > 0 ? 1 : null)
			.downId(longSize > 0 ? -1 : null)
			.upId(longSize > 0 ? 1 : null)
			.downId(shortSize > 0 ? -1 : null)
			.longTraderParam(longParam)
			.shortTraderParam(shortParam)
			.build());
			@@ -1020,298 +1225,738 @@
			log.info("[Gate] 网格元素列表已构建, 共{}个元素 (空仓:{} 位置:0 多仓:{})", elements.size(), shortSize, longSize);
			}


			private void processShortGrid(BigDecimal currentPrice) {
			int prec = config.getPriceScale();
			List<BigDecimal> matched = new ArrayList<>();
			synchronized (shortPriceQueue) {
			for (BigDecimal p : shortPriceQueue) {
			BigDecimal matched = BigDecimal.ZERO;
			synchronized (totalLongPriceQueue) {
			for (BigDecimal p : totalLongPriceQueue) {
			if (p.compareTo(currentPrice) >= 0) {
			matched.add(p);
			} else {
			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(prec, 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(prec, 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) {

			/**
			* 下一个开仓位置
			* 获取队列第一个元素的价格对应的网格
			* 判断网格是否能开空仓，如果不能则跳过
			* 前进方向挂空仓条件单
			* 后置方向挂多空条件单
			*/
			//下一个开仓位置
			BigDecimal newLongFirst = shortPriceQueue.get(0);
			GridElement UpGridElement = GridElement.findByPrice(newLongFirst);
			// String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()) + Integer.parseInt(config.getQuantity()));
			String quantity = String.valueOf(config.getBaseQuantity());
			// 向下检查是否已有多单挂在更低价格网格，有则跳过（防止价格回升后重复挂单）
			boolean hasLongOrderBelow = false;
			GridElement checkDownCursor = GridElement.findById(newEntryGrid.getDownId());
			while (checkDownCursor != null) {
			if (checkDownCursor.isHasLongOrder()) {
			hasLongOrderBelow = true;
			log.info("[Gate] 多仓仓位归零 gridId:{}, 下方gridId:{}已有多单, 跳过本次挂单",
			newEntryGrid.getId(), checkDownCursor.getId());
			break;
			}
			Integer nextDownId = checkDownCursor.getDownId();
			checkDownCursor = nextDownId != null ? GridElement.findById(nextDownId) : null;
			}

			// 判断网格是否能开空仓，如果不能则跳过
			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
			);
			}
			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
			){
			executor.placeConditionalEntryOrder(
			downShortTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			negate(downShortTraderParam.getQuantity()),
			orderId ->
			{
			shortEntryTraderIdParam(
			downGridElement,
			orderId,
			true
			);
			},
			null
			);

			}

			TraderParam downLongTraderParam = downGridElement.getLongTraderParam();
			if (
			!downGridElement.isHasLongOrder() &&
			downGridPrice.compareTo(longEntryPrice) <= 0
			){
			executor.placeConditionalEntryOrder(
			downLongTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			downLongTraderParam.getQuantity(),
			orderId ->
			{
			longEntryTraderIdParam(
			downGridElement,
			orderId,
			true
			);
			},
			null
			);
			// 向上遍历取消所有遗留多单（跳过基础入场网格0）
			GridElement cancelCursor = GridElement.findById(newEntryGrid.getUpId());
			while (cancelCursor != null) {
			if (cancelCursor.isHasLongOrder()) {
			for (String longOrderId : new ArrayList<>(cancelCursor.getLongOrderIds())) {
			GridElement finalCancelCursor = cancelCursor;
			executor.cancelConditionalOrder(longOrderId, oid -> {
			longEntryTraderIdParam(finalCancelCursor, longOrderId, false);
			log.info("[Gate] 多仓仓位归零, 取消gridId:{}的多单,{}", finalCancelCursor.getId(), longOrderId);
			});
			}
			}
			Integer nextUpId = cancelCursor.getUpId();
			cancelCursor = nextUpId != null ? GridElement.findById(nextUpId) : null;
			}
			// log.info("[Gate-2] 多仓仓位归零空仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
			if (!newEntryGrid.isHasLongOrder() && !hasLongOrderBelow) {
			BigDecimal triggerPrice = newEntryGrid.getGridPrice();
			String size = quantity;
			log.info("[Gate] 多仓仓位归零 gridId:{}, 挂{}基础张多单",
			newEntryGrid.getId(), size);
			newEntryGrid.getLongTraderParam().setQuantity(size);
			placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
			}
			}
			}
			}
			}

			}

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

			log.info("[Gate] 多仓队列触发, 匹配{}个元素, 当前价:{}", matched.size(), 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);
			// log.info("[Gate-3] 空仓仓位归零多仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
			if (BigDecimal.ZERO.compareTo( matched) == 0) {
			return;
			}
			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);
			}
			}

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

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

			// 判断网格是否能开多仓，如果不能则跳过
			if (UpGridElement != null) {
			// String quantity = String.valueOf((accumulatedShortLossCount + 1) * Integer.parseInt(config.getQuantity()));
			// String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()) + Integer.parseInt(config.getQuantity()));
			String quantity = String.valueOf(config.getBaseQuantity());
			// 向上检查是否已有空单挂在更高价格网格，有则跳过（防止价格回落后重复挂单）
			boolean hasShortOrderAbove = false;
			GridElement checkUpCursor = GridElement.findById(newEntryGrid.getUpId());
			while (checkUpCursor != null) {
			if (checkUpCursor.isHasShortOrder()) {
			hasShortOrderAbove = true;
			log.info("[Gate] 空仓仓位归零 gridId:{}, 上方gridId:{}已有空单, 跳过本次挂单",
			newEntryGrid.getId(), checkUpCursor.getId());
			break;
			}
			Integer nextUpId = checkUpCursor.getUpId();
			checkUpCursor = nextUpId != null ? GridElement.findById(nextUpId) : null;
			}

			if (!UpGridElement.isHasLongOrder()) {
			//挂多仓条件单
			TraderParam upLongTraderParam = UpGridElement.getLongTraderParam();
			executor.placeConditionalEntryOrder(
			upLongTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			config.getQuantity(),
			orderId ->
			{
			longEntryTraderIdParam(
			UpGridElement,
			orderId,
			true
			);
			},
			null
			);
			}
			// 向下遍历取消所有遗留空单（跳过基础入场网格0）
			GridElement cancelCursor = GridElement.findById(newEntryGrid.getDownId());
			while (cancelCursor != null) {
			if (cancelCursor.isHasShortOrder()) {
			for (String shortOrderId : new ArrayList<>(cancelCursor.getShortOrderIds())) {
			GridElement finalCancelCursor = cancelCursor;
			executor.cancelConditionalOrder(shortOrderId, oid -> {
			shortEntryTraderIdParam(finalCancelCursor, shortOrderId, false);
			log.info("[Gate] 空仓仓位归零, 取消gridId:{}的多单{}", finalCancelCursor.getId(), shortOrderId);
			});
			}
			}
			Integer nextDownId = cancelCursor.getDownId();
			cancelCursor = nextDownId != null ? GridElement.findById(nextDownId) : null;
			}
			// log.info("[Gate-4] 空仓仓位归零多仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
			if (!newEntryGrid.isHasShortOrder() && !hasShortOrderAbove){
			BigDecimal triggerPrice = newEntryGrid.getGridPrice();
			String size = quantity;
			log.info("[Gate] 空仓仓位归零 gridId:{}, 挂{}基础张多单",
			newEntryGrid.getId(), size);
			newEntryGrid.getShortTraderParam().setQuantity(size);
			placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
			}

			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
			){
			executor.placeConditionalEntryOrder(
			downLongTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			config.getQuantity(),
			orderId ->
			{
			longEntryTraderIdParam(
			downGridElement,
			orderId,
			true
			);
			},
			null
			);

			}

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

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

			// ---- 保证金安全阀 ----
			// ========== 加仓计算 ==========

			/**
			* 保证金安全阀检查。
			* 根据 {@code stopLossCountMode} 计算当前有效的止损次数。
			* <ul>
			* <li>{@code "single"}（单向）：返回该方向的累计止损次数</li>
			* <li>{@code "dual"}（双向）：返回多空双向累计总次数</li>
			* </ul>
			*
			* <p>实时查询当前保证金占用额（positionInitialMargin），计算其占初始本金的比例。
			* 比例 ≥ marginRatioLimit（默认 20%）时拒绝开仓，但仍照常更新队列。
			*
			* <p>查询失败时默认放行（返回 true），避免因 REST API 异常导致策略完全停滞。
			*
			* @return true=安全可开仓 / false=保证金超限跳过开仓
			* @param isLong {@code true}=多仓方向，{@code false}=空仓方向
			* @return 有效止损次数
			*/
			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;
			private int getEffectiveStopLossCount(boolean isLong) {
			if ("single".equals(config.getStopLossCountMode())) {
			return isLong ? accumulatedLongLossCount : accumulatedShortLossCount;
			}
			// "dual" — 双向总次数
			return accumulatedLongLossCount + accumulatedShortLossCount;
			}

			/**
			* 根据加仓配置计算止损追单时的实际下单量。
			* <p>公式：</p>
			* <pre>
			* divisor = addPositionInterval + 1
			* addMultiplier = floor(effectiveStopLossCount / divisor)
			* addQty = addMultiplier × addPositionQuantity
			* finalQty = min(baseQuantity + addQty, maxPositionPerSide > 0 ? maxPositionPerSide : ∞)
			* </pre>
			*
			* @param isLong {@code true}=多仓方向，{@code false}=空仓方向
			* @return 实际下单张数（字符串）
			*/
			private String calculateEntryQuantity(boolean isLong) {
			int baseQty = Integer.parseInt(config.getBaseQuantity());
			int interval = config.getAddPositionInterval();
			int addQtyPerUnit = config.getAddPositionQuantity();
			int maxPerSide = config.getMaxPositionPerSide();

			int effectiveCount = getEffectiveStopLossCount(isLong);
			int startThreshold = config.getAddPositionStartThreshold();
			if (startThreshold > 0) {
			effectiveCount = Math.max(0, effectiveCount - startThreshold);
			}
			// divisor = interval + 1：interval=0→每次加仓, interval=1→每2次加仓(2,4,6...), interval=3→每4次加仓(4,8,12...)
			int divisor = interval + 1;
			int addMultiplier = interval >= 0 ? effectiveCount / divisor : 0;
			int addQty = addMultiplier * addQtyPerUnit;
			int totalQty = baseQty + addQty;

			if (maxPerSide > 0 && totalQty > maxPerSide) {
			totalQty = maxPerSide;
			}

			return String.valueOf(totalQty);
			}

			private void handleLongStopLossTriggered(GridElement gridElement, String orderId) {
			gridElement.removeLongStopLossOrderId(orderId);

			int gridId = gridElement.getId();
			boolean sameGrid = (gridId == lastLongStopLossGridId);
			if (sameGrid) {
			log.info("[Gate] 多仓止损触发同网格, 忽略");
			return;
			}

			lastLongStopLossGridId = gridId;

			accumulatedLongLossCount++;
			log.info("[Gate] 多仓止损触发 gridId:{}, 止损次数:{}{}, 开始追单",
			gridId, accumulatedLongLossCount, sameGrid ? "(同网格)" : "");

			// 埋点: STOP_LOSS_TRIGGERED
			emitStats("STOP_LOSS_TRIGGERED", mapOf(
			"direction", "long",
			"gridId", gridId,
			"lossCount", accumulatedLongLossCount
			));
			int newEntryGridId = gridId + 1;

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

			// 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
			BigDecimal triggerPrice = newEntryGrid.getGridPrice();
			String size = calculateEntryQuantity(true);
			log.info("[Gate] 多仓止损追单有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
			getEffectiveStopLossCount(true), config.getBaseQuantity(), size, config.getStopLossCountMode());
			newEntryGrid.getLongTraderParam().setQuantity(size);
			placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_1, size);

			// 取消 gridId+2 位置的所有多单
			int cancelGridId = gridId + 2;
			GridElement cancelGrid = GridElement.findById(cancelGridId);
			if (cancelGrid != null && cancelGrid.isHasLongOrder()) {
			for (String cancelOrderId : new ArrayList<>(cancelGrid.getLongOrderIds())) {
			executor.cancelConditionalOrder(cancelOrderId, oid -> {
			longEntryTraderIdParam(cancelGrid, cancelOrderId, false);
			log.info("[Gate] 多仓止损触发, 取消gridId:{}的多单,{}", cancelGridId, cancelOrderId);
			});
			}
			}

			}

			private void handleShortStopLossTriggered(GridElement gridElement, String orderId) {
			gridElement.removeShortStopLossOrderId(orderId);

			int gridId = gridElement.getId();
			boolean sameGrid = (gridId == lastShortStopLossGridId);
			if (sameGrid) {
			log.info("[Gate] 空仓止损触发同网格, 忽略");
			return;
			}
			lastShortStopLossGridId = gridId;
			accumulatedShortLossCount++;
			log.info("[Gate] 空仓止损触发 gridId:{}, 止损次数:{}{}, 开始追单",
			gridId, accumulatedShortLossCount, sameGrid ? "(同网格)" : "");

			// 埋点: STOP_LOSS_TRIGGERED
			emitStats("STOP_LOSS_TRIGGERED", mapOf(
			"direction", "short",
			"gridId", gridId,
			"lossCount", accumulatedShortLossCount
			));
			int newEntryGridId = gridId - 1;

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

			// 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
			BigDecimal triggerPrice = newEntryGrid.getGridPrice();
			String size = calculateEntryQuantity(false);
			log.info("[Gate] 空仓止损追单有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
			getEffectiveStopLossCount(false), config.getBaseQuantity(), size, config.getStopLossCountMode());
			newEntryGrid.getShortTraderParam().setQuantity(size);
			placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));

			// 取消 gridId-2 位置的所有空单
			int cancelGridId = gridId - 2;
			GridElement cancelGrid = GridElement.findById(cancelGridId);
			if (cancelGrid != null && cancelGrid.isHasShortOrder()) {
			for (String cancelOrderId : new ArrayList<>(cancelGrid.getShortOrderIds())) {
			executor.cancelConditionalOrder(cancelOrderId, oid -> {
			shortEntryTraderIdParam(cancelGrid, cancelOrderId, false);
			log.info("[Gate] 空仓止损触发, 取消gridId:{}的空单,{}", cancelGridId, cancelOrderId);
			});
			}
			}
			}

			// ========== 止盈/止损取消辅助方法 ==========

			/**
			* 止盈触发后检查跨度是否达至要求，满足条件则重启策略。
			*
			* <h3>跨度定义</h3>
			* {@code restartGridSpan} 表示多少倍的绝对步长 step（= 短基价 × gridRate）。
			*
			* <h3>判断逻辑</h3>
			* <ol>
			* <li>多空双边均有持仓：longEntryPrice − shortEntryPrice > span × step</li>
			* <li>仅持多仓：currentPrice − longEntryPrice > span × step</li>
			* <li>仅持空仓：shortEntryPrice − currentPrice > span × step</li>
			* </ol>
			* restartGridSpan=0 时禁用此功能。重启复用仓位归零模式：取消全部条件单 → 平仓 → 延迟启动。
			*/
			private void checkLastTakeProfitAndRestart() {
			int span = config.getRestartGridSpan();
			if (span <= 0) {
			return;
			}

			// 检查是否还有剩余止盈单，只有多空止盈全部清空才继续
			if (GridElement.getLongTakeProfitCount() > 0 \|\| GridElement.getShortTakeProfitCount() > 0) {
			log.info("[Gate] 尚有未触发止盈单, 暂不检查跨度重启 longTpCount:{}, shortTpCount:{}",
			GridElement.getLongTakeProfitCount(), GridElement.getShortTakeProfitCount());
			return;
			}

			BigDecimal step = config.getStep();
			if (step == null \|\| step.compareTo(BigDecimal.ZERO) == 0) {
			return;
			}
			BigDecimal threshold = step.multiply(new BigDecimal(span));

			BigDecimal currentPrice = lastKlinePrice;
			if (currentPrice == null \|\| currentPrice.compareTo(BigDecimal.ZERO) == 0) {
			return;
			}

			// 查交易所获取最新持仓均价和持仓量，不用本地缓存避免 WS 时序竞态
			Position longPos = queryPosition(Position.ModeEnum.DUAL_LONG);
			Position shortPos = queryPosition(Position.ModeEnum.DUAL_SHORT);
			boolean hasLong = longPos != null && Math.abs(Integer.parseInt(longPos.getSize())) > 0;
			boolean hasShort = shortPos != null && Math.abs(Integer.parseInt(shortPos.getSize())) > 0;
			BigDecimal longAvgPrice = (longPos != null && longPos.getEntryPrice() != null)
			? new BigDecimal(longPos.getEntryPrice()) : BigDecimal.ZERO;
			BigDecimal shortAvgPrice = (shortPos != null && shortPos.getEntryPrice() != null)
			? new BigDecimal(shortPos.getEntryPrice()) : BigDecimal.ZERO;

			boolean shouldRestart = false;
			String reason = "";

			if (hasLong && hasShort) {
			// 多空双边持仓：\|多均价 − 空均价\| > span × step
			BigDecimal gap = shortAvgPrice.subtract(longAvgPrice);
			if (gap.compareTo(threshold) >= 0) {
			shouldRestart = true;
			reason = StrUtil.format("双边跨度 \|多均价:{} − 空均价:{}\| = {} >= {} (span:{}×step:{})",
			longAvgPrice, shortAvgPrice, gap, threshold, span, step);
			}
			} else if (hasLong) {
			// 仅持多仓：当前价 − 多均价 > span × step
			BigDecimal gap = currentPrice.subtract(longAvgPrice);
			if (gap.compareTo(threshold) >= 0) {
			shouldRestart = true;
			reason = StrUtil.format("多仓跨度当前价:{} − 多均价:{} = {} > {} (span:{}×step:{})",
			currentPrice, longAvgPrice, gap, threshold, span, step);
			}
			} else if (hasShort) {
			// 仅持空仓：空均价 − 当前价 > span × step
			BigDecimal gap = shortAvgPrice.subtract(currentPrice);
			if (gap.compareTo(threshold) >= 0) {
			shouldRestart = true;
			reason = StrUtil.format("空仓跨度空均价:{} − 当前价:{} = {} > {} (span:{}×step:{})",
			shortAvgPrice, currentPrice, gap, threshold, span, step);
			}
			}

			if (shouldRestart) {
			log.info("[Gate] 跨度已达要求 → {}，最后一个止盈触发策略重启", reason);
			try {
			futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
			} catch (ApiException ex) {
			log.warn("[Gate] 重启前清理条件单失败", ex);
			}
			closeExistingPositions();
			state = StrategyState.STOPPED;
			executor.submitTask(() -> {
			try { Thread.sleep(3000); } catch (InterruptedException ex) { Thread.currentThread().interrupt(); }
			startGrid();
			});
			}
			}

			/**
			* 取消最近的多仓止损订单（A 位置，gridId 最大即最接近 0）。
			* 多仓止损在 gridId 负方向，A = gridId-2，是三个位置中 ID 最大（最接近 0）的那个。
			*/
			private void cancelNearestLongStopLoss() {
			GridElement nearest = null;
			for (GridElement e : config.getGridElements()) {
			if (e.hasLongStopLossOrders()) {
			if (nearest == null \|\| e.getId() > nearest.getId()) {
			nearest = e;
			}
			}
			}
			if (nearest != null && nearest.hasLongStopLossOrders()) {
			List<String> ids = nearest.getLongStopLossOrderIds();
			String slId = ids.get(0); // 取第一个（最早加入的 = A 位置第一单）
			nearest.removeLongStopLossOrderId(slId);
			GridElement.refreshIndices();
			GridElement finalNearest = nearest;
			executor.cancelConditionalOrder(slId, oid ->
			log.info("[Gate] 止盈触发, 取消最近多仓止损 gridId:{}, orderId:{}", finalNearest.getId(), slId));
			}
			}

			/**
			* 取消最近的空仓止损订单（A 位置，gridId 最小即最接近 0）。
			* 空仓止损在 gridId 正方向，A = gridId+2，是三个位置中 ID 最小（最接近 0）的那个。
			*/
			private void cancelNearestShortStopLoss() {
			GridElement nearest = null;
			for (GridElement e : config.getGridElements()) {
			if (e.hasShortStopLossOrders()) {
			if (nearest == null \|\| e.getId() < nearest.getId()) {
			nearest = e;
			}
			}
			}
			if (nearest != null && nearest.hasShortStopLossOrders()) {
			List<String> ids = nearest.getShortStopLossOrderIds();
			String slId = ids.get(0); // 取第一个（最早加入的 = A 位置第一单）
			nearest.removeShortStopLossOrderId(slId);
			GridElement.refreshIndices();
			GridElement finalNearest = nearest;
			executor.cancelConditionalOrder(slId, oid ->
			log.info("[Gate] 止盈触发, 取消最近空仓止损 gridId:{}, orderId:{}", finalNearest.getId(), slId));
			}
			}

			/**
			* 取消所有多仓止盈 + 多仓止损订单（加仓后重建前清场）。
			*/
			private void cancelAllLongTakeProfitsAndStopLosses() {
			for (GridElement e : config.getGridElements()) {
			String tpId = e.getLongTakeProfitOrderId();
			if (tpId != null) {
			e.getLongTraderParam().setTakeProfitPlaced(false);
			e.setLongTakeProfitOrderId(null);
			executor.cancelConditionalOrder(tpId, oid -> {});
			}
			for (String slId : new ArrayList<>(e.getLongStopLossOrderIds())) {
			executor.cancelConditionalOrder(slId, oid -> {});
			}
			e.clearLongStopLossOrderIds();
			}
			GridElement.refreshIndices();
			log.info("[Gate] 已提交取消所有多仓止盈+止损");
			}

			/**
			* 取消所有空仓止盈 + 空仓止损订单（加仓后重建前清场）。
			*/
			private void cancelAllShortTakeProfitsAndStopLosses() {
			for (GridElement e : config.getGridElements()) {
			String tpId = e.getShortTakeProfitOrderId();
			if (tpId != null) {
			e.getShortTraderParam().setTakeProfitPlaced(false);
			e.setShortTakeProfitOrderId(null);
			executor.cancelConditionalOrder(tpId, oid -> {});
			}
			for (String slId : new ArrayList<>(e.getShortStopLossOrderIds())) {
			executor.cancelConditionalOrder(slId, oid -> {});
			}
			e.clearShortStopLossOrderIds();
			}
			GridElement.refreshIndices();
			log.info("[Gate] 已提交取消所有空仓止盈+止损");
			}

			/**
			* 首次挂单成交时，取消初始化阶段挂的所有止盈单（多+空），止损单保留不动。
			*/
			private void cancelAllInitialTakeProfits() {


			GridElement tpElemLong = GridElement.findById(3);
			String longTpId = tpElemLong.getLongTakeProfitOrderId();
			if (longTpId != null) {
			longTakeProfitTraderIdParam(tpElemLong, null, false);
			executor.cancelConditionalOrder(longTpId, oid -> {});
			}

			GridElement tpElemShort = GridElement.findById(-3);
			String shortTpId = tpElemShort.getShortTakeProfitOrderId();
			if (shortTpId != null) {
			shortTakeProfitTraderIdParam(tpElemShort, null, false);
			executor.cancelConditionalOrder(shortTpId, oid -> {});
			}
			GridElement.refreshIndices();
			log.info("[Gate] 首次成交，取消所有初始化止盈单");
			}

			// ========== 止损追单（新逻辑：3 个固定位置，每个位置挂多个 1 张止损单） ==========

			/**
			* 多仓止损追单 — 网格数量 = baseQuantity/quantity，从近到远分配。
			* aCount<0跳过, aCount=0→主=2, aCount=1→主=2,辅0=1, aCount>=2→主=aCount,辅依次填1
			*/
			private void extendLongStopLoss(int filledQty, int gridId) {
			int qty = Integer.parseInt(config.getQuantity());
			int baseQty = Integer.parseInt(config.getBaseQuantity());
			int gridCount = baseQty / qty;
			GridElement entryElem = GridElement.findById(gridId);
			if (gridCount <= 0 \|\| filledQty < qty) {
			// 早期返回需重置防重入标记
			if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
			return;
			}

			int totalOrders = filledQty / qty;
			int[] orders = new int[gridCount];

			if (gridCount == 1) {
			// 只有1个网格，全量挂在上面
			orders[0] = totalOrders;
			} else {
			// 最近网格(orders[0])挂剩余张数，其余每个网格各挂1张
			orders[0] = totalOrders - (gridCount - 1);
			if (orders[0] < 1) {
			// 订单数不够覆盖所有网格(理论上不会出现)，全量挂在最近网格
			orders[0] = totalOrders;
			} else {
			for (int i = 1; i < gridCount; i++) {
			orders[i] = 1;
			}
			}
			}

			// 计算总订单数，用于异步回调完成时重置防重入标记
			int totalOrdersToPlace = 0;
			for (int i = 0; i < gridCount; i++) {
			if (orders[i] > 0) { totalOrdersToPlace += orders[i]; }
			}
			if (totalOrdersToPlace == 0) {
			if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
			return;
			}
			AtomicInteger remainCount = new AtomicInteger(totalOrdersToPlace);

			StringBuilder detail = new StringBuilder();
			for (int i = 0; i < gridCount; i++) {
			if (orders[i] > 0) {
			int sgId = gridId - 2 - i;
			placeStopLossOrders(sgId, orders[i], qty, FuturesPriceTrigger.RuleEnum.NUMBER_2,
			ORDER_TYPE_CLOSE_LONG, true, remainCount, entryElem);
			if (detail.length() > 0) {
			detail.append(" ");
			}
			detail.append(sgId).append("x").append(orders[i]);
			}
			}

			log.info("[Gate] 多仓追挂止损, 成交{}张, gridId:{}, 网格数:{}, 分配:{}",
			filledQty, gridId, gridCount, detail);
			}

			/**
			* 空仓止损追单 — 网格数量 = baseQuantity/quantity，从近到远分配。
			* aCount<0跳过, aCount=0→主=2, aCount=1→主=2,辅0=1, aCount>=2→主=aCount,辅依次填1
			*/
			private void extendShortStopLoss(int filledQty, int gridId) {
			int qty = Integer.parseInt(config.getQuantity());
			int baseQty = Integer.parseInt(config.getBaseQuantity());
			int gridCount = baseQty / qty;
			GridElement entryElem = GridElement.findById(gridId);
			if (gridCount <= 0 \|\| filledQty < qty) {
			// 早期返回需重置防重入标记
			if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
			return;
			}

			int totalOrders = filledQty / qty;
			int[] orders = new int[gridCount];

			if (gridCount == 1) {
			// 只有1个网格，全量挂在上面
			orders[0] = totalOrders;
			} else {
			// 最近网格(orders[0])挂剩余张数，其余每个网格各挂1张
			orders[0] = totalOrders - (gridCount - 1);
			if (orders[0] < 1) {
			// 订单数不够覆盖所有网格(理论上不会出现)，全量挂在最近网格
			orders[0] = totalOrders;
			} else {
			for (int i = 1; i < gridCount; i++) {
			orders[i] = 1;
			}
			}
			}

			// 计算总订单数，用于异步回调完成时重置防重入标记
			int totalOrdersToPlace = 0;
			for (int i = 0; i < gridCount; i++) {
			if (orders[i] > 0) { totalOrdersToPlace += orders[i]; }
			}
			if (totalOrdersToPlace == 0) {
			if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
			return;
			}
			AtomicInteger remainCount = new AtomicInteger(totalOrdersToPlace);

			StringBuilder detail = new StringBuilder();
			for (int i = 0; i < gridCount; i++) {
			if (orders[i] > 0) {
			int sgId = gridId + 2 + i;
			placeStopLossOrders(sgId, orders[i], qty, FuturesPriceTrigger.RuleEnum.NUMBER_1,
			ORDER_TYPE_CLOSE_SHORT, false, remainCount, entryElem);
			if (detail.length() > 0) {
			detail.append(" ");
			}
			detail.append(sgId).append("x").append(orders[i]);
			}
			}

			log.info("[Gate] 空仓追挂止损, 成交{}张, gridId:{}, 网格数:{}, 分配:{}",
			filledQty, gridId, gridCount, detail);
			}

			/**
			* 延展完成后重挂止损（处理被跳过的入场单成交）。
			* 取消已有止损单并用最新仓位重新挂单，确保止损覆盖最新持仓数。
			*/
			private void reExtendLongStopLoss(GridElement entryElem) {
			if (entryElem.isExtendStopLossInProgress()) {
			log.info("[Gate] 多仓重挂止损跳过, entryGridId:{}, 仍在进行中", entryElem.getId());
			return;
			}
			entryElem.setExtendStopLossInProgress(true);
			cancelAllLongTakeProfitsAndStopLosses();
			int latestPos = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue());
			log.info("[Gate] 多仓重挂止损, entryGridId:{}, 最新仓位:{}张", entryElem.getId(), latestPos);
			extendLongStopLoss(latestPos, entryElem.getId());
			}

			private void reExtendShortStopLoss(GridElement entryElem) {
			if (entryElem.isExtendStopLossInProgress()) {
			log.info("[Gate] 空仓重挂止损跳过, entryGridId:{}, 仍在进行中", entryElem.getId());
			return;
			}
			entryElem.setExtendStopLossInProgress(true);
			cancelAllShortTakeProfitsAndStopLosses();
			int latestPos = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue());
			log.info("[Gate] 空仓重挂止损, entryGridId:{}, 最新仓位:{}张", entryElem.getId(), latestPos);
			extendShortStopLoss(latestPos, entryElem.getId());
			}

			/**
			* 在指定网格位置挂 count 个独立止损单，每个 size 张。
			*/
			private void placeStopLossOrders(int gridId, int count, int qty,
			FuturesPriceTrigger.RuleEnum rule,
			String orderType, boolean isLong,
			AtomicInteger remainCount,
			GridElement entryElement) {
			if (count <= 0) {
			return;
			}
			GridElement elem = GridElement.findById(gridId);
			if (elem == null) {
			log.warn("[Gate] 止损挂单位置不存在, gridId:{}", gridId);
			// 即使挂单位置不存在也需递减计数器，避免标志永不重置
			if (remainCount != null && entryElement != null) {
			for (int i = 0; i < count; i++) {
			if (remainCount.decrementAndGet() == 0) {
			entryElement.setExtendStopLossInProgress(false);
			log.info("[Gate] {}止损追单全部完成(部分位置缺失), entryGridId:{}, 防重入标记已重置",
			isLong ? "多仓" : "空仓", entryElement.getId());
			// 检查待重挂请求
			if (entryElement.isPendingStopLossReExtend()) {
			entryElement.setPendingStopLossReExtend(false);
			if (isLong) {
			reExtendLongStopLoss(entryElement);
			} else {
			reExtendShortStopLoss(entryElement);
			}
			}
			}
			}
			}
			return;
			}
			BigDecimal triggerPrice = elem.getGridPrice();
			for (int i = 0; i < count; i++) {
			String size = isLong ? negate(String.valueOf(qty)) : String.valueOf(qty);
			int finalGridId = gridId;
			int finalI = i;
			executor.placeTakeProfit(
			triggerPrice, rule, orderType, size,
			profitId -> {
			if (isLong) {
			elem.addLongStopLossOrderId(profitId);
			} else {
			elem.addShortStopLossOrderId(profitId);
			}
			GridElement.refreshIndices();
			log.info("[Gate] {}止损追加, gridId:{}, 触发价:{}, 第{}单, stopLossId:{}",
			isLong ? "多仓" : "空仓", finalGridId, triggerPrice, finalI + 1, profitId);
			// 计数器归零时重置防重入标记，并检查是否有待重挂请求
			if (remainCount != null && remainCount.decrementAndGet() == 0 && entryElement != null) {
			entryElement.setExtendStopLossInProgress(false);
			log.info("[Gate] {}止损追单全部完成, entryGridId:{}, 防重入标记已重置",
			isLong ? "多仓" : "空仓", entryElement.getId());
			// 如果有被跳过的入场单成交，用最新仓位重挂一次止损
			if (entryElement.isPendingStopLossReExtend()) {
			entryElement.setPendingStopLossReExtend(false);
			if (isLong) {
			reExtendLongStopLoss(entryElement);
			} else {
			reExtendShortStopLoss(entryElement);
			}
			}
			}
			}
			);
			}
			}

			@@ -1323,6 +1968,53 @@
			*/
			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) {
			if (!gridElement.hasLongOrderIds()) {
			gridElement.setHasLongOrder(false);
			}
			} else {
			if (!gridElement.hasShortOrderIds()) {
			gridElement.setHasShortOrder(false);
			}
			}
			GridElement.refreshIndices();
			log.warn("[Gate] 条件单创建失败 gridId:{}, isLong:{}", gridElement.getId(), isLong);
			}
			);
			}

			/**
			@@ -1374,12 +2066,144 @@
			public void setMarkPrice(BigDecimal markPrice) { this.markPrice = markPrice; }
			/** @return 策略是否处于活跃状态（非 STOPPED 且非 WAITING_KLINE） */
			public boolean isStrategyActive() { return state != StrategyState.STOPPED && state != StrategyState.WAITING_KLINE; }
			/** @return 当前已完成轮数 */
			public int getCurrentRound() { return currentRound; }
			/** @return 累计已实现盈亏（平仓推送驱动累加） */
			public BigDecimal getCumulativePnl() { return cumulativePnl; }
			/** @return 初始本金 */
			public BigDecimal getInitialPrincipal() { return initialPrincipal; }
			/** @return 当前未实现盈亏（每根 K 线实时计算） */
			public BigDecimal getUnrealizedPnl() { return unrealizedPnl; }
			/** @return Gate 用户 ID（用于私有频道订阅 payload） */
			public Long getUserId() { return userId; }
			/** @return 当前策略状态 */
			public StrategyState getState() { return state; }
			/** 注入WS客户端，用于订阅状态检查 */
			public void setWsClient(GateKlineWebSocketClient wsClient) { this.wsClient = wsClient; }

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

			/** 找到第一个有多仓止损单的网格（首个匹配即返回） */
			private GridElement findFirstLongStopLossGrid() {
			for (GridElement e : config.getGridElements()) {
			if (!e.getLongStopLossOrderIds().isEmpty()) return e;
			}
			return null;
			}

			/** 找到第一个有空仓止损单的网格（首个匹配即返回） */
			private GridElement findFirstShortStopLossGrid() {
			for (GridElement e : config.getGridElements()) {
			if (!e.getShortStopLossOrderIds().isEmpty()) return e;
			}
			return null;
			}

			/**
			* 挂单成交后，将超出基础仓位的部分挂止盈单，挂在对向仓位的第一止损位上。
			*
			* <p>遍历所有 GridElement，找到对向仓位第一个有止损单的网格作为止盈挂单位置。
			*
			* <p>例：空仓成交后持仓 8 张，基础 4 张 → 超出 4 张，
			* 找到多仓第一止损位（如 gridId=-2）→ 在该位置挂空仓止盈单。
			*
			* @param posSize 当前总持仓张数
			* @param isLong true=多仓成交，false=空仓成交
			*/
			private void placeExcessTakeProfit(int posSize, boolean isLong) {
			int baseQty = Integer.parseInt(config.getBaseQuantity());
			int excessQty = posSize - baseQty;
			if (excessQty <= 0) {
			return;
			}

			// 遍历找到对向仓位第一个有止损单的网格
			GridElement tpElem = isLong ? findFirstShortStopLossGrid() : findFirstLongStopLossGrid();
			if (tpElem == null) {
			log.warn("[Gate] {}止盈挂单失败：未找到对向仓止损位", isLong ? "多仓" : "空仓");
			return;
			}
			int tpGridId = tpElem.getId();

			BigDecimal triggerPrice = tpElem.getGridPrice();
			String orderType = isLong ? ORDER_TYPE_CLOSE_LONG : ORDER_TYPE_CLOSE_SHORT;
			// 多仓止盈：价格≥触发价时平仓(NUMBER_1)；空仓止盈：价格≤触发价时平仓(NUMBER_2)
			FuturesPriceTrigger.RuleEnum rule = isLong ? FuturesPriceTrigger.RuleEnum.NUMBER_1
			: FuturesPriceTrigger.RuleEnum.NUMBER_2;
			String size = isLong ? negate(String.valueOf(excessQty)) : String.valueOf(excessQty);

			// if (isLong && tpElem.getLongTakeProfitOrderId() != null) {
			// executor.cancelConditionalOrder(tpElem.getLongTakeProfitOrderId(), oid -> {
			// longTakeProfitTraderIdParam(tpElem, null, false);
			// log.info("[Gate] 取消旧止盈, gridId:{}, orderId:{}", tpGridId, oid);
			// });
			// } else if (!isLong && tpElem.getShortTakeProfitOrderId() != null) {
			// executor.cancelConditionalOrder(tpElem.getShortTakeProfitOrderId(), oid -> {
			// shortTakeProfitTraderIdParam(tpElem, null, false);
			// log.info("[Gate] 取消旧止盈, gridId:{}, orderId:{}", tpGridId, oid);
			// });
			// }

			String finalSize = size;
			int finalTpGridId = tpGridId;
			executor.placeTakeProfit(triggerPrice, rule, orderType, size,
			profitId -> {
			if (isLong) {
			longTakeProfitTraderIdParam(tpElem, profitId, true);
			} else {
			shortTakeProfitTraderIdParam(tpElem, profitId, true);
			}
			log.info("[Gate] {}止盈挂单, gridId:{}, 触发价:{}, 数量:{}, takeProfitId:{}",
			isLong ? "多仓" : "空仓", finalTpGridId, triggerPrice, finalSize, profitId);
			}
			);
			}

			/**
			* 在指定网格挂一笔对手止盈单（非满仓超额止盈，挂在止损触发位的下一格）。
			*/
			private void placeTakeProfitAtGrid(GridElement tpElem, boolean isLong, int qty, int times) {
			BigDecimal triggerPrice = tpElem.getGridPrice();
			String orderType = isLong ? ORDER_TYPE_CLOSE_LONG : ORDER_TYPE_CLOSE_SHORT;
			FuturesPriceTrigger.RuleEnum rule = isLong ? FuturesPriceTrigger.RuleEnum.NUMBER_1
			: FuturesPriceTrigger.RuleEnum.NUMBER_2;
			String size = isLong ? negate(String.valueOf(qty)) : String.valueOf(qty);
			int gridId = tpElem.getId();
			executor.placeTakeProfit(triggerPrice, rule, orderType, size,
			profitId -> {
			if (isLong) {
			longTakeProfitTraderIdParam(tpElem, profitId, true);
			} else {
			shortTakeProfitTraderIdParam(tpElem, profitId, true);
			}
			log.info("[Gate] 止损{}→对手超额止盈 gridId:{}, 量:{}, tpId:{}", times, gridId, qty, profitId);
			}
			);
			}

			/**
			* 挂对手盘止盈单：在对向仓位第一止损位挂止盈。
			* @param isLong true=挂多仓止盈(对空仓), false=挂空仓止盈(对多仓)
			*/
			private void placeOpponentTakeProfit(boolean isLong, int tpQty, int times, int gridId) {
			GridElement tpElem = GridElement.findById(isLong ? gridId + 1 : gridId - 1);
			if (tpElem == null) {
			log.warn("[Gate] 对手止盈挂单失败：未找到止损位");
			return;
			}
			int tpGridId = tpElem.getId();
			BigDecimal triggerPrice = tpElem.getGridPrice();
			String orderType = isLong ? ORDER_TYPE_CLOSE_LONG : ORDER_TYPE_CLOSE_SHORT;
			FuturesPriceTrigger.RuleEnum rule = isLong ? FuturesPriceTrigger.RuleEnum.NUMBER_1
			: FuturesPriceTrigger.RuleEnum.NUMBER_2;
			String size = isLong ? negate(String.valueOf(tpQty)) : String.valueOf(tpQty);
			executor.placeTakeProfit(triggerPrice, rule, orderType, size,
			profitId -> {
			if (isLong) longTakeProfitTraderIdParam(tpElem, profitId, true);
			else shortTakeProfitTraderIdParam(tpElem, profitId, true);
			log.info("[Gate] 止损次数{}→对手{}止盈 gridId:{}, 量:{}, tpId:{}",
			times, isLong ? "多仓" : "空仓", tpGridId, size, profitId);
			}
			);
			}
			}