exchange.git - Gitblit

			@@ -14,11 +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.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;
			@@ -116,6 +113,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<>());
			@@ -136,6 +135,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;
			@@ -146,6 +157,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;
			@@ -301,13 +313,19 @@
			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();

			// 每次重启重新获取当前本金
			refreshInitialPrincipal();
			currentRound = 0;

			log.info("[Gate] 网格策略已启动, 当前本金: {} USDT", initialPrincipal);
			}
			@@ -331,6 +349,7 @@
			public void stopGrid() {
			state = StrategyState.STOPPED;
			executor.cancelAllPriceTriggeredOrders();
			closeExistingPositions();
			executor.shutdown();
			log.info("[Gate] 策略已停止, 累计盈亏: {}", cumulativePnl);
			}
			@@ -356,48 +375,115 @@
			* @param closePrice K 线收盘价（即当前最新成交价）
			*/
			public void onKline(BigDecimal closePrice) {

			log.info("当前价：{}", closePrice);

			lastKlinePrice = closePrice;
			updateUnrealizedPnl();
			if (state == StrategyState.STOPPED) {
			try {
			futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
			} catch (ApiException e) {
			e.printStackTrace();
			}
			closeExistingPositions();

			BigDecimal totalPnl = cumulativePnl.add(unrealizedPnl);
			log.info("[Gate] 已实现:{}, 未实现:{}, 合计:{}",
			cumulativePnl, unrealizedPnl, totalPnl);

			startGrid();
			return;
			}

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

			state = StrategyState.OPENING;
			log.info("[Gate] 首根K线到达，开基底仓位多空各{}张...", config.getBaseQuantity());
			executor.openLong(config.getBaseQuantity(), (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.getBaseQuantity()), (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;
			}
			checkProfitAndReset();
			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);

			if (totalEquity.compareTo(target) > 0) {
			currentRound++;
			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);
			}
			}

			// ---- 仓位推送回调 ----
			@@ -412,7 +498,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>
			@@ -432,126 +517,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;
			// checkShortEntryOrderToCancel();
			// checkLongEntryOrderToCancel();
			}
			} else {
			if (longActive && state == StrategyState.ACTIVE) {
			log.info("[Gate] 多仓持仓归零，重置策略");
			handlePositionZeroAndReset("多仓");
			}
			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();
			// checkShortEntryOrderToCancel();
			// checkLongEntryOrderToCancel();
			}
			} else {
			if (shortActive && state == StrategyState.ACTIVE) {
			log.info("[Gate] 空仓持仓归零，重置策略");
			handlePositionZeroAndReset("空仓");
			}
			shortActive = false;
			shortPositionSize = BigDecimal.ZERO;
			shortBaseEntryPrice = entryPrice;
			baseShortOpened = true;
			log.info("[Gate] 基底空成交价: {}", shortBaseEntryPrice);
			tryGenerateQueues();
			}
			}
			}

			private void checkShortEntryOrderToCancel() {
			List<GridElement> allLongOrders = GridElement.findAllShortOrders(shortEntryPrice);
			if (CollUtil.isNotEmpty(allLongOrders)){
			GridElement keep = allLongOrders.stream()
			.min((a, b) -> a.getGridPrice().compareTo(b.getGridPrice()))
			.orElse(null);
			for (GridElement e : allLongOrders) {
			if (e == keep) {
			continue;
			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;
			}
			executor.cancelConditionalOrder(
			e.getShortOrderId(),
			orderId -> {
			shortEntryTraderIdParam(
			e,
			null,
			false
			);
			}
			);
			if (e.getShortTakeProfitOrderId() != null){
			executor.cancelConditionalOrder(
			e.getShortTakeProfitOrderId(),
			orderId -> {
			shortTakeProfitTraderIdParam(
			e,
			null,
			false
			);
			}
			);
			} 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;
			}
			}
			}
			}

			private void checkLongEntryOrderToCancel() {
			List<GridElement> allShortOrders = GridElement.findAllLongOrders(longEntryPrice);
			if (CollUtil.isNotEmpty(allShortOrders)){
			GridElement keep = allShortOrders.stream()
			.max((a, b) -> a.getGridPrice().compareTo(b.getGridPrice()))
			.orElse(null);
			for (GridElement e : allShortOrders) {
			if (e == keep) {
			continue;
			}
			executor.cancelConditionalOrder(
			e.getLongOrderId(),
			orderId -> {
			longEntryTraderIdParam(
			e,
			null,
			false
			);
			}
			);

			if (e.getLongTakeProfitOrderId() != null){
			executor.cancelConditionalOrder(
			e.getLongTakeProfitOrderId(),
			orderId -> {
			longTakeProfitTraderIdParam(
			e,
			null,
			false
			);
			}
			);
			}
			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;
			}
			}

			@@ -586,133 +617,6 @@
			}
			}

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

			/**
			* 订单推送回调。由 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()){
			longEntryTraderIdParam(
			longGridElement,
			null,
			false
			);
			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()){
			shortEntryTraderIdParam(
			shortGridElement,
			null,
			false
			);
			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);
			}

			/**
			* 自动订单（条件单）状态变更回调。
			@@ -735,154 +639,124 @@
			}

			GridElement longStopLossElem = GridElement.findByLongStopLossOrderId(orderId);
			if (longStopLossElem != null) {
			handleLongStopLossTriggered(longStopLossElem);
			if (longStopLossElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
			handleLongStopLossTriggered(longStopLossElem, orderId);
			return;
			}
			GridElement shortStopLossElem = GridElement.findByShortStopLossOrderId(orderId);
			if (shortStopLossElem != null) {
			handleShortStopLossTriggered(shortStopLossElem);
			if (shortStopLossElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
			handleShortStopLossTriggered(shortStopLossElem, orderId);
			return;
			}

			// GridElement byShortTakeProfitOrderId = GridElement.findByShortTakeProfitOrderId(orderId);
			// if (byShortTakeProfitOrderId != null){
			// shortTakeProfitTraderIdParam(
			// byShortTakeProfitOrderId,
			// null,
			// false
			// );
			// shortEntryTraderIdParam(
			// byShortTakeProfitOrderId,
			// null,
			// false
			// );
			// TPonUserTradeShortEntry(byShortTakeProfitOrderId);
			// }
			// GridElement byLongTakeProfitOrderId = GridElement.findByLongTakeProfitOrderId(orderId);
			// if (byLongTakeProfitOrderId != null){
			// longTakeProfitTraderIdParam(
			// byLongTakeProfitOrderId,
			// null,
			// false
			// );
			// longEntryTraderIdParam(
			// byLongTakeProfitOrderId,
			// null,
			// false
			// );
			// TPonUserTradeLongEntry(byLongTakeProfitOrderId);
			// }

			GridElement shortGridElement = GridElement.findByShortOrderId(orderId);
			if (shortGridElement != null) {
			if (shortGridElement.isHasShortOrder() && !tradeId.equals("0")){
			if (StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0") ){
			int filledQty = Integer.parseInt(shortGridElement.getShortTraderParam().getQuantity());
			shortEntryTraderIdParam(shortGridElement, null, false);
			extendShortStopLoss(filledQty);
			log.info("[Gate] 空单成交 gridId:{}, qty:{}, 追挂止损", shortGridElement.getId(), filledQty);
			shortEntryTraderIdParam(shortGridElement, orderId, false);

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

			accumulatedShortLossCount = 0;
			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] 止盈挂单：超出基础仓位的部分，挂在多仓第一止损位
			placeExcessTakeProfit(posSize, false);
			log.info("[Gate] 空单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);

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

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

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

			accumulatedLongLossCount = 0;
			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] 止盈挂单：超出基础仓位的部分，挂在空仓第一止损位
			placeExcessTakeProfit(posSize, true);
			log.info("[Gate] 多单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);

			}
			}
			}

			private void TPonUserTradeShortEntry(GridElement gridElement) {
			if (!isMarginSafe()) {
			log.warn("[Gate] 保证金超限，跳过挂条件单");
			} else {
			// 判断网格是否能开多仓，如果不能则跳过
			GridElement upGridElement = GridElement.findById(gridElement.getUpId());
			if (upGridElement != null){
			BigDecimal upGridPrice = upGridElement.getGridPrice();
			TraderParam upLongTraderParam = upGridElement.getLongTraderParam();
			if (
			!upGridElement.isHasLongOrder() &&
			upGridPrice.compareTo(longEntryPrice) <= 0
			){
			placeEntryOrderWithPreFlag(upGridElement, true,
			upLongTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			upLongTraderParam.getQuantity());
			}
			}

			/**
			* 查询交易所当前持仓张数（绝对值）。加仓/开仓后重挂止盈止损时调用，
			* 绕过本地 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;
			}

			private void TPonUserTradeLongEntry(GridElement gridElement) {
			if (!isMarginSafe()) {
			log.warn("[Gate] 保证金超限，跳过挂条件单");
			} else {
			// 判断网格是否能开空仓，如果不能则跳过
			GridElement downGridElement = GridElement.findById(gridElement.getDownId());
			if (downGridElement != null){

			BigDecimal downGridPrice = downGridElement.getGridPrice();

			TraderParam shortTraderParam = downGridElement.getShortTraderParam();
			if (
			!downGridElement.isHasShortOrder() &&
			downGridPrice.compareTo(shortEntryPrice) >= 0
			){
			placeEntryOrderWithPreFlag(downGridElement, false,
			shortTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			negate(config.getQuantity()));
			}
			}
			/**
			* 查询交易所当前持仓均价，绕过本地 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 void onUserTradeShortEntry(GridElement gridElement) {
			if (!isMarginSafe()) {
			log.warn("[Gate] 保证金超限，跳过挂条件单");
			} else {
			//下一个开仓位置
			GridElement UpGridElement = GridElement.findById(gridElement.getDownId());
			BigDecimal newLongFirst = UpGridElement.getGridPrice();

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

			if (!UpGridElement.isHasShortOrder() && shortEntryPrice.compareTo(newLongFirst) > 0) {

			TraderParam upShortTraderParam = UpGridElement.getShortTraderParam();
			placeEntryOrderWithPreFlag(UpGridElement, false,
			upShortTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			negate(upShortTraderParam.getQuantity()));
			/**
			* 查询指定模式的持仓对象。
			*/
			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);
			}
			}

			private void onUserTradeLongEntry(GridElement gridElement) {
			if (!isMarginSafe()) {
			log.warn("[Gate] 保证金超限，跳过挂条件单");
			} else {
			//下一个开仓位置
			GridElement UpGridElement = GridElement.findById(gridElement.getUpId());
			BigDecimal newLongFirst = UpGridElement.getGridPrice() ;

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

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

			// ---- 网格队列处理 ----
			@@ -897,7 +771,6 @@
			* 止盈价 = 触发价 − step，通过 onSuccess 回调将 orderId → 止盈价存入 currentShortOrderIds</li>
			* <li>状态切换为 ACTIVE</li>
			* </ol>
			* 条件单成交后由 {@link #onOrderUpdate} 匹配止盈价并挂止盈条件单。
			*/
			private void tryGenerateQueues() {
			if (baseLongOpened && baseShortOpened) {
			@@ -913,47 +786,128 @@
			baseGridElement.setShortOrderId(baseShortTraderParam.getEntryOrderId());
			baseGridElement.setHasShortOrder(true);

			for (int id = 2; id <= 11; id++) {
			// // 空仓止损对应的多仓止盈：多仓止盈挂在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,
			config.getQuantity(),
			size,
			profitId -> {
			elem.setShortStopLossOrderId(profitId);
			elem.addShortStopLossOrderId(profitId);
			GridElement.refreshIndices();
			log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
			}
			);
			}

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


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

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

			state = StrategyState.ACTIVE;
			}
			}
			@@ -986,8 +940,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();
			}

			@@ -997,8 +957,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();
			}

			@@ -1010,12 +976,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;
			@@ -1037,10 +1008,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);
			}

			/**
			@@ -1063,9 +1040,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)
			@@ -1114,8 +1090,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());
			@@ -1153,221 +1129,162 @@
			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()));

			// 判断网格是否能开空仓，如果不能则跳过
			if (UpGridElement != null) {
			// 向下检查是否已有多单挂在更低价格网格，有则跳过（防止价格回升后重复挂单）
			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.isHasShortOrder() && shortEntryPrice.compareTo(newLongFirst) > 0) {
			//
			// TraderParam upShortTraderParam = UpGridElement.getShortTraderParam();
			// placeEntryOrderWithPreFlag(UpGridElement, false,
			// upShortTraderParam.getEntryPrice(),
			// FuturesPriceTrigger.RuleEnum.NUMBER_2,
			// negate(upShortTraderParam.getQuantity()));
			// }
			int i = UpGridElement.getId() + 2;
			GridElement downGridElement = GridElement.findById(i);
			if (downGridElement != null){

			BigDecimal downGridPrice = downGridElement.getGridPrice();

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

			TraderParam downLongTraderParam = downGridElement.getLongTraderParam();
			if (
			!downGridElement.isHasLongOrder() &&
			downGridPrice.compareTo(longEntryPrice) <= 0
			){
			placeEntryOrderWithPreFlag(downGridElement, true,
			downLongTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			downLongTraderParam.getQuantity());
			// 向上遍历取消所有遗留多单（跳过基础入场网格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()));

			// if (!UpGridElement.isHasLongOrder() && longEntryPrice.compareTo(newLongFirst) < 0) {
			// TraderParam upLongTraderParam = UpGridElement.getLongTraderParam();
			// placeEntryOrderWithPreFlag(UpGridElement, true,
			// upLongTraderParam.getEntryPrice(),
			// FuturesPriceTrigger.RuleEnum.NUMBER_1,
			// config.getQuantity());
			// }
			// 向上检查是否已有空单挂在更高价格网格，有则跳过（防止价格回落后重复挂单）
			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;
			}

			int i = UpGridElement.getId() - 2;
			GridElement downGridElement = GridElement.findById(i);
			if (downGridElement != 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));
			}

			BigDecimal downGridPrice = downGridElement.getGridPrice();

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

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

			placeEntryOrderWithPreFlag(downGridElement, false,
			shortTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			negate(config.getQuantity()));
			}
			}
			}
			}
			}

			private void handleLongStopLossTriggered(GridElement gridElement) {
			int gridId = gridElement.getId();
			int N = Math.abs(gridId);
			gridElement.setLongStopLossOrderId(null);
			log.info("[Gate] 多仓止损触发 gridId:{}, 开始追单", gridId);
			private void handleLongStopLossTriggered(GridElement gridElement, String orderId) {
			gridElement.removeLongStopLossOrderId(orderId);

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

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

			GridElement newEntryGrid = GridElement.findById(newEntryGridId);
			if (newEntryGrid == null) {
			@@ -1376,36 +1293,40 @@
			return;
			}

			if (N > 2) {
			int cancelGridId = -(N - 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);
			// 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
			BigDecimal triggerPrice = newEntryGrid.getGridPrice();
			String size = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()) + Integer.parseInt(config.getQuantity()));
			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);
			});
			}
			}

			BigDecimal triggerPrice = newEntryGrid.getGridPrice();
			BigDecimal priceDiff = longEntryPrice.subtract(triggerPrice).abs();
			int entryQty = priceDiff.divide(config.getStep(), 0, RoundingMode.DOWN).intValue();
			entryQty = Math.max(1, entryQty);
			String size = new BigDecimal(String.valueOf(entryQty)).multiply(new BigDecimal(config.getQuantity())).toString();
			log.info("[Gate] 多仓止损触发 gridId:{}, 在gridId:{}挂{}张多单, 均价:{}, 价差:{}, 步长:{}",
			gridId, newEntryGridId, entryQty, longEntryPrice, priceDiff, config.getStep());
			newEntryGrid.getLongTraderParam().setQuantity(size);
			placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
			}

			private void handleShortStopLossTriggered(GridElement gridElement) {
			int gridId = gridElement.getId();
			int N = gridId;
			gridElement.setShortStopLossOrderId(null);
			log.info("[Gate] 空仓止损触发 gridId:{}, 开始追单", gridId);
			private void handleShortStopLossTriggered(GridElement gridElement, String orderId) {
			gridElement.removeShortStopLossOrderId(orderId);

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

			GridElement newEntryGrid = GridElement.findById(newEntryGridId);
			if (newEntryGrid == null) {
			@@ -1414,151 +1335,546 @@
			return;
			}

			if (N > 2) {
			int cancelGridId = N - 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);
			});
			}
			}



			// 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
			BigDecimal triggerPrice = newEntryGrid.getGridPrice();
			BigDecimal priceDiff = shortEntryPrice.subtract(triggerPrice).abs();
			int entryQty = priceDiff.divide(config.getStep(), 0, RoundingMode.DOWN).intValue();
			entryQty = Math.max(1, entryQty);
			String size = new BigDecimal(String.valueOf(entryQty)).multiply(new BigDecimal(config.getQuantity())).toString();
			log.info("[Gate] 空仓止损触发 gridId:{}, 在gridId:{}挂{}张空单, 均价:{}, 价差:{}, 步长:{}",
			gridId, newEntryGridId, entryQty, shortEntryPrice, priceDiff, config.getStep());
			String size = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()) + Integer.parseInt(config.getQuantity()));
			newEntryGrid.getShortTraderParam().setQuantity(size);
			placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
			FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
			}

			private void extendLongStopLoss(int filledQty) {
			int furthestSlId = 0;
			for (GridElement e : config.getGridElements()) {
			if (e.getLongStopLossOrderId() != null && e.getId() < furthestSlId) {
			furthestSlId = e.getId();
			// 取消 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);
			});
			}
			}
			if (furthestSlId == 0) {
			furthestSlId = -11;
			}
			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 furthestSlId = 0;
			for (GridElement e : config.getGridElements()) {
			if (e.getShortStopLossOrderId() != null && e.getId() > furthestSlId) {
			furthestSlId = e.getId();
			}
			}
			if (furthestSlId == 0) {
			furthestSlId = 11;
			}
			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);
			}
			);
			}
			}

			private void checkProfitAndReset() {
			try {
			FuturesAccount account = futuresApi.listFuturesAccounts(SETTLE);
			BigDecimal unrealisedPnl = new BigDecimal(account.getCrossUnrealisedPnl());
			BigDecimal available = new BigDecimal(account.getCrossAvailable());
			BigDecimal totalEquity = unrealisedPnl.add(available);
			BigDecimal target = initialPrincipal.add(config.getExpectedProfit());
			log.info("[Gate] 盈亏检查 cross_unrealised_pnl:{}, cross_available:{}, 合计:{}, 目标:{}",
			unrealisedPnl, available, totalEquity, target);
			if (totalEquity.compareTo(target) > 0) {
			log.info("[Gate] 盈亏达标({}>{})，重置策略", totalEquity, target);
			state = StrategyState.STOPPED;
			closeExistingPositions();
			futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
			startGrid();
			}
			} catch (Exception e) {
			log.warn("[Gate] 盈亏检查失败", e);
			}
			}

			private void handlePositionZeroAndReset(String direction) {
			state = StrategyState.STOPPED;
			try {
			futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
			} catch (Exception e) {
			log.warn("[Gate] {}持仓归零后取消条件单失败", direction, e);
			}
			closeExistingPositions();
			startGrid();
			}

			// ---- 保证金安全阀 ----
			// ========== 止盈/止损取消辅助方法 ==========

			/**
			* 保证金安全阀检查。
			* 止盈触发后检查跨度是否达至要求，满足条件则重启策略。
			*
			* <p>实时查询当前保证金占用额（positionInitialMargin），计算其占初始本金的比例。
			* 比例 ≥ marginRatioLimit（默认 20%）时拒绝开仓，但仍照常更新队列。
			* <h3>跨度定义</h3>
			* {@code restartGridSpan} 表示多少倍的绝对步长 step（= 短基价 × gridRate）。
			*
			* <p>查询失败时默认放行（返回 true），避免因 REST API 异常导致策略完全停滞。
			*
			* @return true=安全可开仓 / false=保证金超限跳过开仓
			* <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 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 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);
			}

			/**
			* 挂单成交后，将超出基础仓位的部分挂止盈单，挂在对向仓位的第一止损位上。
			*
			* <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);
			}
			);
			}

			/**
			* 找到有长仓止损单且离 0 最近的网格（第一个多仓止损位）。
			*/
			private GridElement findFirstLongStopLossGrid() {
			GridElement first = null;
			for (GridElement e : config.getGridElements()) {
			if (!e.getLongStopLossOrderIds().isEmpty()) {
			// 多仓止损在负数区，取 id 最大（最靠近 0）的
			if (first == null \|\| e.getId() > first.getId()) {
			first = e;
			}
			}
			}
			return first;
			}

			/**
			* 找到有空仓止损单且离 0 最近的网格（第一个空仓止损位）。
			*/
			private GridElement findFirstShortStopLossGrid() {
			GridElement first = null;
			for (GridElement e : config.getGridElements()) {
			if (!e.getShortStopLossOrderIds().isEmpty()) {
			// 空仓止损在正数区，取 id 最小（最靠近 0）的
			if (first == null \|\| e.getId() < first.getId()) {
			first = e;
			}
			}
			}
			return first;
			}

			/**
			* 延展完成后重挂止损（处理被跳过的入场单成交）。
			* 取消已有止损单并用最新仓位重新挂单，确保止损覆盖最新持仓数。
			*/
			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);
			}
			}
			}
			}
			);
			}
			}

			@@ -1603,15 +1919,18 @@
			}
			},
			() -> {
			// 仅当列表为空（无其他有效订单）时才清预置标志，避免误伤其他并发挂单
			if (isLong) {
			gridElement.setHasLongOrder(false);
			gridElement.setLongOrderId(null);
			if (!gridElement.hasLongOrderIds()) {
			gridElement.setHasLongOrder(false);
			}
			} else {
			gridElement.setHasShortOrder(false);
			gridElement.setShortOrderId(null);
			if (!gridElement.hasShortOrderIds()) {
			gridElement.setHasShortOrder(false);
			}
			}
			GridElement.refreshIndices();
			log.warn("[Gate] 条件单创建失败，回滚标志位 gridId:{}, isLong:{}", gridElement.getId(), isLong);
			log.warn("[Gate] 条件单创建失败 gridId:{}, isLong:{}", gridElement.getId(), isLong);
			}
			);
			}
			@@ -1673,4 +1992,6 @@
			public Long getUserId() { return userId; }
			/** @return 当前策略状态 */
			public StrategyState getState() { return state; }
			/** 注入WS客户端，用于订阅状态检查 */
			public void setWsClient(GateKlineWebSocketClient wsClient) { this.wsClient = wsClient; }
			}