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 details = account.getJSONArray("data");
|
if (details != null && !details.isEmpty()) {
|
JSONObject total = details.getJSONObject(0);
|
this.initialPrincipal = total.getBigDecimal("totalEq");
|
log.info("[OKX] 初始本金: {} USDT", initialPrincipal);
|
}
|
|
// 设置双向持仓模式
|
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 details = account.getJSONArray("data");
|
if (details != null && !details.isEmpty()) {
|
this.initialPrincipal = details.getJSONObject(0).getBigDecimal("totalEq");
|
}
|
} 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);
|
}, null);
|
executor.openShort(size, (orderId) -> {
|
TraderParam baseShortTp = TraderParam.builder()
|
.entryOrderId(orderId)
|
.build();
|
config.setBaseShortTraderParam(baseShortTp);
|
}, 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) {
|
if (isLong && hasPosition && !baseLongOpened) {
|
longActive = true;
|
longPositionSize = size;
|
longEntryPrice = entryPrice;
|
longBaseEntryPrice = entryPrice;
|
baseLongOpened = true;
|
log.info("[OKX] 基底多成交价: {}", longBaseEntryPrice);
|
tryGenerateQueues();
|
} else if (!isLong && hasPosition && !baseShortOpened) {
|
shortActive = true;
|
shortPositionSize = size.abs();
|
shortEntryPrice = entryPrice;
|
shortBaseEntryPrice = entryPrice;
|
baseShortOpened = true;
|
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(), "");
|
}
|
}
|
|
// ---- 自动订单（条件单）状态变更回调 ----
|
|
/**
|
* 自动订单状态变更回调。由 OrderAlgoOkxChannelHandler 调用。
|
*/
|
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:{}, 当前持仓:{}张", 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:{}, 当前持仓:{}张", 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() {
|
if (baseLongOpened && baseShortOpened) {
|
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);
|
|
// 挂基座止盈
|
{
|
BigDecimal tpPrice = baseGridElement.getGridPrice().add(config.getStep());
|
executor.placeTakeProfit(tpPrice, "close_long", config.getBaseQuantity(),
|
profitId -> {
|
longTakeProfitTraderIdParam(baseGridElement, profitId, true);
|
log.info("[OKX] 基座多仓止盈已挂, gridId:0, 触发价:{}, tpId:{}", tpPrice, profitId);
|
});
|
}
|
{
|
BigDecimal tpPrice = baseGridElement.getGridPrice().subtract(config.getStep());
|
executor.placeTakeProfit(tpPrice, "close_short", config.getBaseQuantity(),
|
profitId -> {
|
shortTakeProfitTraderIdParam(baseGridElement, profitId, true);
|
log.info("[OKX] 基座空仓止盈已挂, gridId:0, 触发价:{}, tpId:{}", tpPrice, profitId);
|
});
|
}
|
|
// 挂初始止损
|
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.placeTakeProfit(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.placeTakeProfit(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);
|
|
// 挂初始条件开仓单
|
GridElement longFirst = GridElement.findById(1);
|
if (longFirst != null && !longFirst.isHasLongOrder()) {
|
BigDecimal triggerPrice = longFirst.getGridPrice();
|
log.info("[OKX] 挂初始多仓条件单, gridId:1, trigger:{}", triggerPrice);
|
placeEntryOrderWithPreFlag(longFirst, true, triggerPrice, config.getBaseQuantity());
|
}
|
GridElement shortFirst = GridElement.findById(-1);
|
if (shortFirst != null && !shortFirst.isHasShortOrder()) {
|
BigDecimal triggerPrice = shortFirst.getGridPrice();
|
log.info("[OKX] 挂初始空仓条件单, gridId:-1, trigger:{}", triggerPrice);
|
placeEntryOrderWithPreFlag(shortFirst, false, triggerPrice, negate(config.getBaseQuantity()));
|
}
|
|
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.placeTakeProfit(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.placeTakeProfit(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; }
|
}
|
