From e45e705c22df5bc979e72db6014dd1ff9637be42 Mon Sep 17 00:00:00 2001
From: Administrator <15274802129@163.com>
Date: Wed, 24 Jun 2026 22:21:58 +0800
Subject: [PATCH] fix(okx): 修复网格交易成交日志记录问题
---
src/main/java/com/xcong/excoin/modules/okxApi/OkxGridTradeService.java | 1221 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 1,221 insertions(+), 0 deletions(-)
diff --git a/src/main/java/com/xcong/excoin/modules/okxApi/OkxGridTradeService.java b/src/main/java/com/xcong/excoin/modules/okxApi/OkxGridTradeService.java
new file mode 100644
index 0000000..131952d
--- /dev/null
+++ b/src/main/java/com/xcong/excoin/modules/okxApi/OkxGridTradeService.java
@@ -0,0 +1,1221 @@
+package com.xcong.excoin.modules.okxApi;
+
+import cn.hutool.core.util.StrUtil;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.xcong.excoin.utils.dingtalk.DingTalkUtils;
+import lombok.extern.slf4j.Slf4j;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.*;
+
+/**
+ * OKX 网格交易策略引擎 — 多空对冲网格。
+ *
+ * <h3>策略原理</h3>
+ * 以空仓基底入场价（shortBaseEntryPrice）为价格基准，向上/向下各生成一个价格网格队列。
+ * 价格触发网格层级时挂条件单，成交后自动挂止盈单。每笔止盈盈利 = step - minTick。
+ *
+ * <h3>与 GateGridTradeService 的关系</h3>
+ * 策略逻辑完全一致，仅 API 层（REST/WS/签名）替换为 OKX 实现。
+ * GridElement 和 TraderParam 从 gateApi 包复用（交易所无关的数据模型）。
+ *
+ * <h3>完整生命周期</h3>
+ * <pre>
+ * 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
+ * ↓
+ * onKline() → processLongGrid() + processShortGrid()
+ * ├── 匹配队列元素 → 队列补偿 → 保证金检查
+ * ├── 首元素方向：挂条件开仓单 → 订单ID + GridElement状态同步
+ * └── 反向守卫：在 downGrid 位置挂对向单
+ * ↓
+ * onAutoOrder() ← orders-algo WS 推送
+ * ├── 匹配止盈单ID → 清空止盈状态（已成交）
+ * └── 匹配挂单ID → 挂止盈条件单 → 止盈ID + GridElement状态同步
+ * </pre>
+ *
+ * @author Administrator
+ */
+@Slf4j
+public class OkxGridTradeService {
+
+ public enum StrategyState {
+ WAITING_KLINE, OPENING, ACTIVE, STOPPED
+ }
+
+ /** 止盈条件单 order_type：平多仓 */
+ private static final String ORDER_TYPE_CLOSE_LONG = "plan-close-long-position";
+ /** 止盈条件单 order_type：平空仓 */
+ private static final String ORDER_TYPE_CLOSE_SHORT = "plan-close-short-position";
+
+ private final OkxConfig config;
+ private final OkxTradeExecutor executor;
+
+ private volatile StrategyState state = StrategyState.WAITING_KLINE;
+
+ /** 空仓价格队列，降序排列（大→小），容量 gridQueueSize */
+ 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<>());
+
+ /** 当前多仓条件单映射 */
+ private final Map<String, BigDecimal> currentLongOrderIds = Collections.synchronizedMap(new LinkedHashMap<>());
+ /** 当前空仓条件单映射 */
+ private final Map<String, BigDecimal> currentShortOrderIds = Collections.synchronizedMap(new LinkedHashMap<>());
+
+ /** 基底空头入场价 */
+ private BigDecimal shortBaseEntryPrice;
+ /** 基底多头入场价 */
+ private BigDecimal longBaseEntryPrice;
+ /** 基底多头是否已开 */
+ private volatile boolean baseLongOpened = false;
+ /** 基底空头是否已开 */
+ private volatile boolean baseShortOpened = false;
+
+ /** 空头是否活跃 */
+ private volatile boolean shortActive = false;
+ /** 多头是否活跃 */
+ private volatile boolean longActive = false;
+
+ /** 多头累计止损张数 */
+ private volatile int accumulatedLongLossCount = 0;
+ /** 空头累计止损张数 */
+ private volatile int accumulatedShortLossCount = 0;
+
+ private volatile BigDecimal lastKlinePrice;
+ private volatile BigDecimal markPrice = BigDecimal.ZERO;
+ private volatile BigDecimal cumulativePnl = BigDecimal.ZERO;
+ private volatile BigDecimal unrealizedPnl = BigDecimal.ZERO;
+ private volatile BigDecimal longEntryPrice = BigDecimal.ZERO;
+ private volatile BigDecimal shortEntryPrice = BigDecimal.ZERO;
+ private volatile BigDecimal longPositionSize = BigDecimal.ZERO;
+ private volatile BigDecimal shortPositionSize = BigDecimal.ZERO;
+ private volatile BigDecimal initialPrincipal = BigDecimal.ZERO;
+ private volatile OkxKlineWebSocketClient wsClient;
+
+ public OkxGridTradeService(OkxConfig config) {
+ this.config = config;
+ this.executor = new OkxTradeExecutor(config);
+ }
+
+ // ---- 仓位模式（替代 Gate 的 Position.ModeEnum）----
+
+ /** OKX 持仓方向枚举 */
+ public enum OkxPosMode { LONG, SHORT }
+
+ /** 持仓查询结果 */
+ static class OkxPositionInfo {
+ String size;
+ String entryPrice;
+ }
+
+ // ---- 初始化 ----
+
+ /**
+ * 初始化策略环境：获取账户信息 → 切双向持仓 → 清旧条件单 → 平仓 → 设杠杆。
+ */
+ public void init() {
+ try {
+ JSONObject account = executorGet("/api/v5/account/balance");
+ JSONArray dataArr = account.getJSONArray("data");
+ if (dataArr != null && !dataArr.isEmpty()) {
+ JSONArray details = dataArr.getJSONObject(0).getJSONArray("details");
+ if (details != null) {
+ for (int i = 0; i < details.size(); i++) {
+ JSONObject currency = details.getJSONObject(i);
+ if ("USDT".equals(currency.getString("ccy"))) {
+ this.initialPrincipal = currency.getBigDecimal("eq");
+ log.info("[OKX] 初始本金(USDT余额): {}", initialPrincipal);
+ break;
+ }
+ }
+ }
+ }
+
+ // 设置双向持仓模式
+ JSONObject posModeBody = new JSONObject();
+ posModeBody.put("posMode", config.getPositionMode());
+ executorPost("/api/v5/account/set-position-mode", posModeBody.toJSONString());
+ log.info("[OKX] 持仓模式已设为: {}", config.getPositionMode());
+
+ // 设置杠杆
+ JSONObject levBody = new JSONObject();
+ levBody.put("instId", config.getContract());
+ levBody.put("lever", config.getLeverage());
+ levBody.put("mgnMode", config.getMarginMode());
+ executorPost("/api/v5/account/set-leverage", levBody.toJSONString());
+ log.info("[OKX] 杠杆已设为: {}x {}", config.getLeverage(), config.getMarginMode());
+
+ executor.cancelAllPriceTriggeredOrders();
+ log.info("[OKX] 旧条件单已清除");
+ closeExistingPositions();
+
+ log.info("[OKX] 初始化完成");
+ } catch (Exception e) {
+ log.error("[OKX] 初始化失败", e);
+ }
+ }
+
+ /**
+ * 平掉当前合约的所有已有仓位。
+ */
+ private void closeExistingPositions() {
+ try {
+ JSONObject resp = executorGet("/api/v5/account/positions?instType=SWAP");
+ JSONArray data = resp.getJSONArray("data");
+ if (data == null || data.isEmpty()) {
+ log.info("[OKX] 无已有仓位");
+ return;
+ }
+ for (int i = 0; i < data.size(); i++) {
+ JSONObject pos = data.getJSONObject(i);
+ String instId = pos.getString("instId");
+ if (instId == null || !instId.equals(config.getContract())) {
+ continue;
+ }
+ String posVal = pos.getString("pos");
+ if (posVal == null || "0".equals(posVal)) {
+ continue;
+ }
+ String posSide = pos.getString("posSide");
+ String side = "long".equals(posSide) ? "sell" : "buy";
+
+ JSONObject body = new JSONObject();
+ body.put("instId", config.getContract());
+ body.put("tdMode", "cross");
+ body.put("side", side);
+ body.put("posSide", posSide);
+ body.put("ordType", "market");
+ body.put("sz", posVal);
+ executorPost("/api/v5/trade/order", body.toJSONString());
+ log.info("[OKX] 平已有仓位, posSide:{}, sz:{}", posSide, posVal);
+ }
+ } catch (Exception e) {
+ log.warn("[OKX] 平仓位异常", e);
+ }
+ }
+
+ // ---- 启动/停止 ----
+
+ public void startGrid() {
+ if (state != StrategyState.WAITING_KLINE && state != StrategyState.STOPPED) {
+ log.warn("[OKX] 策略已在运行中, state:{}", state);
+ return;
+ }
+ state = StrategyState.WAITING_KLINE;
+ cumulativePnl = BigDecimal.ZERO;
+ unrealizedPnl = BigDecimal.ZERO;
+ markPrice = BigDecimal.ZERO;
+ longEntryPrice = BigDecimal.ZERO;
+ shortEntryPrice = BigDecimal.ZERO;
+ longPositionSize = BigDecimal.ZERO;
+ shortPositionSize = BigDecimal.ZERO;
+ baseLongOpened = false;
+ baseShortOpened = false;
+ longActive = false;
+ shortActive = false;
+ accumulatedLongLossCount = 0;
+ accumulatedShortLossCount = 0;
+ shortPriceQueue.clear();
+ longPriceQueue.clear();
+ totalShortPriceQueue.clear();
+ totalLongPriceQueue.clear();
+ currentLongOrderIds.clear();
+ currentShortOrderIds.clear();
+ refreshInitialPrincipal();
+ log.info("[OKX] 网格策略已启动, 当前本金: {} USDT", initialPrincipal);
+ }
+
+ private void refreshInitialPrincipal() {
+ try {
+ JSONObject account = executorGet("/api/v5/account/balance");
+ JSONArray dataArr = account.getJSONArray("data");
+ if (dataArr != null && !dataArr.isEmpty()) {
+ JSONArray details = dataArr.getJSONObject(0).getJSONArray("details");
+ if (details != null) {
+ for (int i = 0; i < details.size(); i++) {
+ JSONObject currency = details.getJSONObject(i);
+ if ("USDT".equals(currency.getString("ccy"))) {
+ this.initialPrincipal = currency.getBigDecimal("eq");
+ break;
+ }
+ }
+ }
+ }
+ } catch (Exception e) {
+ log.warn("[OKX] 获取初始化本金失败，使用旧值: {}", initialPrincipal);
+ }
+ }
+
+ public void stopGrid() {
+ state = StrategyState.STOPPED;
+ executor.cancelAllPriceTriggeredOrders();
+ closeExistingPositions();
+ executor.shutdown();
+ log.info("[OKX] 策略已停止, 累计盈亏: {}", cumulativePnl);
+ }
+
+ // ---- K线回调 ----
+
+ public void onKline(BigDecimal closePrice) {
+ lastKlinePrice = closePrice;
+
+ if (state == StrategyState.WAITING_KLINE) {
+ if (wsClient == null || !wsClient.areAllSubscribed()) {
+ return;
+ }
+ state = StrategyState.OPENING;
+ String size = config.getBaseQuantity();
+ log.info("[OKX] 首根K线到达，开基底仓位 多空各{}张...", size);
+ executor.openLong(size, (orderId) -> {
+ TraderParam baseLongTp = TraderParam.builder()
+ .entryOrderId(orderId)
+ .build();
+ config.setBaseLongTraderParam(baseLongTp);
+ baseLongOpened = true;
+ }, null);
+ executor.openShort(size, (orderId) -> {
+ TraderParam baseShortTp = TraderParam.builder()
+ .entryOrderId(orderId)
+ .build();
+ config.setBaseShortTraderParam(baseShortTp);
+ baseShortOpened = true;
+ }, null);
+ return;
+ }
+
+
+
+ if (state == StrategyState.ACTIVE &&
+ !longActive &&
+ longPositionSize.compareTo(BigDecimal.ZERO) == 0) {
+ processShortGrid(closePrice);
+ }
+
+ if (state == StrategyState.ACTIVE &&
+ !shortActive &&
+ shortPositionSize.compareTo(BigDecimal.ZERO) == 0) {
+ processLongGrid(closePrice);
+ }
+ }
+
+ // ---- 仓位推送回调 ----
+
+ /**
+ * 仓位推送回调。由 PositionsOkxChannelHandler 调用。
+ * direction 使用 TraderParam.Direction：LONG 表示多头，SHORT 表示空头。
+ */
+ public void onPositionUpdate(String contract, TraderParam.Direction direction, BigDecimal size,
+ BigDecimal entryPrice) {
+ if (state == StrategyState.STOPPED || state == StrategyState.WAITING_KLINE) {
+ return;
+ }
+
+ boolean hasPosition = size.abs().compareTo(BigDecimal.ZERO) > 0;
+ boolean isLong = (direction == TraderParam.Direction.LONG);
+
+ if (state == StrategyState.OPENING) {
+ // 基底成交通知仅记录价格/数量，flag 在 REST 回调中设置
+ if (isLong && hasPosition) {
+ longActive = true;
+ longPositionSize = size;
+ longEntryPrice = entryPrice;
+ longBaseEntryPrice = entryPrice;
+ log.info("[OKX] 基底多成交价: {}", longBaseEntryPrice);
+ tryGenerateQueues();
+ } else if (!isLong && hasPosition) {
+ shortActive = true;
+ shortPositionSize = size.abs();
+ shortEntryPrice = entryPrice;
+ shortBaseEntryPrice = entryPrice;
+ log.info("[OKX] 基底空成交价: {}", shortBaseEntryPrice);
+ tryGenerateQueues();
+ }
+ }
+
+ if (state == StrategyState.ACTIVE) {
+ if (isLong) {
+ if (hasPosition) {
+ longActive = true;
+ longPositionSize = size;
+ longEntryPrice = entryPrice;
+ } else {
+ log.info("[OKX-0]多仓归零: {}", shortBaseEntryPrice);
+ longActive = false;
+ longPositionSize = BigDecimal.ZERO;
+ longEntryPrice = BigDecimal.ZERO;
+ }
+ } else {
+ if (hasPosition) {
+ shortActive = true;
+ shortPositionSize = size.abs();
+ shortEntryPrice = entryPrice;
+ } else {
+ log.info("[OKX-0]空仓归零: {}", shortBaseEntryPrice);
+ shortActive = false;
+ shortPositionSize = BigDecimal.ZERO;
+ shortEntryPrice = BigDecimal.ZERO;
+ }
+ }
+ }
+
+ if (state == StrategyState.ACTIVE && !shortActive && !longActive) {
+ executor.cancelAllPriceTriggeredOrders();
+ closeExistingPositions();
+ state = StrategyState.STOPPED;
+ executor.submitTask(() -> {
+ try { Thread.sleep(3000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
+ startGrid();
+ });
+ log.info("[OKX] 重置策略");
+ }
+ }
+
+ // ---- 平仓推送回调 ----
+
+ /**
+ * 平仓盈亏累加（OKX 目前没有独立的 position_closes 频道，
+ * 盈亏信息可从 orders 频道或 REST API 获取，这里保留接口以备将来使用）。
+ */
+ public void onPositionClose(String contract, String side, BigDecimal pnl) {
+ if (state == StrategyState.STOPPED) {
+ return;
+ }
+ cumulativePnl = cumulativePnl.add(pnl);
+ updateUnrealizedPnl();
+ BigDecimal totalPnl = cumulativePnl.add(unrealizedPnl);
+ log.info("[OKX] 已实现:{}, 未实现:{}, 合计:{}",
+ cumulativePnl, unrealizedPnl, totalPnl);
+ if (totalPnl.compareTo(config.getMaxLoss().negate()) <= 0) {
+ String logMessage = StrUtil.format("[OKX] 已达亏损风险值(合计{}), 已实现:{}, 未实现:{}",
+ totalPnl, cumulativePnl, unrealizedPnl);
+ log.info(logMessage);
+ DingTalkUtils.getDefault().sendActionCard("风险提醒", logMessage, config.getApiKey(), "");
+ }
+ }
+
+ // ---- 自动订单（条件单）状态变更回调 ----
+
+ /**
+ * 自动订单状态变更回调。由 OrdersOkxChannelHandler 调用。
+ */
+ public void onAutoOrder(String orderId, String status, String reason, String orderType, String tradeId) {
+ if (state == StrategyState.STOPPED) {
+ return;
+ }
+ log.info("[OKX] 条件单状态变更, id:{}, status:{}, reason:{}, order_type:{}",
+ orderId, status, reason, orderType);
+ if (!"finished".equals(status)) {
+ return;
+ }
+
+ // 多仓止盈触发
+ GridElement longTpElem = GridElement.findByLongTakeProfitOrderId(orderId);
+ if (longTpElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ longTakeProfitTraderIdParam(longTpElem, null, false);
+ log.info("[OKX] 多仓止盈触发 gridId:{}, orderId:{}", longTpElem.getId(), orderId);
+ cancelFarthestLongStopLoss();
+ checkLastTakeProfitAndRestart();
+ return;
+ }
+ // 空仓止盈触发
+ GridElement shortTpElem = GridElement.findByShortTakeProfitOrderId(orderId);
+ if (shortTpElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ shortTakeProfitTraderIdParam(shortTpElem, null, false);
+ log.info("[OKX] 空仓止盈触发 gridId:{}, orderId:{}", shortTpElem.getId(), orderId);
+ cancelFarthestShortStopLoss();
+ checkLastTakeProfitAndRestart();
+ return;
+ }
+
+ // 多仓止损触发
+ GridElement longStopLossElem = GridElement.findByLongStopLossOrderId(orderId);
+ if (longStopLossElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ handleLongStopLossTriggered(longStopLossElem);
+ return;
+ }
+ // 空仓止损触发
+ GridElement shortStopLossElem = GridElement.findByShortStopLossOrderId(orderId);
+ if (shortStopLossElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ handleShortStopLossTriggered(shortStopLossElem);
+ return;
+ }
+
+ // 空仓挂单成交
+ GridElement shortGridElement = GridElement.findByShortOrderId(orderId);
+ if (shortGridElement != null) {
+ if (shortGridElement.isHasShortOrder() && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ int filledQty = Integer.parseInt(shortGridElement.getShortTraderParam().getQuantity());
+ shortEntryTraderIdParam(shortGridElement, null, false);
+ cancelAllShortTakeProfitsAndStopLosses();
+ int posSize = queryPositionSize(OkxPosMode.SHORT);
+ extendShortStopLoss(posSize, shortGridElement.getId());
+ accumulatedShortLossCount = 0;
+ log.info("[OKX] 空单成交 gridId:{}, 成交{}张, 当前持仓:{}张",
+ shortGridElement.getId(), filledQty, posSize);
+
+ BigDecimal shortBaseQty = new BigDecimal(config.getBaseQuantity());
+ BigDecimal shortGridQty = new BigDecimal(config.getQuantity());
+ if (BigDecimal.valueOf(posSize).compareTo(shortBaseQty) > 0) {
+ BigDecimal shortExcess = BigDecimal.valueOf(posSize).subtract(shortBaseQty);
+ int shortExcessCount = shortExcess.divide(shortGridQty, 0, RoundingMode.DOWN).intValue();
+ for (int i = 0; i < shortExcessCount; i++) {
+ int tpGridId = shortGridElement.getId() - 2 - i;
+ if (i > 0) { tpGridId = tpGridId - 1; }
+ GridElement tpElem = GridElement.findById(tpGridId);
+ if (tpElem == null || tpElem.getShortTakeProfitOrderId() != null) {
+ continue;
+ }
+ BigDecimal tpPrice = tpElem.getGridPrice();
+ int finalTpGridId = tpGridId;
+ executor.placeTakeProfit(
+ tpPrice,
+ "close_short",
+ config.getQuantity(),
+ profitId -> {
+ shortTakeProfitTraderIdParam(tpElem, profitId, true);
+ log.info("[OKX] 空仓止盈挂单, gridId:{}, 触发价:{}, takeProfitId:{}",
+ finalTpGridId, tpPrice, profitId);
+ }
+ );
+ }
+ }
+ }
+ }
+ // 多仓挂单成交
+ GridElement longGridElement = GridElement.findByLongOrderId(orderId);
+ if (longGridElement != null) {
+ if (longGridElement.isHasLongOrder() && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ int filledQty = Integer.parseInt(longGridElement.getLongTraderParam().getQuantity());
+ longEntryTraderIdParam(longGridElement, null, false);
+ cancelAllLongTakeProfitsAndStopLosses();
+ int posSize = queryPositionSize(OkxPosMode.LONG);
+ extendLongStopLoss(posSize, longGridElement.getId());
+ accumulatedLongLossCount = 0;
+ log.info("[OKX] 多单成交 gridId:{}, 成交{}张, 当前持仓:{}张",
+ longGridElement.getId(), filledQty, posSize);
+
+ BigDecimal longBaseQty = new BigDecimal(config.getBaseQuantity());
+ BigDecimal longGridQty = new BigDecimal(config.getQuantity());
+ if (BigDecimal.valueOf(posSize).compareTo(longBaseQty) > 0) {
+ BigDecimal longExcess = BigDecimal.valueOf(posSize).subtract(longBaseQty);
+ int longExcessCount = longExcess.divide(longGridQty, 0, RoundingMode.DOWN).intValue();
+ for (int i = 0; i < longExcessCount; i++) {
+ int tpGridId = longGridElement.getId() + 2 + i;
+ if (i > 0) { tpGridId = tpGridId + 1; }
+ GridElement tpElem = GridElement.findById(tpGridId);
+ if (tpElem == null || tpElem.getLongTakeProfitOrderId() != null) {
+ continue;
+ }
+ BigDecimal tpPrice = tpElem.getGridPrice();
+ int finalTpGridId = tpGridId;
+ executor.placeTakeProfit(
+ tpPrice,
+ "close_long",
+ config.getQuantity(),
+ profitId -> {
+ longTakeProfitTraderIdParam(tpElem, profitId, true);
+ log.info("[OKX] 多仓止盈挂单, gridId:{}, 触发价:{}, takeProfitId:{}",
+ finalTpGridId, tpPrice, profitId);
+ }
+ );
+ }
+ }
+ }
+ }
+ }
+
+ // ========== REST 查询辅助 ==========
+
+ private int queryPositionSize(OkxPosMode mode) {
+ OkxPositionInfo p = queryPosition(mode);
+ if (p != null) {
+ return new BigDecimal(p.size).abs().intValue();
+ }
+ return 0;
+ }
+
+ private BigDecimal queryEntryPrice(OkxPosMode mode) {
+ OkxPositionInfo p = queryPosition(mode);
+ if (p != null && p.entryPrice != null) {
+ return new BigDecimal(p.entryPrice);
+ }
+ return BigDecimal.ZERO;
+ }
+
+ private OkxPositionInfo queryPosition(OkxPosMode mode) {
+ try {
+ JSONObject resp = executorGet("/api/v5/account/positions?instType=SWAP");
+ JSONArray data = resp.getJSONArray("data");
+ if (data != null) {
+ for (int i = 0; i < data.size(); i++) {
+ JSONObject p = data.getJSONObject(i);
+ if (config.getContract().equals(p.getString("instId"))
+ && mode.name().toLowerCase().equals(p.getString("posSide"))) {
+ OkxPositionInfo info = new OkxPositionInfo();
+ info.size = p.getString("pos");
+ info.entryPrice = p.getString("avgPx");
+ return info;
+ }
+ }
+ }
+ } catch (Exception e) {
+ log.warn("[OKX] 查询{}持仓失败", mode, e);
+ }
+ return null;
+ }
+
+ // ---- REST 快捷方法 ----
+
+ private JSONObject executorGet(String path) throws Exception {
+ return executor.okGet(path);
+ }
+
+ private JSONObject executorPost(String path, String body) throws Exception {
+ return executor.okPost(path, body);
+ }
+
+ // ---- 网格队列处理 ----
+
+ private void tryGenerateQueues() {
+ // OPENING 状态下若 WS 仓位已确认但 REST 回调尚未完成，等标记价格推送时重试队列生成
+ if (state == StrategyState.OPENING && baseLongOpened && baseShortOpened) {
+ // 确保 openLong/openShort 的 REST 回调已完成（WS 推送可能比回调更快到达）
+ if (config.getBaseLongTraderParam() == null || config.getBaseShortTraderParam() == null) {
+ log.warn("[OKX] 基底REST回调尚未完成, 延后队列生成");
+ return;
+ }
+
+ generateShortQueue();
+ generateLongQueue();
+ updateGridElements();
+
+ GridElement baseGridElement = GridElement.findById(0);
+ TraderParam baseLongTraderParam = config.getBaseLongTraderParam();
+ baseGridElement.setLongOrderId(baseLongTraderParam.getEntryOrderId());
+ baseGridElement.setHasLongOrder(true);
+ TraderParam baseShortTraderParam = config.getBaseShortTraderParam();
+ baseGridElement.setShortOrderId(baseShortTraderParam.getEntryOrderId());
+ baseGridElement.setHasShortOrder(true);
+
+ // 挂初始止损
+ int stopCount = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
+ for (int id = 2; id <= stopCount; id++) {
+ GridElement elem = GridElement.findById(id);
+ if (elem == null) {
+ continue;
+ }
+ BigDecimal triggerPrice = elem.getGridPrice();
+ int finalId = id;
+ executor.placeStopLoss(triggerPrice, "close_short", config.getQuantity(),
+ profitId -> {
+ elem.setShortStopLossOrderId(profitId);
+ GridElement.refreshIndices();
+ log.info("[OKX] 空仓止损已挂, gridId:{}, 触发价:{}, slId:{}", finalId, triggerPrice, profitId);
+ });
+ }
+ for (int id = -2; id >= -stopCount; id--) {
+ GridElement elem = GridElement.findById(id);
+ if (elem == null) {
+ continue;
+ }
+ BigDecimal triggerPrice = elem.getGridPrice();
+ int finalId = id;
+ executor.placeStopLoss(triggerPrice, "close_long", config.getQuantity(),
+ profitId -> {
+ elem.setLongStopLossOrderId(profitId);
+ GridElement.refreshIndices();
+ log.info("[OKX] 多仓止损已挂, gridId:{}, 触发价:{}, slId:{}", finalId, triggerPrice, profitId);
+ });
+ }
+ log.info("[OKX] 止损单已全部挂完, 空仓止损: 2~{}, 多仓止损: -2~-{}", stopCount, stopCount);
+
+ state = StrategyState.ACTIVE;
+ }
+ }
+
+ // ---- TraderParam 更新辅助方法 ----
+
+ private void longTakeProfitTraderIdParam(GridElement e, String profitId, boolean flag) {
+ TraderParam tp = e.getLongTraderParam();
+ tp.setTakeProfitOrderId(profitId);
+ tp.setTakeProfitPlaced(flag);
+ e.setLongTakeProfitOrderId(profitId);
+ GridElement.refreshIndices();
+ }
+
+ private void shortTakeProfitTraderIdParam(GridElement e, String profitId, boolean flag) {
+ TraderParam tp = e.getShortTraderParam();
+ tp.setTakeProfitOrderId(profitId);
+ tp.setTakeProfitPlaced(flag);
+ e.setShortTakeProfitOrderId(profitId);
+ GridElement.refreshIndices();
+ }
+
+ private void longEntryTraderIdParam(GridElement e, String entryId, boolean flag) {
+ TraderParam tp = e.getLongTraderParam();
+ tp.setEntryOrderId(entryId);
+ tp.setEntryOrderPlaced(flag);
+ e.setHasLongOrder(flag);
+ e.setLongOrderId(entryId);
+ GridElement.refreshIndices();
+ }
+
+ private void shortEntryTraderIdParam(GridElement e, String entryId, boolean flag) {
+ TraderParam tp = e.getShortTraderParam();
+ tp.setEntryOrderId(entryId);
+ tp.setEntryOrderPlaced(flag);
+ e.setHasShortOrder(flag);
+ e.setShortOrderId(entryId);
+ GridElement.refreshIndices();
+ }
+
+ // ---- 队列生成 ----
+
+ 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;
+ }
+ }
+ shortPriceQueue.sort((a, b) -> b.compareTo(a));
+ log.info("[OKX] 空队列:{}", shortPriceQueue);
+ }
+
+ private void generateLongQueue() {
+ longPriceQueue.clear();
+ int prec = config.getPriceScale();
+ BigDecimal step = config.getStep();
+ 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("[OKX] 多队列:{}", longPriceQueue);
+ totalShortPriceQueue.sort((a, b) -> b.compareTo(a));
+ totalLongPriceQueue.sort(BigDecimal::compareTo);
+ }
+
+ private void updateGridElements() {
+ List<GridElement> elements = new ArrayList<>();
+ int shortSize = shortPriceQueue.size();
+ int longSize = longPriceQueue.size();
+ int prec = config.getPriceScale();
+ BigDecimal step = config.getStep();
+ String qty = config.getQuantity();
+
+ // 空仓队列：id 从 -1 自减
+ for (int i = 0; i < shortSize; i++) {
+ int id = -(i + 1);
+ Integer upId = (i == 0) ? 0 : id + 1;
+ Integer downId = (i == shortSize - 1) ? null : id - 1;
+ BigDecimal price = shortPriceQueue.get(i);
+ elements.add(GridElement.builder()
+ .id(id).gridPrice(price).upId(upId).downId(downId)
+ .longTraderParam(TraderParam.builder().direction(TraderParam.Direction.LONG)
+ .entryPrice(price).takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
+ .quantity(qty).build())
+ .shortTraderParam(TraderParam.builder().direction(TraderParam.Direction.SHORT)
+ .entryPrice(price).takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
+ .quantity(qty).build())
+ .build());
+ }
+
+ // 位置 0
+ {
+ BigDecimal price = shortBaseEntryPrice;
+ elements.add(GridElement.builder()
+ .id(0).gridPrice(price)
+ .upId(longSize > 0 ? 1 : null).downId(shortSize > 0 ? -1 : null)
+ .longTraderParam(TraderParam.builder().direction(TraderParam.Direction.LONG)
+ .entryPrice(price).takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
+ .quantity(qty).build())
+ .shortTraderParam(TraderParam.builder().direction(TraderParam.Direction.SHORT)
+ .entryPrice(price).takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
+ .quantity(qty).build())
+ .build());
+ }
+
+ // 多仓队列：id 从 1 自增
+ for (int i = 0; i < longSize; i++) {
+ int id = i + 1;
+ Integer downId = (i == 0) ? 0 : id - 1;
+ Integer upId = (i == longSize - 1) ? null : id + 1;
+ BigDecimal price = longPriceQueue.get(i);
+ elements.add(GridElement.builder()
+ .id(id).gridPrice(price).upId(upId).downId(downId)
+ .longTraderParam(TraderParam.builder().direction(TraderParam.Direction.LONG)
+ .entryPrice(price).takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
+ .quantity(qty).build())
+ .shortTraderParam(TraderParam.builder().direction(TraderParam.Direction.SHORT)
+ .entryPrice(price).takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
+ .quantity(qty).build())
+ .build());
+ }
+
+ config.setGridElements(elements);
+ log.info("[OKX] 网格元素列表已构建, 共{}个元素 (空仓:{} 位置:0 多仓:{})", elements.size(), shortSize, longSize);
+ }
+
+ // ---- processShortGrid / processLongGrid ----
+
+ private void processShortGrid(BigDecimal currentPrice) {
+ BigDecimal matched = BigDecimal.ZERO;
+ synchronized (totalLongPriceQueue) {
+ for (BigDecimal p : totalLongPriceQueue) {
+ if (p.compareTo(currentPrice) >= 0) { matched = p; break; }
+ }
+ if (BigDecimal.ZERO.compareTo(matched) == 0) {
+ return;
+ }
+ GridElement matchedUpGridElement = GridElement.findByPrice(matched);
+ if (matchedUpGridElement != null && !matchedUpGridElement.isHasLongOrder()) {
+ Integer upId = matchedUpGridElement.getUpId();
+ GridElement newEntryGrid = GridElement.findById(upId);
+ if (newEntryGrid != null) {
+ GridElement cancelGridElement = GridElement.findById(newEntryGrid.getUpId());
+ String quantity = cancelGridElement != null
+ ? cancelGridElement.getLongTraderParam().getQuantity()
+ : config.getBaseQuantity();
+ if (cancelGridElement != null && cancelGridElement.isHasLongOrder()) {
+ String longOrderId = cancelGridElement.getLongOrderId();
+ executor.cancelConditionalOrder(longOrderId, oid -> {
+ longEntryTraderIdParam(cancelGridElement, null, false);
+ log.info("[OKX] 多仓仓位归零, 取消gridId:{}的多单,{}", cancelGridElement.getId(), longOrderId);
+ });
+ }
+ if (!newEntryGrid.isHasLongOrder()) {
+ BigDecimal triggerPrice = newEntryGrid.getGridPrice();
+ String size = quantity;
+ log.info("[OKX] 多仓仓位归零 gridId:{}, 挂{}基础张多单", newEntryGrid.getId(), size);
+ newEntryGrid.getLongTraderParam().setQuantity(size);
+ placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice, size);
+ }
+ }
+ }
+ }
+ }
+
+ private void processLongGrid(BigDecimal currentPrice) {
+ BigDecimal matched = BigDecimal.ZERO;
+ synchronized (totalShortPriceQueue) {
+ for (BigDecimal p : totalShortPriceQueue) {
+ if (p.compareTo(currentPrice) <= 0) { matched = p; break; }
+ }
+ if (BigDecimal.ZERO.compareTo(matched) == 0) {
+ return;
+ }
+ GridElement matchedUpGridElement = GridElement.findByPrice(matched);
+ if (matchedUpGridElement != null && !matchedUpGridElement.isHasShortOrder()) {
+ Integer downId = matchedUpGridElement.getDownId();
+ GridElement newEntryGrid = GridElement.findById(downId);
+ if (newEntryGrid != null) {
+ GridElement cancelGridElement = GridElement.findById(newEntryGrid.getDownId());
+ String quantity = cancelGridElement != null
+ ? cancelGridElement.getShortTraderParam().getQuantity()
+ : config.getBaseQuantity();
+ if (cancelGridElement != null && cancelGridElement.isHasShortOrder()) {
+ String shortOrderId = cancelGridElement.getShortOrderId();
+ executor.cancelConditionalOrder(shortOrderId, oid -> {
+ shortEntryTraderIdParam(cancelGridElement, null, false);
+ log.info("[OKX] 空仓仓位归零, 取消gridId:{}的空单{}", cancelGridElement.getId(), shortOrderId);
+ });
+ }
+ if (!newEntryGrid.isHasShortOrder()) {
+ BigDecimal triggerPrice = newEntryGrid.getGridPrice();
+ String size = quantity;
+ log.info("[OKX] 空仓仓位归零 gridId:{}, 挂{}基础张空单", newEntryGrid.getId(), size);
+ newEntryGrid.getShortTraderParam().setQuantity(size);
+ placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice, negate(size));
+ }
+ }
+ }
+ }
+ }
+
+ // ---- 止损处理 ----
+
+ private void handleLongStopLossTriggered(GridElement gridElement) {
+ gridElement.setLongStopLossOrderId(null);
+ int gridId = gridElement.getId();
+ log.info("[OKX] 多仓止损触发 gridId:{}, 开始追单", gridId);
+ int newEntryGridId = gridId + 1;
+ GridElement newEntryGrid = GridElement.findById(newEntryGridId);
+ if (newEntryGrid == null) {
+ log.warn("[OKX] 多仓止损触发 but gridId:{} 不存在", newEntryGridId);
+ GridElement.refreshIndices();
+ return;
+ }
+ if (!newEntryGrid.isHasLongOrder()) {
+ BigDecimal triggerPrice = newEntryGrid.getGridPrice();
+ accumulatedLongLossCount += Integer.parseInt(config.getQuantity());
+ String size = String.valueOf(accumulatedLongLossCount + Integer.parseInt(config.getQuantity()));
+ log.info("[OKX] 多仓止损触发 gridId:{}, 在gridId:{}挂{}基础张多单", gridId, newEntryGridId, size);
+ newEntryGrid.getLongTraderParam().setQuantity(size);
+ placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice, size);
+ } else {
+ log.warn("[OKX] 多仓止损触发 gridId:{}, 目标gridId:{}已有挂单，跳过", gridId, newEntryGridId);
+ }
+ int cancelGridId = gridId + 2;
+ GridElement cancelGrid = GridElement.findById(cancelGridId);
+ if (cancelGrid != null && cancelGrid.isHasLongOrder()) {
+ executor.cancelConditionalOrder(cancelGrid.getLongOrderId(), oid -> {
+ longEntryTraderIdParam(cancelGrid, null, false);
+ log.info("[OKX] 多仓止损触发, 取消gridId:{}的多单", cancelGridId);
+ });
+ }
+ GridElement farthestLongTp = null;
+ for (GridElement e : config.getGridElements()) {
+ if (e.getLongTakeProfitOrderId() != null) {
+ if (farthestLongTp == null || e.getGridPrice().compareTo(farthestLongTp.getGridPrice()) > 0) {
+ farthestLongTp = e;
+ }
+ }
+ }
+ if (farthestLongTp != null) {
+ String tpOrderId = farthestLongTp.getLongTakeProfitOrderId();
+ GridElement finalFarthest = farthestLongTp;
+ executor.cancelConditionalOrder(tpOrderId, oid -> {
+ longTakeProfitTraderIdParam(finalFarthest, null, false);
+ log.info("[OKX] 多仓止损触发, 取消最远止盈 gridId:{}, orderId:{}", finalFarthest.getId(), tpOrderId);
+ });
+ }
+ }
+
+ private void handleShortStopLossTriggered(GridElement gridElement) {
+ gridElement.setShortStopLossOrderId(null);
+ int gridId = gridElement.getId();
+ log.info("[OKX] 空仓止损触发 gridId:{}, 开始追单", gridId);
+ int newEntryGridId = gridId - 1;
+ GridElement newEntryGrid = GridElement.findById(newEntryGridId);
+ if (newEntryGrid == null) {
+ log.warn("[OKX] 空仓止损触发 but gridId:{} 不存在", newEntryGridId);
+ GridElement.refreshIndices();
+ return;
+ }
+ if (!newEntryGrid.isHasShortOrder()) {
+ BigDecimal triggerPrice = newEntryGrid.getGridPrice();
+ accumulatedShortLossCount += Integer.parseInt(config.getQuantity());
+ String size = String.valueOf(accumulatedShortLossCount + Integer.parseInt(config.getQuantity()));
+ log.info("[OKX] 空仓止损触发 gridId:{}, 在gridId:{}挂{}基础张空单", gridId, newEntryGridId, size);
+ newEntryGrid.getShortTraderParam().setQuantity(size);
+ placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice, negate(size));
+ } else {
+ log.warn("[OKX] 空仓止损触发 gridId:{}, 目标gridId:{}已有挂单，跳过", gridId, newEntryGridId);
+ }
+ int cancelGridId = gridId - 2;
+ GridElement cancelGrid = GridElement.findById(cancelGridId);
+ if (cancelGrid != null && cancelGrid.isHasShortOrder()) {
+ executor.cancelConditionalOrder(cancelGrid.getShortOrderId(), oid -> {
+ shortEntryTraderIdParam(cancelGrid, null, false);
+ log.info("[OKX] 空仓止损触发, 取消gridId:{}的空单", cancelGridId);
+ });
+ }
+ GridElement farthestShortTp = null;
+ for (GridElement e : config.getGridElements()) {
+ if (e.getShortTakeProfitOrderId() != null) {
+ if (farthestShortTp == null || e.getGridPrice().compareTo(farthestShortTp.getGridPrice()) < 0) {
+ farthestShortTp = e;
+ }
+ }
+ }
+ if (farthestShortTp != null) {
+ String tpOrderId = farthestShortTp.getShortTakeProfitOrderId();
+ GridElement finalFarthest = farthestShortTp;
+ executor.cancelConditionalOrder(tpOrderId, oid -> {
+ shortTakeProfitTraderIdParam(finalFarthest, null, false);
+ log.info("[OKX] 空仓止损触发, 取消最远止盈 gridId:{}, orderId:{}", finalFarthest.getId(), tpOrderId);
+ });
+ }
+ }
+
+ // ---- 止盈/止损取消辅助 ----
+
+ private void checkLastTakeProfitAndRestart() {
+ int span = config.getRestartGridSpan();
+ if (span <= 0) {
+ return;
+ }
+
+ if (GridElement.getLongTakeProfitCount() > 0 || GridElement.getShortTakeProfitCount() > 0) {
+ log.info("[OKX] 尚有未触发止盈单, 暂不检查跨度重启 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;
+ }
+
+ // 查交易所获取最新持仓均价
+ OkxPositionInfo longPos = queryPosition(OkxPosMode.LONG);
+ OkxPositionInfo shortPos = queryPosition(OkxPosMode.SHORT);
+ boolean hasLong = longPos != null && Math.abs(Integer.parseInt(longPos.size)) > 0;
+ boolean hasShort = shortPos != null && Math.abs(Integer.parseInt(shortPos.size)) > 0;
+ BigDecimal longAvgPrice = (longPos != null && longPos.entryPrice != null)
+ ? new BigDecimal(longPos.entryPrice) : BigDecimal.ZERO;
+ BigDecimal shortAvgPrice = (shortPos != null && shortPos.entryPrice != null)
+ ? new BigDecimal(shortPos.entryPrice) : BigDecimal.ZERO;
+
+ boolean shouldRestart = false;
+ String reason = "";
+
+ if (hasLong && hasShort) {
+ 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) {
+ 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) {
+ 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("[OKX] 跨度已达要求 → {}，最后一个止盈触发策略重启", reason);
+ executor.cancelAllPriceTriggeredOrders();
+ closeExistingPositions();
+ state = StrategyState.STOPPED;
+ executor.submitTask(() -> {
+ try { Thread.sleep(3000); } catch (InterruptedException ex) { Thread.currentThread().interrupt(); }
+ startGrid();
+ });
+ }
+ }
+
+ private void cancelFarthestLongStopLoss() {
+ GridElement farthest = null;
+ for (GridElement e : config.getGridElements()) {
+ if (e.getLongStopLossOrderId() != null) {
+ if (farthest == null || e.getId() < farthest.getId()) {
+ farthest = e;
+ }
+ }
+ }
+ if (farthest != null) {
+ String slId = farthest.getLongStopLossOrderId();
+ farthest.setLongStopLossOrderId(null);
+ GridElement.refreshIndices();
+ GridElement finalFarthest = farthest;
+ executor.cancelConditionalOrder(slId, oid ->
+ log.info("[OKX] 止盈触发, 取消最远多仓止损 gridId:{}, orderId:{}", finalFarthest.getId(), slId));
+ }
+ }
+
+ private void cancelFarthestShortStopLoss() {
+ GridElement farthest = null;
+ for (GridElement e : config.getGridElements()) {
+ if (e.getShortStopLossOrderId() != null) {
+ if (farthest == null || e.getId() > farthest.getId()) {
+ farthest = e;
+ }
+ }
+ }
+ if (farthest != null) {
+ String slId = farthest.getShortStopLossOrderId();
+ farthest.setShortStopLossOrderId(null);
+ GridElement.refreshIndices();
+ GridElement finalFarthest = farthest;
+ executor.cancelConditionalOrder(slId, oid ->
+ log.info("[OKX] 止盈触发, 取消最远空仓止损 gridId:{}, orderId:{}", finalFarthest.getId(), slId));
+ }
+ }
+
+ private void cancelAllLongTakeProfitsAndStopLosses() {
+ for (GridElement e : config.getGridElements()) {
+ String tpId = e.getLongTakeProfitOrderId();
+ if (tpId != null) { e.setLongTakeProfitOrderId(null); executor.cancelConditionalOrder(tpId, oid -> {}); }
+ String slId = e.getLongStopLossOrderId();
+ if (slId != null) { e.setLongStopLossOrderId(null); executor.cancelConditionalOrder(slId, oid -> {}); }
+ }
+ GridElement.refreshIndices();
+ log.info("[OKX] 已提交取消所有多仓止盈+止损");
+ }
+
+ private void cancelAllShortTakeProfitsAndStopLosses() {
+ for (GridElement e : config.getGridElements()) {
+ String tpId = e.getShortTakeProfitOrderId();
+ if (tpId != null) { e.setShortTakeProfitOrderId(null); executor.cancelConditionalOrder(tpId, oid -> {}); }
+ String slId = e.getShortStopLossOrderId();
+ if (slId != null) { e.setShortStopLossOrderId(null); executor.cancelConditionalOrder(slId, oid -> {}); }
+ }
+ GridElement.refreshIndices();
+ log.info("[OKX] 已提交取消所有空仓止盈+止损");
+ }
+
+ // ---- 止损追单 ----
+
+ private void extendLongStopLoss(int filledQty, int gridId) {
+ int furthestSlId = 0;
+ for (GridElement e : config.getGridElements()) {
+ if (e.getLongStopLossOrderId() != null && e.getId() < furthestSlId) {
+ furthestSlId = e.getId();
+ }
+ }
+ int interval = 1;
+ if (furthestSlId == 0) { furthestSlId = gridId; interval = 2; }
+ int stopLossCount = filledQty / Integer.parseInt(config.getQuantity());
+ log.info("[OKX] 多仓追挂止损, 当前最远止损gridId:{}, 成交{}张, 追加{}个止损单", furthestSlId, filledQty, stopLossCount);
+ for (int i = 0; i < stopLossCount; i++) {
+ int newSlId = furthestSlId - i - interval;
+ GridElement elem = GridElement.findById(newSlId);
+ if (elem == null) {
+ continue;
+ }
+ BigDecimal triggerPrice = elem.getGridPrice();
+ int finalSlId = newSlId;
+ executor.placeStopLoss(triggerPrice, "close_long", config.getQuantity(),
+ profitId -> {
+ elem.setLongStopLossOrderId(profitId);
+ GridElement.refreshIndices();
+ log.info("[OKX] 多仓止损追加, gridId:{}, 触发价:{}, slId:{}", finalSlId, triggerPrice, profitId);
+ });
+ }
+ }
+
+ private void extendShortStopLoss(int filledQty, int gridId) {
+ int furthestSlId = 0;
+ for (GridElement e : config.getGridElements()) {
+ if (e.getShortStopLossOrderId() != null && e.getId() > furthestSlId) {
+ furthestSlId = e.getId();
+ }
+ }
+ int interval = 1;
+ if (furthestSlId == 0) { furthestSlId = gridId; interval = 2; }
+ int stopLossCount = filledQty / Integer.parseInt(config.getQuantity());
+ log.info("[OKX] 空仓追挂止损, 当前最远止损gridId:{}, 成交{}张, 追加{}个止损单", furthestSlId, filledQty, stopLossCount);
+ for (int i = 0; i < stopLossCount; i++) {
+ int newSlId = furthestSlId + i + interval;
+ GridElement elem = GridElement.findById(newSlId);
+ if (elem == null) {
+ continue;
+ }
+ BigDecimal triggerPrice = elem.getGridPrice();
+ int finalSlId = newSlId;
+ executor.placeStopLoss(triggerPrice, "close_short", config.getQuantity(),
+ profitId -> {
+ elem.setShortStopLossOrderId(profitId);
+ GridElement.refreshIndices();
+ log.info("[OKX] 空仓止损追加, gridId:{}, 触发价:{}, slId:{}", finalSlId, triggerPrice, profitId);
+ });
+ }
+ }
+
+ // ---- 工具 ----
+
+ private String negate(String qty) {
+ return qty.startsWith("-") ? qty.substring(1) : "-" + qty;
+ }
+
+ private void placeEntryOrderWithPreFlag(GridElement gridElement, boolean isLong,
+ BigDecimal triggerPrice, String size) {
+ if (isLong) {
+ gridElement.setHasLongOrder(true);
+ } else {
+ gridElement.setHasShortOrder(true);
+ }
+ executor.placeConditionalEntryOrder(triggerPrice, isLong, size,
+ orderId -> {
+ if (isLong) {
+ longEntryTraderIdParam(gridElement, orderId, true);
+ } else {
+ shortEntryTraderIdParam(gridElement, orderId, true);
+ }
+ },
+ () -> {
+ if (isLong) {
+ gridElement.setHasLongOrder(false);
+ gridElement.setLongOrderId(null);
+ } else {
+ gridElement.setHasShortOrder(false);
+ gridElement.setShortOrderId(null);
+ }
+ GridElement.refreshIndices();
+ log.warn("[OKX] 条件单创建失败，回滚标志位 gridId:{}, isLong:{}", gridElement.getId(), isLong);
+ });
+ }
+
+ private void updateUnrealizedPnl() {
+ BigDecimal price = resolvePnlPrice();
+ if (price == null || price.compareTo(BigDecimal.ZERO) == 0) {
+ return;
+ }
+ BigDecimal multiplier = config.getContractMultiplier();
+ BigDecimal longPnl = BigDecimal.ZERO;
+ BigDecimal shortPnl = BigDecimal.ZERO;
+ if (longPositionSize.compareTo(BigDecimal.ZERO) > 0 && longEntryPrice.compareTo(BigDecimal.ZERO) > 0) {
+ longPnl = longPositionSize.multiply(multiplier).multiply(price.subtract(longEntryPrice));
+ }
+ if (shortPositionSize.compareTo(BigDecimal.ZERO) > 0 && shortEntryPrice.compareTo(BigDecimal.ZERO) > 0) {
+ shortPnl = shortPositionSize.multiply(multiplier).multiply(shortEntryPrice.subtract(price));
+ }
+ unrealizedPnl = longPnl.add(shortPnl);
+ log.info("[OKX] 未实现盈亏: {}", unrealizedPnl);
+ }
+
+ private BigDecimal resolvePnlPrice() {
+ if (config.getUnrealizedPnlPriceMode() == OkxConfig.PnLPriceMode.MARK_PRICE
+ && markPrice.compareTo(BigDecimal.ZERO) > 0) {
+ return markPrice;
+ }
+ return lastKlinePrice;
+ }
+
+ // ---- getters ----
+
+ public BigDecimal getLastKlinePrice() { return lastKlinePrice; }
+ public void setMarkPrice(BigDecimal markPrice) { this.markPrice = markPrice; }
+ public boolean isStrategyActive() { return state != StrategyState.STOPPED && state != StrategyState.WAITING_KLINE; }
+ public BigDecimal getCumulativePnl() { return cumulativePnl; }
+ public BigDecimal getUnrealizedPnl() { return unrealizedPnl; }
+ public StrategyState getState() { return state; }
+ public void setWsClient(OkxKlineWebSocketClient wsClient) { this.wsClient = wsClient; }
+}
--
Gitblit v1.9.1