Strategy Ranking Sniper

SOL Ranking Sniper v1.0.0

欢迎使用 SOL 涨幅榜狙击策略！

我们实时监控 OKX DEX 涨幅榜，当新币进入榜单时自动触发买入，跌出榜单时自动卖出。策略内置 25 项安全检查（流动性、持仓集中度、Dev 钱包等）+ 动量评分（0-125分），只交易评分达标的高质量标的，6 层退出机制全程保护仓位。

投资案例：

小陈用 2 SOL 启动涨幅榜狙击。某天上午一个新币 $BONK2 冲进涨幅榜前 10，动量评分 98 分，安全检查全过。

机器人以均价 $0.0012 自动买入，持仓期间 $BONK2 继续拉升 40%。

跌出榜单触发排名退出，以 $0.00165 自动卖出，单笔盈利约 $82（+37.5%）。

同日另一个币安全检查未通过（Dev 钱包集中度过高），自动跳过，规避了一次归零风险。

Automated Solana token sniper that monitors the OKX DEX trending ranking, applies a 3-layer safety filter with momentum scoring, and executes trades with a 6-layer exit system. Available as standalone strategy-ranking-sniper binary.

Pre-flight Checks

Run immediately when this skill is triggered — before any response or command. Always follow these steps in order. Do not echo routine command output to the user; only provide a brief status update when installing, updating, or handling a failure.

Step 1: Check onchainos

which onchainos

• Found → run onchainos --version to confirm, then proceed to Step 2.
• Not found → install automatically:

  curl -sSL https://raw.githubusercontent.com/okx/onchainos-skills/main/install.sh | sh

• If install succeeds → verify with onchainos --version, then proceed to Step 2.
• If install fails → notify the user to install manually:

    自动安装失败，请手动安装 onchainos：
    https://github.com/okx/onchainos-skills

Stop here until user confirms onchainos is available.

Step 2: Check skills-store

which skills-store

• Not found → install:

  curl -sSL https://raw.githubusercontent.com/purong-huang-1121/skills-store/main/install.sh | sh

• Check for updates: Read ~/.cargo/bin/.skills-store/last_check_ranking_sniper and compare with current timestamp:

  cached_ts=$(cat ~/.cargo/bin/.skills-store/last_check_ranking_sniper 2>/dev/null || true)
  now=$(date +%s)

• If cached_ts is non-empty and (now - cached_ts) < 43200 (12 hours), skip the update.
• Otherwise, run the installer to check for updates.

Step 3: Check strategy-ranking-sniper

which strategy-ranking-sniper

• Found → proceed.
• Not found → install:

  curl -sSL https://raw.githubusercontent.com/purong-huang-1121/skills-store/main/install_strategy.sh | sh -s -- strategy-ranking-sniper

• If install succeeds → verify with strategy-ranking-sniper --version, then proceed.
• If install fails → notify the user:

    自动安装失败，请手动安装 strategy-ranking-sniper：
    curl -sSL https://raw.githubusercontent.com/purong-huang-1121/skills-store/main/install_strategy.sh | sh -s -- strategy-ranking-sniper

Stop here until user confirms installation.

Skill Routing

• For manual token lookup / analytics -> use okx-dex-token
• For DEX swap -> use okx-dex-swap
• For token prices / charts -> use okx-dex-market
• For wallet balances -> use okx-wallet-portfolio
• For grid trading -> use strategy-grid-trade
• For DeFi yield -> use strategy-defi-yield
• For memepump scanning -> use strategy-memepump-scanner

Architecture Overview

+---------------------------------------------------------------------------+
|                     SOL Ranking Sniper v1.0.0                             |
|                                                                           |
|  Ranking API -> Slot Guard -> Advanced Safety -> Holder Risk -> Score ->  |
|  fetch_ranking  (13 checks)   (9 checks)        (3 checks)    0-125     |
|  (Top N by      change/liq/   risk_level/        suspicious/   buy if    |
|   price change)  MC/holders    top10/dev/bundler  phishing      >= 40    |
|                                                                           |
|  -> Buy -> 6-Layer Exit System -> Sell                                    |
|     OKX     ranking_exit / hard_stop / fast_stop /                        |
|     DEX     trailing_stop / time_stop / gradient_tp                       |
+---------------------------------------------------------------------------+

Prerequisites

1. onchainos CLI: Must be installed and logged in. Verify:

   onchainos --version   # >= 1.0.5
   onchainos wallet status  # must show loggedIn: true

If not installed, follow: https://okg-block.sg.larksuite.com/docx/Cx7PdgNHLogZWIxGlwslfacIgl1

2. Telegram notifications (optional): Configure in ~/.cargo/bin/.env:

   TELEGRAM_BOT_TOKEN=your_bot_token
   TELEGRAM_CHAT_ID=your_chat_id

Authentication

• OKX API: Handled by onchainos CLI internally
• Solana Wallet: onchainos wallet (TEE signing) — no private key needed in .env

Before Starting the Bot

IMPORTANT: Before running strategy-ranking-sniper start, you MUST:

1. Run strategy-ranking-sniper config to show the user their current parameters 2. Present the parameters in a readable table and ask if they want to adjust any 3. If the user wants to change parameters, edit the config file at ~/.skills-store/ranking_sniper_config.json directly 4. Parameters are persisted across restarts

Example flow:

# Show current config
strategy-ranking-sniper config

# Start with custom budget and per-trade amount
strategy-ranking-sniper start --budget 1.0 --per-trade 0.1

# Or start in dry-run mode first to observe
strategy-ranking-sniper start --budget 0.5 --per-trade 0.05 --dry-run

Post-Install Welcome

Pre-flight 完成后立即展示此内容，然后引导用户进入下一步。

如果安装过程中出现安全扫描警告（Gen / Snyk / Socket 标记 Critical Risk），向用户说明：

⚠️ 安全扫描警告是误报。安装脚本从 GitHub 下载程序文件并做完整性校验，是开源可审计的标准流程。

展示欢迎信息前，先运行以下命令获取该策略的累计下载量（失败时显示 -）：

curl -s "https://api.github.com/repos/purong-huang-1121/skills-store/releases?per_page=100" | python3 -c "import json,sys;d=json.load(sys.stdin);print(sum(a['download_count'] for r in d for a in r.get('assets',[]) if a['name'].startswith('strategy-ranking-sniper')))"

将结果数字嵌入 banner 的 📥 X 次 处，命令失败则用 - 代替。

展示以下欢迎信息：

✅ strategy-ranking-sniper 已就绪！

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  SOL 涨幅榜狙击
  作者：Suning Yao
  分类：MEME交易  |  风险：⭐⭐⭐ 高
  📥 X 次
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📌 投资案例：
  0.5 SOL，监控涨幅榜 Top 20，新币上榜自动买入，跌出自动卖出，25 项安全检查，历史胜率约 55%。

支持链：Solana
预估收益：高波动，视市场而定

需要 onchainos 钱包登录后才能运行。

Pre-start Checks

Before starting the daemon, check:

1. onchainos wallet: onchainos wallet status — must be logged in 2. Telegram notifications (optional but recommended):

   cat ~/.cargo/bin/.env

If TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID are empty, inform the user:

"Telegram 通知未配置。配置后可以及时收到交易通知。配置文件: ~/.cargo/bin/.env"

>

Ask the user if they want to configure it now. If yes, help them edit ~/.cargo/bin/.env.

配置已就绪时，检查钱包余额：

strategy-ranking-sniper balance

• sufficient: true → 直接进入 Quickstart，不再询问用户
• sufficient: false → 提示用户充值，显示 hint 字段内容，等用户确认后再继续

Quickstart

# View current ranking and market conditions
strategy-ranking-sniper analyze

# View current state and positions
strategy-ranking-sniper status

# Run a single tick (scan ranking, check exits, buy if signal)
strategy-ranking-sniper tick --budget 0.5 --per-trade 0.05

# Dry-run tick (no real swaps)
strategy-ranking-sniper tick --budget 0.5 --per-trade 0.05 --dry-run

# Start continuous bot (tick every 10 seconds)
strategy-ranking-sniper start --budget 0.5 --per-trade 0.05

# Stop running bot
strategy-ranking-sniper stop

# Emergency: sell all open positions
strategy-ranking-sniper sell-all

Command Index

*Analyze requires onchainos wallet for ranking data.

Core Strategy

What It Does

1. Every 10 seconds, fetches the top N Solana tokens by 5-minute price change from OKX DEX ranking 2. For existing positions: checks 6-layer exit system (ranking exit, stops, trailing, TP) 3. For new tokens entering the ranking: applies 3-layer safety filter (25 total checks) 4. Calculates momentum score (0-125) — only buys if score >= threshold 5. Executes swap via OKX DEX aggregator with Solana on-chain signing 6. Sends Telegram notifications on buy/sell/error events

What It Won't Do

---

3-Layer Safety Filter (25 Checks)

Layer 1: Slot Guard (13 checks from ranking data)

Layer 2: Advanced Safety (9 checks from advanced-info API)

Layer 3: Holder Risk Scan (3 checks from holder API)

Note: Default thresholds are relaxed for testing. For production use, update the config file with the "Production Suggestion" values.

---

Momentum Score (0-125)

Base Score (0-100)

Bonus Score (0-25, capped)

Buy threshold: Default 10 (testing), production suggestion 40.

---

6-Layer Exit System

Priority order (first match exits):

Gradient Take-Profit Levels

---

Configurable Parameters

Parameters are persisted at ~/.skills-store/ranking_sniper_config.json. View with strategy-ranking-sniper config. Edit the JSON file directly to change values.

Money Management

Trading Parameters

Exit System

Circuit Breaker

---

CLI Command Reference

strategy-ranking-sniper tick

Execute one tick cycle: fetch ranking, check exits for existing positions, scan for new entry signals, execute trades.

strategy-ranking-sniper tick [--budget <sol>] [--per-trade <sol>] [--dry-run]

Return fields:

Action types in output:

• buy — New position opened (symbol, price, amount_sol, score, tx_hash)
• exit — Position closed (symbol, reason, exit_type, pnl_pct, pnl_sol, tx_hash)
• skip — Token rejected by safety filter or score (symbol, reason)
• buy_failed — Buy swap failed (symbol, error)
• exit_failed — Sell swap failed (symbol, reason, error)
• no_ranking_data — No ranking data available

strategy-ranking-sniper start

Start the bot in foreground, executing tick every 10 seconds. Creates a PID file at ~/.skills-store/ranking_sniper.pid. Use Ctrl+C or ranking-sniper stop to terminate. Logs to ~/.skills-store/ranking_sniper.log.

strategy-ranking-sniper start [--budget <sol>] [--per-trade <sol>] [--dry-run]

Prints the full parameter summary before starting. Sends Telegram notification on start/stop if configured.

strategy-ranking-sniper stop

Stop a running bot by sending SIGTERM to the process in the PID file.

strategy-ranking-sniper stop

strategy-ranking-sniper status

Show current bot state, open positions, PnL overview, and whether the bot is running.

strategy-ranking-sniper status

Return fields:

strategy-ranking-sniper report

Detailed performance report with win/loss stats.

strategy-ranking-sniper report

Return fields:

strategy-ranking-sniper history

Show trade history (most recent first).

strategy-ranking-sniper history [--limit <n>]

Each trade includes: time, symbol, token_address, action (BUY/SELL), price, amount_sol, score, exit_reason, pnl_pct, pnl_sol, tx_hash.

strategy-ranking-sniper reset

Delete all sniper state. Requires --force flag for safety.

strategy-ranking-sniper reset --force

strategy-ranking-sniper analyze

Market analysis showing the current trending ranking, top tokens, and bot state summary.

strategy-ranking-sniper analyze

Return fields:

strategy-ranking-sniper test-trade

Execute a buy+sell round-trip for a specific token. For development and debugging only. Buys a small amount of the token, waits a few seconds, then sells it back.

strategy-ranking-sniper test-trade <token_address> [--amount <sol>]

Return fields:

strategy-ranking-sniper config

Show all configurable parameters and their current values, organized by category. Also shows the config file and log file paths.

strategy-ranking-sniper config

Displays parameter groups:

• Money management (budget, per_trade, max_positions, etc.)
• Trading parameters (slippage, score threshold, tick interval, etc.)
• Layer 1 Slot Guard thresholds
• Layer 2 Advanced Safety thresholds
• Layer 3 Holder Risk Scan thresholds
• Exit system (stops, trailing, take-profit levels)
• Circuit breaker
• Logging
• Telegram notifications

strategy-ranking-sniper sell-all

Force-sell all open positions immediately. Retries with halved amounts if liquidity is insufficient (up to 4 attempts per position).

strategy-ranking-sniper sell-all

Return fields:

strategy-ranking-sniper sell

Sell a specific token by contract address with a raw token amount.

strategy-ranking-sniper sell <token_address> --amount <raw_amount>

Return fields:

---

OKX API Endpoints Used

Market Data APIs

Trade Execution APIs

Solana RPC (Direct)

---

Execution Pipeline

fetch_ranking(top_n=20)              <- OKX /token/toplist (sort by 5m change)
    |
    +-> For each existing position:
    |     fetch_price(token)          <- OKX /price-info
    |     check_exits(6 layers)       <- engine.rs pure function
    |     If exit signal -> sell      <- OKX /aggregator/swap + sign + broadcast
    |
    +-> For each new token in ranking:
          known_tokens check           <- skip if already seen
          budget + position check      <- skip if insufficient
          fetch_advanced_info()        <- OKX /token/advanced-info
          run_slot_guard(13 checks)    <- engine.rs pure function
          run_advanced_safety(9 checks)<- engine.rs pure function
          fetch_holder_risk()          <- OKX /token/holder (tag 6 + 8)
          run_holder_risk_scan(3 chks) <- engine.rs pure function
          calc_momentum_score()        <- engine.rs (0-125)
          If score >= threshold:
            fetch_price()              <- OKX /price-info
            buy_token()                <- OKX /aggregator/swap + sign + broadcast

---

Cross-Skill Workflows

Workflow A: Analyze Then Snipe

User: "What's trending on Solana right now? Start sniping if it looks good."

1. strategy-ranking-sniper analyze          -> see current ranking + top tokens
2. strategy-ranking-sniper config           -> review parameters
       | user adjusts thresholds if needed
3. strategy-ranking-sniper tick --dry-run   -> dry-run to see what passes filters
       | looks good
4. strategy-ranking-sniper start --budget 0.5 --per-trade 0.05  -> go live
5. strategy-ranking-sniper status           -> monitor positions

Workflow B: Monitor and Emergency Exit

User: "Check my sniper positions. Sell everything if it's losing."

1. strategy-ranking-sniper status           -> see positions + PnL
       | user sees losses
2. strategy-ranking-sniper sell-all         -> emergency exit all positions
3. strategy-ranking-sniper report           -> review final stats

Workflow C: Research a Specific Token

User: "The sniper bought TOKEN, tell me more about it."

1. strategy-ranking-sniper status                              -> get token address
2. okx-dex-token    skills-store token search TOKEN --chain solana -> token details
3. okx-dex-market   skills-store market kline --address <addr> --chain solana -> chart
4. okx-wallet-portfolio  skills-store portfolio balance --chain solana -> wallet balance

Workflow D: Test Before Deploying

User: "I want to test the sniper on a specific token before going live."

1. okx-dex-token    skills-store token search HYPE --chain solana              -> find token
2. strategy-ranking-sniper test-trade <token_address> --amount 0.01        -> round-trip test
3. strategy-ranking-sniper start --budget 0.5 --per-trade 0.05 --dry-run  -> dry-run session
       | verify actions look correct
4. strategy-ranking-sniper start --budget 0.5 --per-trade 0.05            -> go live

---

State Persistence

State is stored at ~/.skills-store/ranking_sniper_state.json with atomic writes (write to .tmp, rename).

State includes:

• known_tokens — Set of all token addresses ever seen (prevents re-entry)
• positions — Map of token_address -> Position (with buy price, time, peak PnL, trailing state)
• trades — Trade history (last 100 entries)
• stats — Cumulative stats (buys, sells, invested, returned, daily PnL)
• errors — Consecutive error tracking for circuit breaker
• last_sell_times — Per-token cooldown timestamps

---

Key Concepts

• Ranking-based entry: Unlike signal-based scanners, this bot only considers tokens that appear in the OKX top-N trending list. Entry is triggered by a token being new to the ranking AND passing all safety checks.
• Ranking-based exit: The primary exit signal is a token dropping off the ranking entirely. This is Layer 1 of the exit system and takes priority over most other exit conditions.
• Momentum Score: A composite score (0-125) combining buy pressure, price change, trader count, liquidity, and bonus signals (smart money, low concentration, etc.). Prevents buying tokens that pass safety but lack momentum.
• Known tokens set: Once a token is seen in the ranking, it enters the known_tokens set permanently (within a session). The bot will never re-enter the same token. Use reset --force to clear.
• Gradient take-profit: Sells in 3 tranches (25%/35%/40%) at increasing profit levels, rather than all-at-once. Locks in partial profit while allowing further upside.
• Trailing stop: Activates when PnL reaches a threshold (default +8%), then sells if price drops by the drawdown percentage (default 12%) from the peak.
• Dry-run mode: Executes the full pipeline (ranking fetch, safety checks, scoring) but skips actual swap execution. Actions are logged as DRY_RUN. Useful for validating filter parameters.

---

Edge Cases

---

Troubleshooting

---

Security Notes

• Wallet signing: onchainos wallet (TEE signing) — private keys never leave the secure enclave
• API auth: Handled by onchainos CLI internally
• Atomic state writes: Write to .tmp file then rename to prevent corruption
• Fail-closed: API failures result in skipping the token, not proceeding with partial data
• Capital controls: Budget tracking, position limits, daily loss limits, and circuit breaker prevent runaway losses

SOL Ranking Sniper v0 SKILL

概述

SOL Ranking Sniper 是一个基于 OKX Onchain OS 公开 MCP 的 Solana Meme 币自动狙击策略。

核心逻辑：每 10 秒轮询 Solana 涨幅排行榜 Top 20，当有新代币首次上榜时，经过三级过滤： 1. 一级 Slot Guard（基于 ranking 返回的基础指标：涨幅、流动性、市值、买入比、持有者数等） 2. 二级 Advanced Safety Check（调用 dex-okx-market-token-advanced-info 获取蜜罐风险、开发者 rug 历史、狙击手持仓、LP 销毁、Top10 集中度等安全数据） 3. 三级 Holder Risk Scan（调用 dex-okx-market-token-holder 检测可疑地址、疑似钓鱼地址持仓占比）

通过三级过滤后计算 Momentum Score 评分，高分优先买入。持仓后通过 6 层退出系统（排名退出 → 硬止损 → 快速止损 → 追踪止损 → 时间止损 → 梯度止盈）自动管理仓位。

策略设计理念：捕捉 Meme 币在涨幅榜初次出现时的短期动量，在代币跌出排行榜前快速获利离场。

使用的 OKX Onchain OS MCP 接口

本策略使用以下 OKX Onchain OS 公开 MCP 接口：

MCP 调用方式

所有 MCP 调用通过 HTTP POST 到 https://web3.okx.com/api/v1/plugin-store-mcp：

async function mcpCall(toolName, args) {
  const res = await fetch('https://web3.okx.com/api/v1/plugin-store-mcp', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'OK-ACCESS-KEY': process.env.OKX_API_KEY,
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      method: 'tools/call',
      params: { name: toolName, arguments: args },
      id: ++requestId,
    }),
    signal: AbortSignal.timeout(15000),
  });
  // ⚠️ 必须先读 text 再 parse，避免非 JSON 响应导致 .json() 报错
  const raw = await res.text();
  if (!res.ok) throw new Error(`MCP HTTP ${res.status}: ${raw.slice(0, 200)}`);
  let json;
  try { json = JSON.parse(raw); } catch { throw new Error(`MCP non-JSON: ${raw.slice(0, 200)}`); }
  if (json.error) throw new Error(json.error.message || JSON.stringify(json.error));
  const text = json.result?.content?.[0]?.text;
  if (!text) throw new Error(`MCP empty for ${toolName}`);
  let parsed;
  try { parsed = JSON.parse(text); } catch { throw new Error(`MCP text error: ${text.slice(0, 200)}`); }
  if (parsed.code !== 0 && parsed.code !== '0') throw new Error(`MCP [${parsed.code}]: ${parsed.msg || ''}`);
  const data = parsed.data;
  // 部分 MCP 返回类数组对象 {0:..., 1:...} 而非真数组，需转换
  if (data && typeof data === 'object' && !Array.isArray(data) && '0' in data) {
    return Object.values(data);
  }
  return data;
}

注意事项：

• MCP 响应解析必须两步：先 res.text() 读取原始文本，再 JSON.parse()。直接用 res.json() 在服务端返回非 JSON 错误时会丢失错误信息
• dex-okx-market-token-ranking 使用参数 chains（复数），其他接口使用 chainIndex（单数）
• `dex-okx-dex-swap` / `dex-okx-dex-quote` 返回数组：data 是 [{routerResult, tx}] 数组格式，取第一个元素 data[0]
• `dex-okx-dex-swap` 滑点参数名为 `slippagePercent`（字符串 "2" 表示 2%），不是 slippage
• Solana swap 交易数据 `tx.data` 为 base58 编码，不是 base64。反序列化时需用 bs58.decode() 而非 Buffer.from(data, 'base64')
• dex-okx-index-current-price 需要 items 数组格式（支持批量查询最多 100 个代币）：

mcpCall('dex-okx-index-current-price', {
  items: [
    { chainIndex: '501', tokenContractAddress: 'So111...112' },
    { chainIndex: '501', tokenContractAddress: '<token_addr>' },
  ],
})
// 返回: [{ chainIndex, tokenContractAddress, price, time }]

前置条件

环境要求

• Node.js >= 18（ESM 模块支持）
• npm 或 pnpm 包管理器

依赖包

{
  "@solana/web3.js": "^1.98.4",
  "bs58": "^6.0.0",
  "express": "^5.x",
  "cors": "^2.8.x",
  "dotenv": "^17.x"
}

Dashboard UI（必须构建）：

{
  "react": "^19.x",
  "recharts": "^3.x",
  "tailwindcss": "^4.x",
  "vite": "^7.x"
}

前端 UI 设计规范（OKX Branding）

Dashboard 前端需遵循 OKX 品牌视觉规范，确保与 OKX 产品风格一致：

配色体系：

字体：

• 英文/数字："Roboto Mono", "SF Mono", monospace（数据密集型场景用等宽字体）
• 中文："PingFang SC", "Microsoft YaHei", sans-serif
• 标题字重：600（Semi Bold），正文：400（Regular）

UI 组件风格：

Dashboard 布局参考：

┌─────────────────────────────────────────────────────┐
│  SOL Ranking Sniper v0          [Running ●]  [Stop] │  ← Header
├──────────┬──────────┬──────────┬───────────────────── │
│ 总 PnL   │ 今日 PnL │ 胜率     │ 持仓数/上限         │  ← Stats Bar
│ +0.12SOL │ -0.03SOL │ 42.8%   │ 3 / 5              │
├──────────┴──────────┴──────────┴───────────────────── │
│  当前持仓                                             │
│  ┌────────┬────────┬────────┬──────┬───────────────┐ │
│  │ Token  │ Entry  │ Current│ PnL% │ Exit Trigger  │ │  ← Positions
│  ├────────┼────────┼────────┼──────┼───────────────┤ │
│  │ BONK   │ $0.012 │ $0.014 │ +16% │ Trail ▲8%    │ │
│  └────────┴────────┴────────┴──────┴───────────────┘ │
├─────────────────────────────────────────────────────── │
│  排行榜 Top 20              │  信号日志               │
│  ┌──────┬───────┬────────┐ │  12:01 BUY BONK +23%   │  ← Ranking + Logs
│  │ Rank │ Token │ Change │ │  12:00 SKIP ABC: liq<5k │
│  └──────┴───────┴────────┘ │  11:59 SELL XYZ -8%     │
└─────────────────────────────────────────────────────┘

OKX Logo 使用：

• Dashboard 左上角展示 "Powered by OKX Onchain OS" 文字标识
• 不嵌入 OKX Logo 图片文件（避免版权分发问题），使用纯文字 + SVG 简化标识
• 字号 14px，颜色 #8B919E

API Keys & 环境变量

在项目根目录 .env 文件中配置：

OKX_API_KEY=<OKX Web3 API Key>          # 必需：OKX Onchain OS MCP API 访问
SOLANA_PRIVATE_KEY=<base58 私钥>         # Live 模式必需：用于签名交易
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com  # 可选：自定义 RPC
PORT=3051                               # 可选：API 服务端口（默认 3051，避免与其他策略冲突）
DASHBOARD_PORT=5051                     # 可选：Dashboard 端口（默认 5051）

获取 OKX API Key：前往 OKX Developer Portal 创建。

用户初始化输入

项目搭建完成后，AI 必须主动询问用户以下参数，不可直接使用默认值跳过。用户确认后再写入 state/config.json 并启动引擎。

必问参数（无默认值，必须用户输入）

可选参数（有默认值，用户可调整）

初始化对话示例

AI: 策略搭建完成！启动前需要确认几个参数：

1. 交易模式？ paper（模拟）/ live（实盘）
2. 策略总预算多少 SOL？（范围 1-100）
3. 每笔买入多少 SOL？（范围 0.01-1，建议不超过总预算的 5%）
4. 日亏损停止线？（占总预算比例，如 0.15 = 亏 15% 当日停止买入）

User: live, 10 SOL, 每笔 0.1, 亏损 20% 停

AI: 收到，配置如下：
- 模式：Live（实盘）
- 总预算：10 SOL
- 单笔买入：0.1 SOL
- 日亏损停止线：20%（即当日亏损超 2 SOL 停止买入）
- 最大持仓：5（默认）
正在写入配置并启动引擎...

风险偏好配置

Moderate（默认 / 推荐）

Conservative（保守）

可调整：buyAmountPerTrade=0.02, stopLoss=-15%, quickStop 3min/-5%, maxPositions=3

Aggressive（激进）

可调整：buyAmountPerTrade=0.1, stopLoss=-35%, maxChangePercent=300, maxPositions=8

信号源规范

唯一信号源：OKX Token Ranking

排行榜返回字段（用于一级过滤）

tokenContractAddress, tokenSymbol, price, change (%),
liquidity, marketCap, holders, volume,
txs, txsBuy, txsSell, uniqueTraders

买入决策规则

一级过滤：Slot Guard（基于 ranking 数据）

按顺序检查，任一不通过则跳过该代币：

二级过滤：Advanced Safety Check（安全审查）

通过一级过滤的代币，调用 dex-okx-market-token-advanced-info 获取安全数据，执行以下检查：

mcpCall('dex-okx-market-token-advanced-info', {
  chainIndex: '501',
  tokenContractAddress: token.tokenContractAddress,
})

返回字段与检查规则：

安全检查通过后，进入三级 Holder Risk Scan。

三级过滤：Holder Risk Scan（持有者风险扫描）

通过二级过滤的代币，调用 dex-okx-market-token-holder 检测可疑和钓鱼地址：

// 查询可疑地址持仓
const suspicious = await mcpCall('dex-okx-market-token-holder', {
  chainIndex: '501',
  tokenContractAddress: token.tokenContractAddress,
  tagFilter: '6',  // Suspicious
});

// 查询疑似钓鱼地址持仓
const phishing = await mcpCall('dex-okx-market-token-holder', {
  chainIndex: '501',
  tokenContractAddress: token.tokenContractAddress,
  tagFilter: '8',  // Suspected Phishing
});

持有者风险检查计算方式：

// 计算仍在持仓的可疑地址占比
const suspiciousHoldPercent = suspicious
  .filter(h => parseFloat(h.holdPercent) > 0)
  .reduce((sum, h) => sum + parseFloat(h.holdPercent) * 100, 0);
const suspiciousActiveCount = suspicious
  .filter(h => parseFloat(h.holdPercent) > 0).length;

// 计算仍在持仓的钓鱼地址数
const phishingActiveCount = phishing
  .filter(h => parseFloat(h.holdPercent) > 0).length;

if (suspiciousHoldPercent > 10) reject('SuspiciousHold:' + suspiciousHoldPercent.toFixed(1) + '%');
if (phishingActiveCount > 0) reject('PhishingHolder:' + phishingActiveCount);
if (suspiciousActiveCount > 5) reject('SuspiciousCount:' + suspiciousActiveCount);

三级过滤全部通过后，从 tokenTags、advanced-info 和 holder 数据中提取加分项用于 Momentum Score 计算。

Momentum Score 计算（0-125 分）

每个通过两级过滤的代币计算综合动量评分：

Base Score（0-100 分，来自 ranking 数据）:
  buyScore      = min(buyRatio, 1) * 40           // 买入比权重最高
  changePenalty = change > 100 ?
                  max(0, 20 - (change-100)/10) :
                  min(change/5, 20)                // 适中涨幅优于极端
  traderScore   = min(traders/50, 1) * 20          // 独立交易者
  liqScore      = min(liquidity/50000, 1) * 20     // 流动性

Bonus Score（0-25 分，来自 advanced-info + holder 数据）:
  smartMoneyBonus     = tokenTags 含 'smartMoneyBuy' ? +8 : 0
  concentrationBonus  = top10HoldPercent < 30 ? +5 : (< 50 ? +2 : 0)
  dsPaidBonus         = tokenTags 含 'dsPaid' ? +3 : 0
  communityBonus      = tokenTags 含 'dexScreenerTokenCommunityTakeOver' ? +2 : 0
  lowSniperBonus      = sniperHoldingPercent < 5 ? +4 : (< 10 ? +2 : 0)
  devCleanBonus       = devHoldingPercent == 0 && devRugPullTokenCount < 3 ? +3 : 0
  zeroSuspiciousBonus = suspiciousActiveCount == 0 ? +2 : 0  // 无可疑地址 = 更干净

  bonusTotal = min(smartMoneyBonus + concentrationBonus + dsPaidBonus
                   + communityBonus + lowSniperBonus + devCleanBonus
                   + zeroSuspiciousBonus, 25)

totalScore = base + bonusTotal

买入触发逻辑

每 10 秒执行一次 pollRanking():

1. 调用 dex-okx-market-token-ranking(chains='501', sortBy='2', timeFrame='1')
   → 获取当前 Top 20 代币列表
2. 计算差集：newEntries = currentSnapshot - prevSnapshot
   （首次启动时仅记录快照，不触发买入）
3. 更新快照：prevSnapshot = currentSnapshot
4. 对每个 newEntry:
   a. 执行一级 Slot Guard 13 项检查 → 不通过则 SKIP 并记录原因
   b. 通过后调用 dex-okx-market-token-advanced-info → 执行二级安全检查 9 项
      → 不通过则 SKIP 并记录安全拒绝原因（如 "Honeypot", "DevRug:63", "Sniper:14%"）
   c. 通过后调用 dex-okx-market-token-holder(tagFilter=6,8) → 执行三级持有者风险检查 3 项
      → 不通过则 SKIP 并记录原因（如 "PhishingHolder:2", "SuspiciousHold:15.3%"）
   d. 全部通过后计算 Momentum Score（0-125）
5. 按 Momentum Score 降序排序
6. 依次执行买入（高分优先），每笔间隔 2s（Live）/ 300ms（Paper）

买入执行参数

Paper 模式买入：调用 dex-okx-dex-quote 获取报价模拟真实摩擦（price impact），用报价结果计算有效买入价。

Live 模式买入（WSOL 处理流程关键）：

Solana DEX 交易需要 WSOL（Wrapped SOL）。OKX 返回的 swap 交易假设 WSOL 账户已预充值，因此每次买入前必须执行：

1. 检查 WSOL ATA 账户是否存在
2. 如果存在 → CloseAccount（回收旧余额）
3. CreateIdempotent ATA（创建新账户）
4. SystemProgram.transfer（充入 amountLamports）
5. SyncNative（同步 token 余额）
   ↑ 以上 2-5 合并为一个 Solana Transaction
6. 发送并确认 prepareWsol 交易
7. 调用 dex-okx-dex-swap → 取 data[0]（返回数组） → 签名 → 发送 → 确认
8. CleanupWsol（关闭 WSOL 账户回收 rent）

⚠️ Swap API 关键细节：

• 参数名：滑点参数为 slippagePercent（字符串 "2" 表示 2%），不是 slippage
• 返回格式：dex-okx-dex-swap 和 dex-okx-dex-quote 返回数组 [{routerResult, tx}]，必须取 data[0]
• 交易编码：tx.data 为 base58 编码的 Solana VersionedTransaction，反序列化时需要：

// 自动检测编码格式（hex / base64 / base58）
let buf;
if (callData.startsWith('0x')) {
  buf = Buffer.from(callData.slice(2), 'hex');
} else if (/^[A-Za-z0-9+/=]+$/.test(callData) && callData.length % 4 === 0) {
  buf = Buffer.from(callData, 'base64');
} else {
  buf = Buffer.from(bs58.decode(callData));  // Solana 默认 base58
}
const tx = VersionedTransaction.deserialize(buf);
tx.sign([keypair]);

买入价格三级回退

price = OKX routerResult.toTokenUsdPrice
if (!price || price <= 0): price = ranking API token.price
if (!price || price <= 0): price = (buyAmountSol * solPrice) / tokenAmount
if (!price || price <= 0): SKIP — 不建仓（避免 PnL Infinity）

卖出决策规则

卖出触发机制

每 10 秒检查一次所有持仓（monitorPositions），按以下优先级依次判断，命中即卖出：

卖出执行参数

定时任务清单

项目结构

策略以 Node.js ESM 项目构建，结构如下：

sol-ranking-sniper/
├── .env                     # 环境变量（API Key, 私钥）
├── package.json             # 依赖声明
├── server/
│   ├── index.mjs            # Express 服务入口，监听端口 PORT（默认 3051）
│   ├── routes.mjs           # API 路由定义
│   ├── engine.mjs           # 策略引擎（pollRanking + monitorPositions）
│   └── lib/
│       ├── okx-api.mjs      # OKX MCP 调用封装（仅公开接口）
│       ├── state.mjs        # 状态文件读写（JSON 持久化）
│       └── swap-executor.mjs # Solana 链上交易执行（WSOL 管理 + 签名发送）
├── state/                   # 运行时状态（JSON 文件）
│   ├── config.json          # 策略完整配置（共享，含 mode 字段）
│   ├── paper/               # 模拟盘数据（自动创建）
│   │   ├── positions.json
│   │   ├── trades.json
│   │   ├── daily-stats.json
│   │   ├── signals-log.json
│   │   └── signals-seen.json
│   └── live/                # 实盘数据（自动创建）
│       ├── positions.json
│       ├── trades.json
│       ├── daily-stats.json
│       ├── signals-log.json
│       └── signals-seen.json
└── dashboard/               # React + Vite Dashboard（必须构建）
    ├── index.html
    ├── package.json
    ├── vite.config.js         # 含 proxy 到 API 服务
    ├── tailwind.config.js
    └── src/
        ├── main.jsx
        ├── index.css          # Tailwind + OKX Branding 全局样式
        └── App.jsx            # 主 Dashboard 组件

API 路由

项目初始化流程

AI 收到用户指令后，必须按以下顺序完整搭建项目：

Step 1：创建项目骨架

mkdir -p sol-ranking-sniper/{server/lib,state,dashboard/src}

Step 2：初始化后端

1. 创建 package.json（type: "module"，声明所有依赖） 2. 创建 .env（提示用户填入 OKX_API_KEY、SOLANA_PRIVATE_KEY） 3. 创建 .gitignore（必须包含 .env、state/、node_modules/） 4. 创建 state/config.json（完整配置，参考"配置文件示例"章节） 5. npm install

Step 3：实现核心模块（按依赖顺序）

1. server/lib/okx-api.mjs — MCP 调用封装（注意 chains vs chainIndex 参数差异、current-price 的 items 数组格式、类数组对象转换） 2. server/lib/state.mjs — JSON 状态文件读写（原子写入：先写 .tmp 再 rename） 3. server/lib/swap-executor.mjs — Solana 链上交易（WSOL 管理 + 签名；私钥仅在此模块内使用） 4. server/engine.mjs — 策略引擎（pollRanking + monitorPositions + 三级过滤 + 六层退出） 5. server/routes.mjs — API 路由 6. server/index.mjs — Express 入口（端口从 process.env.PORT || 3051 读取，绑定 127.0.0.1）

Step 4：构建 Dashboard 前端（必须）

1. cd dashboard && npm create vite@latest . -- --template react 2. npm install && npm install -D tailwindcss@3 postcss autoprefixer && npx tailwindcss init -p 3. 配置 tailwind.config.js（OKX Branding 色值） 4. 配置 vite.config.js（proxy /api → 后端服务端口） 5. 实现 src/index.css（Tailwind + OKX 暗色全局样式） 6. 实现 src/App.jsx（完整 Dashboard：Header + StatsBar + Positions + Trades + Ranking + Logs） 7. 遵循"前端 UI 设计规范（OKX Branding）"章节的配色/字体/组件/布局

Step 5：启动验证

1. 启动后端：node server/index.mjs 2. 启动前端：cd dashboard && npx vite --port ${DASHBOARD_PORT:-5051} 3. 验证 /health 和 /api/status 返回正常 4. 验证排行榜数据在 Dashboard 中显示 5. 验证信号日志中出现 SKIP/SAFETY_REJECT/PASS 等事件

Step 6：提示用户

告知用户：

• API 服务地址：http://127.0.0.1:${PORT}
• Dashboard 地址：http://localhost:${DASHBOARD_PORT}
• 当前模式：Paper/Live
• 引擎已自动启动

通知推送规范

通过服务器 console 日志 + Dashboard UI 实时展示：

数据存储规范

所有状态以 JSON 文件存储于 state/ 目录：

Position 结构

{
  "tokenAddress": "436wV8pV...",
  "tokenSymbol": "Loopy",
  "decimal": 9,
  "buyPrice": "0.000040280562643865",
  "buyAmountSol": "0.05",
  "holdAmount": "274.82319297",
  "buyCount": 1,
  "buyTimestamp": 1741180000000,
  "lastCheckPrice": "0.000042",
  "lastCheckTime": 1741180060000,
  "peakPrice": "0.000045",
  "takeProfitTier": 0,
  "triggerReason": "Rank +45% S:62",
  "safetyData": {
    "riskControlLevel": "1",
    "top10HoldPercent": "24.38",
    "devHoldingPercent": "0",
    "bundleHoldingPercent": "0.48",
    "sniperHoldingPercent": "3.2",
    "devRugPullTokenCount": "0",
    "hasSmartMoney": true
  }
}

Trade 结构

{
  "tradeId": "buy-1741180000000-a3f2",
  "timestamp": 1741180000000,
  "direction": "buy | sell",
  "tokenAddress": "436w...",
  "tokenSymbol": "Loopy",
  "amountSol": "0.05",
  "amountToken": "274.82",
  "priceUsd": "0.00004028",
  "txHash": "5xK9...",
  "reason": "rank_score_62 | SL(-25%) | TP1(+5%) | RankExit | StopExit | ...",
  "pnlPercent": "4.27",
  "pnlSol": "0.00213",
  "mode": "live | paper"
}

配置文件示例

{
  "strategyId": "sol-ranking-sniper",
  "version": "0.0.1",
  "mode": "<USER_INPUT: paper | live>",
  "chainIndex": "501",
  "myWallet": "",
  "totalBudget": "<USER_INPUT: 1-100 SOL>",
  "riskLevel": "moderate",
  "dailyLossLimitRatio": "<USER_INPUT: 0.05-0.50>",
  "trading": {
    "buyAmountPerTrade": "<USER_INPUT: 0.01-1 SOL>",
    "maxPositions": 5,
    "maxSingleTokenBuys": 1,
    "slippagePercent": 2,
    "gasReserve": 0.01,
    "minWalletBalance": 0.1
  },
  "ranking": {
    "pollInterval": 10000,
    "timeFrame": "1",
    "sortBy": "2",
    "topN": 20,
    "minChangePercent": 5,
    "maxChangePercent": 5000,
    "minLiquidity": 3000,
    "minMarketCap": 3000,
    "maxMarketCap": 500000000,
    "minHolders": 10,
    "minBuyRatio": 0.4,
    "minTraders": 10,
    "cooldownMinutes": 5,
    "enableRankingExit": true,
    "skipTokens": [
      "11111111111111111111111111111111",
      "So11111111111111111111111111111111111111112",
      "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ],
    "blacklist": []
  },
  "safety": {
    "maxRiskLevel": 3,
    "blockHoneypot": true,
    "maxTop10HoldPercent": 80,
    "maxDevHoldPercent": 50,
    "maxBundleHoldPercent": 30,
    "minLpBurnPercent": 0,
    "maxDevRugCount": 20,
    "maxSniperHoldPercent": 30,
    "blockInternal": false,
    "maxSuspiciousHoldPercent": 50,
    "maxSuspiciousActiveCount": 20,
    "blockPhishingHolder": false
  },
  "takeProfit": {
    "tiers": [
      { "percent": 5, "sellRatio": 0.25 },
      { "percent": 15, "sellRatio": 0.35 },
      { "percent": 30, "sellRatio": 0.40 }
    ]
  },
  "stopLoss": {
    "percent": -25
  },
  "trailingStop": {
    "activatePercent": 8,
    "trailPercent": 12
  },
  "quickStop": {
    "minutes": 5,
    "maxLossPercent": -8
  },
  "timeStop": {
    "maxHoldHours": 6
  },
  "monitoring": {
    "positionCheckInterval": 10000,
    "healthCheckInterval": 300000
  }
}

LLM 使用策略

需要 LLM 的环节

不需要 LLM 的环节

本策略运行时 100% 纯规则驱动，以下环节均不需要 LLM：

• 排行榜数据获取 → MCP 调用
• Slot Guard 过滤 → 数值比较
• Advanced Safety Check → MCP 调用 + 数值比较
• Momentum Score 计算 → 数学公式
• 买卖决策 → 规则引擎
• 交易执行 → Solana 链上签名提交
• 仓位监控 → 定时轮询 + 价格比较

错误处理规范

故障排除指南

当用户遇到问题时，AI 应按以下流程诊断。用户可能完全不了解策略内部机制，AI 需要主动检查并给出明确结论，不要让用户自己看日志。

诊断步骤

1. 检查进程是否存活
   → curl http://127.0.0.1:${PORT}/health
   → 如果无响应：检查 node 进程是否在运行，查看启动日志

2. 检查引擎状态
   → curl http://127.0.0.1:${PORT}/api/status
   → running=false：引擎未启动，提示用户点 Start 或调用 /api/start
   → mode 是否正确

3. 检查最近日志
   → curl http://127.0.0.1:${PORT}/api/logs?n=20
   → 关注 ERROR 和 WARN 类型日志

4. 根据日志类型定位问题（见下方常见问题表）

常见问题速查

AI 诊断提示词

当用户说"出错了"、"不工作了"、"为什么没有买入"等模糊描述时，AI 应该：

1. 先读日志：curl http://127.0.0.1:${PORT}/api/logs?n=30 2. 再看状态：curl http://127.0.0.1:${PORT}/api/status 3. 然后看持仓：curl http://127.0.0.1:${PORT}/api/positions 4. 根据上表给出结论，用用户能理解的语言解释 5. 如果需要改参数，直接帮用户改 state/config.json 并重启引擎

Dashboard 功能

模拟盘 / 实盘切换

Dashboard 顶部提供模拟盘和实盘切换按钮：

• 模拟盘（Paper）：默认模式，不需要私钥，使用 DEX Quote 模拟交易
• 实盘（Live）：真实链上交易，需要在 .env 中配置 SOLANA_PRIVATE_KEY

切换规则：

• 必须先停止引擎才能切换模式
• 切换到实盘时，后端会验证 SOLANA_PRIVATE_KEY 是否已配置
• 切换成功后配置自动保存到 state/config.json

API：POST /api/mode — Body: { "mode": "paper" | "live" }

模拟盘 / 实盘数据隔离

模拟盘和实盘的运行数据完全隔离，互不影响：

state/
├── config.json          # 共享配置（含 mode 字段）
├── paper/               # 模拟盘数据
│   ├── positions.json
│   ├── trades.json
│   ├── daily-stats.json
│   ├── signals-log.json
│   └── signals-seen.json
└── live/                # 实盘数据
    ├── positions.json
    ├── trades.json
    ├── daily-stats.json
    ├── signals-log.json
    └── signals-seen.json

• config.json 在根目录共享，切换模式只改 mode 字段
• 所有 API（/api/positions、/api/trades、/api/logs）自动返回当前模式的数据
• 切换模式后 Dashboard 自动显示对应模式的持仓、交易和日志

数据重置

Dashboard 顶部提供重置按钮，用于清空当前模式的策略运行数据：

• 清空持仓（<mode>/positions.json）
• 清空交易记录（<mode>/trades.json）
• 清空每日统计（<mode>/daily-stats.json）
• 清空信号日志（<mode>/signals-log.json）
• 清空已见代币缓存（<mode>/signals-seen.json）

使用规则：

• 必须先停止引擎才能重置
• 重置前会弹出确认对话框
• 重置只影响当前模式的数据，不影响另一个模式
• 重置不影响 config.json 配置

API：POST /api/reset

实盘钱包信息

实盘模式下，Dashboard 顶部右侧会显示：

• 钱包地址缩写：xxxx...xxxx（前 4 位 + 后 4 位）
• SOL 实时余额：每 3 秒自动刷新

显示条件：

• mode 为 live 且 .env 中已配置 SOLANA_PRIVATE_KEY
• 模拟盘模式下不显示

数据来源：GET /api/status 在 live 模式下额外返回 wallet（地址）和 solBalance（余额）字段

停止引擎自动清仓（StopExit）

停止引擎时，自动卖出所有当前持仓：

• 获取所有持仓的当前价格（dex-okx-index-current-price）
• 逐个执行全额卖出（ratio=1），退出原因为 StopExit
• 实盘模式：调用 dex-okx-dex-swap 获取卖出交易 → 签名 → 发送链上
• 模拟盘模式：调用 dex-okx-dex-quote 记录虚拟卖出
• 所有卖出完成后清空持仓列表
• PnL 和交易记录正常写入

这确保无论模拟盘还是实盘，停止时不会遗留未平仓的位置。

PnL 显示精度

Dashboard 统计卡片中 PnL 金额显示规则：

• 百分比（%）：固定 2 位小数
• SOL 金额：绝对值 < 0.01 SOL 时显示 4 位小数（如 -0.0014 SOL），否则 2 位小数

避免小额 PnL 被四舍五入显示为 +0.00 SOL / -0.00 SOL。

交易纪律规则

• RULE-1: 日亏损 > totalBudget * dailyLossLimitRatio（用户初始化时设定）时，停止所有新买入
• RULE-2: 同一代币卖出后 cooldownMinutes（30 分钟）内不可重复买入
• RULE-3: 同时持仓不超过 maxPositions（默认 5 个）
• RULE-4: 每笔交易金额固定 buyAmountPerTrade，不追加仓位（maxSingleTokenBuys=1）
• RULE-5: 排名退出（EXIT 0）是最高优先级——代币跌出 Top N 即全部卖出，不等其他止盈止损
• RULE-6: Live 模式必须配置 SOLANA_PRIVATE_KEY，否则引擎拒绝启动
• RULE-7: 永远保留 gasReserve（0.01 SOL）用于交易手续费
• RULE-8: SOL 余额低于 minWalletBalance（0.1 SOL）时停止买入
• RULE-9: advanced-info 或 token-holder 安全检查失败的代币绝不买入，即使其他指标再好
• RULE-10: 任何安全检查接口请求失败时，该代币视为不安全，不买入（Fail-Closed 原则）

代码安全规范

私钥安全

私钥处理代码规范

// ✅ 正确：从环境变量加载，仅在需要签名时使用
import { Keypair } from '@solana/web3.js';
import bs58 from 'bs58';

let _keypair = null;
function getKeypair() {
  if (!_keypair) {
    const pk = process.env.SOLANA_PRIVATE_KEY;
    if (!pk) throw new Error('SOLANA_PRIVATE_KEY not set');
    _keypair = Keypair.fromSecretKey(bs58.decode(pk));
  }
  return _keypair;
}

// ✅ 正确：只暴露公钥地址
export function getWalletAddress() {
  return getKeypair().publicKey.toBase58();
}

// ✅ 正确：签名操作封装在内部
export async function signAndSend(transaction) {
  transaction.sign(getKeypair());
  // ...send
}

// ❌ 错误：绝不做以下操作
// console.log('Private key:', process.env.SOLANA_PRIVATE_KEY);
// return { keypair: getKeypair(), ... };
// state.save({ privateKey: pk });

API Key 安全

输入校验

运行时安全

.gitignore 模板

项目初始化时必须创建：

# 环境变量（含私钥和 API Key）
.env
.env.*

# 运行时状态（含交易记录和持仓数据）
state/

# 依赖
node_modules/

# 系统文件
.DS_Store
*.log

网络安全

风控检查完整清单总览

共 25 项风控检查，分三级执行：

一级 Slot Guard（13 项，基于 ranking 数据，0 额外 API 调用）： 1. 涨幅下限 ≥ 5% 2. 涨幅上限 ≤ 5000% 3. 流动性 ≥ $3,000 4. 市值下限 ≥ $3,000 5. 市值上限 ≤ $500,000,000 6. 持有者数 ≥ 10 7. 买入比 ≥ 40% 8. 独立交易者 ≥ 10 9. 不在黑名单 10. 冷却期 ≥ 5 分钟 11. 仓位数 < maxPositions 12. 未持有该代币 13. 日亏损 < 15%

二级 Advanced Safety Check（9 项，调用 `advanced-info` 1 次）： 14. 风控等级 ≤ 3 15. 无蜜罐标签 16. Top10 集中度 ≤ 80% 17. 开发者持仓 ≤ 50% 18. Bundler 持仓 ≤ 30% 19. LP 销毁 ≥ 0%（不强制要求） 20. 开发者 Rug 历史 ≤ 20 21. 狙击手持仓 ≤ 30% 22. 允许内盘（blockInternal = false）

三级 Holder Risk Scan（3 项，调用 `token-holder` 2 次）： 23. 可疑地址持仓占比 ≤ 50% 24. 钓鱼地址检查关闭（blockPhishingHolder = false） 25. 可疑地址数 ≤ 20

术语表

SOL Ranking Sniper v0

思路

实时监控链上涨幅榜，新币上榜自动买入、跌出自动卖出——不提前预判哪个币能涨，而是吃上榜后的那一段动量。

策略细节

1. 每 10 秒轮询 OKX Solana 涨幅榜 Top 20 2. 新上榜代币先过 25 项风控（三级过滤）：

• 一级基础过滤（13 项）：涨幅区间 / 流动性 / 市值区间 / 持有者数 / 买入比 / 独立交易者 / 黑名单 / 冷却期 / 仓位上限 / 去重 / 日亏损上限
• 二级链上安全检查（9 项）：风控等级 / 蜜罐检测 / Top10 集中度 ≤50% / Dev 持仓 ≤20% / Bundler ≤15% / LP 销毁 ≥80% / 开发者 Rug 历史 ≤10 次 / 狙击手持仓 ≤20% / 内盘检测
• 三级持有者风险扫描（3 项）：可疑地址持仓 ≤10% / 无钓鱼地址 / 可疑地址数 ≤5

3. Smart Money 标签 +8 分、持仓分散度、低狙击手、开发者干净度、无可疑地址等信号加分 4. 0-125 分动量评分达标后买入（固定金额/笔） 5. 6 层退出机制：排名退出(最高优先级) > 硬止损(-25%) > 快速止损(5min/-8%) > 追踪止损(+8%激活/12%回撤) > 时间止损(6h) > 梯度止盈(+5%/+15%/+30% 分三批)。日亏损上限 15% 自动停机。

策略所使用的能力

所有接口均通过 OKX Onchain OS 公开 MCP https://web3.okx.com/api/v1/plugin-store-mcp 调用。

风控体系：有所为，有所不为

有所为（策略会做的事）

买入前 — 25 项三级风控过滤：

持仓中 — 6 层退出系统：

资金管理：

• 单笔固定金额（0.05 SOL），不加仓
• 日亏损 > 总预算 15% 自动停机
• SOL 余额 < 0.1 停止买入
• 永远保留 0.01 SOL gas 费

有所不为（策略不会做的事）

安全设计

• 私钥安全：仅从 .env 加载，不出现在日志/状态文件/API 响应/错误信息中；Keypair 对象封装在 swap-executor 内部
• Fail-Closed 原则：安全检查接口请求失败时，视为不安全，不买入
• 原子写入：状态文件先写 .tmp 再 rename，防止崩溃导致数据损坏
• 网络隔离：Dashboard 仅监听 127.0.0.1，不暴露公网
• 输入校验：所有用户输入和 MCP 返回值做类型/范围校验
• `.gitignore` 保护：.env、state/、node_modules/ 全部排除
• 超时控制：所有外部调用 15s 超时，防止挂起
• 内存限制：日志/缓存设上限，防止内存泄漏