From c6723169df10d313263bcd25f041d7cdbcaa7ccf Mon Sep 17 00:00:00 2001
From: Administrator <15274802129@163.com>
Date: Wed, 30 Sep 2026 22:11:13 +0800
Subject: [PATCH] feat(gateApi): 添加基础仓位止盈网格功能
---
src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java | 1331 ++++++++++++++++++++++++++++++++++++++++++++++++++++-----
1 files changed, 1,199 insertions(+), 132 deletions(-)
diff --git a/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java b/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java
index 8c90d42..481b041 100644
--- a/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java
+++ b/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java
@@ -3,9 +3,13 @@
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.xcong.excoin.utils.dingtalk.DingTalkUtils;
+import com.google.gson.ExclusionStrategy;
+import com.google.gson.FieldAttributes;
+import com.google.gson.Gson;
import io.gate.gateapi.ApiClient;
import io.gate.gateapi.ApiException;
import io.gate.gateapi.GateApiException;
+import io.gate.gateapi.JSON;
import io.gate.gateapi.api.AccountApi;
import io.gate.gateapi.api.FuturesApi;
import io.gate.gateapi.models.*;
@@ -15,6 +19,8 @@
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import com.xcong.excoin.modules.gateApi.wsHandler.handler.CandlestickChannelHandler;
@@ -37,8 +43,8 @@
* onPositionUpdate() → 基底成交 → baseLongOpened && baseShortOpened
* ↓
* tryGenerateQueues()
- * ├── generateShortQueue() ← 空仓价格队列（降序，从 shortBaseEntryPrice-step 向下）
- * ├── generateLongQueue() ← 多仓价格队列（升序，从 shortBaseEntryPrice+step 向上）
+ * ├── generateShortQueue() ← 空仓价格队列（降序，基价×(1−gridRate) 等比向下）
+ * ├── generateLongQueue() ← 多仓价格队列（升序，基价×(1+gridRate) 等比向上）
* ├── updateGridElements() ← 构建 GridElement 列表 + TraderParam + 全局索引
* ├── 挂基座止盈单（ID=0 的 long/short takeProfit）
* └── 挂初始条件单（up=-1 多单, down=1 空单）
@@ -68,11 +74,11 @@
*
* <h3>关键公式</h3>
* <pre>
- * step = shortBaseEntryPrice × gridRate ← 网格绝对步长
+ * step = shortBaseEntryPrice × gridRate ← 首档间距（0档与±1档的距离度量）
* minTick = 10^(-priceScale) ← 交易所最小价格单位
- * 多止盈 = gridPrice + (step - minTick) ← 多仓止盈价
- * 空止盈 = gridPrice - (step - minTick) ← 空仓止盈价
- * 单笔盈利 = (step - minTick) × contractMultiplier × quantity ← USDT
+ * 等比网格: 下一档 = 本档 × (1 ± gridRate) ← 向下×(1−r)，向上×(1+r)
+ * 止盈价 = 本档价 × (1 ± gridRate)（与相邻网格价联动） ← 多仓向上，空仓向下
+ * 单笔盈利 ≈ 档价 × gridRate × contractMultiplier × quantity（随网格位置浮动）
* </pre>
*
* <h3>线程模型</h3>
@@ -103,9 +109,16 @@
private static final String ORDER_TYPE_CLOSE_SHORT = "plan-close-short-position";
private final GateConfig config;
+ private final StatsEventProducer statsProducer;
+ private String apiKeyMd5;
private final GateTradeExecutor executor;
private final FuturesApi futuresApi;
private static final String SETTLE = "usdt";
+
+ /** 手动市价平仓遭遇价格保护(MARKET_PRICE_TOO_DEVIATED)后的重试次数 */
+ private static final int CLOSE_POSITION_RETRY_MAX_ATTEMPTS = 3;
+ /** 手动市价平仓遭遇价格保护后的重试间隔（毫秒） */
+ private static final long CLOSE_POSITION_RETRY_DELAY_MS = 800L;
private volatile StrategyState state = StrategyState.WAITING_KLINE;
@@ -146,6 +159,13 @@
private volatile int lastLongStopLossGridId = Integer.MAX_VALUE;
/** 最近触发止损的空头网格ID */
private volatile int lastShortStopLossGridId = Integer.MAX_VALUE;
+ /** 自定义止损模式激活标记：true=尚未发生第一次止损触发，第一次触发后置 false（触发未触发侧重挂默认） */
+ private final AtomicBoolean dualStopLossModeActive = new AtomicBoolean(false);
+
+ /** 止盈触发对向加仓：多仓止盈→空仓开仓单ID → 网格ID（成交后在该网格+1挂空仓止损） */
+ private final Map<String, Integer> tpOppositeShortOrderGridMap = new ConcurrentHashMap<>();
+ /** 止盈触发对向加仓：空仓止盈→多仓开仓单ID → 网格ID（成交后在该网格-1挂多仓止损） */
+ private final Map<String, Integer> tpOppositeLongOrderGridMap = new ConcurrentHashMap<>();
private volatile BigDecimal lastKlinePrice;
private volatile BigDecimal markPrice = BigDecimal.ZERO;
@@ -157,15 +177,60 @@
private volatile BigDecimal shortPositionSize = BigDecimal.ZERO;
private Long userId;
private volatile BigDecimal initialPrincipal = BigDecimal.ZERO;
+ /** 上次 PNL 快照时间（毫秒），用于控制 PNL_SNAPSHOT 埋点频率 */
+ private volatile long lastPnlSnapshotTime = 0;
private volatile GateKlineWebSocketClient wsClient;
- public GateGridTradeService(GateConfig config) {
+ public GateGridTradeService(GateConfig config, StatsEventProducer statsProducer) {
this.config = config;
+ this.statsProducer = statsProducer;
ApiClient apiClient = new ApiClient();
apiClient.setBasePath(config.getRestBasePath());
apiClient.setApiKeySecret(config.getApiKey(), config.getApiSecret());
+ // 修复 gate-api SDK finishAs 枚举不完整导致的反序列化失败（见 buildLenientJson）
+ apiClient.setJSON(buildLenientJson());
this.futuresApi = new FuturesApi(apiClient);
this.executor = new GateTradeExecutor(apiClient, config.getContract());
+ }
+
+ /**
+ * 构建容错的 JSON 序列化器，跳过部分枚举不完整字段的反序列化。
+ *
+ * <p>gate-api SDK 的枚举定义滞后于交易所实际返回值，反序列化未知枚举值时
+ * {@code fromValue} 会抛 {@link IllegalArgumentException}，导致接口被误判为失败。
+ * 已确认业务不使用以下字段，因此通过 Gson 排除策略直接跳过其解析：
+ * <ul>
+ * <li>{@code finishAs}：{@code FuturesOrder.FinishAsEnum} 缺少
+ * {@code price_rate_protected}（价格保护）等值（如日志
+ * {@code Unexpected value 'price_rate_proteced'}）；</li>
+ * <li>{@code posMarginMode}：{@code FuturesPriceTriggeredOrder.PosMarginModeEnum}
+ * 只定义 {@code cross}/{@code dual}，而 {@code cancelPriceTriggeredOrderList}
+ * 会返回组合值 {@code cross|dual}（如日志 {@code Unexpected value 'cross|dual'}）。</li>
+ * </ul>
+ */
+ private static JSON buildLenientJson() {
+ JSON json = new JSON();
+ Gson gson = json.getGson().newBuilder()
+ .setExclusionStrategies(new ExclusionStrategy() {
+ @Override
+ public boolean shouldSkipField(FieldAttributes f) {
+ if ("finishAs".equals(f.getName())) {
+ return true;
+ }
+ // 仅跳过 FuturesPriceTriggeredOrder 的 posMarginMode，避免误伤
+ // FuturesOrder / Position 的同名字段（二者语义为 isolated/cross）
+ return "posMarginMode".equals(f.getName())
+ && FuturesPriceTriggeredOrder.class.equals(f.getDeclaringClass());
+ }
+
+ @Override
+ public boolean shouldSkipClass(Class<?> clazz) {
+ return false;
+ }
+ })
+ .create();
+ json.setGson(gson);
+ return json;
}
// ---- 初始化 ----
@@ -290,6 +355,44 @@
}
}
+ // ---- 埋点 ----
+
+ private String apiKeyMd5() {
+ if (apiKeyMd5 == null) {
+ try {
+ java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+ byte[] digest = md.digest(config.getApiKey().getBytes(java.nio.charset.StandardCharsets.UTF_8));
+ StringBuilder sb = new StringBuilder();
+ for (byte b : digest) sb.append(String.format("%02x", b));
+ apiKeyMd5 = sb.toString();
+ } catch (Exception e) {
+ apiKeyMd5 = Integer.toHexString(config.getApiKey().hashCode());
+ }
+ }
+ return apiKeyMd5;
+ }
+
+ private void emitStats(String type, Object payload) {
+ if (statsProducer == null) return;
+ try {
+ statsProducer.sendStats(statsProducer.newStats(type, apiKeyMd5(), payload));
+ } catch (Exception e) {
+ log.warn("[Gate] 埋点发送失败, type={}", type, e);
+ }
+ }
+
+ /**
+ * Java 8 兼容的 Map 构造工具（Map.of 为 Java 9 API，此处手动实现）。
+ * 接受偶数个参数：key1, value1, key2, value2, ...
+ */
+ private static Map<String, Object> mapOf(Object... kv) {
+ Map<String, Object> m = new LinkedHashMap<>();
+ for (int i = 0; i < kv.length; i += 2) {
+ m.put((String) kv[i], kv[i + 1]);
+ }
+ return m;
+ }
+
// ---- 启动/停止 ----
/**
@@ -311,12 +414,15 @@
shortPositionSize = BigDecimal.ZERO;
baseLongOpened = false;
baseShortOpened = false;
+ config.setBaseLongTraderParam(null);
+ config.setBaseShortTraderParam(null);
longActive = false;
shortActive = false;
accumulatedLongLossCount = 0;
accumulatedShortLossCount = 0;
lastLongStopLossGridId = Integer.MAX_VALUE;
lastShortStopLossGridId = Integer.MAX_VALUE;
+ dualStopLossModeActive.set(false);
shortPriceQueue.clear();
longPriceQueue.clear();
totalShortPriceQueue.clear();
@@ -328,6 +434,13 @@
currentRound = 0;
log.info("[Gate] 网格策略已启动, 当前本金: {} USDT", initialPrincipal);
+
+ // 埋点: STRATEGY_START — 附全量配置快照
+ GateConfigDTO snapshot = GateConfigDTO.from(config);
+ Map<String, Object> params = snapshot.toParamsMap();
+ params.put("principal", initialPrincipal.toPlainString());
+ params.put("contract", config.getContract());
+ emitStats("STRATEGY_START", params);
}
/**
@@ -348,6 +461,14 @@
*/
public void stopGrid() {
state = StrategyState.STOPPED;
+
+ // 埋点: STRATEGY_STOP
+ emitStats("STRATEGY_STOP", mapOf(
+ "reason", "manual",
+ "rounds", currentRound,
+ "pnl", cumulativePnl.toPlainString()
+ ));
+
executor.cancelAllPriceTriggeredOrders();
closeExistingPositions();
executor.shutdown();
@@ -395,12 +516,14 @@
.entryOrderId(orderId)
.build();
config.setBaseLongTraderParam(baseLongTp);
+ tryGenerateQueues();
}, null);
executor.openShort(negate(size), (orderId) -> {
TraderParam baseShortTp = TraderParam.builder()
.entryOrderId(orderId)
.build();
config.setBaseShortTraderParam(baseShortTp);
+ tryGenerateQueues();
}, null);
return;
}
@@ -412,7 +535,7 @@
config.isPriceDriveEnabled() &&
longActive == false &&
longPositionSize.compareTo(BigDecimal.ZERO) == 0){
- processShortGrid(closePrice);
+ processLongGrid(closePrice);
}
@@ -420,7 +543,7 @@
config.isPriceDriveEnabled() &&
shortActive == false &&
shortPositionSize.compareTo(BigDecimal.ZERO) == 0){
- processLongGrid(closePrice);
+ processShortGrid(closePrice);
}
}
@@ -451,8 +574,28 @@
.add(new BigDecimal(account.getUnrealisedPnl()))
.subtract(estimatedCloseFee);
+ // 埋点: PNL_SNAPSHOT — 每60秒发射一次
+ long now = System.currentTimeMillis();
+ if (now - lastPnlSnapshotTime >= 60_000) {
+ lastPnlSnapshotTime = now;
+ BigDecimal total = new BigDecimal(account.getTotal());
+ emitStats("PNL_SNAPSHOT", mapOf(
+ "cumulativePnl", cumulativePnl.toPlainString(),
+ "unrealizedPnl", new BigDecimal(account.getUnrealisedPnl()).toPlainString(),
+ "totalEquity", total.toPlainString(),
+ "markPrice", markPrice.toPlainString()
+ ));
+ }
+
if (totalEquity.compareTo(target) > 0) {
currentRound++;
+
+ // 埋点: ROUND_COMPLETE
+ emitStats("ROUND_COMPLETE", mapOf(
+ "roundNum", currentRound,
+ "totalEquity", totalEquity.toPlainString()
+ ));
+
int maxRounds = config.getRounds();
log.info("[Gate] 盈亏达标(净权益{}→含手续费-{}=实际{}>目标{})，第{}轮完成",
new BigDecimal(account.getTotal()).add(new BigDecimal(account.getUnrealisedPnl())),
@@ -649,11 +792,36 @@
return;
}
+ // 止盈单成交 → 清理止盈状态，并按配置触发对向加仓
+ GridElement longTpElem = GridElement.findByLongTakeProfitOrderId(orderId);
+ if (longTpElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ handleLongTakeProfitTriggered(longTpElem, orderId);
+ return;
+ }
+ GridElement shortTpElem = GridElement.findByShortTakeProfitOrderId(orderId);
+ if (shortTpElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ handleShortTakeProfitTriggered(shortTpElem, orderId);
+ return;
+ }
+
GridElement shortGridElement = GridElement.findByShortOrderId(orderId);
if (shortGridElement != null) {
if (StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0") ){
+ // 止盈触发的对向加仓空仓开仓单成交 → 在网格+1挂空仓止损
+ Integer tpOppositeGridId = tpOppositeShortOrderGridMap.remove(orderId);
+ if (tpOppositeGridId != null) {
+ handleTpOppositeShortAddFilled(shortGridElement, tpOppositeGridId);
+ return;
+ }
int filledQty = Integer.parseInt(shortGridElement.getShortTraderParam().getQuantity());
shortEntryTraderIdParam(shortGridElement, orderId, false);
+
+ // 埋点: ENTRY_FILLED — 空仓加仓成交
+ emitStats("ENTRY_FILLED", mapOf(
+ "direction", "short",
+ "gridId", shortGridElement.getId(),
+ "filledQty", filledQty
+ ));
// 防重入：同一网格存在多个入场单且相近时间成交时，只处理第一次 extend，
// 后续成交打标 pendingReExtend，延展完成后自动用最新仓位重挂一次。
@@ -672,9 +840,13 @@
int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue());
extendShortStopLoss(posSize, shortGridElement.getId());
// [Gate] 止盈挂单：超出基础仓位的部分，挂在多仓第一止损位
- if (config.isPlaceExcessTakeProfit()) {
+ if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
placeExcessTakeProfit(posSize, false);
+ } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
+ placeDispersedTakeProfit(posSize, false, shortGridElement.getId());
}
+ // [Gate] 基础仓位止盈挂单：与超额止盈并行，独立于止盈模式
+ placeBaseTakeProfit(posSize, false, shortGridElement.getId());
log.info("[Gate] 空单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);
@@ -685,8 +857,21 @@
if (longGridElement != null) {
if (StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")){
+ // 止盈触发的对向加仓多仓开仓单成交 → 在网格-1挂多仓止损
+ Integer tpOppositeGridId = tpOppositeLongOrderGridMap.remove(orderId);
+ if (tpOppositeGridId != null) {
+ handleTpOppositeLongAddFilled(longGridElement, tpOppositeGridId);
+ return;
+ }
int filledQty = Integer.parseInt(longGridElement.getLongTraderParam().getQuantity());
longEntryTraderIdParam(longGridElement, orderId, false);
+
+ // 埋点: ENTRY_FILLED — 多仓加仓成交
+ emitStats("ENTRY_FILLED", mapOf(
+ "direction", "long",
+ "gridId", longGridElement.getId(),
+ "filledQty", filledQty
+ ));
// 防重入：同一网格存在多个入场单且相近时间成交时，只处理第一次 extend，
// 后续成交打标 pendingReExtend，延展完成后自动用最新仓位重挂一次。
@@ -705,13 +890,244 @@
int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue());
extendLongStopLoss(posSize, longGridElement.getId());
// [Gate] 止盈挂单：超出基础仓位的部分，挂在空仓第一止损位
- if (config.isPlaceExcessTakeProfit()) {
+ if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
placeExcessTakeProfit(posSize, true);
+ } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
+ placeDispersedTakeProfit(posSize, true, longGridElement.getId());
}
+ // [Gate] 基础仓位止盈挂单：与超额止盈并行，独立于止盈模式
+ placeBaseTakeProfit(posSize, true, longGridElement.getId());
log.info("[Gate] 多单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);
}
}
+ }
+
+
+ /**
+ * 多仓止盈单成交：清理止盈状态，并按配置在对向（空仓）挂开仓单。
+ *
+ * @param tpElem 触发止盈的网格元素
+ * @param orderId 止盈单 ID
+ */
+ private void handleLongTakeProfitTriggered(GridElement tpElem, String orderId) {
+ // 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
+ boolean isLastTp = GridElement.getLongTakeProfitCount() <= 1;
+ // 清理止盈单状态（移除已成交的这笔止盈单）
+ longTakeProfitTraderIdParam(tpElem, orderId, false);
+ log.info("[Gate] 多仓止盈触发 gridId:{}, orderId:{}, 剩余止盈:{}", tpElem.getId(), orderId,
+ GridElement.getLongTakeProfitCount());
+
+ // 止盈依次上移：先取消之前挂的对向空开仓单，再挂新单
+ cancelTpOppositeShortEntries();
+
+ if (!config.isTpTriggerOppositeAddEnabled()) {
+ return;
+ }
+ if (isLastTp) {
+ log.info("[Gate] 多仓止盈为最后一个, 不触发对向加仓, gridId:{}", tpElem.getId());
+ return;
+ }
+ int qty = config.getTpTriggerOppositeAddQuantity();
+ if (qty <= 0) {
+ return;
+ }
+ // 多仓止盈在 gridId=N 成交，对向空仓开仓单挂在 gridId=N-1
+ int targetGridId = tpElem.getId() - 1;
+ GridElement target = GridElement.findById(targetGridId);
+ if (target == null) {
+ log.warn("[Gate] 止盈触发对向加仓: 目标网格不存在, 止盈gridId:{}, 目标gridId:{}", tpElem.getId(), targetGridId);
+ return;
+ }
+ placeOppositeAddShortEntry(target, tpElem, qty);
+ }
+
+ /**
+ * 空仓止盈单成交：清理止盈状态，并按配置在对向（多仓）挂开仓单。
+ *
+ * @param tpElem 触发止盈的网格元素
+ * @param orderId 止盈单 ID
+ */
+ private void handleShortTakeProfitTriggered(GridElement tpElem, String orderId) {
+ // 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
+ boolean isLastTp = GridElement.getShortTakeProfitCount() <= 1;
+ // 清理止盈单状态（移除已成交的这笔止盈单）
+ shortTakeProfitTraderIdParam(tpElem, orderId, false);
+ log.info("[Gate] 空仓止盈触发 gridId:{}, orderId:{}, 剩余止盈:{}", tpElem.getId(), orderId,
+ GridElement.getShortTakeProfitCount());
+
+ // 止盈依次下移：先取消之前挂的对向多开仓单，再挂新单
+ cancelTpOppositeLongEntries();
+
+ if (!config.isTpTriggerOppositeAddEnabled()) {
+ return;
+ }
+ if (isLastTp) {
+ log.info("[Gate] 空仓止盈为最后一个, 不触发对向加仓, gridId:{}", tpElem.getId());
+ return;
+ }
+ int qty = config.getTpTriggerOppositeAddQuantity();
+ if (qty <= 0) {
+ return;
+ }
+ // 空仓止盈在 gridId=N 成交，对向多仓开仓单挂在 gridId=N+1
+ int targetGridId = tpElem.getId() + 1;
+ GridElement target = GridElement.findById(targetGridId);
+ if (target == null) {
+ log.warn("[Gate] 止盈触发对向加仓: 目标网格不存在, 止盈gridId:{}, 目标gridId:{}", tpElem.getId(), targetGridId);
+ return;
+ }
+ placeOppositeAddLongEntry(target, tpElem, qty);
+ }
+
+ /**
+ * 取消所有已挂未成交的对向空仓开仓单（止盈依次上移时，取消旧位置的开仓单）。
+ */
+ private void cancelTpOppositeShortEntries() {
+ if (tpOppositeShortOrderGridMap.isEmpty()) {
+ return;
+ }
+ List<String> orderIds = new ArrayList<>(tpOppositeShortOrderGridMap.keySet());
+ tpOppositeShortOrderGridMap.clear();
+ for (String oid : orderIds) {
+ GridElement elem = GridElement.findByShortOrderId(oid);
+ if (elem != null) {
+ elem.removeShortOrderId(oid);
+ elem.setHasShortOrder(elem.hasShortOrderIds());
+ }
+ executor.cancelConditionalOrder(oid, o -> {});
+ log.info("[Gate] 取消对向空开仓单, orderId:{}", oid);
+ }
+ GridElement.refreshIndices();
+ }
+
+ /**
+ * 取消所有已挂未成交的对向多仓开仓单（止盈依次下移时，取消旧位置的开仓单）。
+ */
+ private void cancelTpOppositeLongEntries() {
+ if (tpOppositeLongOrderGridMap.isEmpty()) {
+ return;
+ }
+ List<String> orderIds = new ArrayList<>(tpOppositeLongOrderGridMap.keySet());
+ tpOppositeLongOrderGridMap.clear();
+ for (String oid : orderIds) {
+ GridElement elem = GridElement.findByLongOrderId(oid);
+ if (elem != null) {
+ elem.removeLongOrderId(oid);
+ elem.setHasLongOrder(elem.hasLongOrderIds());
+ }
+ executor.cancelConditionalOrder(oid, o -> {});
+ log.info("[Gate] 取消对向多开仓单, orderId:{}", oid);
+ }
+ GridElement.refreshIndices();
+ }
+
+ /**
+ * 在目标网格挂空仓对向开仓单，并记录订单ID→网格ID映射，供成交后挂止损。
+ */
+ private void placeOppositeAddShortEntry(GridElement target, GridElement tpElem, int qty) {
+ target.setHasShortOrder(true);
+ executor.placeConditionalEntryOrder(
+ target.getGridPrice(),
+ FuturesPriceTrigger.RuleEnum.NUMBER_2,
+ negate(String.valueOf(qty)),
+ orderId -> {
+ tpOppositeShortOrderGridMap.put(orderId, target.getId());
+ shortEntryTraderIdParam(target, orderId, true);
+ log.info("[Gate] 多仓止盈触发对向加仓, 止盈gridId:{}, 空仓开仓gridId:{}, 数量:{}张, orderId:{}",
+ tpElem.getId(), target.getId(), qty, orderId);
+ },
+ () -> {
+ if (!target.hasShortOrderIds()) {
+ target.setHasShortOrder(false);
+ }
+ GridElement.refreshIndices();
+ log.warn("[Gate] 多仓止盈触发对向加仓挂单失败, 止盈gridId:{}, 目标gridId:{}",
+ tpElem.getId(), target.getId());
+ }
+ );
+ }
+
+ /**
+ * 在目标网格挂多仓对向开仓单，并记录订单ID→网格ID映射，供成交后挂止损。
+ */
+ private void placeOppositeAddLongEntry(GridElement target, GridElement tpElem, int qty) {
+ target.setHasLongOrder(true);
+ executor.placeConditionalEntryOrder(
+ target.getGridPrice(),
+ FuturesPriceTrigger.RuleEnum.NUMBER_1,
+ String.valueOf(qty),
+ orderId -> {
+ tpOppositeLongOrderGridMap.put(orderId, target.getId());
+ longEntryTraderIdParam(target, orderId, true);
+ log.info("[Gate] 空仓止盈触发对向加仓, 止盈gridId:{}, 多仓开仓gridId:{}, 数量:{}张, orderId:{}",
+ tpElem.getId(), target.getId(), qty, orderId);
+ },
+ () -> {
+ if (!target.hasLongOrderIds()) {
+ target.setHasLongOrder(false);
+ }
+ GridElement.refreshIndices();
+ log.warn("[Gate] 空仓止盈触发对向加仓挂单失败, 止盈gridId:{}, 目标gridId:{}",
+ tpElem.getId(), target.getId());
+ }
+ );
+ }
+
+ /**
+ * 对向加仓空仓开仓单成交：在网格+1 挂空仓止损。
+ *
+ * @param elem 开仓单成交的网格元素
+ * @param oppositeGridId 记录的对向开仓网格ID
+ */
+ private void handleTpOppositeShortAddFilled(GridElement elem, int oppositeGridId) {
+ int qty = Integer.parseInt(elem.getShortTraderParam().getQuantity());
+ int stopLossGridId = oppositeGridId + 1;
+ GridElement slElem = GridElement.findById(stopLossGridId);
+ if (slElem == null) {
+ log.warn("[Gate] 对向加仓止损位置不存在, 开仓gridId:{}, 止损gridId:{}", oppositeGridId, stopLossGridId);
+ return;
+ }
+ executor.placeTakeProfit(
+ slElem.getGridPrice(),
+ FuturesPriceTrigger.RuleEnum.NUMBER_1,
+ ORDER_TYPE_CLOSE_SHORT,
+ String.valueOf(qty),
+ profitId -> {
+ slElem.addShortStopLossOrderId(profitId);
+ GridElement.refreshIndices();
+ log.info("[Gate] 对向加仓空仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
+ oppositeGridId, stopLossGridId, qty, profitId);
+ }
+ );
+ }
+
+ /**
+ * 对向加仓多仓开仓单成交：在网格-1 挂多仓止损。
+ *
+ * @param elem 开仓单成交的网格元素
+ * @param oppositeGridId 记录的对向开仓网格ID
+ */
+ private void handleTpOppositeLongAddFilled(GridElement elem, int oppositeGridId) {
+ int qty = Integer.parseInt(elem.getLongTraderParam().getQuantity());
+ int stopLossGridId = oppositeGridId - 1;
+ GridElement slElem = GridElement.findById(stopLossGridId);
+ if (slElem == null) {
+ log.warn("[Gate] 对向加仓止损位置不存在, 开仓gridId:{}, 止损gridId:{}", oppositeGridId, stopLossGridId);
+ return;
+ }
+ executor.placeTakeProfit(
+ slElem.getGridPrice(),
+ FuturesPriceTrigger.RuleEnum.NUMBER_2,
+ ORDER_TYPE_CLOSE_LONG,
+ negate(String.valueOf(qty)),
+ profitId -> {
+ slElem.addLongStopLossOrderId(profitId);
+ GridElement.refreshIndices();
+ log.info("[Gate] 对向加仓多仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
+ oppositeGridId, stopLossGridId, qty, profitId);
+ }
+ );
}
@@ -776,19 +1192,23 @@
* <li>状态切换为 ACTIVE</li>
* </ol>
*/
- private void tryGenerateQueues() {
- if (baseLongOpened && baseShortOpened) {
+ private synchronized void tryGenerateQueues() {
+ // 幂等保护：生成队列后 state 切换为 ACTIVE，避免多线程重复执行
+ if (state != StrategyState.OPENING) {
+ return;
+ }
+ TraderParam baseLongTraderParam = config.getBaseLongTraderParam();
+ TraderParam baseShortTraderParam = config.getBaseShortTraderParam();
+ // 需同时满足：多空基底均已成交，且两个下单参数(orderId)均已通过下单成功回调拿到。
+ // IOC 市价单成交后 WS 持仓推送可能先于 REST 下单响应返回，必须等参数就绪再生成队列。
+ if (!(baseLongOpened && baseShortOpened)
+ || baseLongTraderParam == null || baseShortTraderParam == null) {
+ 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);
// // 空仓止损对应的多仓止盈：多仓止盈挂在ID=3
// int tpGridIdLong = 3;
@@ -864,56 +1284,182 @@
// );
// }
- int shortTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
- for (int id = 2; id <= shortTime; id++) {
- GridElement elem = GridElement.findById(id);
- if (elem == null) {
- continue;
- }
- BigDecimal triggerPrice = elem.getGridPrice();
- String size = config.getQuantity();
- int finalId = id;
- executor.placeTakeProfit(
- triggerPrice,
- FuturesPriceTrigger.RuleEnum.NUMBER_1,
- ORDER_TYPE_CLOSE_SHORT,
- size,
- profitId -> {
- elem.addShortStopLossOrderId(profitId);
- GridElement.refreshIndices();
- log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
- }
- );
+ if (config.isDualStopLossEnabled()) {
+ placeCustomStopLosses();
+ } else {
+ placeDefaultStopLossLadders();
}
+ state = StrategyState.ACTIVE;
+ }
+ }
+ // ========== 自定义止损（按触发价各挂一单） ==========
- int longTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
- for (int id = -2; id >= -longTime; id--) {
- GridElement elem = GridElement.findById(id);
- if (elem == null) {
- continue;
- }
- BigDecimal triggerPrice = elem.getGridPrice();
- String size = config.getQuantity();
- int finalId = id;
+ /**
+ * 自定义止损初始化：按多空止损触发价匹配最近网格，各挂一张覆盖全仓位（baseQuantity）的止损单。
+ * 多仓止损：NUMBER_2（价格 ≤ 触发价平多），空仓止损：NUMBER_1（价格 ≥ 触发价平空）。
+ */
+ private void placeCustomStopLosses() {
+ dualStopLossModeActive.set(true);
+ String baseQty = config.getBaseQuantity();
+ BigDecimal longPrice = config.getLongStopLossPrice();
+ BigDecimal shortPrice = config.getShortStopLossPrice();
+
+ if (longPrice != null && longPrice.compareTo(BigDecimal.ZERO) > 0) {
+ GridElement longElem = findNearestGridElementByPrice(longPrice);
+ if (longElem != null) {
+ BigDecimal triggerPrice = longElem.getGridPrice();
executor.placeTakeProfit(
triggerPrice,
FuturesPriceTrigger.RuleEnum.NUMBER_2,
ORDER_TYPE_CLOSE_LONG,
- negate(size),
+ negate(baseQty),
profitId -> {
- elem.addLongStopLossOrderId(profitId);
+ longElem.addLongStopLossOrderId(profitId);
GridElement.refreshIndices();
- log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
+ log.info("[Gate] 自定义多仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
+ longPrice, longElem.getId(), triggerPrice, profitId);
}
);
+ } else {
+ log.warn("[Gate] 自定义多仓止损价:{} 未匹配到任何网格", longPrice);
}
-
- log.info("[Gate] 止损止盈单已全部挂完, 空仓止损:2~{}, 多仓止损:-2~-{}", shortTime, longTime);
-
- state = StrategyState.ACTIVE;
}
+
+ if (shortPrice != null && shortPrice.compareTo(BigDecimal.ZERO) > 0) {
+ GridElement shortElem = findNearestGridElementByPrice(shortPrice);
+ if (shortElem != null) {
+ BigDecimal triggerPrice = shortElem.getGridPrice();
+ executor.placeTakeProfit(
+ triggerPrice,
+ FuturesPriceTrigger.RuleEnum.NUMBER_1,
+ ORDER_TYPE_CLOSE_SHORT,
+ baseQty,
+ profitId -> {
+ shortElem.addShortStopLossOrderId(profitId);
+ GridElement.refreshIndices();
+ log.info("[Gate] 自定义空仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
+ shortPrice, shortElem.getId(), triggerPrice, profitId);
+ }
+ );
+ } else {
+ log.warn("[Gate] 自定义空仓止损价:{} 未匹配到任何网格", shortPrice);
+ }
+ }
+ log.info("[Gate] 自定义止损初始化完成, 多仓止损价:{}, 空仓止损价:{}", longPrice, shortPrice);
+ }
+
+ /**
+ * 默认止损阶梯（原有逻辑）：空仓从 ID=2 向上、多仓从 ID=-2 向下，各挂 baseQuantity/quantity 格、每格 quantity 张。
+ */
+ private void placeDefaultStopLossLadders() {
+ placeDefaultShortStopLossLadder();
+ placeDefaultLongStopLossLadder();
+ int shortTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
+ int longTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
+ log.info("[Gate] 止损止盈单已全部挂完, 空仓止损:2~{}, 多仓止损:-2~-{}", shortTime, longTime);
+ }
+
+ /**
+ * 默认空仓止损阶梯：从 ID=2 向上挂，每格 quantity 张，NUMBER_1（价格 ≥ 触发价平空）。
+ */
+ private void placeDefaultShortStopLossLadder() {
+ int shortTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
+ for (int id = 2; id <= shortTime; id++) {
+ GridElement elem = GridElement.findById(id);
+ if (elem == null) {
+ continue;
+ }
+ BigDecimal triggerPrice = elem.getGridPrice();
+ String size = config.getQuantity();
+ int finalId = id;
+ executor.placeTakeProfit(
+ triggerPrice,
+ FuturesPriceTrigger.RuleEnum.NUMBER_1,
+ ORDER_TYPE_CLOSE_SHORT,
+ size,
+ profitId -> {
+ elem.addShortStopLossOrderId(profitId);
+ GridElement.refreshIndices();
+ log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
+ }
+ );
+ }
+ }
+
+ /**
+ * 默认多仓止损阶梯：从 ID=-2 向下挂，每格 quantity 张，NUMBER_2（价格 ≤ 触发价平多）。
+ */
+ private void placeDefaultLongStopLossLadder() {
+ int longTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
+ for (int id = -2; id >= -longTime; id--) {
+ GridElement elem = GridElement.findById(id);
+ if (elem == null) {
+ continue;
+ }
+ BigDecimal triggerPrice = elem.getGridPrice();
+ String size = config.getQuantity();
+ int finalId = id;
+ executor.placeTakeProfit(
+ triggerPrice,
+ FuturesPriceTrigger.RuleEnum.NUMBER_2,
+ ORDER_TYPE_CLOSE_LONG,
+ negate(size),
+ profitId -> {
+ elem.addLongStopLossOrderId(profitId);
+ GridElement.refreshIndices();
+ log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
+ }
+ );
+ }
+ }
+
+ /**
+ * 按「价格 → 最近网格」匹配：返回 gridPrice 与目标价绝对值差最小的网格元素。
+ */
+ private GridElement findNearestGridElementByPrice(BigDecimal price) {
+ if (price == null || price.compareTo(BigDecimal.ZERO) <= 0) {
+ return null;
+ }
+ GridElement nearest = null;
+ BigDecimal minDiff = null;
+ for (GridElement e : config.getGridElements()) {
+ BigDecimal diff = e.getGridPrice().subtract(price).abs();
+ if (minDiff == null || diff.compareTo(minDiff) < 0) {
+ minDiff = diff;
+ nearest = e;
+ }
+ }
+ return nearest;
+ }
+
+ /**
+ * 只取消空仓止损单（保留空仓止盈），用于自定义止损首次触发时重挂未触发侧。
+ */
+ private void cancelAllShortStopLossesOnly() {
+ for (GridElement e : config.getGridElements()) {
+ for (String slId : new ArrayList<>(e.getShortStopLossOrderIds())) {
+ executor.cancelConditionalOrder(slId, oid -> {});
+ }
+ e.clearShortStopLossOrderIds();
+ }
+ GridElement.refreshIndices();
+ log.info("[Gate] 已提交取消所有空仓止损（保留止盈）");
+ }
+
+ /**
+ * 只取消多仓止损单（保留多仓止盈），用于自定义止损首次触发时重挂未触发侧。
+ */
+ private void cancelAllLongStopLossesOnly() {
+ for (GridElement e : config.getGridElements()) {
+ for (String slId : new ArrayList<>(e.getLongStopLossOrderIds())) {
+ executor.cancelConditionalOrder(slId, oid -> {});
+ }
+ e.clearLongStopLossOrderIds();
+ }
+ GridElement.refreshIndices();
+ log.info("[Gate] 已提交取消所有多仓止损（保留止盈）");
}
/**
@@ -923,18 +1469,48 @@
GridElement baseElement,String profitId, boolean flag
) {
TraderParam tp = baseElement.getLongTraderParam();
- tp.setTakeProfitOrderId(profitId);
- tp.setTakeProfitPlaced(flag);
- baseElement.setLongTakeProfitOrderId(profitId);
+ if (flag && profitId != null) {
+ // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单）
+ tp.setTakeProfitOrderId(profitId);
+ tp.setTakeProfitPlaced(true);
+ baseElement.addLongTakeProfitOrderId(profitId);
+ } else {
+ // 清理：profitId 非空移除指定止盈单，为空清空该网格全部止盈单
+ tp.setTakeProfitPlaced(false);
+ if (profitId != null) {
+ baseElement.removeLongTakeProfitOrderId(profitId);
+ if (!baseElement.hasLongTakeProfitOrders()) {
+ tp.setTakeProfitOrderId(null);
+ }
+ } else {
+ baseElement.clearLongTakeProfitOrderIds();
+ tp.setTakeProfitOrderId(null);
+ }
+ }
GridElement.refreshIndices();
}
private void shortTakeProfitTraderIdParam(
GridElement baseElement,String profitId, boolean flag
) {
TraderParam tp = baseElement.getShortTraderParam();
- tp.setTakeProfitOrderId(profitId);
- tp.setTakeProfitPlaced(flag);
- baseElement.setShortTakeProfitOrderId(profitId);
+ if (flag && profitId != null) {
+ // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单）
+ tp.setTakeProfitOrderId(profitId);
+ tp.setTakeProfitPlaced(true);
+ baseElement.addShortTakeProfitOrderId(profitId);
+ } else {
+ // 清理：profitId 非空移除指定止盈单，为空清空该网格全部止盈单
+ tp.setTakeProfitPlaced(false);
+ if (profitId != null) {
+ baseElement.removeShortTakeProfitOrderId(profitId);
+ if (!baseElement.hasShortTakeProfitOrders()) {
+ tp.setTakeProfitOrderId(null);
+ }
+ } else {
+ baseElement.clearShortTakeProfitOrderIds();
+ tp.setTakeProfitOrderId(null);
+ }
+ }
GridElement.refreshIndices();
}
@@ -973,51 +1549,73 @@
}
/**
- * 生成空仓价格队列。
- * 以 shortBaseEntryPrice × gridRate 作为绝对步长 step，存到 config。
- * 第1个元素 = shortBaseEntryPrice − step，后续依次递减 step，共 gridQueueSize 个。
- * 队列降序排列（大→小），方便 processShortGrid 中从头遍历。
+ * 生成空仓价格队列（等比 / 复合百分比网格）。
+ *
+ * <p>每个网格价 = 上一档 × (1 − gridRate)，即自 shortBaseEntryPrice 向下等比递减：
+ * <pre>
+ * 第1档 = shortBaseEntryPrice × (1 − gridRate)
+ * 第2档 = 第1档 × (1 − gridRate)
+ * ...
+ * </pre>
+ * 档间距 = 该档价格 × gridRate，随价格下降而收窄。
+ *
+ * <p>同时将 step（= shortBaseEntryPrice × gridRate，即 0档 与 ±1档 的间距）注入 config，
+ * 供跨度重启等需要固定距离度量的功能使用。
+ *
+ * <p>队列降序排列（大→小），方便 processShortGrid 中从头遍历。
*/
private void generateShortQueue() {
shortPriceQueue.clear();
totalShortPriceQueue.clear();
totalLongPriceQueue.clear();
int prec = config.getPriceScale();
- BigDecimal step = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(prec, RoundingMode.HALF_UP);
+ BigDecimal gridRate = config.getGridRate();
+ // 首档间距 = 基价 × gridRate（0档与±1档的间距），保留作跨度等固定距离度量
+ BigDecimal step = shortBaseEntryPrice.multiply(gridRate).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);
+ BigDecimal factor = BigDecimal.ONE.subtract(gridRate);
+ BigDecimal elem = shortBaseEntryPrice.multiply(factor).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;
- }
+ elem = elem.multiply(factor).setScale(prec, RoundingMode.HALF_UP);
+ if (elem.compareTo(BigDecimal.ZERO) <= 0) {
+ break;
}
+ }
shortPriceQueue.sort((a, b) -> b.compareTo(a));
- log.info("[Gate] 空队列:{}", shortPriceQueue);
+ log.info("[Gate] 空队列(等比):{}", shortPriceQueue);
}
/**
- * 生成多仓价格队列。
- * 以 shortBaseEntryPrice + step 为首元素，后续依次递增 step，共 gridQueueSize 个。
- * 队列升序排列（小→大），方便 processLongGrid 中从头遍历。
+ * 生成多仓价格队列（等比 / 复合百分比网格）。
+ *
+ * <p>每个网格价 = 上一档 × (1 + gridRate)，即自 shortBaseEntryPrice 向上等比递增：
+ * <pre>
+ * 第1档 = shortBaseEntryPrice × (1 + gridRate)
+ * 第2档 = 第1档 × (1 + gridRate)
+ * ...
+ * </pre>
+ * 档间距 = 该档价格 × gridRate，随价格上升而放大；
+ * 与空仓队列（下方 ×(1−gridRate)）关于基价对称，保证上下网格连续一致。
+ *
+ * <p>队列升序排列（小→大），方便 processLongGrid 中从头遍历。
*/
private void generateLongQueue() {
longPriceQueue.clear();
int prec = config.getPriceScale();
- BigDecimal step = config.getStep();
- BigDecimal elem = shortBaseEntryPrice.add(step).setScale(prec, RoundingMode.HALF_UP);
+ BigDecimal factor = BigDecimal.ONE.add(config.getGridRate());
+ BigDecimal elem = shortBaseEntryPrice.multiply(factor).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);
+ totalLongPriceQueue.add(elem);
+ totalShortPriceQueue.add(elem);
+ elem = elem.multiply(factor).setScale(prec, RoundingMode.HALF_UP);
}
longPriceQueue.sort(BigDecimal::compareTo);
- log.info("[Gate] 多队列:{}", longPriceQueue);
+ log.info("[Gate] 多队列(等比):{}", longPriceQueue);
totalShortPriceQueue.sort((a, b) -> b.compareTo(a));
log.info("[Gate] 队列从大到小:{}", totalShortPriceQueue);
totalLongPriceQueue.sort(BigDecimal::compareTo);
@@ -1044,7 +1642,9 @@
int longSize = longPriceQueue.size();
//根据精度转换成小数
int prec = config.getPriceScale();
- BigDecimal step = config.getStep();
+ // 等比网格：止盈价与本档相邻网格价联动 = 本档价 × (1 ± gridRate)
+ BigDecimal tpUpFactor = BigDecimal.ONE.add(config.getGridRate());
+ BigDecimal tpDownFactor = BigDecimal.ONE.subtract(config.getGridRate());
// String qty = config.getBaseQuantity();
String qty = config.getQuantity();
@@ -1057,13 +1657,13 @@
TraderParam longParam = TraderParam.builder()
.direction(TraderParam.Direction.LONG)
.entryPrice(price)
- .takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
+ .takeProfitPrice(price.multiply(tpUpFactor).setScale(prec, RoundingMode.HALF_UP))
.quantity(qty)
.build();
TraderParam shortParam = TraderParam.builder()
.direction(TraderParam.Direction.SHORT)
.entryPrice(price)
- .takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
+ .takeProfitPrice(price.multiply(tpDownFactor).setScale(prec, RoundingMode.HALF_UP))
.quantity(qty)
.build();
elements.add(GridElement.builder()
@@ -1082,13 +1682,13 @@
TraderParam longParam = TraderParam.builder()
.direction(TraderParam.Direction.LONG)
.entryPrice(price)
- .takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
+ .takeProfitPrice(price.multiply(tpUpFactor).setScale(prec, RoundingMode.HALF_UP))
.quantity(qty)
.build();
TraderParam shortParam = TraderParam.builder()
.direction(TraderParam.Direction.SHORT)
.entryPrice(price)
- .takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
+ .takeProfitPrice(price.multiply(tpDownFactor).setScale(prec, RoundingMode.HALF_UP))
.quantity(qty)
.build();
elements.add(GridElement.builder()
@@ -1110,13 +1710,13 @@
TraderParam longParam = TraderParam.builder()
.direction(TraderParam.Direction.LONG)
.entryPrice(price)
- .takeProfitPrice(price.add(step).setScale(prec, RoundingMode.HALF_UP))
+ .takeProfitPrice(price.multiply(tpUpFactor).setScale(prec, RoundingMode.HALF_UP))
.quantity(qty)
.build();
TraderParam shortParam = TraderParam.builder()
.direction(TraderParam.Direction.SHORT)
.entryPrice(price)
- .takeProfitPrice(price.subtract(step).setScale(prec, RoundingMode.HALF_UP))
+ .takeProfitPrice(price.multiply(tpDownFactor).setScale(prec, RoundingMode.HALF_UP))
.quantity(qty)
.build();
elements.add(GridElement.builder()
@@ -1134,7 +1734,8 @@
}
- private void processShortGrid(BigDecimal currentPrice) {
+ /** 多仓仓位归零后，在当前价上方最近网格重新挂多单（遍历 totalLongPriceQueue 升序）。 */
+ private void processLongGrid(BigDecimal currentPrice) {
BigDecimal matched = BigDecimal.ZERO;
synchronized (totalLongPriceQueue) {
for (BigDecimal p : totalLongPriceQueue) {
@@ -1157,7 +1758,10 @@
if (newEntryGrid != null) {
// String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()) + Integer.parseInt(config.getQuantity()));
- String quantity = String.valueOf(config.getBaseQuantity());
+// String quantity = String.valueOf(config.getBaseQuantity());
+
+
+ String quantity = calculateEntryQuantity(true, false);
// 向下检查是否已有多单挂在更低价格网格，有则跳过（防止价格回升后重复挂单）
boolean hasLongOrderBelow = false;
GridElement checkDownCursor = GridElement.findById(newEntryGrid.getDownId());
@@ -1204,7 +1808,8 @@
}
- private void processLongGrid(BigDecimal currentPrice) {
+ /** 空仓仓位归零后，在当前价下方最近网格重新挂空单（遍历 totalShortPriceQueue 降序）。 */
+ private void processShortGrid(BigDecimal currentPrice) {
BigDecimal matched = BigDecimal.ZERO;
synchronized (totalShortPriceQueue) {
for (BigDecimal p : totalShortPriceQueue) {
@@ -1228,7 +1833,9 @@
// String quantity = String.valueOf((accumulatedShortLossCount + 1) * Integer.parseInt(config.getQuantity()));
// String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()) + Integer.parseInt(config.getQuantity()));
- String quantity = String.valueOf(config.getBaseQuantity());
+// String quantity = String.valueOf(config.getBaseQuantity());
+
+ String quantity = calculateEntryQuantity(false, false);
// 向上检查是否已有空单挂在更高价格网格，有则跳过（防止价格回落后重复挂单）
boolean hasShortOrderAbove = false;
GridElement checkUpCursor = GridElement.findById(newEntryGrid.getUpId());
@@ -1251,7 +1858,7 @@
GridElement finalCancelCursor = cancelCursor;
executor.cancelConditionalOrder(shortOrderId, oid -> {
shortEntryTraderIdParam(finalCancelCursor, shortOrderId, false);
- log.info("[Gate] 空仓仓位归零, 取消gridId:{}的多单{}", finalCancelCursor.getId(), shortOrderId);
+ log.info("[Gate] 空仓仓位归零, 取消gridId:{}的空单{}", finalCancelCursor.getId(), shortOrderId);
});
}
}
@@ -1262,7 +1869,7 @@
if (!newEntryGrid.isHasShortOrder() && !hasShortOrderAbove){
BigDecimal triggerPrice = newEntryGrid.getGridPrice();
String size = quantity;
- log.info("[Gate] 空仓仓位归零 gridId:{}, 挂{}基础张多单",
+ log.info("[Gate] 空仓仓位归零 gridId:{}, 挂{}基础张空单",
newEntryGrid.getId(), size);
newEntryGrid.getShortTraderParam().setQuantity(size);
placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
@@ -1296,19 +1903,27 @@
}
/**
- * 根据加仓配置计算止损追单时的实际下单量。
+ * 根据加仓配置计算入场/追单时的实际下单量。
* <p>公式：</p>
* <pre>
* divisor = addPositionInterval + 1
* addMultiplier = floor(effectiveStopLossCount / divisor)
* addQty = addMultiplier × addPositionQuantity
- * finalQty = min(baseQuantity + addQty, maxPositionPerSide > 0 ? maxPositionPerSide : ∞)
+ * finalQty = min(baseQuantity + addQty, upperLimit)
* </pre>
+ * <p>上限 upperLimit：</p>
+ * <ul>
+ * <li>{@code respectCurrentPosition=false}：{@code upperLimit = maxPositionPerSide}
+ * （仓位归零重新入场，仅限制单次下单量）</li>
+ * <li>{@code respectCurrentPosition=true}：{@code upperLimit = maxPositionPerSide - 当前持仓}
+ * （止损追单，保证单边总持仓 ≤ maxPositionPerSide）</li>
+ * </ul>
*
- * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
+ * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
+ * @param respectCurrentPosition {@code true}=按「单边总持仓 ≤ maxPositionPerSide」扣减当前持仓；{@code false}=仅限制单次下单量
* @return 实际下单张数（字符串）
*/
- private String calculateEntryQuantity(boolean isLong) {
+ private String calculateEntryQuantity(boolean isLong, boolean respectCurrentPosition) {
int baseQty = Integer.parseInt(config.getBaseQuantity());
int interval = config.getAddPositionInterval();
int addQtyPerUnit = config.getAddPositionQuantity();
@@ -1325,8 +1940,22 @@
int addQty = addMultiplier * addQtyPerUnit;
int totalQty = baseQty + addQty;
- if (maxPerSide > 0 && totalQty > maxPerSide) {
- totalQty = maxPerSide;
+ if (maxPerSide > 0) {
+ int upperLimit = maxPerSide;
+ if (respectCurrentPosition) {
+ // 止损追单：单边总持仓不得超过 maxPerSide，追单量 = maxPerSide - 当前持仓。
+ // 止损单刚成交、WS 持仓推送尚未到达，必须用 REST 实时查询绕过 WS 缓存时序竞态，
+ // 否则会取到滞后的旧持仓（如止损前仍为 10），把追单量错误扣减。
+ int currentPos = isLong
+ ? queryPositionSize(Position.ModeEnum.DUAL_LONG)
+ : queryPositionSize(Position.ModeEnum.DUAL_SHORT);
+ upperLimit = maxPerSide - currentPos;
+ }
+ if (upperLimit <= 0) {
+ totalQty = 0;
+ } else if (totalQty > upperLimit) {
+ totalQty = upperLimit;
+ }
}
return String.valueOf(totalQty);
@@ -1347,6 +1976,13 @@
accumulatedLongLossCount++;
log.info("[Gate] 多仓止损触发 gridId:{}, 止损次数:{}{}, 开始追单",
gridId, accumulatedLongLossCount, sameGrid ? "(同网格)" : "");
+
+ // 埋点: STOP_LOSS_TRIGGERED
+ emitStats("STOP_LOSS_TRIGGERED", mapOf(
+ "direction", "long",
+ "gridId", gridId,
+ "lossCount", accumulatedLongLossCount
+ ));
int newEntryGridId = gridId + 1;
GridElement newEntryGrid = GridElement.findById(newEntryGridId);
@@ -1358,12 +1994,16 @@
// 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
BigDecimal triggerPrice = newEntryGrid.getGridPrice();
- String size = calculateEntryQuantity(true);
+ String size = calculateEntryQuantity(true, true);
log.info("[Gate] 多仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
getEffectiveStopLossCount(true), config.getBaseQuantity(), size, config.getStopLossCountMode());
- newEntryGrid.getLongTraderParam().setQuantity(size);
- placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
- FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
+ if (Integer.parseInt(size) <= 0) {
+ log.warn("[Gate] 多仓止损追单 当前持仓已达单边上限({}), 跳过挂单", config.getMaxPositionPerSide());
+ } else {
+ newEntryGrid.getLongTraderParam().setQuantity(size);
+ placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
+ FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
+ }
// 取消 gridId+2 位置的所有多单
int cancelGridId = gridId + 2;
@@ -1375,6 +2015,13 @@
log.info("[Gate] 多仓止损触发, 取消gridId:{}的多单,{}", cancelGridId, cancelOrderId);
});
}
+ }
+
+ // 自定义止损模式：第一次止损触发时，取消未触发侧（空仓）自定义止损单并重挂默认阶梯
+ if (config.isDualStopLossEnabled() && dualStopLossModeActive.compareAndSet(true, false)) {
+ cancelAllShortStopLossesOnly();
+ placeDefaultShortStopLossLadder();
+ log.info("[Gate] 自定义止损首次触发(多仓), 已取消空仓自定义止损并重挂默认阶梯");
}
}
@@ -1392,6 +2039,13 @@
accumulatedShortLossCount++;
log.info("[Gate] 空仓止损触发 gridId:{}, 止损次数:{}{}, 开始追单",
gridId, accumulatedShortLossCount, sameGrid ? "(同网格)" : "");
+
+ // 埋点: STOP_LOSS_TRIGGERED
+ emitStats("STOP_LOSS_TRIGGERED", mapOf(
+ "direction", "short",
+ "gridId", gridId,
+ "lossCount", accumulatedShortLossCount
+ ));
int newEntryGridId = gridId - 1;
GridElement newEntryGrid = GridElement.findById(newEntryGridId);
@@ -1403,12 +2057,16 @@
// 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
BigDecimal triggerPrice = newEntryGrid.getGridPrice();
- String size = calculateEntryQuantity(false);
+ String size = calculateEntryQuantity(false, true);
log.info("[Gate] 空仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
getEffectiveStopLossCount(false), config.getBaseQuantity(), size, config.getStopLossCountMode());
- newEntryGrid.getShortTraderParam().setQuantity(size);
- placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
- FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
+ if (Integer.parseInt(size) <= 0) {
+ log.warn("[Gate] 空仓止损追单 当前持仓已达单边上限({}), 跳过挂单", config.getMaxPositionPerSide());
+ } else {
+ newEntryGrid.getShortTraderParam().setQuantity(size);
+ placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
+ FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
+ }
// 取消 gridId-2 位置的所有空单
int cancelGridId = gridId - 2;
@@ -1420,6 +2078,13 @@
log.info("[Gate] 空仓止损触发, 取消gridId:{}的空单,{}", cancelGridId, cancelOrderId);
});
}
+ }
+
+ // 自定义止损模式：第一次止损触发时，取消未触发侧（多仓）自定义止损单并重挂默认阶梯
+ if (config.isDualStopLossEnabled() && dualStopLossModeActive.compareAndSet(true, false)) {
+ cancelAllLongStopLossesOnly();
+ placeDefaultLongStopLossLadder();
+ log.info("[Gate] 自定义止损首次触发(空仓), 已取消多仓自定义止损并重挂默认阶梯");
}
}
@@ -1571,11 +2236,13 @@
*/
private void cancelAllLongTakeProfitsAndStopLosses() {
for (GridElement e : config.getGridElements()) {
- String tpId = e.getLongTakeProfitOrderId();
- if (tpId != null) {
- e.getLongTraderParam().setTakeProfitPlaced(false);
- e.setLongTakeProfitOrderId(null);
+ for (String tpId : new ArrayList<>(e.getLongTakeProfitOrderIds())) {
executor.cancelConditionalOrder(tpId, oid -> {});
+ }
+ e.clearLongTakeProfitOrderIds();
+ if (e.getLongTraderParam() != null) {
+ e.getLongTraderParam().setTakeProfitPlaced(false);
+ e.getLongTraderParam().setTakeProfitOrderId(null);
}
for (String slId : new ArrayList<>(e.getLongStopLossOrderIds())) {
executor.cancelConditionalOrder(slId, oid -> {});
@@ -1591,11 +2258,13 @@
*/
private void cancelAllShortTakeProfitsAndStopLosses() {
for (GridElement e : config.getGridElements()) {
- String tpId = e.getShortTakeProfitOrderId();
- if (tpId != null) {
- e.getShortTraderParam().setTakeProfitPlaced(false);
- e.setShortTakeProfitOrderId(null);
+ for (String tpId : new ArrayList<>(e.getShortTakeProfitOrderIds())) {
executor.cancelConditionalOrder(tpId, oid -> {});
+ }
+ e.clearShortTakeProfitOrderIds();
+ if (e.getShortTraderParam() != null) {
+ e.getShortTraderParam().setTakeProfitPlaced(false);
+ e.getShortTraderParam().setTakeProfitOrderId(null);
}
for (String slId : new ArrayList<>(e.getShortStopLossOrderIds())) {
executor.cancelConditionalOrder(slId, oid -> {});
@@ -1610,20 +2279,28 @@
* 首次挂单成交时，取消初始化阶段挂的所有止盈单（多+空），止损单保留不动。
*/
private void cancelAllInitialTakeProfits() {
-
-
GridElement tpElemLong = GridElement.findById(3);
- String longTpId = tpElemLong.getLongTakeProfitOrderId();
- if (longTpId != null) {
- longTakeProfitTraderIdParam(tpElemLong, null, false);
- executor.cancelConditionalOrder(longTpId, oid -> {});
+ if (tpElemLong != null) {
+ for (String tpId : new ArrayList<>(tpElemLong.getLongTakeProfitOrderIds())) {
+ executor.cancelConditionalOrder(tpId, oid -> {});
+ }
+ tpElemLong.clearLongTakeProfitOrderIds();
+ if (tpElemLong.getLongTraderParam() != null) {
+ tpElemLong.getLongTraderParam().setTakeProfitPlaced(false);
+ tpElemLong.getLongTraderParam().setTakeProfitOrderId(null);
+ }
}
GridElement tpElemShort = GridElement.findById(-3);
- String shortTpId = tpElemShort.getShortTakeProfitOrderId();
- if (shortTpId != null) {
- shortTakeProfitTraderIdParam(tpElemShort, null, false);
- executor.cancelConditionalOrder(shortTpId, oid -> {});
+ if (tpElemShort != null) {
+ for (String tpId : new ArrayList<>(tpElemShort.getShortTakeProfitOrderIds())) {
+ executor.cancelConditionalOrder(tpId, oid -> {});
+ }
+ tpElemShort.clearShortTakeProfitOrderIds();
+ if (tpElemShort.getShortTraderParam() != null) {
+ tpElemShort.getShortTraderParam().setTakeProfitPlaced(false);
+ tpElemShort.getShortTraderParam().setTakeProfitOrderId(null);
+ }
}
GridElement.refreshIndices();
log.info("[Gate] 首次成交，取消所有初始化止盈单");
@@ -1646,6 +2323,7 @@
return;
}
+ // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈
int totalOrders = filledQty / qty;
int[] orders = new int[gridCount];
@@ -1708,6 +2386,7 @@
return;
}
+ // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈
int totalOrders = filledQty / qty;
int[] orders = new int[gridCount];
@@ -1960,8 +2639,12 @@
public void setMarkPrice(BigDecimal markPrice) { this.markPrice = markPrice; }
/** @return 策略是否处于活跃状态（非 STOPPED 且非 WAITING_KLINE） */
public boolean isStrategyActive() { return state != StrategyState.STOPPED && state != StrategyState.WAITING_KLINE; }
+ /** @return 当前已完成轮数 */
+ public int getCurrentRound() { return currentRound; }
/** @return 累计已实现盈亏（平仓推送驱动累加） */
public BigDecimal getCumulativePnl() { return cumulativePnl; }
+ /** @return 初始本金 */
+ public BigDecimal getInitialPrincipal() { return initialPrincipal; }
/** @return 当前未实现盈亏（每根 K 线实时计算） */
public BigDecimal getUnrealizedPnl() { return unrealizedPnl; }
/** @return Gate 用户 ID（用于私有频道订阅 payload） */
@@ -1970,6 +2653,212 @@
public StrategyState getState() { return state; }
/** 注入WS客户端，用于订阅状态检查 */
public void setWsClient(GateKlineWebSocketClient wsClient) { this.wsClient = wsClient; }
+
+ // ========== 手动控制（Station 指令） ==========
+
+ /**
+ * 手动取消多仓止盈 + 止损挂单，并同步清理对应 GridElement 的挂单记录。
+ */
+ public void cancelLongTakeProfitAndStopLoss() {
+ submitManualTask(this::cancelAllLongTakeProfitsAndStopLosses);
+ }
+
+ /**
+ * 手动取消空仓止盈 + 止损挂单，并同步清理对应 GridElement 的挂单记录。
+ */
+ public void cancelShortTakeProfitAndStopLoss() {
+ submitManualTask(this::cancelAllShortTakeProfitsAndStopLosses);
+ }
+
+ /**
+ * 手动重新生成多仓止盈 + 止损挂单，逻辑与挂单成交（onAutoOrder）一致：
+ * 先撤多仓所有止盈止损，再按交易所最新持仓重挂止损阶梯，超额部分挂止盈到空仓第一止损位。
+ */
+ public void rebuildLongTakeProfitAndStopLoss() {
+ submitManualTask(() -> {
+ cancelAllLongTakeProfitsAndStopLosses();
+ int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue());
+ if (posSize <= 0) {
+ log.warn("[Gate] 生成多仓止盈止损失败：无多仓持仓");
+ return;
+ }
+ extendLongStopLoss(posSize, 0);
+ if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
+ placeExcessTakeProfit(posSize, true);
+ } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
+ placeDispersedTakeProfit(posSize, true, 0);
+ }
+ placeBaseTakeProfit(posSize, true, 0);
+ log.info("[Gate] 生成多仓止盈止损完成, 仓位:{}张", posSize);
+ });
+ }
+
+ /**
+ * 手动重新生成空仓止盈 + 止损挂单，逻辑与挂单成交（onAutoOrder）一致：
+ * 先撤空仓所有止盈止损，再按交易所最新持仓重挂止损阶梯，超额部分挂止盈到多仓第一止损位。
+ */
+ public void rebuildShortTakeProfitAndStopLoss() {
+ submitManualTask(() -> {
+ cancelAllShortTakeProfitsAndStopLosses();
+ int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue());
+ if (posSize <= 0) {
+ log.warn("[Gate] 生成空仓止盈止损失败：无空仓持仓");
+ return;
+ }
+ extendShortStopLoss(posSize, 0);
+ if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
+ placeExcessTakeProfit(posSize, false);
+ } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
+ placeDispersedTakeProfit(posSize, false, 0);
+ }
+ placeBaseTakeProfit(posSize, false, 0);
+ log.info("[Gate] 生成空仓止盈止损完成, 仓位:{}张", posSize);
+ });
+ }
+
+ /**
+ * 多单平仓：市价平掉多仓 → 撤多仓所有挂单并更新 GridElement → 交由价格驱动（onKline→processGrid）重新入场。
+ */
+ public void closeLongPosition() {
+ submitManualTask(() -> closePositionByMode(Position.ModeEnum.DUAL_LONG, true));
+ }
+
+ /**
+ * 空单平仓：市价平掉空仓 → 撤空仓所有挂单并更新 GridElement → 交由价格驱动（onKline→processGrid）重新入场。
+ */
+ public void closeShortPosition() {
+ submitManualTask(() -> closePositionByMode(Position.ModeEnum.DUAL_SHORT, false));
+ }
+
+ /**
+ * 统一提交手动操作任务。策略停止（executor 已关闭）时直接忽略，避免 RejectedExecutionException。
+ */
+ private void submitManualTask(Runnable task) {
+ if (state == StrategyState.STOPPED) {
+ log.warn("[Gate] 策略已停止，忽略手动操作");
+ return;
+ }
+ executor.submitTask(task);
+ }
+
+ /**
+ * 按持仓模式市价平仓（reduceOnly + IOC），随后撤该方向所有挂单（止盈/止损/入场单）、
+ * 更新 GridElement，并清空 active 与持仓量标记，让价格驱动在下一根 K 线重新挂入场单。
+ *
+ * @param mode 持仓模式（DUAL_LONG / DUAL_SHORT）
+ * @param isLong true=多仓，false=空仓
+ */
+ private void closePositionByMode(Position.ModeEnum mode, boolean isLong) {
+ String sideLabel = isLong ? "多" : "空";
+ // 1. 市价平掉对应方向仓位（价格保护拒绝时重试）
+ try {
+ Position pos = queryPosition(mode);
+ if (pos != null) {
+ String sizeStr = pos.getSize();
+ long size = Long.parseLong(sizeStr);
+ if (size != 0) {
+ Position.ModeEnum posMode = pos.getMode();
+ FuturesOrder closeOrder = new FuturesOrder();
+ closeOrder.setContract(config.getContract());
+ closeOrder.setPrice("0");
+ closeOrder.setTif(FuturesOrder.TifEnum.IOC);
+ closeOrder.setReduceOnly(true);
+ if (posMode != null && posMode.getValue() != null && posMode.getValue().contains("dual")) {
+ closeOrder.setSize("0");
+ closeOrder.setClose(false);
+ closeOrder.setAutoSize(size > 0 ? FuturesOrder.AutoSizeEnum.LONG : FuturesOrder.AutoSizeEnum.SHORT);
+ } else {
+ closeOrder.setSize(size > 0 ? String.valueOf(-size) : String.valueOf(Math.abs(size)));
+ }
+ closeOrder.setText("t-grid-manual-close");
+ for (int attempt = 1; attempt <= CLOSE_POSITION_RETRY_MAX_ATTEMPTS; attempt++) {
+ try {
+ futuresApi.createFuturesOrder(SETTLE, closeOrder, null);
+ log.info("[Gate] 手动平{}仓, size:{}, mode:{}", sideLabel, sizeStr, posMode);
+ break;
+ } catch (Exception e) {
+ if (attempt < CLOSE_POSITION_RETRY_MAX_ATTEMPTS && isPriceProtectionRejected(e)) {
+ log.warn("[Gate] 手动平{}仓遭遇价格保护, 第{}次失败, {}ms后重试: {}",
+ sideLabel, attempt, CLOSE_POSITION_RETRY_DELAY_MS, e.getMessage());
+ try {
+ Thread.sleep(CLOSE_POSITION_RETRY_DELAY_MS);
+ } catch (InterruptedException ie) {
+ Thread.currentThread().interrupt();
+ break;
+ }
+ } else {
+ throw e;
+ }
+ }
+ }
+ }
+ }
+ } catch (Exception e) {
+ log.warn("[Gate] 手动平{}仓失败", sideLabel, e);
+ }
+
+ // 2. 撤该方向所有挂单 + 更新 GridElement
+ if (isLong) {
+ cancelAllLongTakeProfitsAndStopLosses();
+ cancelAllLongEntryOrders();
+ longActive = false;
+ longPositionSize = BigDecimal.ZERO;
+ } else {
+ cancelAllShortTakeProfitsAndStopLosses();
+ cancelAllShortEntryOrders();
+ shortActive = false;
+ shortPositionSize = BigDecimal.ZERO;
+ }
+ log.info("[Gate] {}仓已平仓并清理挂单，交由价格驱动重新入场", sideLabel);
+ }
+
+ /**
+ * 判断异常是否为市价单价格保护拒绝（{@code MARKET_PRICE_TOO_DEVIATED}）。
+ *
+ * <p>该错误是交易所对市价单的保护：当盘口价相对最新价偏离超过滑点比率时拒绝下单，
+ * 属于瞬时行情错误，等待行情稳定后重试通常可成功。
+ */
+ private boolean isPriceProtectionRejected(Exception e) {
+ if (e instanceof GateApiException) {
+ String label = ((GateApiException) e).getErrorLabel();
+ return label != null && label.contains("PRICE_TOO_DEVIATED");
+ }
+ return false;
+ }
+
+ /**
+ * 取消所有多仓入场单（条件开仓单），并清空 GridElement 的多仓挂单记录。
+ */
+ private void cancelAllLongEntryOrders() {
+ for (GridElement e : config.getGridElements()) {
+ for (String oid : new ArrayList<>(e.getLongOrderIds())) {
+ executor.cancelConditionalOrder(oid, o -> {});
+ }
+ e.getLongTraderParam().setEntryOrderId(null);
+ e.getLongTraderParam().setEntryOrderPlaced(false);
+ e.setHasLongOrder(false);
+ e.clearLongOrderIds();
+ }
+ GridElement.refreshIndices();
+ log.info("[Gate] 已提交取消所有多仓入场单");
+ }
+
+ /**
+ * 取消所有空仓入场单（条件开仓单），并清空 GridElement 的空仓挂单记录。
+ */
+ private void cancelAllShortEntryOrders() {
+ for (GridElement e : config.getGridElements()) {
+ for (String oid : new ArrayList<>(e.getShortOrderIds())) {
+ executor.cancelConditionalOrder(oid, o -> {});
+ }
+ e.getShortTraderParam().setEntryOrderId(null);
+ e.getShortTraderParam().setEntryOrderPlaced(false);
+ e.setHasShortOrder(false);
+ e.clearShortOrderIds();
+ }
+ GridElement.refreshIndices();
+ log.info("[Gate] 已提交取消所有空仓入场单");
+ }
// ========== 止损查表辅助方法 ==========
@@ -2050,6 +2939,184 @@
}
/**
+ * 分散止盈：把超出基础仓位的部分，从入场网格下一格开始逐格挂止盈单，
+ * 一直挂到对手盘止损位的前一格（不含止损位那一格）。
+ *
+ * <p>数量分配：每个网格至少挂 1 张；当 excessQty < 网格数时，张数不够则从起点逐格各挂 1 张、
+ * 挂满 excessQty 张即停止；当 excessQty ≥ 网格数时，每格 excessQty÷n，余数堆最后一格（即止损位的前一格）。
+ *
+ * <p>方向：多仓成交向价格更高方向（id 递增）铺到空仓第一止损位；
+ * 空仓成交向价格更低方向（id 递减）铺到多仓第一止损位。
+ *
+ * @param posSize 当前总持仓张数
+ * @param isLong true=多仓成交，false=空仓成交
+ * @param entryGridId 入场网格 ID
+ */
+ private void placeDispersedTakeProfit(int posSize, boolean isLong, int entryGridId) {
+ int baseQty = Integer.parseInt(config.getBaseQuantity());
+ int excessQty = posSize - baseQty;
+ if (excessQty <= 0) {
+ return;
+ }
+
+ GridElement endElem = isLong ? findFirstShortStopLossGrid() : findFirstLongStopLossGrid();
+ if (endElem == null) {
+ log.warn("[Gate] {}分散止盈失败：未找到对手盘止损位", isLong ? "多仓" : "空仓");
+ return;
+ }
+ int dir = isLong ? 1 : -1;
+ int startId = entryGridId + dir;
+ // 分配范围到止损位的前一格截止（不含止损位那一格）
+ int endId = endElem.getId() - dir;
+
+ // 终点必须在起点前进方向上，否则退化为集中止盈（全部挂对手盘止损位）
+ boolean valid = isLong ? (endId >= startId) : (endId <= startId);
+ if (!valid) {
+ placeExcessTakeProfit(posSize, isLong);
+ return;
+ }
+
+ // 收集区间内全部网格（含两端）
+ List<GridElement> gridList = new ArrayList<>();
+ int id = startId;
+ while (true) {
+ GridElement e = GridElement.findById(id);
+ if (e == null) {
+ break;
+ }
+ gridList.add(e);
+ if (id == endId) {
+ break;
+ }
+ id += dir;
+ if (gridList.size() > config.getGridQueueSize() * 2 + 4) {
+ break;
+ }
+ }
+ if (gridList.isEmpty() || gridList.get(gridList.size() - 1).getId() != endId) {
+ // 未能铺满到终点（网格缺失），退化为集中止盈
+ placeExcessTakeProfit(posSize, isLong);
+ return;
+ }
+
+ int n = gridList.size();
+ int perGrid = excessQty / n;
+ int remainder = excessQty % n;
+
+ for (int i = 0; i < n; i++) {
+ int qty;
+ if (excessQty >= n) {
+ // 超额仓位 ≥ 网格数：每格 perGrid，余数堆最后一格（即止损位的前一格）
+ qty = perGrid;
+ if (i == n - 1) {
+ qty += remainder;
+ }
+ } else {
+ // 超额仓位 < 网格数：前 excessQty 个网格各挂 1 张，其余不挂（避免退化为合并止盈）
+ qty = (i < excessQty) ? 1 : 0;
+ }
+ if (qty <= 0) {
+ continue;
+ }
+ final GridElement elem = gridList.get(i);
+ final int gid = elem.getId();
+ final BigDecimal triggerPrice = elem.getGridPrice();
+ final String size = isLong ? negate(String.valueOf(qty)) : String.valueOf(qty);
+ final String orderType = isLong ? ORDER_TYPE_CLOSE_LONG : ORDER_TYPE_CLOSE_SHORT;
+ final FuturesPriceTrigger.RuleEnum rule = isLong ? FuturesPriceTrigger.RuleEnum.NUMBER_1
+ : FuturesPriceTrigger.RuleEnum.NUMBER_2;
+ executor.placeTakeProfit(triggerPrice, rule, orderType, size,
+ profitId -> {
+ if (isLong) {
+ longTakeProfitTraderIdParam(elem, profitId, true);
+ } else {
+ shortTakeProfitTraderIdParam(elem, profitId, true);
+ }
+ log.info("[Gate] 分散止盈 {} gridId:{}, 触发价:{}, 数量:{}, tpId:{}",
+ isLong ? "多仓" : "空仓", gid, triggerPrice, size, profitId);
+ }
+ );
+ }
+ }
+
+ /**
+ * 基础止盈：对基础仓位（baseQuantity）也挂止盈单，与超额止盈并行。
+ *
+ * <p>规则：从入场网格下一格（entryGridId ± 1）开始，每格 baseTakeProfitPerGrid 张，
+ * 最多挂 baseTakeProfitGridCount 格，挂到止损位的前一格截止（与分散止盈同起点/同终点）。
+ *
+ * <p>边界：累计张数到 min(baseQuantity, 当前持仓) 即停（张数不足则最后一格挂剩余 = "挂几个算几个"）；
+ * 网格不足时挂到停止位置结束。
+ *
+ * @param posSize 当前总持仓张数
+ * @param isLong true=多仓止盈，false=空仓止盈
+ * @param entryGridId 入场网格 ID
+ */
+ private void placeBaseTakeProfit(int posSize, boolean isLong, int entryGridId) {
+ int perGrid = config.getBaseTakeProfitPerGrid();
+ int gridCount = config.getBaseTakeProfitGridCount();
+ if (perGrid <= 0 || gridCount <= 0) {
+ return;
+ }
+ int baseQty = Integer.parseInt(config.getBaseQuantity());
+ if (baseQty <= 0) {
+ return;
+ }
+ // 张数硬上限 = min(基础张数, 当前持仓)，避免持仓不足 baseQuantity 时超挂
+ int maxQty = Math.min(baseQty, posSize);
+ if (maxQty <= 0) {
+ return;
+ }
+
+ GridElement endElem = isLong ? findFirstShortStopLossGrid() : findFirstLongStopLossGrid();
+ if (endElem == null) {
+ log.warn("[Gate] {}基础止盈失败：未找到对手盘止损位", isLong ? "多仓" : "空仓");
+ return;
+ }
+ int dir = isLong ? 1 : -1;
+ int startId = entryGridId + dir;
+ // 分配范围到止损位的前一格截止（与分散止盈一致）
+ int endId = endElem.getId() - dir;
+
+ int remaining = maxQty;
+ int placed = 0;
+ int id = startId;
+ while (placed < gridCount && remaining > 0) {
+ if (isLong ? id > endId : id < endId) {
+ break;
+ }
+ GridElement elem = GridElement.findById(id);
+ if (elem == null) {
+ break;
+ }
+ int qty = Math.min(perGrid, remaining);
+ final GridElement fe = elem;
+ final int gid = id;
+ final BigDecimal triggerPrice = elem.getGridPrice();
+ final String size = isLong ? negate(String.valueOf(qty)) : String.valueOf(qty);
+ final String orderType = isLong ? ORDER_TYPE_CLOSE_LONG : ORDER_TYPE_CLOSE_SHORT;
+ final FuturesPriceTrigger.RuleEnum rule = isLong ? FuturesPriceTrigger.RuleEnum.NUMBER_1
+ : FuturesPriceTrigger.RuleEnum.NUMBER_2;
+ executor.placeTakeProfit(triggerPrice, rule, orderType, size,
+ profitId -> {
+ if (isLong) {
+ longTakeProfitTraderIdParam(fe, profitId, true);
+ } else {
+ shortTakeProfitTraderIdParam(fe, profitId, true);
+ }
+ log.info("[Gate] 基础止盈 {} gridId:{}, 触发价:{}, 数量:{}, tpId:{}",
+ isLong ? "多仓" : "空仓", gid, triggerPrice, size, profitId);
+ }
+ );
+ remaining -= qty;
+ placed++;
+ id += dir;
+ }
+ log.info("[Gate] 基础止盈 {} 挂单完成, 入场gridId:{}, 挂{}格, 剩余{}张",
+ isLong ? "多仓" : "空仓", entryGridId, placed, remaining);
+ }
+
+ /**
* 在指定网格挂一笔对手止盈单（非满仓超额止盈，挂在止损触发位的下一格）。
*/
private void placeTakeProfitAtGrid(GridElement tpElem, boolean isLong, int qty, int times) {
--
Gitblit v1.9.1