exchange.git - Gitblit

			@@ -24,79 +24,63 @@
			import com.xcong.excoin.modules.gateApi.wsHandler.handler.PositionsChannelHandler;

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

			if (e.getShortTakeProfitOrderId() != null){
			executor.cancelConditionalOrder(
			e.getShortTakeProfitOrderId(),
			orderId -> {
			shortTakeProfitTraderIdParam(
			e,
			null,
			false
			);
			}
			);
			}
			}
			}
			}
			@@ -457,11 +463,32 @@
			tryGenerateQueues();
			}else {
			shortPositionSize = size.abs();
			//取消多仓位线以上的开空仓挂单
			//取消空仓仓位线以下的开多仓挂单
			List<GridElement> allLongOrders = GridElement.findAllLongOrders(shortEntryPrice);
			if (CollUtil.isNotEmpty(allLongOrders)){
			for (GridElement e : allLongOrders) {
			executor.cancelOrder(e.getShortOrderId());
			executor.cancelConditionalOrder(
			e.getLongOrderId(),
			orderId -> {
			longEntryTraderIdParam(
			e,
			null,
			false
			);
			}
			);
			if (e.getLongTakeProfitOrderId() != null){
			executor.cancelConditionalOrder(
			e.getLongTakeProfitOrderId(),
			orderId -> {
			longTakeProfitTraderIdParam(
			e,
			null,
			false
			);
			}
			);
			}
			}
			}
			}
			@@ -629,12 +656,94 @@
			* @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;
			}
			log.info("[Gate] 条件单状态变更, id:{}, status:{}, reason:{}, order_type:{}",
			orderId, status, reason, orderType);
			if (!"finished".equals(status)) {
			return;
			}

			/**
			* 匹配止盈单止盈
			*/
			GridElement byLongTakeProfitOrderId = GridElement.findByLongTakeProfitOrderId(orderId);
			if (byLongTakeProfitOrderId != null){
			longTakeProfitTraderIdParam(
			byLongTakeProfitOrderId,
			null,
			false
			);
			longEntryTraderIdParam(
			byLongTakeProfitOrderId,
			null,
			false
			);
			}
			GridElement 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() && !tradeId.equals("0")){
			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() && !tradeId.equals("0")){
			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());
			}
			}
			}
			}
			}

			// ---- 网格队列处理 ----
			@@ -936,30 +1045,6 @@
			log.info("[Gate] 网格元素列表已构建, 共{}个元素 (空仓:{} 位置:0 多仓:{})", elements.size(), shortSize, longSize);
			}

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

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

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

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

			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
			);
			}
			}
			}

			}

			}

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

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

			BigDecimal downGridPrice = downGridElement.getGridPrice();

			int i = UpGridElement.getId() - 2;
			GridElement downGridElement = GridElement.findById(i);
			if (downGridElement != null){
			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()){
			executor.placeConditionalEntryOrder(
			shortTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_2,
			negate(config.getQuantity()),
			orderId ->
			{
			shortEntryTraderIdParam(
			downGridElement,
			orderId,
			true
			);
			},
			null
			);
			}
			}

			TraderParam downLongTraderParam = downGridElement.getLongTraderParam();
			BigDecimal downGridPrice = downGridElement.getGridPrice();
			if (
			!downGridElement.isHasLongOrder() &&
			downGridPrice.compareTo(currentPrice) > 0 &&
			downGridPrice.compareTo(longEntryPrice) <= 0 &&
			downGridPrice.compareTo(shortEntryPrice) >= 0
			){
			executor.placeConditionalEntryOrder(
			downLongTraderParam.getEntryPrice(),
			FuturesPriceTrigger.RuleEnum.NUMBER_1,
			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
			);
			}
			}
			}

			}

			}

			// ---- 保证金安全阀 ----