From 7247b46f0f6567520eb036962c954d4c2be17a9d Mon Sep 17 00:00:00 2001
From: Administrator <15274802129@163.com>
Date: Mon, 22 Jun 2026 10:36:27 +0800
Subject: [PATCH] feat(gateApi): 实现网格交易止盈止损管理功能
---
src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java | 1227 ++++++++++++++++++++++++---------------------------------
1 files changed, 522 insertions(+), 705 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 df29b87..01bea3a 100644
--- a/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java
+++ b/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java
@@ -14,11 +14,7 @@
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
import com.xcong.excoin.modules.gateApi.wsHandler.handler.CandlestickChannelHandler;
import com.xcong.excoin.modules.gateApi.wsHandler.handler.PositionClosesChannelHandler;
@@ -116,6 +112,8 @@
private final List<BigDecimal> shortPriceQueue = Collections.synchronizedList(new ArrayList<>());
/** 多仓价格队列，升序排列（小→大），容量 gridQueueSize */
private final List<BigDecimal> longPriceQueue = Collections.synchronizedList(new ArrayList<>());
+ private final List<BigDecimal> totalLongPriceQueue = Collections.synchronizedList(new ArrayList<>());
+ private final List<BigDecimal> totalShortPriceQueue = Collections.synchronizedList(new ArrayList<>());
/** 当前多仓条件单映射：订单ID → 止盈价格，订单成交后通过订单订阅推送匹配止盈 */
private final Map<String, BigDecimal> currentLongOrderIds = Collections.synchronizedMap(new LinkedHashMap<>());
@@ -136,6 +134,11 @@
/** 多头是否活跃（有仓位） */
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;
@@ -147,11 +150,6 @@
private Long userId;
private volatile BigDecimal initialPrincipal = BigDecimal.ZERO;
private volatile GateKlineWebSocketClient wsClient;
-
- /** 多仓挂单张数计数器：止损触发时用当前值挂单，随后+1；挂单成交后重置为1 */
- private volatile int longEntryQty = 1;
- /** 空仓挂单张数计数器：止损触发时用当前值挂单，随后+1；挂单成交后重置为1 */
- private volatile int shortEntryQty = 1;
public GateGridTradeService(GateConfig config) {
this.config = config;
@@ -307,13 +305,12 @@
baseShortOpened = false;
longActive = false;
shortActive = false;
+ accumulatedLongLossCount = 0;
+ accumulatedShortLossCount = 0;
shortPriceQueue.clear();
longPriceQueue.clear();
currentLongOrderIds.clear();
currentShortOrderIds.clear();
- longEntryQty = 1;
- shortEntryQty = 1;
-
// 每次重启重新获取当前本金
refreshInitialPrincipal();
@@ -339,6 +336,7 @@
public void stopGrid() {
state = StrategyState.STOPPED;
executor.cancelAllPriceTriggeredOrders();
+ closeExistingPositions();
executor.shutdown();
log.info("[Gate] 策略已停止, 累计盈亏: {}", cumulativePnl);
}
@@ -365,55 +363,39 @@
*/
public void onKline(BigDecimal closePrice) {
lastKlinePrice = closePrice;
- updateUnrealizedPnl();
- if (state == StrategyState.STOPPED) {
- try {
- futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
- } catch (ApiException e) {
- e.printStackTrace();
- }
- closeExistingPositions();
-
- BigDecimal totalPnl = cumulativePnl.add(unrealizedPnl);
- log.info("[Gate] 已实现:{}, 未实现:{}, 合计:{}",
- cumulativePnl, unrealizedPnl, totalPnl);
-
- startGrid();
- return;
- }
//初始化0位置的开仓，并且用空的开仓价格，作为价格基准来划分网格
if (state == StrategyState.WAITING_KLINE) {
if (wsClient == null || !wsClient.areAllSubscribed()) {
return;
}
+
state = StrategyState.OPENING;
- log.info("[Gate] 首根K线到达，开基底仓位 多空各{}张...", config.getBaseQuantity());
- executor.openLong(config.getBaseQuantity(), (orderId) -> {
+
+ String size = config.getBaseQuantity();
+ log.info("[Gate] 首根K线到达，开基底仓位 多空各{}张...", size);
+ executor.openLong(size, (orderId) -> {
TraderParam baseLongTp = TraderParam.builder()
.entryOrderId(orderId)
.build();
config.setBaseLongTraderParam(baseLongTp);
}, null);
- executor.openShort(negate(config.getBaseQuantity()), (orderId) -> {
+ executor.openShort(negate(size), (orderId) -> {
TraderParam baseShortTp = TraderParam.builder()
.entryOrderId(orderId)
.build();
config.setBaseShortTraderParam(baseShortTp);
}, null);
-
return;
}
- if (state != StrategyState.ACTIVE) {
- return;
- }
- checkProfitAndReset();
+
+// checkProfitAndReset();
if (state == StrategyState.ACTIVE &&
longActive == false &&
- longPositionSize.compareTo(BigDecimal.ZERO) == 0){
+ longPositionSize.compareTo(BigDecimal.ZERO) == 0){
processShortGrid(closePrice);
}
@@ -422,6 +404,46 @@
shortActive == false &&
shortPositionSize.compareTo(BigDecimal.ZERO) == 0){
processLongGrid(closePrice);
+ }
+ }
+
+ /** Gate 永续合约 taker 费率 0.05% */
+ private static final BigDecimal TAKER_FEE_RATE = new BigDecimal("0.0005");
+ private void checkProfitAndReset() {
+ try {
+
+ BigDecimal target = initialPrincipal.add(config.getExpectedProfit());
+
+ FuturesAccount account = futuresApi.listFuturesAccounts(SETTLE);
+ BigDecimal unrealisedPnl = new BigDecimal(account.getCrossUnrealisedPnl());
+ BigDecimal available = new BigDecimal(account.getCrossAvailable());
+ BigDecimal totalEquity = unrealisedPnl.add(available);
+
+ // 估算平仓手续费：(多仓张数+空仓张数) × 合约面值 × 当前价 × taker费率
+ BigDecimal totalSize = longPositionSize.abs().add(shortPositionSize.abs());
+ BigDecimal closeContractValue =
+ totalSize.multiply(config.getContractMultiplier()).multiply(lastKlinePrice != null ? lastKlinePrice : BigDecimal.ZERO);
+ BigDecimal estimatedFee = closeContractValue.multiply(TAKER_FEE_RATE);
+ BigDecimal netEquity = totalEquity.subtract(estimatedFee);
+ log.info("[Gate] 盈亏检查,总张数：{}, upl:{}, avail:{}, 合计:{}, 估手续费:{}, 净权益:{}, 目标:{}",
+ totalSize,unrealisedPnl, available, totalEquity, estimatedFee, netEquity, target);
+ if (netEquity.compareTo(target) > 0) {
+ log.info("[Gate] 盈亏达标(净权益{}>目标{})，重置策略", netEquity, target);
+ state = StrategyState.STOPPED;
+ try {
+ futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
+ } catch (ApiException e) {
+ e.printStackTrace();
+ }
+ closeExistingPositions();
+ // 提交到 executor 末尾：单线程FIFO保证前面所有平仓/取消任务完成后才重置
+ executor.submitTask(() -> {
+ try { Thread.sleep(3000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
+ startGrid();
+ });
+ }
+ } catch (Exception e) {
+ log.warn("[Gate] 盈亏检查失败", e);
}
}
@@ -437,7 +459,6 @@
* <li>首次开仓（基底）：标记 baseOpened=true，记录基底入场价，双基底都成交后生成网格队列</li>
* <li>仓位净减少（size.abs() < 之前记录值）：止盈平仓后 → 检查反向条件单条件 →
* 满足时以 entryPrice ± step 为止盈价挂反向市价单（订单ID + 止盈价存入 Map）</li>
- * <li>仓位净增加或不变：仅更新 positionSize，止盈由 {@link #onOrderUpdate} 通过订单订阅匹配处理</li>
* </ul>
* </li>
* <li><b>无仓位 (size = 0)</b>：清空活跃标记和持仓量</li>
@@ -457,126 +478,70 @@
}
boolean hasPosition = size.abs().compareTo(BigDecimal.ZERO) > 0;
-
- if (Position.ModeEnum.DUAL_LONG == mode) {
- if (hasPosition) {
+ if (state == StrategyState.OPENING){
+ if (Position.ModeEnum.DUAL_LONG == mode && hasPosition && !baseLongOpened) {
longActive = true;
+ longPositionSize = size;
longEntryPrice = entryPrice;
- if (!baseLongOpened) {
- longPositionSize = size;
- longBaseEntryPrice = entryPrice;
- baseLongOpened = true;
- log.info("[Gate] 基底多成交价: {}", longBaseEntryPrice);
- tryGenerateQueues();
- }else {
- longPositionSize = size;
-// checkShortEntryOrderToCancel();
-// checkLongEntryOrderToCancel();
- }
- } else {
- if (longActive && state == StrategyState.ACTIVE) {
-// log.info("[Gate] 多仓持仓归零，重置策略");
-// handlePositionZeroAndReset("多仓");
- }
- longActive = false;
- longPositionSize = BigDecimal.ZERO;
- }
- } else if (Position.ModeEnum.DUAL_SHORT == mode) {
- if (hasPosition) {
+ longBaseEntryPrice = entryPrice;
+ baseLongOpened = true;
+ log.info("[Gate] 基底多成交价: {}", longBaseEntryPrice);
+ tryGenerateQueues();
+ } else if (Position.ModeEnum.DUAL_SHORT == mode && hasPosition && !baseShortOpened) {
shortActive = true;
+ shortPositionSize = size.abs();
shortEntryPrice = entryPrice;
- if (!baseShortOpened) {
- shortPositionSize = size.abs();
- shortBaseEntryPrice = entryPrice;
- baseShortOpened = true;
- log.info("[Gate] 基底空成交价: {}", shortBaseEntryPrice);
- tryGenerateQueues();
- }else {
- shortPositionSize = size.abs();
-// checkShortEntryOrderToCancel();
-// checkLongEntryOrderToCancel();
- }
- } else {
- if (shortActive && state == StrategyState.ACTIVE) {
-// log.info("[Gate] 空仓持仓归零，重置策略");
-// handlePositionZeroAndReset("空仓");
- }
- shortActive = false;
- shortPositionSize = BigDecimal.ZERO;
+ shortBaseEntryPrice = entryPrice;
+ baseShortOpened = true;
+ log.info("[Gate] 基底空成交价: {}", shortBaseEntryPrice);
+ tryGenerateQueues();
}
}
- }
- private void checkShortEntryOrderToCancel() {
- List<GridElement> allLongOrders = GridElement.findAllShortOrders(shortEntryPrice);
- if (CollUtil.isNotEmpty(allLongOrders)){
- GridElement keep = allLongOrders.stream()
- .min((a, b) -> a.getGridPrice().compareTo(b.getGridPrice()))
- .orElse(null);
- for (GridElement e : allLongOrders) {
- if (e == keep) {
- continue;
+ if (state == StrategyState.ACTIVE){
+ if (Position.ModeEnum.DUAL_LONG == mode) {
+ if (hasPosition) {
+ longActive = true;
+ longPositionSize = size;
+ longEntryPrice = entryPrice;
+ } else {
+
+ log.info("[Gate-0]多仓: {}", shortBaseEntryPrice);
+ longActive = false;
+ longPositionSize = BigDecimal.ZERO;
+ longEntryPrice = BigDecimal.ZERO;
}
- executor.cancelConditionalOrder(
- e.getShortOrderId(),
- orderId -> {
- shortEntryTraderIdParam(
- e,
- null,
- false
- );
- }
- );
- if (e.getShortTakeProfitOrderId() != null){
- executor.cancelConditionalOrder(
- e.getShortTakeProfitOrderId(),
- orderId -> {
- shortTakeProfitTraderIdParam(
- e,
- null,
- false
- );
- }
- );
+ } else if (Position.ModeEnum.DUAL_SHORT == mode) {
+ if (hasPosition) {
+ shortActive = true;
+ shortPositionSize = size.abs();
+ shortEntryPrice = entryPrice;
+ } else {
+
+ log.info("[Gate-0]空仓: {}", shortBaseEntryPrice);
+ shortActive = false;
+ shortPositionSize = BigDecimal.ZERO;
+ shortEntryPrice = BigDecimal.ZERO;
}
}
}
- }
- private void checkLongEntryOrderToCancel() {
- List<GridElement> allShortOrders = GridElement.findAllLongOrders(longEntryPrice);
- if (CollUtil.isNotEmpty(allShortOrders)){
- GridElement keep = allShortOrders.stream()
- .max((a, b) -> a.getGridPrice().compareTo(b.getGridPrice()))
- .orElse(null);
- for (GridElement e : allShortOrders) {
- if (e == keep) {
- continue;
- }
- executor.cancelConditionalOrder(
- e.getLongOrderId(),
- orderId -> {
- longEntryTraderIdParam(
- e,
- null,
- false
- );
- }
- );
-
- if (e.getLongTakeProfitOrderId() != null){
- executor.cancelConditionalOrder(
- e.getLongTakeProfitOrderId(),
- orderId -> {
- longTakeProfitTraderIdParam(
- e,
- null,
- false
- );
- }
- );
- }
+ if (state == StrategyState.ACTIVE && shortActive == false && longActive == false) {
+ try {
+ futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
+ } catch (ApiException e) {
+ e.printStackTrace();
}
+ closeExistingPositions();
+
+ state = StrategyState.STOPPED;
+ // 提交到 executor 末尾：单线程FIFO保证前面所有平仓/取消任务完成后才重置
+ executor.submitTask(() -> {
+ try { Thread.sleep(3000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
+ startGrid();
+ });
+ log.info("[Gate] 重置策略");
+ return;
}
}
@@ -611,133 +576,6 @@
}
}
- // ---- 订单推送回调 ----
-
- /**
- * 订单推送回调。由 OrdersChannelHandler 在收到订单更新推送时调用。
- *
- * <h3>处理逻辑</h3>
- * 当订单状态为 finished 且 finish_as 为 filled 时，
- * 从 {@link #currentLongOrderIds} / {@link #currentShortOrderIds} 中匹配订单ID，
- * 取出止盈价格并挂止盈单。匹配成功后从 Map 中移除该条目，防止重复挂单。
- *
- * @param orderId 订单 ID
- * @param status 订单状态（open / finished）
- * @param finishAs 订单结束方式（filled / cancelled / ioc 等）
- */
- public void onOrderUpdate(String orderId, String status, String finishAs) {
- if (!"finished".equals(status) || !"filled".equals(finishAs)) {
- return;
- }
-
- /**
- * 匹配止盈单止盈
- */
- GridElement byLongTakeProfitOrderId = GridElement.findByLongTakeProfitOrderId(orderId);
- if (byLongTakeProfitOrderId != null){
- longTakeProfitTraderIdParam(
- byLongTakeProfitOrderId,
- null,
- false
- );
-// longEntryTraderIdParam(
-// byLongTakeProfitOrderId,
-// null,
-// false
-// );
- }
- GridElement byShortTakeProfitOrderId = GridElement.findByShortTakeProfitOrderId(orderId);
- if (byShortTakeProfitOrderId != null){
- shortTakeProfitTraderIdParam(
- byShortTakeProfitOrderId,
- null,
- false
- );
-// shortEntryTraderIdParam(
-// byShortTakeProfitOrderId,
-// null,
-// false
-// );
- }
-
- /**
- * 匹配挂单
- */
- GridElement longGridElement = GridElement.findByLongOrderId(orderId);
- if (longGridElement != null) {
- if (longGridElement.isHasLongOrder()){
- longEntryTraderIdParam(
- longGridElement,
- null,
- false
- );
- if (longGridElement.getLongTakeProfitOrderId() == null){
- BigDecimal longTp = longGridElement.getLongTraderParam().getTakeProfitPrice();
- if (longTp != null) {
- executor.placeTakeProfit(longTp,
- FuturesPriceTrigger.RuleEnum.NUMBER_1,
- ORDER_TYPE_CLOSE_LONG,
- negate(config.getQuantity()),
- (profitId) -> {
- longTakeProfitTraderIdParam(
- longGridElement,
- profitId,
- true
- );
- });
- log.info("[Gate] 多单成交匹配止盈, orderId:{}, 止盈价:{}, size:{}", orderId, longTp, negate(config.getQuantity()));
- return;
- }
- }
- }
- }
- GridElement shortGridElement = GridElement.findByShortOrderId(orderId);
- if (shortGridElement != null) {
- if (shortGridElement.isHasShortOrder()){
- shortEntryTraderIdParam(
- shortGridElement,
- null,
- false
- );
- if (shortGridElement.getShortTakeProfitOrderId() == null){
- BigDecimal shortTp = shortGridElement.getShortTraderParam().getTakeProfitPrice();
- if (shortTp != null) {
- executor.placeTakeProfit(shortTp,
- FuturesPriceTrigger.RuleEnum.NUMBER_2,
- ORDER_TYPE_CLOSE_SHORT,
- config.getQuantity(),
- (profitId) -> {
- shortTakeProfitTraderIdParam(
- shortGridElement,
- profitId,
- true
- );
- });
- log.info("[Gate] 空单成交匹配止盈, orderId:{}, 止盈价:{}, size:{}", orderId, shortTp, config.getQuantity());
- }
- }
- }
- }
- }
-
- /**
- * 用户私有成交回调。由 {@link com.xcong.excoin.modules.gateApi.wsHandler.handler.UserTradesChannelHandler}
- * 在收到 {@code futures.usertrades} 推送时调用。
- *
- * @param contract 合约名称
- * @param orderId 订单 ID
- * @param price 成交价格
- * @param size 成交数量
- * @param role 用户角色（maker / taker）
- * @param fee 手续费
- */
- public void onUserTrade(String contract, String orderId, BigDecimal price, String size, String role, BigDecimal fee) {
- if (state == StrategyState.STOPPED) {
- return;
- }
- log.info("[Gate] 成交明细, 合约:{}, 订单ID:{}, 价格:{}, 数量:{}, 角色:{}, 手续费:{}",
- contract, orderId, price, size, role, fee);
- }
/**
* 自动订单（条件单）状态变更回调。
@@ -759,160 +597,119 @@
return;
}
+ // [Gate-需求1] 多仓止盈触发：清空止盈状态 + 取消最远多仓止损
+ GridElement longTpElem = GridElement.findByLongTakeProfitOrderId(orderId);
+ if (longTpElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ longTakeProfitTraderIdParam(longTpElem, null, false);
+ log.info("[Gate] 多仓止盈触发 gridId:{}, orderId:{}", longTpElem.getId(), orderId);
+ cancelFarthestLongStopLoss();
+ return;
+ }
+ // [Gate-需求1] 空仓止盈触发：清空止盈状态 + 取消最远空仓止损
+ GridElement shortTpElem = GridElement.findByShortTakeProfitOrderId(orderId);
+ if (shortTpElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ shortTakeProfitTraderIdParam(shortTpElem, null, false);
+ log.info("[Gate] 空仓止盈触发 gridId:{}, orderId:{}", shortTpElem.getId(), orderId);
+ cancelFarthestShortStopLoss();
+ return;
+ }
+
GridElement longStopLossElem = GridElement.findByLongStopLossOrderId(orderId);
- if (longStopLossElem != null) {
+// if (longStopLossElem != null && longPositionSize.compareTo(BigDecimal.ZERO) > 0 && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ if (longStopLossElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
handleLongStopLossTriggered(longStopLossElem);
return;
}
GridElement shortStopLossElem = GridElement.findByShortStopLossOrderId(orderId);
- if (shortStopLossElem != null) {
+// if (shortStopLossElem != null && shortPositionSize.compareTo(BigDecimal.ZERO) > 0 && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
+ if (shortStopLossElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
handleShortStopLossTriggered(shortStopLossElem);
return;
}
-// GridElement byShortTakeProfitOrderId = GridElement.findByShortTakeProfitOrderId(orderId);
-// if (byShortTakeProfitOrderId != null){
-// shortTakeProfitTraderIdParam(
-// byShortTakeProfitOrderId,
-// null,
-// false
-// );
-// shortEntryTraderIdParam(
-// byShortTakeProfitOrderId,
-// null,
-// false
-// );
-// TPonUserTradeShortEntry(byShortTakeProfitOrderId);
-// }
-// GridElement byLongTakeProfitOrderId = GridElement.findByLongTakeProfitOrderId(orderId);
-// if (byLongTakeProfitOrderId != null){
-// longTakeProfitTraderIdParam(
-// byLongTakeProfitOrderId,
-// null,
-// false
-// );
-// longEntryTraderIdParam(
-// byLongTakeProfitOrderId,
-// null,
-// false
-// );
-// TPonUserTradeLongEntry(byLongTakeProfitOrderId);
-// }
-
GridElement shortGridElement = GridElement.findByShortOrderId(orderId);
if (shortGridElement != null) {
- if (shortGridElement.isHasShortOrder() && !tradeId.equals("0")){
+ if (shortGridElement.isHasShortOrder() && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0") ){
int filledQty = Integer.parseInt(shortGridElement.getShortTraderParam().getQuantity());
shortEntryTraderIdParam(shortGridElement, null, false);
- shortEntryQty = 1;
- extendShortStopLoss(filledQty);
- log.info("[Gate] 空单成交 gridId:{}, qty:{}, 追挂止损", shortGridElement.getId(), filledQty);
-// checkMaxPositionAndPlaceTakeProfit(false, shortGridElement.getId());
+ // [Gate-需求2] 加仓后先撤空仓所有止盈+止损，再重挂
+ cancelAllShortTakeProfitsAndStopLosses();
+ extendShortStopLoss(filledQty,shortGridElement.getId());
+ accumulatedShortLossCount = 0; // 加仓订单成交，重置止损累计
+ log.info("[Gate] 空单成交 gridId:{}", filledQty);
+
+ // 空仓持仓超过baseQuantity时，从gridId-2开始向外追挂止盈
+ BigDecimal shortBaseQty = new BigDecimal(config.getBaseQuantity());
+ BigDecimal shortGridQty = new BigDecimal(config.getQuantity());
+ if (shortPositionSize.compareTo(shortBaseQty) > 0) {
+ BigDecimal shortExcess = shortPositionSize.subtract(shortBaseQty);
+ int shortExcessCount = shortExcess.divide(shortGridQty, 0, RoundingMode.DOWN).intValue();
+ for (int i = 0; i < shortExcessCount; i++) {
+ int tpGridId = shortGridElement.getId() - 2 - i;
+ GridElement tpElem = GridElement.findById(tpGridId);
+ if (tpElem == null || tpElem.getShortTakeProfitOrderId() != null) {
+ continue;
+ }
+ BigDecimal tpPrice = tpElem.getGridPrice();
+ int finalTpGridId = tpGridId;
+ executor.placeTakeProfit(
+ tpPrice,
+ FuturesPriceTrigger.RuleEnum.NUMBER_2,
+ ORDER_TYPE_CLOSE_SHORT,
+ config.getQuantity(),
+ profitId -> {
+ shortTakeProfitTraderIdParam(tpElem, profitId, true);
+ log.info("[Gate] 空仓止盈挂单, gridId:{}, 触发价:{}, takeProfitId:{}",
+ finalTpGridId, tpPrice, profitId);
+ }
+ );
+ }
+ }
}
}
GridElement longGridElement = GridElement.findByLongOrderId(orderId);
if (longGridElement != null) {
- if (longGridElement.isHasLongOrder() && !tradeId.equals("0")){
+ if (longGridElement.isHasLongOrder() && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")){
+
int filledQty = Integer.parseInt(longGridElement.getLongTraderParam().getQuantity());
longEntryTraderIdParam(longGridElement, null, false);
- longEntryQty = 1;
- extendLongStopLoss(filledQty);
- log.info("[Gate] 多单成交 gridId:{}, qty:{}, 追挂止损", longGridElement.getId(), filledQty);
-// checkMaxPositionAndPlaceTakeProfit(true, longGridElement.getId());
- }
- }
- }
+ // [Gate-需求2] 加仓后先撤多仓所有止盈+止损，再重挂
+ cancelAllLongTakeProfitsAndStopLosses();
+ extendLongStopLoss(filledQty,longGridElement.getId());
+ accumulatedLongLossCount = 0; // 加仓订单成交，重置止损累计
+ log.info("[Gate] 多单成交 gridId:{}", filledQty);
- private void TPonUserTradeShortEntry(GridElement gridElement) {
- if (!isMarginSafe()) {
- log.warn("[Gate] 保证金超限，跳过挂条件单");
- } else {
- // 判断网格是否能开多仓，如果不能则跳过
- GridElement upGridElement = GridElement.findById(gridElement.getUpId());
- if (upGridElement != null){
- BigDecimal upGridPrice = upGridElement.getGridPrice();
- TraderParam upLongTraderParam = upGridElement.getLongTraderParam();
- if (
- !upGridElement.isHasLongOrder() &&
- upGridPrice.compareTo(longEntryPrice) <= 0
- ){
- placeEntryOrderWithPreFlag(upGridElement, true,
- upLongTraderParam.getEntryPrice(),
- FuturesPriceTrigger.RuleEnum.NUMBER_1,
- upLongTraderParam.getQuantity());
+ // 多仓持仓超过baseQuantity时，从gridId+2开始向外追挂止盈
+ BigDecimal longBaseQty = new BigDecimal(config.getBaseQuantity());
+ BigDecimal longGridQty = new BigDecimal(config.getQuantity());
+ if (longPositionSize.compareTo(longBaseQty) > 0) {
+ BigDecimal longExcess = longPositionSize.subtract(longBaseQty);
+ int longExcessCount = longExcess.divide(longGridQty, 0, RoundingMode.DOWN).intValue();
+ for (int i = 0; i < longExcessCount; i++) {
+ int tpGridId = longGridElement.getId() + 2 + i;
+ GridElement tpElem = GridElement.findById(tpGridId);
+ if (tpElem == null || tpElem.getLongTakeProfitOrderId() != null) {
+ continue;
+ }
+ BigDecimal tpPrice = tpElem.getGridPrice();
+ int finalTpGridId = tpGridId;
+ executor.placeTakeProfit(
+ tpPrice,
+ FuturesPriceTrigger.RuleEnum.NUMBER_1,
+ ORDER_TYPE_CLOSE_LONG,
+ negate(config.getQuantity()),
+ profitId -> {
+ longTakeProfitTraderIdParam(tpElem, profitId, true);
+ log.info("[Gate] 多仓止盈挂单, gridId:{}, 触发价:{}, takeProfitId:{}",
+ finalTpGridId, tpPrice, profitId);
+ }
+ );
+ }
}
}
}
}
- private void TPonUserTradeLongEntry(GridElement gridElement) {
- if (!isMarginSafe()) {
- log.warn("[Gate] 保证金超限，跳过挂条件单");
- } else {
- // 判断网格是否能开空仓，如果不能则跳过
- GridElement downGridElement = GridElement.findById(gridElement.getDownId());
- if (downGridElement != null){
-
- BigDecimal downGridPrice = downGridElement.getGridPrice();
-
- TraderParam shortTraderParam = downGridElement.getShortTraderParam();
- if (
- !downGridElement.isHasShortOrder() &&
- downGridPrice.compareTo(shortEntryPrice) >= 0
- ){
- placeEntryOrderWithPreFlag(downGridElement, false,
- shortTraderParam.getEntryPrice(),
- FuturesPriceTrigger.RuleEnum.NUMBER_2,
- negate(config.getQuantity()));
- }
- }
- }
- }
-
- private void onUserTradeShortEntry(GridElement gridElement) {
- if (!isMarginSafe()) {
- log.warn("[Gate] 保证金超限，跳过挂条件单");
- } else {
- //下一个开仓位置
- GridElement UpGridElement = GridElement.findById(gridElement.getDownId());
- BigDecimal newLongFirst = UpGridElement.getGridPrice();
-
- // 判断网格是否能开空仓，如果不能则跳过
- if (UpGridElement != null) {
-
- if (!UpGridElement.isHasShortOrder() && shortEntryPrice.compareTo(newLongFirst) > 0) {
-
- TraderParam upShortTraderParam = UpGridElement.getShortTraderParam();
- placeEntryOrderWithPreFlag(UpGridElement, false,
- upShortTraderParam.getEntryPrice(),
- FuturesPriceTrigger.RuleEnum.NUMBER_2,
- negate(upShortTraderParam.getQuantity()));
- }
- }
- }
- }
-
- private void onUserTradeLongEntry(GridElement gridElement) {
- if (!isMarginSafe()) {
- log.warn("[Gate] 保证金超限，跳过挂条件单");
- } else {
- //下一个开仓位置
- GridElement UpGridElement = GridElement.findById(gridElement.getUpId());
- BigDecimal newLongFirst = UpGridElement.getGridPrice() ;
-
- // 判断网格是否能开多仓，如果不能则跳过
- if (UpGridElement != null) {
-
- if (!UpGridElement.isHasLongOrder() && longEntryPrice.compareTo(newLongFirst) < 0) {
- TraderParam upLongTraderParam = UpGridElement.getLongTraderParam();
- placeEntryOrderWithPreFlag(UpGridElement, true,
- upLongTraderParam.getEntryPrice(),
- FuturesPriceTrigger.RuleEnum.NUMBER_1,
- config.getQuantity());
- }
- }
- }
- }
// ---- 网格队列处理 ----
@@ -926,7 +723,6 @@
* 止盈价 = 触发价 − step，通过 onSuccess 回调将 orderId → 止盈价存入 currentShortOrderIds</li>
* <li>状态切换为 ACTIVE</li>
* </ol>
- * 条件单成交后由 {@link #onOrderUpdate} 匹配止盈价并挂止盈条件单。
*/
private void tryGenerateQueues() {
if (baseLongOpened && baseShortOpened) {
@@ -942,19 +738,57 @@
baseGridElement.setShortOrderId(baseShortTraderParam.getEntryOrderId());
baseGridElement.setHasShortOrder(true);
- int shortTime = Integer.parseInt(config.getBaseQuantity()) + 1;
+// int shortTime = 2;
+// GridElement elemShort = GridElement.findById(shortTime);
+// if (elemShort != null) {
+// BigDecimal triggerPrice = elemShort.getGridPrice();
+// String size = config.getBaseQuantity();
+// executor.placeTakeProfit(
+// triggerPrice,
+// FuturesPriceTrigger.RuleEnum.NUMBER_1,
+// ORDER_TYPE_CLOSE_SHORT,
+// size,
+// profitId -> {
+// elemShort.setShortStopLossOrderId(profitId);
+// GridElement.refreshIndices();
+// log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", shortTime, triggerPrice, profitId);
+// }
+// );
+// }
+//
+//
+// int longTime = -2;
+// GridElement elemLong = GridElement.findById(longTime);
+// if (elemLong != null) {
+// BigDecimal triggerPrice = elemLong.getGridPrice();
+// String size = config.getBaseQuantity();
+// executor.placeTakeProfit(
+// triggerPrice,
+// FuturesPriceTrigger.RuleEnum.NUMBER_2,
+// ORDER_TYPE_CLOSE_LONG,
+// negate(size),
+// profitId -> {
+// elemLong.setLongStopLossOrderId(profitId);
+// GridElement.refreshIndices();
+// log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", longTime, triggerPrice, profitId);
+// }
+// );
+// }
+
+ int shortTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
for (int id = 2; id <= shortTime; id++) {
GridElement elem = GridElement.findById(id);
if (elem == null) {
continue;
}
BigDecimal triggerPrice = elem.getGridPrice();
+ String size = config.getQuantity();
int finalId = id;
executor.placeTakeProfit(
triggerPrice,
FuturesPriceTrigger.RuleEnum.NUMBER_1,
ORDER_TYPE_CLOSE_SHORT,
- config.getQuantity(),
+ size,
profitId -> {
elem.setShortStopLossOrderId(profitId);
GridElement.refreshIndices();
@@ -964,19 +798,20 @@
}
- int longTime = Integer.parseInt(config.getBaseQuantity()) + 1;
+ int longTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
for (int id = -2; id >= -longTime; id--) {
GridElement elem = GridElement.findById(id);
if (elem == null) {
continue;
}
BigDecimal triggerPrice = elem.getGridPrice();
+ String size = config.getQuantity();
int finalId = id;
executor.placeTakeProfit(
triggerPrice,
FuturesPriceTrigger.RuleEnum.NUMBER_2,
ORDER_TYPE_CLOSE_LONG,
- negate(config.getQuantity()),
+ negate(size),
profitId -> {
elem.setLongStopLossOrderId(profitId);
GridElement.refreshIndices();
@@ -986,6 +821,7 @@
}
log.info("[Gate] 止损单已全部挂完, 空仓止损: 2~{}, 多仓止损: -2~-{}", shortTime, longTime);
+
state = StrategyState.ACTIVE;
}
}
@@ -1048,6 +884,9 @@
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;
@@ -1069,10 +908,16 @@
BigDecimal elem = shortBaseEntryPrice.add(step).setScale(prec, RoundingMode.HALF_UP);
for (int i = 0; i < config.getGridQueueSize(); i++) {
longPriceQueue.add(elem);
+ totalLongPriceQueue.add( elem);
+ totalShortPriceQueue.add( elem);
elem = elem.add(step).setScale(prec, RoundingMode.HALF_UP);
}
longPriceQueue.sort(BigDecimal::compareTo);
log.info("[Gate] 多队列:{}", longPriceQueue);
+ totalShortPriceQueue.sort((a, b) -> b.compareTo(a));
+ log.info("[Gate] 队列从大到小:{}", totalShortPriceQueue);
+ totalLongPriceQueue.sort(BigDecimal::compareTo);
+ log.info("[Gate] 队列从小到大:{}", totalLongPriceQueue);
}
/**
@@ -1095,9 +940,8 @@
int longSize = longPriceQueue.size();
//根据精度转换成小数
int prec = config.getPriceScale();
-// BigDecimal minTick = BigDecimal.ONE.scaleByPowerOfTen(-prec);
-// BigDecimal step = config.getStep().subtract(minTick);
BigDecimal step = config.getStep();
+// String qty = config.getBaseQuantity();
String qty = config.getQuantity();
// 空仓队列：id 从 -1 自减, shortPriceQueue[i] → id=-(i+1)
@@ -1185,108 +1029,117 @@
log.info("[Gate] 网格元素列表已构建, 共{}个元素 (空仓:{} 位置:0 多仓:{})", elements.size(), shortSize, longSize);
}
+
private void processShortGrid(BigDecimal currentPrice) {
BigDecimal matched = BigDecimal.ZERO;
- synchronized (shortPriceQueue) {
- for (BigDecimal p : shortPriceQueue) {
+ synchronized (totalLongPriceQueue) {
+ for (BigDecimal p : totalLongPriceQueue) {
if (p.compareTo(currentPrice) >= 0) {
matched = p;
- } else {
break;
}
}
- }
- if (BigDecimal.ZERO.compareTo( matched) == 0) {
- return;
- }
- log.info("[Gate] 空仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
+// log.info("[Gate-1] 多仓仓位归零 空仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
+ if (BigDecimal.ZERO.compareTo( matched) == 0) {
+ return;
+ }
- GridElement matchedUpGridElement = GridElement.findByPrice(matched);
+ GridElement matchedUpGridElement = GridElement.findByPrice(matched);
+ if (matchedUpGridElement != null){
+ if (!matchedUpGridElement.isHasLongOrder()){
+ Integer upId = matchedUpGridElement.getUpId();
+ GridElement newEntryGrid = GridElement.findById(upId);
- Integer upId = matchedUpGridElement.getUpId();
- GridElement newEntryGrid = GridElement.findById(upId);
+ if (newEntryGrid != null) {
- if (newEntryGrid != null) {
- GridElement cancelGridElement = GridElement.findById(newEntryGrid.getUpId());
-
- if (cancelGridElement != null) {
- BigDecimal triggerPrice = newEntryGrid.getGridPrice();
- String size = cancelGridElement.getLongTraderParam().getQuantity();
- log.info("[Gate] 多仓仓位归零 gridId:{}, 挂{}基础张多单",
- newEntryGrid.getId(), size);
- newEntryGrid.getLongTraderParam().setQuantity(size);
- placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
- FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
-
-
- /**
- * 看是否有多仓挂单，有就取消
- */
- if (cancelGridElement != null && cancelGridElement.isHasLongOrder()) {
- executor.cancelConditionalOrder(cancelGridElement.getLongOrderId(), oid -> {
- longEntryTraderIdParam(cancelGridElement, null, false);
- log.info("[Gate] 多仓仓位归零, 取消gridId:{}的多单", cancelGridElement);
- });
+ 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("[Gate] 多仓仓位归零, 取消gridId:{}的多单,{}", cancelGridElement.getId(),longOrderId);
+ });
+ }
+// log.info("[Gate-2] 多仓仓位归零 空仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
+ if (!newEntryGrid.isHasLongOrder()) {
+ BigDecimal triggerPrice = newEntryGrid.getGridPrice();
+ String size = quantity;
+ log.info("[Gate] 多仓仓位归零 gridId:{}, 挂{}基础张多单",
+ newEntryGrid.getId(), size);
+ newEntryGrid.getLongTraderParam().setQuantity(size);
+ placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
+ FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
+ }
+ }
}
}
}
+
}
private void processLongGrid(BigDecimal currentPrice) {
BigDecimal matched = BigDecimal.ZERO;
- synchronized (longPriceQueue) {
- for (BigDecimal p : longPriceQueue) {
+ synchronized (totalShortPriceQueue) {
+ for (BigDecimal p : totalShortPriceQueue) {
if (p.compareTo(currentPrice) <= 0) {
matched = p;
- } else {
break;
}
}
- }
- if (BigDecimal.ZERO.compareTo( matched) == 0) {
- return;
- }
-
- log.info("[Gate] 多仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
-
- GridElement matchedUpGridElement = GridElement.findByPrice(matched);
-
- Integer downId = matchedUpGridElement.getDownId();
- GridElement newEntryGrid = GridElement.findById(downId);
-
- if (newEntryGrid != null) {
- GridElement cancelGridElement = GridElement.findById(newEntryGrid.getDownId());
-
- if (cancelGridElement != null) {
- BigDecimal triggerPrice = newEntryGrid.getGridPrice();
- String size = cancelGridElement.getShortTraderParam().getQuantity();
- log.info("[Gate] 空仓仓位归零 gridId:{}, 挂{}基础张多单",
- newEntryGrid.getId(), size);
- newEntryGrid.getShortTraderParam().setQuantity(size);
- placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
- FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
-
- /**
- * 看是否有空仓挂单，有就取消
- */
- if (cancelGridElement != null && cancelGridElement.isHasShortOrder()) {
- executor.cancelConditionalOrder(cancelGridElement.getShortOrderId(), oid -> {
- shortEntryTraderIdParam(cancelGridElement, null, false);
- log.info("[Gate] 空仓仓位归零, 取消gridId:{}的多单", cancelGridElement);
- });
- }
+// log.info("[Gate-3] 空仓仓位归零 多仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
+ if (BigDecimal.ZERO.compareTo( matched) == 0) {
+ return;
}
+ GridElement matchedUpGridElement = GridElement.findByPrice(matched);
+ if (matchedUpGridElement != null){
+ if(!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("[Gate] 空仓仓位归零, 取消gridId:{}的多单{}", cancelGridElement.getId(),shortOrderId);
+ });
+ }
+// log.info("[Gate-4] 空仓仓位归零 多仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
+ if (!newEntryGrid.isHasShortOrder()){
+ BigDecimal triggerPrice = newEntryGrid.getGridPrice();
+ String size = quantity;
+ log.info("[Gate] 空仓仓位归零 gridId:{}, 挂{}基础张多单",
+ newEntryGrid.getId(), size);
+ newEntryGrid.getShortTraderParam().setQuantity(size);
+ placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
+ FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
+ }
+
+ }
+ }
+ }
}
}
private void handleLongStopLossTriggered(GridElement gridElement) {
- int gridId = gridElement.getId();
- int N = Math.abs(gridId);
gridElement.setLongStopLossOrderId(null);
- log.info("[Gate] 多仓止损触发 gridId:{}, 开始追单", gridId);
- int newEntryGridId = -(N - 1);
+ int gridId = gridElement.getId();
+ log.info("[Gate] 多仓止损触发 gridId:{}, 开始追单", gridId);
+ int newEntryGridId = gridId + 1;
GridElement newEntryGrid = GridElement.findById(newEntryGridId);
if (newEntryGrid == null) {
@@ -1295,53 +1148,57 @@
return;
}
- if (N > 2) {
- int cancelGridId = -(N - 2);
- GridElement cancelGrid = GridElement.findById(cancelGridId);
- if (cancelGrid != null && cancelGrid.isHasLongOrder()) {
- executor.cancelConditionalOrder(cancelGrid.getLongOrderId(), oid -> {
- longEntryTraderIdParam(cancelGrid, null, false);
- log.info("[Gate] 多仓止损触发, 取消gridId:{}的多单", cancelGridId);
- });
- }
+ // [Gate-BugFix] 防止与"仓位归零"重复下单：若该网格已有挂单则跳过
+ if (!newEntryGrid.isHasLongOrder()) {
+ BigDecimal triggerPrice = newEntryGrid.getGridPrice();
+
+ // 累计止损张数 + 当前止损量作为追单size，不再依赖positionSize（避免WS竞态）
+ accumulatedLongLossCount += Integer.parseInt(config.getQuantity());
+ String size = String.valueOf(accumulatedLongLossCount + Integer.parseInt(config.getQuantity()));
+ log.info("[Gate] 多仓止损触发 gridId:{}, 在gridId:{}挂{}基础张多单",
+ gridId, newEntryGridId, size);
+
+ newEntryGrid.getLongTraderParam().setQuantity(size);
+ placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
+ FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
+ }else{
+ log.warn("[Gate] 多仓止损触发 gridId:{}, 目标gridId:{}已有挂单，跳过重复下单", gridId, newEntryGridId);
}
- BigDecimal triggerPrice = newEntryGrid.getGridPrice();
- longEntryQty++;
- int entryQty = longEntryQty;
-
- // 最大持仓限制：已持仓+本次挂单 ≤ maxPositionSize
- int maxPos = config.getMaxPositionSize();
- if (maxPos > 0) {
- int currentPos = longPositionSize.intValue();
- int maxAllowed = maxPos - currentPos;
- if (maxAllowed <= 0) {
- log.warn("[Gate] 多仓止损触发 gridId:{}, 已达最大持仓{}，跳过挂单", gridId, maxPos);
- longEntryQty = 1;
- return;
- }
- if (entryQty > maxAllowed) {
- log.info("[Gate] 多仓止损触发 gridId:{}, 挂单{}张超限, 截断为{}张", gridId, entryQty, maxAllowed);
- entryQty = maxAllowed;
- longEntryQty = 1;
- }
+ 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("[Gate] 多仓止损触发, 取消gridId:{}的多单", cancelGridId);
+ });
}
- String size = new BigDecimal(String.valueOf(entryQty)).multiply(new BigDecimal(config.getQuantity())).toString();
- log.info("[Gate] 多仓止损触发 gridId:{}, 在gridId:{}挂{}基础张多单(计数器:{}, size:{})",
- gridId, newEntryGridId, entryQty, longEntryQty, size);
- newEntryGrid.getLongTraderParam().setQuantity(size);
- placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
- FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
+ // 止损触发时，取消最远的多仓止盈订单
+ 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 finalFarthestLongTp = farthestLongTp;
+ executor.cancelConditionalOrder(tpOrderId, oid -> {
+ longTakeProfitTraderIdParam(finalFarthestLongTp, null, false);
+ log.info("[Gate] 多仓止损触发, 取消最远止盈 gridId:{}, orderId:{}", finalFarthestLongTp.getId(), tpOrderId);
+ });
+ }
}
private void handleShortStopLossTriggered(GridElement gridElement) {
- int gridId = gridElement.getId();
- int N = gridId;
gridElement.setShortStopLossOrderId(null);
- log.info("[Gate] 空仓止损触发 gridId:{}, 开始追单", gridId);
- int newEntryGridId = N - 1;
+ int gridId = gridElement.getId();
+ log.info("[Gate] 空仓止损触发 gridId:{}, 开始追单", gridId);
+ int newEntryGridId = gridId - 1;
GridElement newEntryGrid = GridElement.findById(newEntryGridId);
if (newEntryGrid == null) {
@@ -1350,61 +1207,160 @@
return;
}
- if (N > 2) {
- int cancelGridId = N - 2;
- GridElement cancelGrid = GridElement.findById(cancelGridId);
- if (cancelGrid != null && cancelGrid.isHasShortOrder()) {
- executor.cancelConditionalOrder(cancelGrid.getShortOrderId(), oid -> {
- shortEntryTraderIdParam(cancelGrid, null, false);
- log.info("[Gate] 空仓止损触发, 取消gridId:{}的空单", cancelGridId);
- });
- }
+ // [Gate-BugFix] 防止与"仓位归零"重复下单：若该网格已有挂单则跳过
+ if (!newEntryGrid.isHasShortOrder()) {
+ BigDecimal triggerPrice = newEntryGrid.getGridPrice();
+
+ // 累计止损张数 + 当前止损量作为追单size，不再依赖positionSize（避免WS竞态）
+ accumulatedShortLossCount += Integer.parseInt(config.getQuantity());
+ String size = String.valueOf(accumulatedShortLossCount + Integer.parseInt(config.getQuantity()));
+ log.info("[Gate] 空仓止损触发 gridId:{}, 在gridId:{}挂{}基础张空单",
+ gridId, newEntryGridId, size);
+ newEntryGrid.getShortTraderParam().setQuantity(size);
+ placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
+ FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
+ }else{
+ log.warn("[Gate] 空仓止损触发 gridId:{}, 目标gridId:{}已有挂单，跳过重复下单", gridId, newEntryGridId);
}
- BigDecimal triggerPrice = newEntryGrid.getGridPrice();
- shortEntryQty++;
- int entryQty = shortEntryQty;
- // 最大持仓限制：已持仓+本次挂单 ≤ maxPositionSize
- int maxPos = config.getMaxPositionSize();
- if (maxPos > 0) {
- int currentPos = shortPositionSize.intValue();
- int maxAllowed = maxPos - currentPos;
- if (maxAllowed <= 0) {
- log.warn("[Gate] 空仓止损触发 gridId:{}, 已达最大持仓{}，跳过挂单", gridId, maxPos);
- shortEntryQty = 1;
- return;
- }
- if (entryQty > maxAllowed) {
- log.info("[Gate] 空仓止损触发 gridId:{}, 挂单{}张超限, 截断为{}张", gridId, entryQty, maxAllowed);
- entryQty = maxAllowed;
- shortEntryQty = 1;
- }
+ 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("[Gate] 空仓止损触发, 取消gridId:{}的空单", cancelGridId);
+ });
}
- String size = new BigDecimal(String.valueOf(entryQty)).multiply(new BigDecimal(config.getQuantity())).toString();
- log.info("[Gate] 空仓止损触发 gridId:{}, 在gridId:{}挂{}基础张空单(计数器:{}, size:{})",
- gridId, newEntryGridId, entryQty, shortEntryQty, size);
- newEntryGrid.getShortTraderParam().setQuantity(size);
- placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
- FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
+ // 止损触发时，取消最远的空仓止盈订单
+ 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 finalFarthestShortTp = farthestShortTp;
+ executor.cancelConditionalOrder(tpOrderId, oid -> {
+ shortTakeProfitTraderIdParam(finalFarthestShortTp, null, false);
+ log.info("[Gate] 空仓止损触发, 取消最远止盈 gridId:{}, orderId:{}", finalFarthestShortTp.getId(), tpOrderId);
+ });
+ }
}
- private void extendLongStopLoss(int filledQty) {
+ // ========== 止盈/止损取消辅助方法 ==========
+
+ /**
+ * 取消最远的多仓止损订单。
+ * 多仓止损在 gridId 负方向，最远 = id 最小。
+ */
+ 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("[Gate] 止盈触发, 取消最远多仓止损 gridId:{}, orderId:{}", finalFarthest.getId(), slId));
+ }
+ }
+
+ /**
+ * 取消最远的空仓止损订单。
+ * 空仓止损在 gridId 正方向，最远 = id 最大。
+ */
+ 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("[Gate] 止盈触发, 取消最远空仓止损 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("[Gate] 已提交取消所有多仓止盈+止损");
+ }
+
+ /**
+ * 取消所有空仓止盈 + 空仓止损订单（加仓后重建前清场）。
+ */
+ 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("[Gate] 已提交取消所有空仓止盈+止损");
+ }
+
+ // ========== 止损追单 ==========
+
+ 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 = -11;
+ furthestSlId = gridId;
+ interval = 2;
}
- log.info("[Gate] 多仓追挂止损, 当前最远止损gridId:{}, 追加{}张", furthestSlId, filledQty);
- for (int i = 0; i < filledQty; i++) {
- int newSlId = furthestSlId - i - 1;
+ int stopLossCount = filledQty / Integer.parseInt(config.getQuantity());
+ log.info("[Gate] 多仓追挂止损, 当前最远止损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;
@@ -1425,19 +1381,23 @@
}
}
- private void extendShortStopLoss(int filledQty) {
+ 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 = 11;
+ furthestSlId = gridId;
+ interval = 2;
}
- log.info("[Gate] 空仓追挂止损, 当前最远止损gridId:{}, 追加{}张", furthestSlId, filledQty);
- for (int i = 0; i < filledQty; i++) {
- int newSlId = furthestSlId + i + 1;
+ int stopLossCount = filledQty / Integer.parseInt(config.getQuantity());
+ log.info("[Gate] 空仓追挂止损, 当前最远止损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;
@@ -1455,149 +1415,6 @@
log.info("[Gate] 空仓止损追加, gridId:{}, 触发价:{}, stopLossId:{}", finalSlId, triggerPrice, profitId);
}
);
- }
- }
-
- /**
- * 通过 REST API 查询实时持仓，超限则在下一网格挂止盈单。
- * 使用异步执行避免阻塞 WS 回调线程。
- *
- * @param isLong 是否为多仓方向
- * @param gridId 当前挂单成交的网格 ID
- */
- private void checkMaxPositionAndPlaceTakeProfit(boolean isLong, int gridId) {
- int maxPos = config.getMaxPositionSize();
- if (maxPos <= 0) return;
-
- executor.submitTask(() -> {
- try {
- List<Position> positions = futuresApi.listPositions(SETTLE).execute();
- if (positions == null) return;
-
- long actualPosSize = 0;
- String targetMode = isLong ? "dual_long" : "dual_short";
- for (Position pos : positions) {
- if (!config.getContract().equals(pos.getContract())) continue;
- Position.ModeEnum mode = pos.getMode();
- if (mode != null && mode.getValue() != null && targetMode.equals(mode.getValue())) {
- actualPosSize = Math.abs(Long.parseLong(pos.getSize()));
- break;
- }
- }
-
- if (actualPosSize <= maxPos) {
- log.debug("[Gate] 持仓检查 {}方向 实际持仓:{} ≤ 上限:{}, 无需止盈", targetMode, actualPosSize, maxPos);
- return;
- }
-
- // 下一网格 ID：空仓 N→N-1（向基底方向，更低价），多仓 -N→-(N-1)（向基底方向，更高价）
- int nextGridId = isLong ? -(Math.abs(gridId) - 1) : gridId - 1;
- GridElement nextGrid = GridElement.findById(nextGridId);
- if (nextGrid == null) {
- log.warn("[Gate] 持仓超限 but 下一网格{}不存在", nextGridId);
- return;
- }
-
- BigDecimal tpPrice = nextGrid.getGridPrice();
- final long finalPosSize = actualPosSize;
- final int finalNextGridId = nextGridId;
- if (isLong) {
- executor.placeTakeProfit(tpPrice,
- FuturesPriceTrigger.RuleEnum.NUMBER_1,
- ORDER_TYPE_CLOSE_LONG,
- negate(config.getQuantity()),
- profitId -> log.info("[Gate] 多仓超限止盈已挂(持仓:{})>, gridId:{}, tpPrice:{}, id:{}",
- finalPosSize, finalNextGridId, tpPrice, profitId));
- } else {
- executor.placeTakeProfit(tpPrice,
- FuturesPriceTrigger.RuleEnum.NUMBER_2,
- ORDER_TYPE_CLOSE_SHORT,
- config.getQuantity(),
- profitId -> log.info("[Gate] 空仓超限止盈已挂(持仓:{})>, gridId:{}, tpPrice:{}, id:{}",
- finalPosSize, finalNextGridId, tpPrice, profitId));
- }
- } catch (Exception e) {
- log.warn("[Gate] 通过API查询持仓超限检查失败", e);
- }
- });
- }
-
- /** Gate 永续合约 taker 费率 0.05% */
- private static final BigDecimal TAKER_FEE_RATE = new BigDecimal("0.0005");
- /** ETH_USDT 合约面值（每张=0.01 ETH） */
- private static final BigDecimal CT_VAL = new BigDecimal("0.01");
-
- private void checkProfitAndReset() {
- try {
- FuturesAccount account = futuresApi.listFuturesAccounts(SETTLE);
- BigDecimal unrealisedPnl = new BigDecimal(account.getCrossUnrealisedPnl());
- BigDecimal available = new BigDecimal(account.getCrossAvailable());
- BigDecimal totalEquity = unrealisedPnl.add(available);
-
- // 估算平仓手续费：(多仓张数+空仓张数) × 合约面值 × 当前价 × taker费率
- BigDecimal totalSize = longPositionSize.abs().add(shortPositionSize.abs());
- BigDecimal closeContractValue =
- totalSize.multiply(CT_VAL).multiply(lastKlinePrice != null ? lastKlinePrice : BigDecimal.ZERO);
- BigDecimal estimatedFee = closeContractValue.multiply(TAKER_FEE_RATE);
- BigDecimal netEquity = totalEquity.subtract(estimatedFee);
-
- BigDecimal target = initialPrincipal.add(config.getExpectedProfit());
- log.info("[Gate] 盈亏检查,总张数：{}, upl:{}, avail:{}, 合计:{}, 估手续费:{}, 净权益:{}, 目标:{}",
- totalSize,unrealisedPnl, available, totalEquity, estimatedFee, netEquity, target);
- if (netEquity.compareTo(target) > 0) {
- log.info("[Gate] 盈亏达标(净权益{}>目标{})，重置策略", netEquity, target);
- state = StrategyState.STOPPED;
- closeExistingPositions();
- futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
-
- // 提交到 executor 末尾：单线程FIFO保证前面所有平仓/取消任务完成后才重置
- executor.submitTask(() -> {
- try { Thread.sleep(3000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
- startGrid();
- });
- }
- } catch (Exception e) {
- log.warn("[Gate] 盈亏检查失败", e);
- }
- }
-
- private void handlePositionZeroAndReset(String direction) {
- state = StrategyState.STOPPED;
- try {
- futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
- } catch (Exception e) {
- log.warn("[Gate] {}持仓归零后取消条件单失败", direction, e);
- }
- closeExistingPositions();
- // 提交到 executor 末尾：单线程FIFO保证前面所有平仓/取消任务完成后才重置
- executor.submitTask(() -> {
- try { Thread.sleep(3000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
- startGrid();
- });
- }
-
- // ---- 保证金安全阀 ----
-
- /**
- * 保证金安全阀检查。
- *
- * <p>实时查询当前保证金占用额（positionInitialMargin），计算其占初始本金的比例。
- * 比例 ≥ marginRatioLimit（默认 20%）时拒绝开仓，但仍照常更新队列。
- *
- * <p>查询失败时默认放行（返回 true），避免因 REST API 异常导致策略完全停滞。
- *
- * @return true=安全可开仓 / false=保证金超限跳过开仓
- */
- private boolean isMarginSafe() {
- try {
- FuturesAccount account = futuresApi.listFuturesAccounts(SETTLE);
- BigDecimal margin = new BigDecimal(account.getPositionInitialMargin());
- BigDecimal ratio = margin.divide(initialPrincipal, 4, RoundingMode.HALF_UP);
- log.debug("[Gate] 保证金比例: {}/{}={}", margin, initialPrincipal, ratio);
- return ratio.compareTo(config.getMarginRatioLimit()) < 0;
- } catch (Exception e) {
- log.warn("[Gate] 查保证金失败，默认放行", e);
- return true;
}
}
--
Gitblit v1.9.1