encipher88-nadfunagent

Nad.fun 自主交易智能体，扫描市场、分析代币并执行链上交易。

---
name: nadfunagent
description: Nad.fun 的自主交易代理，扫描市场、分析代币、执行交易并将利润分配给 MMIND 代币持有者。使用 nadfun-trading、nadfun-indexer 和 nadfun-agent-api 技能。
user-invocable: true
argument-hint: [action] [options]
---

## 概述（中文）

Nad.fun 自主交易智能体，扫描市场、分析代币并执行链上交易。

## 技能正文

**关键通信规则：**
1. **语言**：始终使用与用户问题相同的语言回复。若为英文，则用英文回复。
2. **数据加载**：执行任何操作前，先从用户或配置文件请求并加载所有必需数据。使用 OpenClaw 记忆/会话存储保存已加载数据，避免重复询问。
3. **Telegram 集成**： 
   - 每个交易周期后向 Telegram 发送详细报告
   - 若 Telegram 机器人连接未建立，请用户先与机器人开始对话
   - 包含持仓状态、盈亏、发现的新机会、已执行交易
4. **初始设置**：首次调用时向用户询问：
   - MMIND_TOKEN_ADDRESS (or load from .env)
   - MONAD_PRIVATE_KEY (or load from .env)
   - MONAD_RPC_URL (or load from .env)
   - MONAD_NETWORK (or load from .env)
   - Telegram user ID for notifications
   将所有数据保存在 OpenClaw 记忆中供后续使用。
5. **缺失变量**：若 `.env` 缺失或任何必需变量（MONAD_PRIVATE_KEY、MONAD_RPC_URL、MMIND_TOKEN_ADDRESS、MONAD_NETWORK）未设置，在运行交易或脚本前**请用户提供**。配置完成前不要进行买卖或 execute-bonding-v2。

# Nad.fun 自主交易智能体

自主交易智能体，扫描 Nad.fun 市场，用动量策略分析代币，执行交易并将利润分配给 MMIND 代币持有者。

## 前置条件

- 已安装 `monad-development` 技能（钱包与 RPC 设置）
- 已安装 `nadfun-trading` 技能（买卖操作），或使用本仓库的 `trading/` 文件夹
- 已安装 `nadfun-indexer` 技能（查询事件）
- 已安装 `nadfun-agent-api` 技能（市场数据）
- 已配置网络（本技能仅主网）
- 已配置 MMIND 代币地址

**路径（干净安装）：** 配置从 `NADFUN_ENV_PATH` 读取（若设置），否则 `$HOME/nadfunagent/.env`。持仓报告：`POSITIONS_REPORT_PATH` 或 `$HOME/nadfunagent/positions_report.json`。`nadfun-trading` 脚本可能在 `~/.openclaw/workspace/skills/nadfun-trading` 或 `<this-repo>/trading`。见 `DEPENDENCIES.md`。

## Configuration

**关键**：从 `.env` 文件加载环境变量（默认路径：`$HOME/nadfunagent/.env`；可用 `NADFUN_ENV_PATH` 覆盖）：

- `MMIND_TOKEN_ADDRESS`：用于利润分配的 MMIND 代币地址（必需）
- `MONAD_PRIVATE_KEY`：交易钱包私钥（必需）
- `MONAD_RPC_URL`：RPC 端点 URL（必需）
- `MONAD_NETWORK`：网络类型 — "mainnet" 或 "testnet"（必需）
- `MAX_POSITION_SIZE`：最大持仓 MON（默认：0.1）
- `PROFIT_TARGET_PERCENT`：止盈阈值（默认：20%）
- `STOP_LOSS_PERCENT`：止损阈值（默认：10%）
- `PNL_DISTRIBUTION_PERCENT`：分配利润百分比（默认：30%）

**开始交易周期前：**
1. 读取 `.env`（路径：`NADFUN_ENV_PATH` 或 `$HOME/nadfunagent/.env`）。若文件缺失或任何必需变量为空，**请用户提供** MMIND_TOKEN_ADDRESS、MONAD_PRIVATE_KEY、MONAD_RPC_URL、MONAD_NETWORK — 配置完成前不要运行交易。
2. 加载 `MMIND_TOKEN_ADDRESS` — 用于利润分配
3. 加载 `MONAD_PRIVATE_KEY` — 用于钱包操作
4. 加载 `MONAD_RPC_URL` — 用于区块链查询
5. 加载 `MONAD_NETWORK` — 决定 API 端点（主网：api.nadapp.net，测试网：dev-api.nad.fun）

## 工作流

**执行摘要 — 请先阅读：**
1. **加载配置** 自 `$HOME/nadfunagent/.env`（MMIND_TOKEN_ADDRESS、MONAD_PRIVATE_KEY、MONAD_RPC_URL、MONAD_NETWORK）
2. **仅执行 3 种方法**（来自 HAR 分析）：方法 5（新事件 API）、方法 6（市值 API）、方法 7（创建时间 API）
3. **合并结果** — 合并 3 种方法的所有代币地址，统计频率（每种代币被多少方法发现，最多 3）
4. **优先级** — 按频率排序（2-3 种方法发现的代币 = 更高优先级）
5. **保存代币** — 将所有发现的代币（存储最多前 50）保存到 `$HOME/nadfunagent/found_tokens.json` 供人工审阅
6. **分析** — 通过 Agent API 获取代币信息、市场数据、指标并计算分数
7. **过滤** — 仅保留最低流动性 5 MON、最低持有者 5 的代币
8. **交易** — 分数 >= 60 时执行交易
9. **分配** — 利润 >= 0.1 MON 时向 MMIND 持有者分配利润

### 1. 市场扫描（新币 + 热门）

**关键指令**：必须使用以下全部 7 种方法扫描代币。逐步执行每种方法并收集所有发现的代币地址。

**执行顺序：**
1. 方法 1：CurveCreate 事件（Indexer）— 新代币
2. 方法 2：CurveBuy 事件（Indexer）— 按成交量热门  
3. 方法 3：Swap History（Agent API）— 按 24h 成交量热门
4. 方法 4：Holdings（Agent API）— 大户活跃代币
5. 方法 5：新事件 API — 实时 BUY/CREATE 事件
6. 方法 6：市值 API — 按市值排名代币
7. 方法 7：创建时间 API — 最新代币

**逐步执行：**

**关键日志要求：**
After executing EACH method, you MUST log:
1. 打印："✅ Method X executed: Found N tokens"
2. 打印："Method X token addresses: <address1> <address2> ..."
3. 若方法失败：打印："❌ Method X failed: <error reason>"
4. 这有助于跟踪哪些方法有效并调试问题

**注意：** 仅使用方法 5、6、7（来自 HAR 分析）。方法 1-4 已禁用。

**状态检查：** 此方法需要 RPC 访问。必须执行，不要跳过！

**做什么：**
1. Read `$HOME/nadfunagent/.env` to get `MONAD_RPC_URL` and `MONAD_NETWORK`
2. Get current block number using RPC: `eth_blockNumber`
3. Calculate: `safeLatest = currentBlock - 10` (safety margin)
4. Scan last 900 blocks in chunks of 100 blocks (RPC limit)
5. For each chunk, query CurveCreate events using `nadfun-indexer` skill

**如何执行：**
- Use `nadfun-indexer` skill with parameters: `event=CurveCreate`, `fromBlock=<start>`, `toBlock=<end>`
- Extract token addresses from events: `event.args.token` or `event.args[1]` (token is second argument)
- Collect all unique token addresses

**Example command structure:**
```
Use skill: nadfun-indexer
Parameters: event=CurveCreate, fromBlock=<calculated_start>, toBlock=<calculated_end>
Extract: token address from each event
```

**预期结果：** Array of token addresses (0x...) from newly created tokens

#### 方法 2：通过 Indexer 的热门代币（CurveBuy 成交量分析）

**状态检查：** 此方法需要 RPC 访问。必须执行，不要跳过！

**做什么：**
1. Query CurveBuy events from last 900 blocks (same pagination as Method 1)
2. For each event, extract: token address and amountIn (MON spent)
3. Sum volume per token address
4. Sort tokens by total volume (descending)
5. Take top 20 tokens with highest volume

**如何执行：**
1. **Use same RPC setup as Method 1:** Get publicClient from monad-development skill
2. **Query CurveBuy events:** For each 100-block chunk:
   - Use `nadfun-indexer` skill: `event=CurveBuy`, `fromBlock=<start>`, `toBlock=<end>`
   - OR use viem: `publicClient.getContractEvents({ address: CURVE_ADDRESS, eventName: "CurveBuy", fromBlock, toBlock })`
3. **Extract data:** From each event:
   - `token = event.args.token` or `event.args[1]`
   - `amountIn = event.args.amountIn` or `event.args[2]` (amount in MON)
4. **Calculate volume:** Group by token address, sum all amountIn values
5. **Sort and filter:** Sort by total volume DESC, take top 20
6. **Log results:** Print "✅ Method 2: Found top 20 trending tokens by volume"

**示例：**
```
1. Use same RPC client from Method 1
2. Query CurveBuy events in chunks of 100 blocks
3. For each event: extract token and amountIn
4. Sum volume per token
5. Sort DESC, take top 20
6. Print: "✅ Method 2: Found 20 trending tokens"
```

**预期结果：** Top 20 token addresses sorted by trading volume

#### 方法 3：通过 Agent API 的热门代币（Swap History 分析）

**做什么：**
1. Take top 10 tokens from Method 2 (highest volume)
2. For each token, query swap history via Agent API
3. Calculate 24h volume from swap history
4. Keep tokens with >= 1 MON volume in last 24 hours

**如何执行：**
- Determine API URL: if `MONAD_NETWORK=mainnet` then `https://api.nadapp.net`, else `https://dev-api.nad.fun`
- For each token, make GET request: `${API_URL}/agent/swap-history/${tokenAddress}?limit=50&trade_type=ALL`
- Parse response JSON
- For each swap in `response.swaps`:
  - Check `swap.swap_info.timestamp` - if within last 24 hours
  - Sum `swap.swap_info.native_amount` (in wei, convert to MON: divide by 1e18)
- Keep tokens with total 24h volume >= 1 MON
- Add 1-2 second delay between API calls to avoid rate limits

**示例：**
```
API_URL = MONAD_NETWORK === 'mainnet' ? 'https://api.nadapp.net' : 'https://dev-api.nad.fun'
For each token in top10:
  GET ${API_URL}/agent/swap-history/${token}?limit=50&trade_type=ALL
  Calculate 24h volume
  If volume >= 1 MON: add to trendingViaAPI
  Wait 1-2 seconds
```

**预期结果：** List of tokens with high 24h trading volume

#### 方法 4：获取所有活跃代币（通过大户持仓）

**STATUS CHECK:** Don't skip this method! Execute it with rate limit delays.

**做什么：**
1. From Method 2 CurveBuy events, find buyers who spent >1 MON
2. Extract their addresses (sender field)
3. Query holdings for first 5 large buyers (to avoid rate limits)
4. Extract all token addresses they hold (balance > 0)

**如何执行：**
1. **From Method 2 results:** Use CurveBuy events already queried
2. **Filter large buyers:**
   - Filter events where `amountIn > 1000000000000000000` (1 MON in wei = 1e18)
   - Extract `sender` address: `event.args.sender` or `event.args[0]`
   - Get unique addresses, take first 5
3. **Query holdings:** For each of 5 addresses:
   - GET: `${API_URL}/agent/holdings/${address}?limit=50`
   - Headers: `Accept: application/json`
   - Wait 2 seconds between requests
4. **Parse and extract:**
   - Parse JSON response
   - For each `holding` in `response.tokens`:
     - Check `holding.balance_info.balance` - if > 0
     - Extract `holding.token_info.address` or `holding.token_info.token_id`
5. **Log results:** Print "✅ Method 4: Found N active tokens from large trader holdings"

**示例：**
```
From Method 2 CurveBuy events:
  Filter: amou