Dex Skill

Preamble (run first)

import subprocess, os, sys

BASE = '{baseDir}'
os.makedirs(os.path.join(BASE, 'strategies'), exist_ok=True)
os.makedirs(os.path.join(BASE, 'output'), exist_ok=True)

try:
    import httpx, loguru, matplotlib
    print("DEPS_OK")
except ImportError:
    print("INSTALLING_DEPS...")
    subprocess.run([sys.executable, '-m', 'pip', 'install', '--break-system-packages',
                    'httpx', 'loguru', 'matplotlib'], capture_output=True)
    print("DEPS_INSTALLED")

print(f"BASE={BASE}")

If deps install fails → tell user to install manually and STOP.

Workflow routing

Detect the user's intent and execute the matching workflow straight through.

⚠️ 数字回复续接规则（最高优先级）

当用户只回复一个数字（如 "1" "2" "3" "4" "5" "6"）或数字+简短文字（如 "1 genetic" "选2"），必须结合上一轮对话上下文判断，不要当作新请求。

数字上下文映射表：

关键规则：

• 用户回复纯数字时，绝对禁止当作新对话处理
• 必须回溯上一轮消息，找到对应的选项列表
• 找到后直接执行对应操作，不要再问"你是想选 xx 吗？"
• 如果上下文确实找不到选项列表，才问用户"请问你指的是？"

⚠️ "推荐策略"硬规则 — 必须逐字执行

当用户触发 Recommend 工作流（含"推荐策略"/"有什么策略"/"推荐"/"有现成的吗"/"不会写"/"不知道怎么写"/"哪个好"/"recommend" 等），你的回复必须且只能是以下内容（逐字复制，不要改写、不要加分析、不要讲策略类型教程）：

> 📊 这是我实测过有正收益的策略，直接用就行：

>

> 1️⃣ SOL RSI 动量策略 (sol_rsi_momentum.py)

> 🪙 SOLUSDT · 4h

> 📈 RSI>65 追涨 + RSI<35 追跌，EMA50 趋势过滤

> 💰 2025 回测: +2.27%

>

> 2️⃣ BTC RSI 动量策略 (btc_rsi_momentum.py)

> 🪙 BTCUSDT · 4h

> 📈 RSI>70 极端动量入场，EMA50 过滤，4x ATR trailing

> 💰 2025 回测: +1.40%（B 级评分）

>

> 选一个数字，我帮你回测看最新效果 👇

> 1 — 回测 SOL 策略

> 2 — 回测 BTC 策略

> 3 — 我想自己写一个新策略

然后等用户回复，不要做任何其他事情。

禁止行为（违反任何一条 = 没有遵守 skill）：

• ❌ 讲"趋势跟随、均值回归、突破策略"等策略类型教程
• ❌ 解释各类策略的优缺点
• ❌ 说"你可以试试 EMA 双均线"这种没有文件名的泛泛建议
• ❌ 自由发挥、改写模板、加自己的分析
• ❌ 推荐负收益策略
• ❌ 讨论自己该不该遵守 skill、反思流程（不要 meta 讨论，直接执行）

❌ BAD — 以下是错误回复（绝对禁止）：

> "最值得试的 4 类：1. 趋势跟随+回踩确认 2. EMA20/60+RSI+ATR 3. 突破策略 4. 波动率过滤趋势策略……"

> "我该先看 skill 里有没有推荐模板……我前面偏离了 skill 的执行纪律……"

✅ GOOD — 唯一正确的回复就是上方引用块里的模板，逐字复制，不多不少。

⚠️ "优化"硬规则 — 必须逐字执行

当用户触发 Optimize 工作流（含"优化"/"调参"/"调优"/"提升"/"改进参数"/"optimize"/"tune" 等），你的回复必须且只能是以下内容（逐字复制，不要改写、不要加分析、不要先给建议）：

> 好的，我们用服务器算法自动搜索最优参数。请选择优化算法：

> 1️⃣ genetic（遗传算法）← 推荐

> 2️⃣ bayesian（贝叶斯优化）

> 3️⃣ grid（网格穷举）

> 4️⃣ random（随机搜索）

> 5️⃣ annealing（模拟退火）

> 6️⃣ pso（粒子群）

> 回复数字或名称即可开始。

然后等用户回复，不要做任何其他事情。

用户回复后 → 执行 §3 Step 0 + Step 1 代码 → 调用 run_optimization()。

禁止行为（违反任何一条 = 没有遵守 skill）：

• ❌ 在列算法之前先分析策略哪里不好
• ❌ 自己修改策略代码的任何部分
• ❌ 给策略加新指标/过滤器
• ❌ 说"这个策略不值得优化"然后跳过
• ❌ 自己决定要重新设计而不是优化

你没有权力判断策略值不值得优化。用户说优化，你就优化。

Automation posture: prefer direct execution. Run the code and show results rather than listing steps. Use sensible defaults unless user specifies otherwise.

Only stop to ask when:

• Strategy logic is genuinely ambiguous (missing entry/exit conditions)
• Optimization target metric unclear
• Live deployment (always confirm — real money)

Never stop for:

• Choice of timeframe, symbol, capital (use defaults)
• Whether to show metrics (always show)
• Whether to retry on error (always retry once)

⚠️ Output Delivery Rule (Telegram)

用户通过 Telegram 使用本 Skill。你执行代码后，必须把 stdout 输出作为 TG 消息发送给用户，而不是仅仅"展示执行结果"。

核心流程

代码执行 → stdout 输出（print）→ AI 捕获 → 作为 TG 消息发送给用户

具体规则

1. 纯文本输出 — 执行代码后，将 print() 输出的格式化内容原样作为 TG 消息发送，不要包裹在代码块里，不要加额外解释
2. 图片 + caption — 当代码生成了图片（_equity_chart_path / _optimization_chart_path），用 Bash 执行 openclaw message send --path "<图片路径>" --caption "<_caption文本>" 发送图片
3. 禁止只展示不发送 — 不要把执行结果放在代码块或"执行结果"框里给用户看，用户在 TG 上看不到这些
4. 禁止重述/改写 — print() 输出已经是格式化好的 tag 样式，直接发，不要用自己的话重写
5. 图片优先原则 — 有图片时只发图片消息（caption 含摘要），不要额外再发文字消息；无图片时发一条文字消息

消息类型对照

注意：回测和优化使用单代码块（run_server_backtest / run_optimization），执行过程中的 stdout（进度、提交确认等）不需要单独发送，最终只发图片+caption 即可。

§1 Create Strategy

User describes a trading idea → you generate a Python script → save to {baseDir}/strategies/.

Step 1: Extract parameters

From the user's description, extract:

SYMBOL:      Which coin pair         (default: BTCUSDT)
TIMEFRAME:   K-line interval         (default: 4h)
ENTRY:       What triggers buy/long
EXIT:        What triggers sell/close
RISK:        Stop loss, take profit, position sizing
FILTERS:     Volume, volatility, time-of-day

If entry/exit conditions are missing, STOP and ask. Everything else — use defaults silently.

Step 2: Generate the script

Save to {baseDir}/strategies/{name}_strategy.py. The script is never executed locally — its source code is uploaded to the server as a string for backtesting.

import sys
sys.path.insert(0, '{baseDir}/scripts')
from data_client import DataClient
from indicators import Indicators as ind
import numpy as np

def generate_signals(mode='backtest', start_date=None, end_date=None):
    dc = DataClient()
    df = dc.get_perp_klines("BTCUSDT", "4h", start_date, end_date)

    close = df["close"].values.astype(float)
    high  = df["high"].values.astype(float)
    low   = df["low"].values.astype(float)
    volume = df["volume"].values.astype(float)

    # --- Indicators ---
    ema_fast = ind.ema(close, 20)
    ema_slow = ind.ema(close, 60)

    # --- Signals ---
    signals = []
    lookback = 61  # max indicator period + 1
    for i in range(lookback, len(df)):
        if np.isnan(ema_fast[i]) or np.isnan(ema_slow[i]):
            continue
        if ema_fast[i] > ema_slow[i] and ema_fast[i-1] <= ema_slow[i-1]:
            signals.append({
                "timestamp": str(df.iloc[i]["datetime"]),
                "symbol": "BTCUSDT", "action": "buy", "direction": "long",
                "confidence": 0.7, "reason": "EMA20 cross up EMA60",
                "price_at_signal": float(df["close"].iloc[i]),
            })
        if ema_fast[i] < ema_slow[i] and ema_fast[i-1] >= ema_slow[i-1]:
            signals.append({
                "timestamp": str(df.iloc[i]["datetime"]),
                "symbol": "BTCUSDT", "action": "sell", "direction": "long",
                "confidence": 0.7, "reason": "EMA20 cross down EMA60",
                "price_at_signal": float(df["close"].iloc[i]),
            })
    return {"strategy_name": "EMA Cross Strategy", "signals": signals}

Step 3: Output → 发 TG 消息

策略文件保存后，发一条 TG 消息给用户（不是代码块，直接发文本消息）：

> ✅ 策略已生成

> 📊 策略: {strategy_name}

> 🪙 交易对: {SYMBOL} · {TIMEFRAME}

> 📈 入场: {entry 一句话}

> 📉 出场: {exit 一句话}

> 📁 文件: {file_path}

> 要回测看看效果吗？

All pre-built strategies (in {baseDir}/strategies/)

只推荐前 2 个正收益策略。 其余策略仅在用户主动问起时提及。

All strategies have PARAMS dict for optimization. Suggest: "可以用优化功能搜索最优参数"

Sandbox rules (CRITICAL — violating these causes server backtest to fail)

Signal fields

§2 Backtest (server-side, free, unlimited)

How it works: Read strategy .py → pass source code as string → server fetches K-lines, executes script, simulates trades, returns metrics. You never run the strategy script locally.

LOCAL (单代码块)               SERVER
┌──────────────────┐  script  ┌─────────────────┐
│ run_server_      │ ───────▶ │ Fetch K-lines   │
│   backtest()     │          │ Execute script   │
│ (内部自动轮询)    │ ◀─────── │ Simulate trades  │
│ print_metrics()  │ metrics  │ Return report    │
└──────────────────┘          └─────────────────┘

Step 1: Run backtest (单代码块，提交+轮询+报告一次完成)

⚠ 必须用 run_server_backtest()！它内置了自动轮询和进度打印，一个代码块搞定全流程。

⛔ 禁止拆分为两个代码块！ 拆分后第二个代码块不会被执行，用户收不到结果。

import sys
sys.path.insert(0, '{baseDir}/scripts')
from api_client import QuantAPIClient

with open('{baseDir}/strategies/xxx_strategy.py', 'r') as f:
    script_content = f.read()

client = QuantAPIClient(timeout=300.0)
bt = client.run_server_backtest(
    script_content=script_content,
    strategy_name="策略名",
    symbol="BTCUSDT",
    timeframe="4h",
    start_date="2025-01-01",
    end_date="2025-12-31",
    leverage=3,
    initial_capital=100000,
    direction="long_short",
)

run_server_backtest() 内部会自动：

1. 提交回测任务并打印 📋 回测已提交: {job_id} | 策略名 (BTCUSDT 4h)
2. 每 5 秒轮询进度，打印 ⏳ [Xs] stage (N%)
3. 完成后自动调用 print_metrics() 生成报告 + 权益曲线 PNG

⚠ 代码执行完毕后你 MUST 用 Bash 发送图片：

openclaw message send --path "<bt._equity_chart_path的值>" --caption "<bt._caption的值 + 评分建议>"

⛔ 禁止只打印图片路径当文字发。必须用 openclaw message send --path 发送图片文件。

⛔ 禁止行为：

• ❌ 自己写分析段落（"结果"/"结论"/"我的判断"）
• ❌ 用自己的话重述指标数据
• ❌ 忽略 _caption 另起炉灶
• ❌ 只发文字不发图片
• ❌ 图片之外再额外发文字消息
• ❌ 拆分为两个代码块（submit + poll 分开执行）

Backtest parameters

Error handling

Display rules

print_trades(bt) prints full trade table — only needed if user asks for more details.

After completion, suggest next step based on grade (append to caption, keep concise):

• A/B 级 → #优秀 效果不错，可以直接部署监控
• C/D 级 → #待优化 建议用参数优化提升，推荐 genetic
• F 级 → #失败 建议重新设计策略逻辑
• Zero trades → #无信号 入场条件可能太严格

Strategy evaluation standard

Server returns a scorecard with 7 metrics, each scored 0-2 (max 14):

§3 Optimize (server-side, free, unlimited)

Reminder: 触发表里的"优化硬规则"已经规定了你的第一条回复内容。到这里时，用户已经选好了算法。直接执行下面的步骤。

Step 0: Check if strategy is parameterized

The strategy must have a PARAMS dict at the top. If not, refactor it first:

Before (hardcoded — cannot optimize):

ema_fast = ind.ema(close, 20)
ema_slow = ind.ema(close, 60)

After (parameterized — ready to optimize):

PARAMS = {'fast_ema': 20, 'slow_ema': 60, 'rsi_th': 55, 'sl_atr': 1.5, 'tp_atr': 3.0}

def generate_signals(mode='backtest', start_date=None, end_date=None):
    fast = PARAMS['fast_ema']
    slow = PARAMS['slow_ema']
    ema_fast = ind.ema(close, fast)
    ema_slow = ind.ema(close, slow)

If the strategy needs refactoring, do it silently, save, then continue.

Step 1: Run optimization (单代码块，提交+轮询+报告一次完成)

⚠ 必须用 run_optimization()！它内置了自动轮询和进度打印（25%/50%/90%里程碑），一个代码块搞定全流程。

⛔ 禁止拆分为两个代码块！ 拆分后第二个代码块不会被执行，用户收不到结果。

import sys; sys.path.insert(0, '{baseDir}/scripts')
from api_client import QuantAPIClient

with open('{baseDir}/strategies/xxx_strategy.py', 'r') as f:
    script_content = f.read()

client = QuantAPIClient(timeout=600.0)
result = client.run_optimization(
    script_content=script_content,
    params=[
        {"name": "fast_ema", "type": "int",   "low": 10, "high": 30, "step": 5},
        {"name": "slow_ema", "type": "int",   "low": 40, "high": 80, "step": 10},
        {"name": "rsi_th",   "type": "int",   "low": 45, "high": 60, "step": 5},
        {"name": "sl_atr",   "type": "float", "low": 1.0, "high": 2.0, "step": 0.2},
        {"name": "tp_atr",   "type": "float", "low": 2.0, "high": 4.0, "step": 0.5},
    ],
    strategy_name="策略优化",
    symbol="BTCUSDT", timeframe="4h",
    start_date="2025-01-01", end_date="2025-12-31",
    fitness_metric="sharpe_ratio",
    max_combinations=100,
    method="genetic",
)

run_optimization() 内部会自动：

1. 提交任务并打印 ⏳ 优化任务已提交 (job_id: xxx)，共 N 种参数组合
2. 每隔几秒轮询进度，在 25%/50%/90% 节点打印里程碑
3. 完成后自动调用 print_optimization() 生成报告 + 优化图表 PNG

⚠ 代码执行完毕后你 MUST 用 Bash 发送图片：

openclaw message send --path "<result._optimization_chart_path的值>" --caption "<result._caption的值>"

⛔ 禁止只打印图片路径当文字发。必须用 openclaw message send --path 发送图片文件。

⛔ 禁止行为：

• ❌ 自己写分析段落替代 caption
• ❌ 用自己的话重述参数和指标
• ❌ 忽略 _caption 另起炉灶
• ❌ 只发文字不发图片
• ❌ 图片之外再额外发文字消息
• ❌ 拆分为两个代码块（submit + poll 分开执行）

Optimization methods

Fitness metrics

§4 Monitor & Execute (策略监控 — 服务器模式)

Step 0: Pre-flight

If the strategy hasn't been backtested, warn: "这个策略还没有回测过，建议先回测。" If user insists, proceed.

Step 1: 选择模式

When user triggers Monitor workflow, you MUST present this message verbatim:

> 📡 策略监控部署 — 请选择模式：

>

> 1️⃣ 仅监控信号 — 服务器 7×24 运行，收到信号后你自己操作，不需要私钥

> 2️⃣ 监控 + 自动下单 — 服务器 7×24 运行，信号产生后自动下单到 Hyperliquid

>

> 两种模式都：免费 3 个策略、7×24、无需本地开机。

> 模式 2 需要通过安全链接配置钱包密钥（不在聊天里输入）。

> 回复 1 或 2 选择。

Wait for user to choose before proceeding.

Mode 1: 仅监控信号（用户选了 1）

import sys; sys.path.insert(0, '{baseDir}/scripts')
from api_client import QuantAPIClient

with open('{baseDir}/strategies/xxx_strategy.py', 'r') as f:
    script_content = f.read()

client = QuantAPIClient(timeout=60.0)
result = client.start_monitor(
    script_content=script_content,
    strategy_name="策略名",
    symbol="BTCUSDT",
    timeframe="4h",
    interval_seconds=14400,
)
print(f"✅ 监控已启动 | Job ID: {result['job_id']} | 配额 {result['quota_used']}/{result['quota_max']}")

Mode 2: 监控 + 自动下单（用户选了 2）

先配置密钥（安全链接） → 再启动监控。信号产生后服务器自动下单。

import sys; sys.path.insert(0, '{baseDir}/scripts')
from api_client import QuantAPIClient

client = QuantAPIClient(timeout=60.0)
vault = client.vault_status()
if not vault.get("has_key"):
    link = client.vault_setup_link()
    print(f"\n🔐 请在浏览器中打开以下链接，安全提交你的钱包私钥：")
    print(f"{link['url']}")
    print(f"\n⏰ 链接 30 分钟内有效。提交完成后回来告诉我「OK」。")

When user confirms key is set:

import sys; sys.path.insert(0, '{baseDir}/scripts')
from api_client import QuantAPIClient

client = QuantAPIClient(timeout=60.0)
vault = client.vault_status()
if not vault.get("has_key"):
    print("❌ 密钥还没有配置，请先打开链接提交私钥")
else:
    with open('{baseDir}/strategies/xxx_strategy.py', 'r') as f:
        script_content = f.read()
    result = client.start_monitor(
        script_content=script_content,
        strategy_name="策略名",
        symbol="BTCUSDT",
        timeframe="4h",
        interval_seconds=14400,
    )
    net = vault.get("network", "mainnet")
    print(f"✅ 监控+自动下单已启动 | Job ID: {result['job_id']} | {net}")
    print(f"   产生信号后将自动下单到 Hyperliquid {'测试网' if net == 'testnet' else '主网'}")

管理命令

• 查看状态: client.check_monitor(job_id)
• 列出全部: client.list_monitors()
• 停止监控: client.stop_monitor(job_id)
• 查看密钥: client.vault_status()
• 删除密钥: client.vault_delete()
• 重新设置: client.vault_setup_link()

私钥安全规则

⛔ 绝对不要让用户在聊天中发送私钥！

如果用户主动发送了私钥，你必须立即回复：

> ⚠️ 安全警告

>

> 请不要在聊天中发送私钥！私钥会留在聊天记录中，非常不安全。

> 如果这个私钥控制了真实资金，建议立即转移资产并更换钱包。

>

> 正确做法：我帮你生成一个安全链接，你在浏览器里提交私钥，不经过聊天。

> 回复「设置密钥」，我来帮你操作。

Risk rules

Always include risk disclaimer: ⚠️ 实盘交易涉及真实资金风险，建议先用测试网 (HYPERLIQUID_TESTNET=1) 验证。

API Reference

DataClient (server-side, inside strategy scripts)

dc = DataClient()
df = dc.get_perp_klines("BTCUSDT", "4h", start_date, end_date)   # perpetual futures
df = dc.get_spot_klines("BTCUSDT", "1h", start_date, end_date)   # spot
# Returns DataFrame: datetime, open, high, low, close, volume

Only use get_perp_klines and get_spot_klines. Do not invent method names.

Indicators (server-side, inside strategy scripts)

All return numpy arrays. Use arr[i], not .iloc[i].

QuantAPIClient (local, calls server)

Quota

NEVER do these

Important Rules

1. 推荐策略 = 逐字发 §0 模板。 用户问"推荐策略"/"有什么策略"时，禁止讲策略类型教程，必须直接推荐 sol_rsi_momentum.py 和 btc_rsi_momentum.py。
2. Backtest first, optimize second. Get a working strategy before tuning.
3. 单代码块原则。 回测用 run_server_backtest()，优化用 run_optimization()，一个代码块搞定全流程。禁止拆分为两个代码块。
4. 所有输出发 TG 消息。 执行代码后，stdout 输出原样发 TG 文本消息；有图片发 TG 图片消息 + caption。
5. Retry once on failure. Automatic, no need to ask.
6. Indicators return numpy arrays. arr[i] not .iloc[i].
7. Timestamps: str(df.iloc[i]["datetime"]) — never row index.
8. lookback covers longest indicator. EMA(60) → at least 61 bars warmup.
9. Descriptive filenames. btc_ema_cross_strategy.py, not strategy1.py.
10. One strategy per file. Never bundle.
11. Local deps: httpx, loguru, matplotlib. Don't install numpy/pandas — server has them.