package com.xcong.excoin.modules.okxApi;
|
|
import cn.hutool.core.util.StrUtil;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.xcong.excoin.utils.dingtalk.DingTalkUtils;
|
import lombok.extern.slf4j.Slf4j;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
|
/**
|
* OKX 盈利回收循环策略 — 永远持有多空双向底仓，盈利兑现 + 利润反向加仓。
|
*
|
* <h3>核心思想</h3>
|
* <ol>
|
* <li>永远持有多空双向底仓</li>
|
* <li>盈利的一边不断兑现利润</li>
|
* <li>用部分利润强化亏损的一边</li>
|
* <li>利用市场波动不断放大利润</li>
|
* </ol>
|
*
|
* <h3>策略流程（状态机）</h3>
|
* <pre>
|
* INIT → 双开底仓 → MONITOR
|
* ↓
|
* 盈利达到50% → 平50%盈利仓 → 利润拆分 → 反向加仓 → 继续监控
|
* ↓
|
* 账户盈利5% → 全部平仓 → 重新双开
|
* </pre>
|
*
|
* <h3>数学模型</h3>
|
* <ul>
|
* <li>ROI = 未实现盈亏 / 该方向保证金</li>
|
* <li>触发条件：ROI ≥ profitTriggerRatio (默认50%)</li>
|
* <li>平仓张数：floor(positionSize / 2)</li>
|
* <li>收益 A = 已实现利润</li>
|
* <li>保证金 B = A × reinvestRatio (默认50%)</li>
|
* <li>单张保证金 = contractMultiplier × entryPrice / leverage</li>
|
* <li>补仓张数 = max(baseQty, floor(B / 单张保证金))</li>
|
* </ul>
|
*
|
* <h3>风控</h3>
|
* <ul>
|
* <li>风控1：反向仓位倍数上限 maxPositionMultiplier（默认10x）</li>
|
* <li>风控2：保证金占比检查（全局亏损 maxLoss 阈值）</li>
|
* <li>风控3：权益增长 equityRestartRatio（默认5%）全平重置</li>
|
* </ul>
|
*
|
* @author Administrator
|
*/
|
@Slf4j
|
public class OkxProfitRecycleStrategy implements IOkxStrategy {
|
|
public enum StrategyState {
|
WAITING_KLINE,
|
OPENING,
|
ACTIVE,
|
RESTARTING,
|
STOPPED
|
}
|
|
private final OkxConfig config;
|
private final OkxTradeExecutor executor;
|
|
private volatile StrategyState state = StrategyState.WAITING_KLINE;
|
|
// ---- 价格 ----
|
private volatile BigDecimal lastPrice = BigDecimal.ZERO;
|
private volatile BigDecimal markPrice = BigDecimal.ZERO;
|
|
// ---- 持仓 ----
|
private volatile BigDecimal longPositionSize = BigDecimal.ZERO;
|
private volatile BigDecimal longEntryPrice = BigDecimal.ZERO;
|
private volatile BigDecimal shortPositionSize = BigDecimal.ZERO;
|
private volatile BigDecimal shortEntryPrice = BigDecimal.ZERO;
|
|
// ---- 盈亏 ----
|
private volatile BigDecimal cumulativePnl = BigDecimal.ZERO;
|
private volatile BigDecimal initialPrincipal = BigDecimal.ZERO;
|
private volatile boolean rebalancing = false;
|
/** 循环计数器（每完成一次"平仓+反向加仓"计数+1） */
|
private volatile int cycleCount = 0;
|
/** 重置计数器（每完成一次权益重置计数+1） */
|
private volatile int restartCount = 0;
|
|
private volatile OkxKlineWebSocketClient wsClient;
|
|
public OkxProfitRecycleStrategy(OkxConfig config) {
|
this.config = config;
|
this.executor = new OkxTradeExecutor(config);
|
}
|
|
// ==================== 生命周期 ====================
|
|
public void init() {
|
try {
|
refreshInitialPrincipal();
|
JSONObject posModeBody = new JSONObject();
|
posModeBody.put("posMode", config.getPositionMode());
|
executorPost("/api/v5/account/set-position-mode", posModeBody.toJSONString());
|
log.info("[ProfitRecycle] 持仓模式: {}", config.getPositionMode());
|
|
JSONObject levBody = new JSONObject();
|
levBody.put("instId", config.getContract());
|
levBody.put("lever", config.getLeverage());
|
levBody.put("mgnMode", config.getMarginMode());
|
executorPost("/api/v5/account/set-leverage", levBody.toJSONString());
|
log.info("[ProfitRecycle] 杠杆: {}x {}", config.getLeverage(), config.getMarginMode());
|
|
executor.cancelAllPriceTriggeredOrders();
|
closeExistingPositions();
|
log.info("[ProfitRecycle] 初始化完成, 本金: {} USDT, 合约: {}, 基础张数: {}",
|
initialPrincipal, config.getContract(), config.getBaseQuantity());
|
} catch (Exception e) {
|
log.error("[ProfitRecycle] 初始化失败", e);
|
}
|
}
|
|
public void startStrategy() {
|
if (state != StrategyState.WAITING_KLINE && state != StrategyState.STOPPED) {
|
log.warn("[ProfitRecycle] 策略已在运行中, state:{}", state);
|
return;
|
}
|
resetState();
|
refreshInitialPrincipal();
|
log.info("[ProfitRecycle] ✅ 策略启动 — 本金: {} USDT | 基础仓位: {}张 | 杠杆: {}x | "
|
+ "触发ROI: {}% | 再投资: {}% | 仓位上限: {}x | 重置阈值: {}%",
|
initialPrincipal, config.getBaseQuantity(), config.getLeverage(),
|
config.getProfitTriggerRatio().multiply(new BigDecimal("100")),
|
config.getReinvestRatio().multiply(new BigDecimal("100")),
|
config.getMaxPositionMultiplier(),
|
config.getEquityRestartRatio().multiply(new BigDecimal("100")));
|
}
|
|
public void stopStrategy() {
|
state = StrategyState.STOPPED;
|
executor.cancelAllPriceTriggeredOrders();
|
closeExistingPositions();
|
executor.shutdown();
|
log.info("[ProfitRecycle] ⏹ 策略停止 — 累计盈亏: {} | 循环: {} | 重置: {}",
|
cumulativePnl, cycleCount, restartCount);
|
}
|
|
@Override
|
public boolean isStrategyActive() {
|
return state != StrategyState.STOPPED && state != StrategyState.WAITING_KLINE;
|
}
|
|
private void resetState() {
|
state = StrategyState.WAITING_KLINE;
|
cumulativePnl = BigDecimal.ZERO;
|
lastPrice = BigDecimal.ZERO;
|
markPrice = BigDecimal.ZERO;
|
longPositionSize = BigDecimal.ZERO;
|
longEntryPrice = BigDecimal.ZERO;
|
shortPositionSize = BigDecimal.ZERO;
|
shortEntryPrice = BigDecimal.ZERO;
|
rebalancing = false;
|
cycleCount = 0;
|
}
|
|
// ==================== WS 回调 ====================
|
|
@Override
|
public void onKline(BigDecimal closePrice) {
|
lastPrice = closePrice;
|
|
if (state == StrategyState.WAITING_KLINE) {
|
if (wsClient == null || !wsClient.areAllSubscribed()) return;
|
state = StrategyState.OPENING;
|
final String size = config.getBaseQuantity();
|
log.info("[ProfitRecycle] 🚀 首根K线到达，多空双开各{}张", size);
|
executor.openLong(size, ordId -> log.info("[ProfitRecycle] 多仓已提交 ordId:{}", ordId), null);
|
executor.openShort(size, ordId -> log.info("[ProfitRecycle] 空仓已提交 ordId:{}", ordId), null);
|
return;
|
}
|
|
if (state == StrategyState.ACTIVE) {
|
checkAndRecycle();
|
}
|
}
|
|
@Override
|
public void setMarkPrice(BigDecimal markPrice) {
|
this.markPrice = markPrice;
|
}
|
|
@Override
|
public void onPositionUpdate(String contract, Direction direction,
|
BigDecimal size, BigDecimal entryPrice) {
|
if (state == StrategyState.STOPPED || state == StrategyState.WAITING_KLINE) return;
|
|
boolean hasPos = size.abs().compareTo(BigDecimal.ZERO) > 0;
|
boolean isLong = (direction == Direction.LONG);
|
|
if (state == StrategyState.OPENING || state == StrategyState.RESTARTING) {
|
if (isLong && hasPos) {
|
longPositionSize = size;
|
longEntryPrice = entryPrice;
|
log.info("[ProfitRecycle] 多仓确认: {}张 @ {}", size, entryPrice);
|
tryActivate();
|
} else if (!isLong && hasPos) {
|
shortPositionSize = size.abs();
|
shortEntryPrice = entryPrice;
|
log.info("[ProfitRecycle] 空仓确认: {}张 @ {}", size.abs(), entryPrice);
|
tryActivate();
|
}
|
}
|
|
if (state == StrategyState.ACTIVE) {
|
if (isLong) {
|
longPositionSize = hasPos ? size : BigDecimal.ZERO;
|
longEntryPrice = hasPos ? entryPrice : BigDecimal.ZERO;
|
} else {
|
shortPositionSize = hasPos ? size.abs() : BigDecimal.ZERO;
|
shortEntryPrice = hasPos ? entryPrice : BigDecimal.ZERO;
|
}
|
}
|
}
|
|
@Override
|
public void onAutoOrder(String orderId, String status, String reason,
|
String orderType, String tradeId) {
|
log.debug("[ProfitRecycle] 条件单: id={} status={}", orderId, status);
|
}
|
|
// ==================== 核心循环 ====================
|
|
private void checkAndRecycle() {
|
if (rebalancing) return;
|
|
final BigDecimal price = resolvePrice();
|
if (price.compareTo(BigDecimal.ZERO) <= 0) return;
|
|
final BigDecimal mult = config.getContractMultiplier();
|
final BigDecimal lev = new BigDecimal(config.getLeverage());
|
final BigDecimal trigger = config.getProfitTriggerRatio();
|
|
// 检查多仓
|
if (longPositionSize.compareTo(BigDecimal.ZERO) > 0
|
&& longEntryPrice.compareTo(BigDecimal.ZERO) > 0) {
|
BigDecimal pnl = longPositionSize.multiply(mult).multiply(price.subtract(longEntryPrice));
|
BigDecimal margin = calcMargin(longPositionSize, longEntryPrice);
|
BigDecimal roi = margin.compareTo(BigDecimal.ZERO) > 0
|
? pnl.divide(margin, 4, RoundingMode.HALF_UP) : BigDecimal.ZERO;
|
|
if (pnl.compareTo(margin.multiply(trigger)) >= 0) {
|
log.info("[ProfitRecycle] 🔔 多头触发 | pnl={} margin={} ROI={}%", pnl, margin, roi.multiply(hundred()));
|
executeRecycle(Direction.LONG, longPositionSize, pnl, longEntryPrice, price);
|
return;
|
}
|
}
|
|
// 检查空仓
|
if (shortPositionSize.compareTo(BigDecimal.ZERO) > 0
|
&& shortEntryPrice.compareTo(BigDecimal.ZERO) > 0) {
|
BigDecimal pnl = shortPositionSize.multiply(mult).multiply(shortEntryPrice.subtract(price));
|
BigDecimal margin = calcMargin(shortPositionSize, shortEntryPrice);
|
BigDecimal roi = margin.compareTo(BigDecimal.ZERO) > 0
|
? pnl.divide(margin, 4, RoundingMode.HALF_UP) : BigDecimal.ZERO;
|
|
if (pnl.compareTo(margin.multiply(trigger)) >= 0) {
|
log.info("[ProfitRecycle] 🔔 空头触发 | pnl={} margin={} ROI={}%", pnl, margin, roi.multiply(hundred()));
|
executeRecycle(Direction.SHORT, shortPositionSize, pnl, shortEntryPrice, price);
|
}
|
}
|
}
|
|
/**
|
* 执行一次完整的盈利回收操作：
|
* 平50%盈利仓 → 利润A → B=A×50% → 计算反方向张数 → 开反向仓
|
*/
|
private void executeRecycle(Direction profitableSide,
|
BigDecimal posSize, BigDecimal totalPnl,
|
BigDecimal entryPrice, BigDecimal price) {
|
rebalancing = true;
|
final boolean isLongProfit = (profitableSide == Direction.LONG);
|
final BigDecimal mult = config.getContractMultiplier();
|
final BigDecimal lev = new BigDecimal(config.getLeverage());
|
final String label = isLongProfit ? "多头" : "空头";
|
|
// ---- Step 1: 平50%仓位 ----
|
final int closeQty = Math.max(posSize.divide(two(), 0, RoundingMode.DOWN).intValue(), 1);
|
final BigDecimal priceDiff = isLongProfit ? price.subtract(entryPrice) : entryPrice.subtract(price);
|
final BigDecimal profitA = new BigDecimal(closeQty).multiply(mult).multiply(priceDiff);
|
|
log.info("[ProfitRecycle] ═══ {} 触发回收 ═══", label);
|
log.info("[ProfitRecycle] Step1 平仓: {}张(总{}张) → 预期利润A = {} USDT", closeQty, posSize, profitA);
|
|
// ---- Step 2: B = A × reinvestRatio ----
|
final BigDecimal reinvestRatio = config.getReinvestRatio();
|
final BigDecimal marginB = profitA.multiply(reinvestRatio);
|
log.info("[ProfitRecycle] Step2 拆分: B = {} × {} = {} USDT", profitA, reinvestRatio, marginB);
|
|
// ---- Step 3: 计算反方向张数 (单张保证金法) ----
|
// 单张保证金 = contractMultiplier × entryPrice / leverage
|
final BigDecimal perContractMargin = mult.multiply(entryPrice).divide(lev, 8, RoundingMode.HALF_UP);
|
final int rawQty = marginB.divide(perContractMargin, 0, RoundingMode.DOWN).intValue();
|
final int baseQty = Integer.parseInt(config.getBaseQuantity());
|
|
// 风控1: 反向仓位倍数上限
|
final BigDecimal oppositeSize = isLongProfit ? shortPositionSize : longPositionSize;
|
final int maxQty = baseQty * config.getMaxPositionMultiplier();
|
final int availableSlots = maxQty - oppositeSize.intValue();
|
|
int newQty = Math.max(rawQty, baseQty); // 至少开基础仓位
|
if (availableSlots <= 0) {
|
log.warn("[ProfitRecycle] 🛑 风控1触发: 反方向已达上限 {}张, 跳过加仓", maxQty);
|
rebalancing = false;
|
return;
|
}
|
if (newQty > availableSlots) {
|
newQty = availableSlots;
|
log.info("[ProfitRecycle] 风控1限制: 调整张数 {} → {}", Math.max(rawQty, baseQty), newQty);
|
}
|
final String openSize = String.valueOf(newQty);
|
|
log.info("[ProfitRecycle] Step3 补仓: 单张保证金={} | raw={} | base={} | max={} | final={}张",
|
perContractMargin, rawQty, baseQty, maxQty, openSize);
|
|
// ---- Step 4: 执行平仓 → 回调中开反方向 ----
|
final String closePosSide = isLongProfit ? "long" : "short";
|
|
executor.marketClosePosition(String.valueOf(closeQty), closePosSide,
|
() -> {
|
cumulativePnl = cumulativePnl.add(profitA);
|
cycleCount++;
|
updatePositionAfterClose(profitableSide, closeQty);
|
|
log.info("[ProfitRecycle] ✅ 平仓完成 | 累计盈亏: {} | 第{}次循环",
|
cumulativePnl, cycleCount);
|
|
// 开反方向
|
if (!isLongProfit) {
|
executor.openLong(openSize,
|
ordId -> log.info("[ProfitRecycle] 反方向开多{}张 ok ordId:{}", openSize, ordId),
|
() -> log.error("[ProfitRecycle] ❌ 反方向开多{}张失败", openSize));
|
} else {
|
executor.openShort(openSize,
|
ordId -> log.info("[ProfitRecycle] 反方向开空{}张 ok ordId:{}", openSize, ordId),
|
() -> log.error("[ProfitRecycle] ❌ 反方向开空{}张失败", openSize));
|
}
|
|
// 当前仓位状态
|
log.info("[ProfitRecycle] 当前仓位: LONG={}张 SHORT={}张",
|
longPositionSize, shortPositionSize);
|
|
// 风控检查
|
if (checkLossStop()) return;
|
if (checkEquityRestart()) return;
|
rebalancing = false;
|
},
|
() -> {
|
log.error("[ProfitRecycle] ❌ 平仓失败 direction:{}", closePosSide);
|
rebalancing = false;
|
});
|
}
|
|
// ==================== 风控 ====================
|
|
/** 风控2: 全局亏损超限 → 停止策略 */
|
private boolean checkLossStop() {
|
BigDecimal totalPnl = cumulativePnl.add(calcUnrealizedPnl());
|
if (config.getMaxLoss() != null && config.getMaxLoss().compareTo(BigDecimal.ZERO) > 0
|
&& totalPnl.compareTo(config.getMaxLoss().negate()) <= 0) {
|
String msg = StrUtil.format("[ProfitRecycle] 🛑 亏损超限! 合计:{} 已实现:{}",
|
totalPnl, cumulativePnl);
|
log.warn(msg);
|
DingTalkUtils.getDefault().sendActionCard("风险提醒", msg, config.getApiKey(), "");
|
stopStrategy();
|
return true;
|
}
|
return false;
|
}
|
|
/** 风控3: 账户权益增长≥5% → 全平重置 */
|
private boolean checkEquityRestart() {
|
BigDecimal equity = fetchCurrentEquity();
|
if (equity.compareTo(BigDecimal.ZERO) <= 0) return false;
|
|
BigDecimal threshold = initialPrincipal.multiply(
|
BigDecimal.ONE.add(config.getEquityRestartRatio()));
|
if (equity.compareTo(threshold) >= 0) {
|
restartCount++;
|
log.info("[ProfitRecycle] 🔄 权益重置触发! 当前权益: {} ≥ 目标: {} (初始: {} + {}%) | 第{}次重置",
|
equity, threshold, initialPrincipal,
|
config.getEquityRestartRatio().multiply(hundred()), restartCount);
|
executeRestart();
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 执行权益重置：全平 → 取消所有订单 → 刷新本金 → 重新双开底仓
|
*/
|
private void executeRestart() {
|
rebalancing = true;
|
state = StrategyState.RESTARTING;
|
log.info("[ProfitRecycle] 开始重置: 平所有仓位...");
|
|
executor.cancelAllPriceTriggeredOrders();
|
// 全平多空
|
if (longPositionSize.compareTo(BigDecimal.ZERO) > 0) {
|
executor.marketClosePosition(longPositionSize.toPlainString(), "long", null, null);
|
}
|
if (shortPositionSize.compareTo(BigDecimal.ZERO) > 0) {
|
executor.marketClosePosition(shortPositionSize.toPlainString(), "short", null, null);
|
}
|
|
// 延迟后重新开仓
|
executor.submitTask(() -> {
|
try { Thread.sleep(2000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
|
refreshInitialPrincipal();
|
resetState();
|
state = StrategyState.OPENING;
|
final String size = config.getBaseQuantity();
|
log.info("[ProfitRecycle] 🔄 重置开仓: 多空各{}张, 新本金: {} USDT", size, initialPrincipal);
|
executor.openLong(size, ordId -> log.info("[ProfitRecycle] 重置多仓 ordId:{}", ordId), null);
|
executor.openShort(size, ordId -> log.info("[ProfitRecycle] 重置空仓 ordId:{}", ordId), null);
|
rebalancing = false;
|
// 等待 WS 仓位确认后 tryActivate()
|
});
|
}
|
|
// ==================== 辅助 ====================
|
|
private BigDecimal calcMargin(BigDecimal size, BigDecimal entry) {
|
return size.multiply(config.getContractMultiplier())
|
.multiply(entry)
|
.divide(new BigDecimal(config.getLeverage()), 8, RoundingMode.HALF_UP);
|
}
|
|
private BigDecimal calcUnrealizedPnl() {
|
BigDecimal price = resolvePrice();
|
if (price.compareTo(BigDecimal.ZERO) <= 0) return BigDecimal.ZERO;
|
BigDecimal m = config.getContractMultiplier();
|
BigDecimal lp = BigDecimal.ZERO, sp = BigDecimal.ZERO;
|
if (longPositionSize.compareTo(BigDecimal.ZERO) > 0 && longEntryPrice.compareTo(BigDecimal.ZERO) > 0)
|
lp = longPositionSize.multiply(m).multiply(price.subtract(longEntryPrice));
|
if (shortPositionSize.compareTo(BigDecimal.ZERO) > 0 && shortEntryPrice.compareTo(BigDecimal.ZERO) > 0)
|
sp = shortPositionSize.multiply(m).multiply(shortEntryPrice.subtract(price));
|
return lp.add(sp);
|
}
|
|
private BigDecimal resolvePrice() {
|
return (config.getUnrealizedPnlPriceMode() == OkxConfig.PnLPriceMode.MARK_PRICE
|
&& markPrice.compareTo(BigDecimal.ZERO) > 0) ? markPrice : lastPrice;
|
}
|
|
private BigDecimal fetchCurrentEquity() {
|
try {
|
JSONObject account = executorGet("/api/v5/account/balance");
|
JSONArray details = account.getJSONArray("data").getJSONObject(0).getJSONArray("details");
|
if (details != null) for (int i = 0; i < details.size(); i++) {
|
if ("USDT".equals(details.getJSONObject(i).getString("ccy")))
|
return details.getJSONObject(i).getBigDecimal("eq");
|
}
|
} catch (Exception e) { log.warn("[ProfitRecycle] 获取权益失败", e); }
|
return BigDecimal.ZERO;
|
}
|
|
private void refreshInitialPrincipal() {
|
BigDecimal eq = fetchCurrentEquity();
|
if (eq.compareTo(BigDecimal.ZERO) > 0) this.initialPrincipal = eq;
|
}
|
|
private void updatePositionAfterClose(Direction side, int closed) {
|
if (side == Direction.LONG) {
|
longPositionSize = longPositionSize.subtract(new BigDecimal(closed));
|
if (longPositionSize.compareTo(BigDecimal.ZERO) <= 0) {
|
longPositionSize = BigDecimal.ZERO;
|
longEntryPrice = BigDecimal.ZERO;
|
}
|
} else {
|
shortPositionSize = shortPositionSize.subtract(new BigDecimal(closed));
|
if (shortPositionSize.compareTo(BigDecimal.ZERO) <= 0) {
|
shortPositionSize = BigDecimal.ZERO;
|
shortEntryPrice = BigDecimal.ZERO;
|
}
|
}
|
}
|
|
private void tryActivate() {
|
if ((state == StrategyState.OPENING || state == StrategyState.RESTARTING)
|
&& longPositionSize.compareTo(BigDecimal.ZERO) > 0
|
&& shortPositionSize.compareTo(BigDecimal.ZERO) > 0) {
|
state = StrategyState.ACTIVE;
|
log.info("[ProfitRecycle] ═══ 策略激活 ═══");
|
log.info("[ProfitRecycle] LONG: {}张 @ {} | SHORT: {}张 @ {} | "
|
+ "多保证金: {} | 空保证金: {}",
|
longPositionSize, longEntryPrice, shortPositionSize, shortEntryPrice,
|
calcMargin(longPositionSize, longEntryPrice),
|
calcMargin(shortPositionSize, shortEntryPrice));
|
}
|
}
|
|
private void closeExistingPositions() {
|
try {
|
JSONObject resp = executorGet("/api/v5/account/positions?instType=SWAP");
|
JSONArray data = resp.getJSONArray("data");
|
if (data == null || data.isEmpty()) return;
|
for (int i = 0; i < data.size(); i++) {
|
JSONObject pos = data.getJSONObject(i);
|
if (!config.getContract().equals(pos.getString("instId"))) continue;
|
String posVal = pos.getString("pos");
|
if (posVal == null || "0".equals(posVal)) continue;
|
String posSide = pos.getString("posSide");
|
String side = "long".equals(posSide) ? "sell" : "buy";
|
JSONObject body = new JSONObject();
|
body.put("instId", config.getContract());
|
body.put("tdMode", "cross");
|
body.put("side", side);
|
body.put("posSide", posSide);
|
body.put("ordType", "market");
|
body.put("sz", posVal);
|
executorPost("/api/v5/trade/order", body.toJSONString());
|
log.info("[ProfitRecycle] 平旧仓 posSide:{} sz:{}", posSide, posVal);
|
}
|
} catch (Exception e) { log.warn("[ProfitRecycle] 平仓异常", e); }
|
}
|
|
// ==================== REST 快捷 ====================
|
|
private JSONObject executorGet(String path) throws Exception { return executor.okGet(path); }
|
|
private JSONObject executorPost(String path, String body) throws Exception { return executor.okPost(path, body); }
|
|
private static BigDecimal two() { return new BigDecimal("2"); }
|
|
private static BigDecimal hundred() { return new BigDecimal("100"); }
|
|
// ==================== Getters ====================
|
|
public BigDecimal getLastKlinePrice() { return lastPrice; }
|
public BigDecimal getCumulativePnl() { return cumulativePnl; }
|
public StrategyState getState() { return state; }
|
public int getCycleCount() { return cycleCount; }
|
public int getRestartCount() { return restartCount; }
|
public BigDecimal getInitialPrincipal() { return initialPrincipal; }
|
public BigDecimal getLongPositionSize() { return longPositionSize; }
|
public BigDecimal getShortPositionSize() { return shortPositionSize; }
|
public BigDecimal getLongEntryPrice() { return longEntryPrice; }
|
public BigDecimal getShortEntryPrice() { return shortEntryPrice; }
|
@Override
|
public void setWsClient(OkxKlineWebSocketClient wsClient) { this.wsClient = wsClient; }
|
}
|
