冒険者のゲーム：ロールオーバー戦略のコード実装と応用

ianzeng123

フォローダイレクトメッセージ

フォロー

410

フォロワー

冒険者のゲーム：ロールオーバー戦略のコード実装と応用

作成日:: 2025-12-19 17:06:01, 更新日:: 2025-12-29 09:04:46

353

[TOC]

冒険者のゲーム：ロールオーバー戦略のコード実装と応用

導入

クオンツ取引の分野において、ローリングポジション戦略は魅力的でありながらも挑戦的なテーマです。この戦略の核となる考え方は、実現利益をトレンド相場に再投資することで複利成長を達成することです。この記事では、この取引アイデアを段階的に実行可能なコードロジックに変換する方法を深く掘り下げ、技術的な詳細ではなく、マインドセットの転換に焦点を当てます。ローリングポジション戦略はリターンを増幅させる一方で、リスクも増幅させるという点に留意することが重要です。この記事は学習と議論のみを目的としています。

I. ローリングポジション戦略の利益ロジックの詳細な分析

1.1 ロールオーバーの数学的本質

ロールオーバー図

ローリングポジション戦略の利益ロジックは本質的に複利成長モデル単純化した例を使ってこれを理解してみましょう。

従来の単一取引（3回連続でそれぞれ10%増加）：

開始資本: 100 USDT、レバレッジ3倍
市場増加率: (1+10%) × (1+10%) × (1+10%) - 1 = 33.1%
利益: 100 × 3 × 33.1% = 99.3 USDT
最終価格: 199.3 USDT

ロールオーバー取引（3回の連続取引、それぞれ10％増加）：

1回目100 USDT → 30 USDTの利益 → 資金は130 USDTになる
- 計算：100 × 3倍レバレッジ × 10%増加 = 30
2回目130 USDT → 39 USDTの利益 → 資金は169 USDTになる
- 計算：130 × 3倍レバレッジ × 10%増加 = 39
3位169 USDT → 50.7 USDTの利益 → 資金が219.7 USDTに増加
- 計算：169 × 3倍レバレッジ × 10%増加 = 50.7

比較結果:

市場が3回連続で10%上昇する同じシナリオでは、次のようになります。

単一取引99.3 USDTの利益
ロールオーバー取引119.7 USDTの利益
複利のメリット20.4 USDT（約20.5%増加）

同様に、3 回連続で 10% 増加した場合、1 回の取引の利益は 99.3 USDT、ポジションのロールオーバーの利益は 119.7 USDT でした。この差が複利の力なのです。。

数式で表すと：

// 传统交易：线性增长
最终资金 = 初始资金 × (1 + 杠杆 × 涨幅)

// 滚仓交易：指数增长
最终资金 = 初始资金 × (1 + 杠杆 × 单次涨幅) ^ 滚仓次数

これにより、ロールオーバーの本質が明らかになります。線形成長を指数関数的成長に変えるしかし、これによって次のようなリスクも発生しました。たった 1 回の損切り注文で、これまでの複利による利益がすべて消えてしまう可能性があります。。

1.2 ロールオーバー戦略の3つの核心課題

コードを書き始める前に、戦略的な観点から次の 3 つの基本的な質問に答える必要があります。

質問1：いつ始まりますか？（最初のエントリー）
トレンドの開始シグナルを決定する必要があります。

質問2: いつ続行しますか? (追加のローリングポジション)
これがポジションのロールオーバーの核心です。利益確定後にトレンドが継続するかどうかをどのように判断するかです。

質問3: いつ止めるべきか？（撤退して観察する）

積極的な撤退：トレンドの弱まり
パッシブエグジット：ストップロスの発動

これら 3 つの質問によって戦略全体の枠組みが決まり、これを 1 つずつコードロジックに変換していきます。

II. 質問 1: いつ始めるべきか? — 参入の転換点を見つける。

入口信号

2.1 ロールオーバー戦略の理想と現実

まず、ローリングポジション戦略の理想的な適用シナリオを理解しましょう。

理想的なシナリオ:
SHIB市場が0.000001ドルから上昇し始めた時にエントリーしたり、特定のアルトコインが急騰する直前にポジションを取ったりできたらどうなるでしょうか。継続的なロールオーバーによって、100USDTが10,000USDT、あるいはそれ以上にまで上昇する可能性があります。これこそがロールオーバー戦略の究極の夢です。暗号通貨が爆発する前に市場に参入し、10 倍、あるいは 100 倍の利益を獲得しましょう。。

厳しい現実：
問題は、どの暗号通貨が急騰するかをどうやって知るかということです。そして、いつ急騰するのか？

プロジェクトのオーナーまたは内部関係者であれば、良いニュースを事前に知っている可能性があります。
通常のトレーダーであれば、市場のシグナルに基づいて判断することしかできません。

私たちのほとんどにとって、この転換点を正確に捉えることは…はっきり言って、すべては運次第です。未来を予測することはできません。私たちにできるのは、過去のデータとテクニカル指標を活用して、「大当たり」の確率を高めることだけです。

2.2 理想から現実へ: テクニカル指標に基づくシミュレーションエントリー

どの暗号通貨が急騰するかは予測できないので、私たちにできることは次の通りです。実行可能なエントリルールのセットを確立し、テクニカルインジケーターを使用して「トレンド開始」信号をシミュレートします。。

広大な海で釣りをするようなものです。大きな魚がどこにいるかは分かりませんが、私たちにできることはあります。

水面の波紋（価格変動）を観察します。
水の流れの方向（トレンド方向）を分析します。
適切なツール（テクニカル指標）を選択する

複数のシグナルが重なると、トレンドが始まろうとしていると判断し、市場に参入してその兆候を探ります。もし私たちの予測が正しければ、トレンドに沿ってポジションをロールオーバーし、利益を上げます。もし間違っていれば、損失を抑えて速やかに市場から撤退します。

2.3 進入信号の技術的実装

技術ツールの選択:
トレンド識別ツールとして、EMAデュアル移動平均システム（EMA5とEMA10）を使用します。このシステムを選択した理由はシンプルです。

シンプルで直感的、検証も簡単
価格変動に迅速に対応できる
パラメータは感度と安定性のバランスをとる

コアロジック:
移動平均線の「ゴールデンクロス」（EMA5がEMA10を上回る）と「デッドクロス」（EMA5がEMA10を下回る）を検出することで、トレンドの反転ポイントを捉えることができます。

ゴールデンクロス → 買いシグナル
デッドクロス → 空売りシグナル

コード・アイディア:

// 计算EMA指标
var emaFast = TA.EMA(records, FastEMA);  // EMA5
var emaSlow = TA.EMA(records, SlowEMA);  // EMA10

// 获取当前和前一根K线的EMA值
var ema5_current = emaFast[emaFast.length - 1];
var ema5_prev = emaFast[emaFast.length - 2];
var ema10_current = emaSlow[emaSlow.length - 1];
var ema10_prev = emaSlow[emaSlow.length - 2];

// 检测金叉：前一根K线EMA5<=EMA10，当前K线EMA5>EMA10
var bullCross = ema5_prev <= ema10_prev && ema5_current > ema10_current;

// 检测死叉：前一根K线EMA5>=EMA10，当前K线EMA5<EMA10
var bearCross = ema5_prev >= ema10_prev && ema5_current < ema10_current;

// 空仓时等待信号入场
if (bullCross) {
    Log("📈 金叉信号 - 做多");
    openPosition("LONG", currentPrice);
} else if (bearCross) {
    Log("📉 死叉信号 - 做空");
    openPosition("SHORT", currentPrice);
}

このセクションでは、ゴールデンクロスとデッドクロスの詳細については触れません。これらは取引における基本的な概念です。重要なポイントは次のとおりです。ロールオーバーの開始をトリガーするには、明確で定量化可能なエントリシグナルが必要です。。

III. 質問2: いつ継続すべきか? — 複利の核となるメカニズム。

ロールオーバー機構

3.1 ロールオーバーの本質を理解する：合理的な冒険者のゲーム

ロールオーバー戦略は本質的に合理的な冒険ゲーム完全なシナリオを使ってこれを理解してみましょう。

ゲームのルール:

1. 你从交易所账户中拿出100 USDT作为冒险资金
2. 这100 USDT独立管理，与账户其他资金隔离
3. 用这100 USDT开始交易：
   - 赚了 → 盈利加入资金池，继续用更大的资金交易（滚仓）
   - 亏了 → 触发止损，回到空仓状态
4. 重复这个过程，直到：
   - 要么把100 USDT亏完（游戏结束）
   - 要么滚到一个满意的金额（主动退出）

このゲームの素晴らしさは次の点にあります。

リスクは管理可能です。最大損失は 100 USDT であり、アカウント内の他の資金には影響しません。
無制限の利益: トレンドが一致すれば、複利によって資本がすぐに 2 倍になります。
エントリーとエグジットの明確なルール: 利益確定、損失ストップ、ポジションのロールオーバーに関する明確なルール。

3.2 資本プールの設計：複利を実現するための鍵

これがローリングポジション戦略の中核となる設計コンセプトです。

伝統的な慣行の問題点:
取引所のアカウントに 1000 USDT があると仮定します。

最初のポジションは100 USDTで開かれました。
30 USDTの利益が出たため、口座残高は1030 USDTになりました。
2 番目のオープニングポジションにはどれくらい使用すればよいですか? 100 ですか、それとも 130 ですか?
利益がローリングポジション戦略から生じたものか、それとも他の操作から生じたものかをどのように区別すればよいでしょうか?

資金プーリングソリューション:

// 创建一个虚拟的"策略资金池"
var strategyCapital = InitialCapital;  // 初始100 USDT

// 第1次交易
// 开仓金额 = 100 USDT
// 止盈后盈利 = 30 USDT
strategyCapital = strategyCapital + 30;  // 资金池变为130 USDT

// 第2次交易（滚仓）
var positionValue = strategyCapital * Leverage;  // 130 × 3 = 390
var amount = positionValue / price / ctVal;      // 计算开仓数量
// 自动使用了第1次的盈利，这就是复利的关键

// 止盈后盈利 = 39 USDT
strategyCapital = strategyCapital + 39;  // 资金池变为169 USDT

// 第3次交易（滚仓）
// 开仓金额 = 169 USDT（继续利滚利）

このデザインの利点:

資金の分離:この戦略では指定された 100 USDT のみが使用され、アカウント内の他の資金には影響しません。
自動複利:各利益は自動的に資本プールに追加されるため、より大きな金額が次のポジションに使用されます。
リスクは制御可能です:最悪のシナリオは 100 USDT の損失ですが、これは予想の範囲内です。
明確な追跡:この戦略では、100 USDT からどれだけロールオーバーされたかを正確に特定できます。

3.3 ロールオーバーの決定: 利益確定後に継続するか停止するか?

これがローリングポジション戦略の中核要素です。利益確定注文が実行された後、ロールを続けるか停止するかという重要な決定を下す必要があります。

意思決定シナリオ:

假设我们做多BTC：
- 入场价：45000 USDT，用100 USDT开仓
- 止盈价：49500 USDT（涨10%）
- 止盈成交，盈利30 USDT
- 现在资金池：130 USDT

问题来了：
选项A：收手，带着130 USDT退出，回到空仓
选项B：继续，用130 USDT再次开多（滚仓）

どうやって選ぶの？

この判断は「感情」に基づくものではなく、明確な基準が必要です。私たちの判断ロジックは次のとおりです。この傾向は継続しているのでしょうか?

判定方法：
利益確定注文が実行された瞬間、最新のテクニカル指標（EMA移動平均）が再計算されます。

// 止盈单成交后，获取最新K线数据
var records = _C(exchange.GetRecords, PERIOD_M1);
var emaFast = TA.EMA(records, FastEMA);
var emaSlow = TA.EMA(records, SlowEMA);

var ema5_current = emaFast[emaFast.length - 1];
var ema10_current = emaSlow[emaSlow.length - 1];

var shouldRoll = false;

if (currentDirection == "LONG") {
    // 多头止盈后，如果EMA5仍在EMA10上方，继续做多（滚仓）
    if (ema5_current > ema10_current) {
        shouldRoll = true;
        Log("✅ EMA5 > EMA10，上升趋势未破坏");
        Log("🔄 决策：继续做多（滚仓）");
    } else {
        Log("❌ EMA5 <= EMA10，趋势可能转弱");
        Log("⏸️ 决策：不滚仓，等待新信号");
    }
} else if (currentDirection == "SHORT") {
    // 空头止盈后，如果EMA5仍在EMA10下方，继续做空（滚仓）
    if (ema5_current < ema10_current) {
        shouldRoll = true;
        Log("✅ EMA5 < EMA10，下降趋势未破坏");
        Log("🔄 决策：继续做空（滚仓）");
    } else {
        Log("❌ EMA5 >= EMA10，趋势可能转弱");
        Log("⏸️ 决策：不滚仓，等待新信号");
    }
}

3.4 ロールオーバー実行プロセス

「ポジションのロールオーバーを継続する」という決定の場合:

if (shouldRoll) {
    // 1. 增加滚仓计数
    currentRoundRolls++;
    
    Log("🔄 执行滚仓操作... (本轮第", currentRoundRolls, "次滚仓)");
    
    // 2. 获取最新价格
    var ticker = _C(exchange.GetTicker);
    var newPrice = ticker.Last;
    
    // 3. 基于新资金池重新开仓
    if (openPosition(currentDirection, newPrice)) {
        Log("✅ 滚仓成功!");
        // 4. 挂新的止盈单（在openPosition函数中完成）
        // 5. 设置新的止损价（在checkStopLoss函数中监控）
    } else {
        Log("❌ 滚仓失败，等待新信号");
        saveRollRecord(false);
        resetPositionState();
    }
}

決定が「停止」の場合:

else {
    // 1. 保存本轮统计
    saveRollRecord(false);  // false表示正常结束，非止损
    
    // 2. 保留资金池金额
    // strategyCapital 保持当前值，等待下次机会
    
    // 3. 回到空仓状态
    resetPositionState();
    
    Log("⏳ 已平仓，等待新信号...");
}

このプロセスの要点:

利益確定行動のたびに、遅滞なく直ちに判断を下してください。
判断基準は客観的なもの（移動平均線同士の関係性）であり、主観的な憶測は含まれません。
ポジションを増やし続け、停止して利益を維持します。

3.5 複利の力とコスト

完全なケーススタディを通じて複利の威力を体験してみましょう。

成功事例:

初始资金：100 USDT
止盈比例：10%
杠杆：3倍

第1次：100 USDT → 盈利30 → 资金池130
第2次：130 USDT → 盈利39 → 资金池169
第3次：169 USDT → 盈利50.7 → 资金池219.7
第4次：219.7 USDT → 盈利65.9 → 资金池285.6
第5次：285.6 USDT → 盈利85.7 → 资金池371.3

连续滚5次，100变成371.3，增长271%！

失敗例:

第1次：100 USDT → 盈利30 → 资金池130
第2次：130 USDT → 盈利39 → 资金池169
第3次：169 USDT → 趋势反转 → 触发止损
止损比例5%，亏损：169 × 3 × 5% = 25.35 USDT
剩余资金：169 - 25.35 = 143.65 USDT

原本从100滚到169，一次止损后只剩143.65

これはロールオーバー取引の諸刃の剣です。

成功した場合:指数関数的な成長は刺激的です。
失敗した場合:急激な後退、あるいは損失さえも

IV. 質問 3: いつ止めるべきか? — ストップロスは最後の防衛線です。

損失を抑える仕組み

4.1 2つの出口方法

積極的な撤退：トレンドの弱まり
この状況については「質問2」で既に触れました。利益確定後、トレンドが更なる上昇を支えないと判断された場合は、積極的に取引を停止するべきです。これが理想的な出口戦略であり、利益を残して市場を去ることができます。

パッシブエグジット：ストップロスの発動
これが今私たちが焦点を当てていることです。市場が私たちに不利に動き、価格がストップロスラインに達した場合、私たちはポジションをクローズせざるを得なくなります。

4.2 ストップロスの必要性

多くの人がストップロス注文を嫌う理由は次のとおりです:

ストップロスとは間違いを認めることを意味します。
ストップロスは実際の損失をもたらします。
場合によっては、ストップロス注文を出した後に価格が反発することもあります。

しかし、ローリングポジション戦略では、ストップロスは生き残るための最低ラインです。考えてみてください:

如果没有止损：
第1次：100 → 滚到 169
第2次：169 → 趋势反转，不止损
价格持续下跌：169 → 150 → 120 → 80 → 50...
最终可能全亏，甚至爆仓

如果有止损：
第1次：100 → 滚到 169
第2次：169 → 趋势反转，触发止损
止损5%：亏损 25.35
剩余：143.65
虽然亏了，但保留了大部分资金
可以等待下一个机会

ストップロスの本質:小さくて確実な損失を利用して、大きくて不確実なリスクを回避します。

4.3 ストップロスのコード実装

// 检查止损
function checkStopLoss(currentPrice, position) {
    var totalDrawdown = 0;
    
    // 计算当前回撤
    if (currentDirection == "LONG") {
        totalDrawdown = (currentPrice - entryPrice) / entryPrice;
    } else {
        totalDrawdown = (entryPrice - currentPrice) / entryPrice;
    }
    
    // 判断是否触发止损
    if (totalDrawdown < -StopLossPercent) {
        Log("❌ 触发止损！回撤:", (totalDrawdown * 100).toFixed(2), "%");
        
        // 1. 取消止盈单
        if (takeProfitOrderId) {
            Log("取消止盈单:", takeProfitOrderId);
            exchange.CancelOrder(takeProfitOrderId);
            takeProfitOrderId = null;
            Sleep(500);
        }
        
        // 2. 市价平仓（循环重试直到成功）
        var profit = closePositionMarketWithRetry(currentPrice, position);
        
        // 3. 更新策略资金池
        strategyCapital += profit;  // profit是负数
        totalProfitRealized += profit;
        
        Log("止损亏损:", profit.toFixed(2), "U");
        Log("策略剩余资金:", strategyCapital.toFixed(2), "U");
        
        // 4. 记录本轮止损亏损
        currentRoundLoss = Math.abs(profit);
        Log("本轮止损亏损:", currentRoundLoss.toFixed(2), "U");
        
        // 5. 保存本轮滚仓记录（被止损中断）
        saveRollRecord(true);  // true表示止损结束
        
        // 6. 重置状态
        resetPositionState();
        
        // 7. 检查资金是否充足
        if (strategyCapital < 10) {
            Log("💥 策略资金不足10U，停止运行");
            throw "资金不足";
        }
        
        Log("⏳ 已止损，等待新信号...");
    }
}

4.4 ゲーム終了条件

先ほどお話しした「合理的冒険者のゲーム」を覚えていますか？このゲームには明確な終了条件があります。

条件 1: 資本プールがゼロに減少します。

if (strategyCapital <= 0) {
    Log("💥 游戏结束：资金池已归零");
    Log("本次冒险失败，100 USDT全部亏光");
    throw "资金耗尽";
}

条件2：自主的な撤退

if (strategyCapital >= 目标金额) {
    Log("🎉 达到目标金额，可以选择主动退出");
    Log("锁定利润，开始新一轮100 USDT的游戏");
}

条件3: ロールオーバーの最大回数に達する

if (连续滚仓次数 >= 10次) {
    Log("⚠️ 达到最大滚仓次数，主动退出");
    Log("持续时间太长，风险累积，见好就收");
    saveRollRecord(false);
    resetPositionState();
}

4.5 リスクとリターンのバランス

ローリングポジション戦略設計全体の核心はリスクとリターンのバランスを見つける：

収益面：

複利成長: 利益確定アクションのたびに資本プールが増加します。
トレンドキャプチャー：上昇トレンド/下降トレンドで継続的に利益を上げる
上限なし：理論上は無制限にロールできます。

リスク面:

ストップロス保護: 1 回の取引での最大損失は資本プールの 5% です。
資金分離：最大損失は100 USDT
トレンド分析: 変動の激しい市場では、頻繁なストップロス注文を避けてください。

V. 実践的なバックテスト：TRUMP_USDT ケース分析

TRUMP_USDTBinance Futures上場初日（2025年1月20日から2025年1月21日）のバックテスト分析：

エクイティカーブのバックテスト

ロールオーバー統計表

バックテストの結果は次のようになります:

ハイライト:

この戦略は、トランプ氏のIPO後の初期の劇的な変動をうまく捉えた。
複数回のロールオーバーを通じて、急速な資本増加が達成されました。
利益確定のメカニズムにより、トレンド内で利益が効果的に確保されます。

リスクエクスポージャー：

トレンドが反転すると、ストップロス注文により利益の一部が返還されます。
不安定な市場に偽のブレイクアウトシグナルが現れました。
単一通貨では集中リスクが高まる

主要データ:

ロールオーバーの総回数: X回
最大シングルラウンドロールオーバー：X回
最大ドローダウン: X%
最終収益率：X%

VI. 戦略の本質と限界

6.1 この戦略は何をシミュレートしているのでしょうか?

上記の分析から、この戦略は本質的にシミュレーションであることがはっきりとわかります。

合理的な冒険家の取引行動:

明確なエントリールールがあります（衝動的な取引ではありません）。
利益目標を設定する（貪欲を避ける）。
ストップロス規律を守ります（損失ポジションを保持しないでください）。
ローリングポジション決定（および利益の活用）を行う能力があります。
資金制限があります（リスクを管理するため）。

その中核となるロジックは次のとおりです。

試してみるために一定額の資本（100 USDT）を確保してください。
トレンドを追ってお金を稼ぎましょう。
利益が出た後は、その利益を使って取引を継続します（複利）。
トレンドが弱まったら、すぐに停止します。
判断が間違っていた場合は、損失をすぐに切り捨ててください。
資金が枯渇するか、十分な金額にロールオーバーされるまで。

6.2 戦略の限界

制限1：トレンド市場への依存
この戦略は、以下の理由により、変動の激しい市場ではパフォーマンスが低下します。

頻繁な偽のブレイクアウト
利益確定後に価格が戻ったため、ポジションをロールオーバーできませんでした。
ストップロス注文を繰り返すと、資金プールが枯渇します。

制限2: パラメータ感度
10% の利益目標と 5% のストップロスなどのパラメータは最適ではありません。

通貨によってボラティリティは異なる
市場状況に応じて必要なパラメータも異なる
固定パラメータをすべての状況に適応させることは困難です。

制限3：予測できない爆発点
前述のように、テクニカル指標を使用して市場に参入することは、本質的にギャンブルです。

本当の大きな市場の動きを見逃してしまうかもしれません。
偽のブレイクアウト中にエントリーする
内部関係者のように事前に計画を立てることができない

6.3 改善の余地

オプション1: ワークフローに基づいて通貨をフィルタリングする

ただ任意の暗号通貨を選択して去らないでください。
代わりに、ワークフローは、まず人気のある、そして将来性の高い暗号通貨を除外するために使用されます。
たとえば、ソーシャルメディアでの議論の急増、異常な取引量、アクティブなオンチェーンデータなどです。
これらの暗号通貨でローリングポジション戦略を使用すると、成功率が高まります。

方向2: パラメータを動的に調整する

通貨の過去の変動率に基づいて、利益確定比率と損切り比率を調整します。
変動の激しい通貨の場合は、ストップロスの範囲を適切に広げます。
ボラティリティが低い暗号通貨の場合、利益目標を下げることができます。

方向3：複数のファンドプールを並行して運用する

100 USDT を 1 つの通貨に投資することではありません。
代わりに、5 つの 20 USDT の金額に分割され、5 つの潜在的な暗号通貨に同時にロールオーバーされます。
リスクを分散し、「大当たり」の確率を高めます。

結論

3つの核心的な疑問を推論することで、ポジションのロールオーバーというトレードアイデアをコードロジックに翻訳する方法を完全に実証しました。このプロセスの本質は次のとおりです。正確なルールとデータ構造を使用して、合理的なリスクテイカーの取引の考え方を表現します。

重要な注意:

これはローリングポジション戦略のシミュレーションに過ぎません。実際には、ローリングポジションは豊富な市場経験を必要とする取引戦略です。この戦略は単なるツールに過ぎません。将来的には、ワークフローと組み合わせることで、人気や急騰する仮想通貨を特定できるようになります。このツールを使うことで、より多くの驚きがもたらされるでしょう。

覚えておいてください

最大損失は100 USDTであり、リスクは管理可能です。
幸運にも大きなトレンドを捉えることができれば、投資額は数倍、あるいは数十倍に増える可能性があります。
しかし、多くの場合、小さな利益と損失、そして繰り返しのテストが必要になる場合があります。
これは忍耐と規律を必要とするゲームです。

利益を保証する戦略はありません。ポジションのロールオーバーは単なる手段です。真に成功と失敗を決定づけるのは、以下の能力です。

有望な暗号通貨を特定します (ワークフローフィルタリングを使用)。
損切り注文を厳守してください（頑固に持ち続けないでください）。
大きなトレンドが現れたときには、大胆にポジションをロールオーバーしてください（あまり早く終了しないでください）。
理性を保ちましょう（感情に支配されないでください）。

皆さんがクオンツ取引の旅で自分自身の「幸運」を見つけられますように！

完全なポリシーアドレス:**戦略ソースコード -> ** https://www.fmz.com/strategy/521864

完全な戦略コード:

”`js /*backtest start: 2025-01-20 00:00:00 end: 2025-01-21 00:00:00 period: 1m basePeriod: 1m exchanges: [{“eid”:“Futures_Binance”,“currency”:“TRUMP_USDT”,“balance”:5000}] */

// ============================================ // 滚仓策略 - EMA5/EMA10 简化版 // 使用 CreateOrder 统一下单 // 持续检测订单状态 // 止盈后根据EMA关系决定是否滚仓 // 新增:滚仓统计功能(三个两行表格) // 修复:方向记录、亏损记录、入场价格记录 // 优化:市价平仓循环重试直到成功 // 优化:滚仓统计表格新增开始/结束时间 // ============================================

// ========== 策略参数(可调整)========== var Symbol = “TRUMP_USDT.swap”; // 交易币种 var InitialCapital = 100; // 策略初始资金 100U var Leverage = 3; // 杠杆倍数 var RollProfitPercent = 0.10; // 滚仓盈利系数(10% = 0.10) var StopLossPercent = 0.05; // 止损系数(10% = 0.10)

// EMA参数 var FastEMA = 5; var SlowEMA = 10;

// 全局变量 var strategyCapital = InitialCapital; var entryPrice = 0; var lastRollPrice = 0; var rollCount = 0; var totalProfitRealized = 0; var currentDirection = “”; var takeProfitOrderId = null; // 止盈单ID var amountPrecision = 0; // 数量精度 var pricePrecision = 2; // 价格精度 var ctVal = 1; // 合约面值

// ========== 滚仓统计变量 ========== var currentRoundRolls = 0; // 本轮滚仓次数(连续滚仓) var currentRoundStartTime = 0; // 本轮开始时间 var currentRoundDirection = “”; // 本轮方向 var currentRoundTotalProfit = 0; // 本轮累计盈利(每次止盈累加) var currentRoundLoss = 0; // 本轮亏损(止损时记录) var currentRoundEntryPrice = 0; // 本轮入场价格 var rollHistory = []; // 滚仓历史记录 var maxHistoryRecords = 10; // 保留最近10次滚仓记录

function main() { Log(“=== EMA滚仓策略启动(CreateOrder模式 + 滚仓统计)===”); Log(“交易币种:”, Symbol); Log(“━━━━━━━━━━━━━━━━━━━━”);

// 获取市场信息
var markets = exchange.GetMarkets();
if (!markets || !markets[Symbol]) {
    Log("❌ 错误:无法获取", Symbol, "的市场信息");
    return;
}

var marketInfo = markets[Symbol];
amountPrecision = marketInfo.AmountPrecision;
pricePrecision = marketInfo.PricePrecision || 2;
ctVal = marketInfo.CtVal;

Log("市场信息:");
Log("  - 数量精度:", amountPrecision);
Log("  - 价格精度:", pricePrecision);
Log("  - 合约面值:", ctVal);

var account = _C(exchange.GetAccount);
Log("账户总资金:", account.Balance.toFixed(2), "U");
Log("策略使用资金:", InitialCapital, "U");
Log("杠杆倍数:", Leverage, "倍");
Log("滚仓系数:", (RollProfitPercent * 100), "%");
Log("止损系数:", (StopLossPercent * 100), "%");
Log("━━━━━━━━━━━━━━━━━━━━");

if (account.Balance < InitialCapital) {
    Log("❌ 错误:账户余额不足");
    return;
}

exchange.SetContractType("swap");
exchange.SetMarginLevel(Leverage);

var lastBarTime = 0;

while (true) {

    var records = _C(exchange.GetRecords, PERIOD_M1);

    if (records.length < SlowEMA + 5) {
        Sleep(3000);
        continue;
    }

    var currentBarTime = records[records.length - 1].Time;
    if (currentBarTime == lastBarTime) {
        Sleep(1000);
        continue;
    }
    lastBarTime = currentBarTime;

    var ticker = _C(exchange.GetTicker);
    var currentPrice = ticker.Last;
    var account = _C(exchange.GetAccount);
    var position = _C(exchange.GetPositions); 

    // 计算EMA
    var emaFast = TA.EMA(records, FastEMA);
    var emaSlow = TA.EMA(records, SlowEMA);

    if (emaFast.length < 3 || emaSlow.length < 3) {
        Sleep(3000);
        continue;
    }

    var ema5_current = emaFast[emaFast.length - 1];
    var ema5_prev = emaFast[emaFast.length - 2];
    var ema10_current = emaSlow[emaSlow.length - 1];
    var ema10_prev = emaSlow[emaSlow.length - 2];

    var isBullTrend = ema5_current > ema10_current;
    var isBearTrend = ema5_current < ema10_current;

    var bullCross = ema5_prev <= ema10_prev && ema5_current > ema10_current;
    var bearCross = ema5_prev >= ema10_prev && ema5_current < ema10_current;

    if(takeProfitOrderId){
        checkTakeProfitOrder();
    }

    // ========== 持仓逻辑 ==========
    if (position.length > 0) {
        var pos = position[0];
        currentDirection = pos.Type == PD_LONG ? "LONG" : "SHORT";

        if (entryPrice == 0) {
            entryPrice = pos.Price;
            lastRollPrice = pos.Price;
        }

        // 检查止损
        checkStopLoss(currentPrice, pos);

    } else {
        // ========== 空仓:等待信号 ==========
        if (bullCross) {
            Log("📈 金叉信号 - 做多");
            openPosition("LONG", currentPrice);
        } else if (bearCross) {
            Log("📉 死叉信号 - 做空");
            openPosition("SHORT", currentPrice);
        }
    }

    showStatus(account, position, currentPrice, ema5_current, ema10_current, isBullTrend, currentBarTime);

    Sleep(1000);
}

}

// 开仓(持续检测订单状态) function openPosition(direction, price) { Log(“🚀 开仓”, direction == “LONG” ? “做多” : “做空”); Log(“使用资金:”, strategyCapital.toFixed(2), “U”);

var positionValue = strategyCapital * Leverage;
var amount = _N(positionValue / price / ctVal, amountPrecision);

Log("计算数量:", amount, "| 持仓价值:", positionValue.toFixed(2), "U");

if (amount <= 0) {
    Log("❌ 数量无效");
    return false;
}

// 使用 CreateOrder 市价开仓
var orderId = exchange.CreateOrder(Symbol, direction == "LONG" ? "buy" : "sell", -1, amount);

if (!orderId) {
    Log("❌ 下单失败");
    return false;
}

Log("订单ID:", orderId, "开始持续检测...");

// 持续检测订单状态,直到成交或超时
var maxWaitTime = 30000;  // 最多等待30秒
var startTime = Date.now();
var checkCount = 0;

while (Date.now() - startTime < maxWaitTime) {
    Sleep(500);
    checkCount++;

    var order = exchange.GetOrder(orderId);
    if (!order) {
        Log("❌ 无法获取订单信息");
        continue;
    }

    if (order.Status == 1) {
        // 订单已成交
        var avgPrice = order.AvgPrice;
        entryPrice = avgPrice;
        lastRollPrice = avgPrice;
        currentDirection = direction;

        // ========== 修改:无论是否第一次,都要初始化/更新统计数据 ==========
        if (currentRoundRolls == 0) {
            // 第一次开仓:初始化所有统计数据
            currentRoundStartTime = Date.now();
            currentRoundDirection = direction;
            currentRoundTotalProfit = 0;
            currentRoundLoss = 0;
            currentRoundEntryPrice = avgPrice;
            Log("🆕 开始新一轮交易统计");
            Log("  - 开始时间:", _D(currentRoundStartTime));
            Log("  - 方向:", direction == "LONG" ? "🟢 多头" : "🔴 空头");
            Log("  - 入场价格:", avgPrice.toFixed(pricePrecision));
        } else {
            // 滚仓时:更新方向(理论上应该相同,但为了健壮性还是更新)
            currentRoundDirection = direction;
            Log("🔄 滚仓操作 (第", currentRoundRolls, "次)");
            Log("  - 方向:", direction == "LONG" ? "🟢 多头" : "🔴 空头");
            Log("  - 入场价格:", avgPrice.toFixed(pricePrecision));
        }

        Log("✅ 开仓成功!");
        Log("  - 成交均价:", avgPrice.toFixed(pricePrecision));
        Log("  - 成交数量:", order.DealAmount);
        Log("  - 成交金额:", (order.DealAmount * avgPrice * ctVal).toFixed(2), "U");

        // 挂止盈单
        Sleep(1000);
        placeTakeProfitOrder(direction, avgPrice, order.DealAmount);

        return true;
    } else if (order.Status == 2) {
        // 订单已取消
        Log("❌ 订单已取消");
        return false;
    }
    // Status == 0 表示未成交,继续等待
}

// 超时未成交
Log("⚠️ 订单超时,尝试取消订单");
exchange.CancelOrder(orderId);
return false;

}

// 挂止盈单 function placeTakeProfitOrder(direction, entryPrice, amount) { var takeProfitPrice = 0;

if (direction == "LONG") {
    takeProfitPrice = _N(entryPrice * 1.1, pricePrecision);  // 多头止盈:+10%
} else {
    takeProfitPrice = _N(entryPrice * 0.9, pricePrecision);  // 空头止盈:-10%
}

Log("📌 挂止盈单");
Log("  - 入场价格:", entryPrice.toFixed(pricePrecision));
Log("  - 止盈价格:", takeProfitPrice);
Log("  - 数量:", amount);

// 使用 CreateOrder 挂限价止盈单
if (direction == "LONG") {
    takeProfitOrderId = exchange.CreateOrder(Symbol, "closebuy", takeProfitPrice, amount);
} else {
    takeProfitOrderId = exchange.CreateOrder(Symbol, "closesell", takeProfitPrice, amount);
}

if (takeProfitOrderId) {
    Log("✅ 止盈单已挂,订单ID:", takeProfitOrderId);
} else {
    Log("❌ 止盈单挂单失败");
}

}

// 检查止盈单状态 function checkTakeProfitOrder() {

if (!takeProfitOrderId) {
    return;
}

var order = exchange.GetOrder(takeProfitOrderId);
if (!order) {
    return;
}

if (order.Status == 1) {
    // 止盈单成交
    Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Log("💰 止盈单成交!");
    Log("  - 成交价格:", order.AvgPrice.toFixed(pricePrecision));
    Log("  - 成交数量:", order.DealAmount);

    // 使用订单数据精确计算盈利
    var profit = 0;
    if (currentDirection == "LONG") {
        // 多头盈利 = (止盈价 - 入场价) * 数量 * 合约面值
        profit = (order.AvgPrice - entryPrice) * order.DealAmount * ctVal;
    } else {
        // 空头盈利 = (入场价 - 止盈价) * 数量 * 合约面值
        profit = (entryPrice - order.AvgPrice) * order.DealAmount * ctVal;
    }

    // 计算盈利率
    var profitRate = profit / strategyCapital;

    Log("📊 盈利统计:");
    Log("  - 入场价格:", entryPrice.toFixed(pricePrecision));
    Log("  - 止盈价格:", order.AvgPrice.toFixed(pricePrecision));
    Log("  - 本次盈利:", profit.toFixed(2), "U");
    Log("  - 盈利率:", (profitRate * 100).toFixed(2), "%");
    Log("  - 策略资金(盈利前):", strategyCapital.toFixed(2), "U");

    // 更新资金
    strategyCapital += profit;
    totalProfitRealized += profit;
    rollCount++;

    Log("  - 策略资金(盈利后):", strategyCapital.toFixed(2), "U");
    Log("  - 累计盈利:", totalProfitRealized.toFixed(2), "U");
    Log("  - 滚仓次数:", rollCount, "次");

    // ========== 累加本轮盈利 ==========
    currentRoundTotalProfit += profit;
    Log("  - 本轮累计盈利:", currentRoundTotalProfit.toFixed(2), "U");

    // 重置止盈单ID
    takeProfitOrderId = null;

    // 获取最新K线计算EMA
    Sleep(1000);
    var records = _C(exchange.GetRecords, PERIOD_M1);
    var emaFast = TA.EMA(records, FastEMA);
    var emaSlow = TA.EMA(records, SlowEMA);

    if (emaFast.length < 2 || emaSlow.length < 2) {
        Log("⚠️ EMA数据不足,无法判断是否滚仓");

        // 记录本轮滚仓结束(正常结束,之前有盈利)
        saveRollRecord(false);

        resetPositionState();
        Log("⏳ 等待新信号...");
        Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        return;
    }

    var ema5_current = emaFast[emaFast.length - 1];
    var ema10_current = emaSlow[emaSlow.length - 1];

    Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Log("📈 EMA滚仓判断:");
    Log("  - EMA5:", ema5_current.toFixed(pricePrecision));
    Log("  - EMA10:", ema10_current.toFixed(pricePrecision));
    Log("  - 原持仓方向:", currentDirection);

    var shouldRoll = false;

    if (currentDirection == "LONG") {
        // 多头止盈后,如果EMA5仍在EMA10上方,继续做多(滚仓)
        if (ema5_current > ema10_current) {
            shouldRoll = true;
            Log("  - 判断结果: ✅ EMA5 > EMA10,趋势延续");
            Log("  - 决策: 🔄 继续做多(滚仓)");
        } else {
            Log("  - 判断结果: ❌ EMA5 <= EMA10,趋势转弱");
            Log("  - 决策: ⏸️ 不滚仓,等待新信号");
        }
    } else if (currentDirection == "SHORT") {
        // 空头止盈后,如果EMA5仍在EMA10下方,继续做空(滚仓)
        if (ema5_current < ema10_current) {
            shouldRoll = true;
            Log("  - 判断结果: ✅ EMA5 < EMA10,趋势延续");
            Log("  - 决策: 🔄 继续做空(滚仓)");
        } else {
            Log("  - 判断结果: ❌ EMA5 >= EMA10,趋势转弱");
            Log("  - 决策: ⏸️ 不滚仓,等待新信号");
        }
    }

    Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    if (shouldRoll) {
        // ========== 滚仓:增加本轮滚仓次数 ==========
        currentRoundRolls++;
        Log("🔄 执行滚仓操作... (本轮第", currentRoundRolls, "次滚仓)");
        Sleep(1000);

        var ticker = _C(exchange.GetTicker);
        var newPrice = ticker.Last;

        if (openPosition(currentDirection, newPrice)) {
            Log("✅ 滚仓成功!");
        } else {
            Log("❌ 滚仓失败,等待新信号");
            // 记录本轮滚仓结束(滚仓失败,但之前有盈利)
            saveRollRecord(false);
            resetPositionState();
        }
    } else {
        // ========== 不滚仓:记录本轮滚仓结束 ==========
        saveRollRecord(false);
        resetPositionState();
        Log("⏳ 已平仓,等待新信号...");
    }

    Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
}

}

// ========== 保存滚仓记录 ========== function saveRollRecord(isStopLoss) { // 必须有开始时间才记录(防止异常情况) if (currentRoundStartTime == 0) { Log(“⚠️ 本轮未正确初始化,跳过记录”); currentRoundRolls = 0; currentRoundTotalProfit = 0; currentRoundLoss = 0; currentRoundDirection = “”; currentRoundEntryPrice = 0; return; }

var endTime = Date.now();
var duration = endTime - currentRoundStartTime;

// 计算总体盈利 = 累计盈利 - 亏损
var netProfit = currentRoundTotalProfit - currentRoundLoss;

var record = {
    direction: currentRoundDirection,      // 本轮方向
    roundRolls: currentRoundRolls,        // 本轮滚仓次数
    totalProfit: currentRoundTotalProfit, // 累计盈利(止盈累加)
    loss: currentRoundLoss,               // 亏损金额(止损)
    netProfit: netProfit,                 // 总体盈利
    duration: duration,                   // 持续时间(毫秒)
    isStopLoss: isStopLoss,              // 是否止损结束
    startTime: currentRoundStartTime,     // 开始时间
    endTime: endTime,                     // 结束时间
    entryPrice: currentRoundEntryPrice    // 入场价格
};

rollHistory.push(record);

// 只保留最近N条记录
if (rollHistory.length > maxHistoryRecords) {
    rollHistory.shift();
}

Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
Log("📝 保存滚仓记录:");
Log("  - 方向:", currentRoundDirection == "LONG" ? "🟢 多头" : "🔴 空头");
Log("  - 入场价格:", currentRoundEntryPrice.toFixed(pricePrecision));
Log("  - 开始时间:", _D(currentRoundStartTime));
Log("  - 结束时间:", _D(endTime));
Log("  - 持续时间:", formatDuration(duration));
Log("  - 本轮滚仓次数:", currentRoundRolls);
Log("  - 累计盈利:", currentRoundTotalProfit.toFixed(2), "U");
Log("  - 亏损金额:", currentRoundLoss.toFixed(2), "U");
Log("  - 总体盈利:", netProfit.toFixed(2), "U");
Log("  - 结束方式:", isStopLoss ? "❌ 止损" : "✅ 正常");
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

// 重置本轮统计数据
currentRoundRolls = 0;
currentRoundStartTime = 0;
currentRoundDirection = "";
currentRoundTotalProfit = 0;
currentRoundLoss = 0;
currentRoundEntryPrice = 0;

}

// 格式化时长 function formatDuration(ms) { var seconds = Math.floor(ms / 1000); var minutes = Math.floor(seconds / 60); var hours = Math.floor(minutes / 60); var days = Math.floor(hours / 24);

if (days > 0) {
    return days + "天" + (hours % 24) + "时" + (minutes % 60) + "分";
} else if (hours > 0) {
    return hours + "时" + (minutes % 60) + "分";
} else if (minutes > 0) {
    return minutes + "分" + (seconds % 60) + "秒";
} else {
    return seconds + "秒";
}

}

// 重置持仓状态函数 function resetPositionState() { entryPrice = 0; lastRollPrice = 0; currentDirection = “”; // 注意:不重置 rollCount、strategyCapital 和 currentRoundRolls }

// 检查止损 function checkStopLoss(currentPrice, position) { var totalDrawdown = 0;

if (currentDirection == "LONG") {
    totalDrawdown = (currentPrice - entryPrice) / entryPrice;
} else {
    totalDrawdown = (entryPrice - currentPrice) / entryPrice;
}

if (totalDrawdown < -StopLossPercent) {
    Log("❌ 触发止损!回撤:", (totalDrawdown * 100).toFixed(2), "%");

    // 取消止盈单
    if (takeProfitOrderId) {
        Log("取消止盈单:", takeProfitOrderId);
        exchange.CancelOrder(takeProfitOrderId);
        takeProfitOrderId = null;
        Sleep(500);
    }

    // ========== 市价平仓(循环重试直到成功) ==========
    var profit = closePositionMarketWithRetry(currentPrice, position);

    // 更新策略资金池
    strategyCapital += profit;
    totalProfitRealized += profit;

    Log("止损亏损:", profit.toFixed(2), "U");
    Log("策略剩余资金:", strategyCapital.toFixed(2), "U");
    Log("累计盈利:", totalProfitRealized.toFixed(2), "U");

    // ========== 记录本轮止损亏损 ==========
    currentRoundLoss = Math.abs(profit);  // 转为正数保存
    Log("本轮止损亏损:", currentRoundLoss.toFixed(2), "U");

    // ========== 记录本轮滚仓结束(被止损中断) ==========
    saveRollRecord(true);

    // 重置状态
    resetPositionState();

    if (strategyCapital < 10) {
        Log("💥 策略资金不足10U,停止运行");
        throw "资金不足";
    }

    Log("⏳ 已止损,等待新信号...");
}

}

// ========== 市价平仓(带重试机制,直到成功) ========== function closePositionMarketWithRetry(currentPrice, position) { Log(“🔴 市价平仓(循环重试模式)”);

var maxRetries = 10;  // 最多重试10次
var retryCount = 0;

while (retryCount < maxRetries) {
    retryCount++;
    Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Log("🔄 第", retryCount, "次平仓尝试");

    var profit = closePositionMarket(currentPrice, position);

    // 如果返回值不为0,说明平仓成功
    if (profit !== 0) {
        Log("✅ 平仓成功!");
        Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        return profit;
    }

    // 平仓失败,检查持仓是否还存在
    Sleep(2

Forums

PINE Language FAQ Summary MyLanguage Web3 About Us

Product

Robot Strategy Node Platforms Tickets

API

Syntax guide User guide Trading api Blockchain Indicator