---
name: nadfunagent
description: Autonomous trading agent for Nad.fun that scans markets, analyzes tokens, executes trades, and distributes profits to MMIND token holders. Uses nadfun-trading, nadfun-indexer, and nadfun-agent-api skills.
user-invocable: true
argument-hint: [action] [options]
---

**CRITICAL COMMUNICATION RULES:**
1. **Language**: Always respond in the SAME language as the user's question.  If in English, respond in English.
2. **Data Loading**: BEFORE executing any operations, FIRST request and load ALL required data from user or configuration files. Use OpenClaw's memory/session storage to save loaded data so you don't need to ask again.
3. **Telegram Integration**: 
   - Send detailed reports to Telegram after each trading cycle
   - If Telegram bot connection is not established, request user to start conversation with bot first
   - Include position status, P&L, new opportunities found, trades executed
4. **Initial Setup**: When first invoked, ask user for:
   - 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
   Save all this data in OpenClaw memory for future use.
5. **Missing variables**: If `.env` is missing or any required variable (MONAD_PRIVATE_KEY, MONAD_RPC_URL, MMIND_TOKEN_ADDRESS, MONAD_NETWORK) is not set, **ask the user to provide it** before running trading or scripts. Do not proceed with buy/sell or execute-bonding-v2 until config is complete.

# Nad.fun Autonomous Trading Agent

Autonomous trading agent that scans Nad.fun markets, analyzes tokens using momentum strategies, executes trades, and distributes profits to MMIND token holders.

## Prerequisites

- `monad-development` skill installed (for wallet and RPC setup)
- `nadfun-trading` skill installed (for buy/sell operations), or use the `trading/` folder from this repo
- `nadfun-indexer` skill installed (for querying events)
- `nadfun-agent-api` skill installed (for market data)
- Network configured (mainnet only for this skill)
- MMIND token address configured

**Paths (clean install):** Config is read from `NADFUN_ENV_PATH` if set, else `$HOME/nadfunagent/.env`. Positions report: `POSITIONS_REPORT_PATH` or `$HOME/nadfunagent/positions_report.json`. Scripts from `nadfun-trading` may be at `~/.openclaw/workspace/skills/nadfun-trading` or at `<this-repo>/trading`. See `DEPENDENCIES.md`.

## Configuration

**CRITICAL**: Load environment variables from `.env` file (default path: `$HOME/nadfunagent/.env`; override with `NADFUN_ENV_PATH`):

- `MMIND_TOKEN_ADDRESS`: Address of MMIND token for profit distribution (required)
- `MONAD_PRIVATE_KEY`: Private key for trading wallet (required)
- `MONAD_RPC_URL`: RPC endpoint URL (required)
- `MONAD_NETWORK`: Network type - "mainnet" or "testnet" (required)
- `MAX_POSITION_SIZE`: Maximum position size in MON (default: 0.1)
- `PROFIT_TARGET_PERCENT`: Take-profit threshold (default: 20%)
- `STOP_LOSS_PERCENT`: Stop-loss threshold (default: 10%)
- `PNL_DISTRIBUTION_PERCENT`: % of profit to distribute (default: 30%)

**Before starting trading cycle:**
1. Read `.env` file (path: `NADFUN_ENV_PATH` or `$HOME/nadfunagent/.env`). If the file is missing or any required variable is empty, **ask the user** to provide MMIND_TOKEN_ADDRESS, MONAD_PRIVATE_KEY, MONAD_RPC_URL, MONAD_NETWORK — do not run trading until config is complete.
2. Load `MMIND_TOKEN_ADDRESS` - use this for profit distribution
3. Load `MONAD_PRIVATE_KEY` - use this for wallet operations
4. Load `MONAD_RPC_URL` - use this for blockchain queries
5. Load `MONAD_NETWORK` - determines API endpoints (mainnet: api.nadapp.net, testnet: dev-api.nad.fun)

## Workflow

**EXECUTION SUMMARY - READ THIS FIRST:**
1. **Load config** from `$HOME/nadfunagent/.env` (MMIND_TOKEN_ADDRESS, MONAD_PRIVATE_KEY, MONAD_RPC_URL, MONAD_NETWORK)
2. **Execute ONLY 3 methods** (from HAR file analysis): Method 5 (New Events API), Method 6 (Market Cap API), Method 7 (Creation Time API)
3. **Combine results** - merge all token addresses from 3 methods, count frequency (how many methods found each token, max 3)
4. **Prioritize** - sort tokens by frequency (tokens found in 2-3 methods = higher priority)
5. **Save tokens** - save ALL found tokens (up to top 50 for storage) to `$HOME/nadfunagent/found_tokens.json` for manual review
6. **Analyze** - get token info, market data, metrics via Agent API, calculate scores
7. **Filter** - keep only tokens with min liquidity 5 MON, min holders 5
8. **Trade** - execute trades if score >= 60
9. **Distribute** - distribute profits to MMIND holders if profit >= 0.1 MON

### 1. Market Scanning (NEW + TRENDING)

**CRITICAL INSTRUCTIONS**: You MUST scan tokens using ALL 7 methods below. Execute each method step-by-step and collect ALL found token addresses.

**EXECUTION ORDER:**
1. Method 1: CurveCreate events (Indexer) - NEW tokens
2. Method 2: CurveBuy events (Indexer) - TRENDING by volume  
3. Method 3: Swap History (Agent API) - TRENDING by 24h volume
4. Method 4: Holdings (Agent API) - ACTIVE tokens from large traders
5. Method 5: New Events API - REAL-TIME BUY/CREATE events
6. Method 6: Market Cap API - TOP tokens by capitalization
7. Method 7: Creation Time API - NEWEST tokens

**STEP-BY-STEP EXECUTION:**

**CRITICAL LOGGING REQUIREMENT:**
After executing EACH method, you MUST log:
1. Print: "✅ Method X executed: Found N tokens"
2. Print: "Method X token addresses: <address1> <address2> ..."
3. If method failed: Print: "❌ Method X failed: <error reason>"
4. This helps track which methods are working and debug issues

**NOTE:** Only Methods 5, 6, and 7 are used (from HAR file analysis). Methods 1-4 are disabled.

**STATUS CHECK:** This method requires RPC access. You MUST execute it, don't skip it!

**What to do:**
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

**How to execute:**
- 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
```

**Expected result:** Array of token addresses (0x...) from newly created tokens

#### Method 2: Trending Tokens via Indexer (CurveBuy volume analysis)

**STATUS CHECK:** This method requires RPC access. You MUST execute it, don't skip it!

**What to do:**
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

**How to execute:**
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"

**Example:**
```
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"
```

**Expected result:** Top 20 token addresses sorted by trading volume

#### Method 3: Trending Tokens via Agent API (Swap History Analysis)

**What to do:**
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

**How to execute:**
- 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

**Example:**
```
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
```

**Expected result:** List of tokens with high 24h trading volume

#### Method 4: Get All Active Tokens (via Holdings of Large Accounts)

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

**What to do:**
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)

**How to execute:**
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"

**Example:**
```
From Method 2 CurveBuy events:
  Filter: amountIn > 1e18 (1 MON)
  Extract: sender addresses
  Take first 5 unique addresses
For each address:
  GET ${API_URL}/agent/holdings/${address}?limit=50
  Extract tokens with balance > 0
  Wait 2 seconds
Print: "✅ Method 4: Found X tokens"
```

**Expected result:** Set of token addresses held by active large traders

#### Method 5: New Events API (Real-time BUY/SELL/CREATE events)

**STATUS:** ✅ This method is WORKING! Found 7 tokens in last scan.

**What to do:**
1. Make GET request to `/api/token/new-event` endpoint
2. Parse JSON response (array of events)
3. Extract token addresses from CREATE and BUY events
4. Add all unique token addresses to collection

**How to execute:**
1. **Determine base URL:** Read MONAD_NETWORK from .env:
   - If `MONAD_NETWORK=mainnet`: `baseUrl = 'https://nad.fun'`
   - Else: `baseUrl = 'https://dev.nad.fun'`
2. **Make GET request:**
   - URL: `${baseUrl}/api/token/new-event`
   - Headers: `Accept: application/json`, `User-Agent: OpenClaw-Agent/1.0`
3. **Parse response:** JSON array of event objects
4. **Extract tokens:**
   - For each event in response:
     - If `event.type === 'CREATE'`: extract `event.token_info.token_id`
     - If `event.type === 'BUY'`: extract `event.token_info.token_id`
     - If `event.type === 'SELL'`: optionally extract (indicates active trading)
5. **Log results:** Print "✅ Method 5: Found N tokens from new events API"

**Example:**
```
baseUrl = MONAD_NETWORK === 'mainnet' ? 'https://nad.fun' : 'https://dev.nad.fun'
GET ${baseUrl}/api/token/new-event
Parse JSON response
For each event:
  If event.type === 'CREATE' or 'BUY':
    Add event.token_info.token_id to tokensFromEvents
Print: "✅ Method 5: Found X tokens"
```

**Expected result:** Array of token addresses from recent CREATE and BUY events

**Response structure:**
- `type`: "BUY" | "SELL" | "CREATE"
- `amount`: Event amount (string)
- `token_info`: Complete token information (token_id, name, symbol, description, creator, etc.)
- `account_info`: Account that performed the action

#### Method 6: Market Cap API (Top tokens by market cap)

**STATUS CHECK:** Previous error: base64 decoding failed. Fix: Use proper decoding method.

**What to do:**
1. GET request to market cap endpoint
2. Response is base64-encoded JSON - decode it PROPERLY
3. Extract token addresses from response
4. Add all token addresses to collection

**How to execute:**
1. **API URL:** `${API_URL}/order/market_cap?page=1&limit=50&is_nsfw=false`
   - Where `API_URL = MONAD_NETWORK === 'mainnet' ? 'https://api.nadapp.net' : 'https://dev-api.nad.fun'`
2. **GET request:**
   - Headers: `Accept: application/json`, `User-Agent: OpenClaw-Agent/1.0`
   - Get response as text (not JSON)
3. **Decode base64 PROPERLY:**
   - Response body is base64 string
   - Use Python: `import base64; decoded = base64.b64decode(response_text).decode('utf-8')`
   - OR use command: `echo "$response_text" | base64 -d`
   - CRITICAL: Make sure response_text is the raw base64 string, not wrapped in JSON
4. **Parse decoded JSON:**
   - Parse decoded string as JSON
   - Structure: `{ "tokens": [...], "total_count": N }`
5. **Extract tokens WITH FULL DATA:**
   - For each token in `data.tokens`:
     - Extract `token.token_info.token_id` (token address)
     - **CRITICAL**: Store FULL token object with both `token_info` AND `market_info`
     - Structure: `{token_info: {...}, market_info: {...}, percent: ...}`
     - Add to topMarketCapTokens array (store full objects, not just addresses)
6. **Log results:** Print "✅ Method 6: Found N tokens with market data from market cap API"

**Example:**
```
API_URL = MONAD_NETWORK === 'mainnet' ? 'https://api.nadapp.net' : 'https://dev-api.nad.fun'
response = GET ${API_URL}/order/market_cap?page=1&limit=100&is_nsfw=false
decoded = base64.b64decode(response.text).decode('utf-8')
data = json.loads(decoded)

topMarketCapTokens = []  # Array of full token objects
For each token in data.tokens:
  # Store FULL token object with token_info + market_info
  topMarketCapTokens.append({
    'token_info': token.token_info,
    'market_info': token.market_info,
    'percent': token.percent,
    'address': token.token_info.token_id  # For easy access
  })
Print: "✅ Method 6: Found X tokens with market data"
```

**Expected result:** Array of full token objects (with token_info + market_info) sorted by market cap

**Response structure:**
- `tokens`: Array of token objects with `token_info` and `market_info`
- `total_count`: Total number of tokens
- Each token includes: `token_info` (token_id, name, symbol, creator, etc.) and `market_info` (market_type, price, volume, holder_count, etc.)

#### Method 7: Creation Time API (Newest tokens)

**CRITICAL**: Include BOTH bonding curve AND DEX tokens! Do NOT filter by is_graduated.

**What to do:**
1. GET request to creation time endpoint (newest first)
2. Decode base64 response PROPERLY (same as Method 6)
3. Extract token addresses - include ALL tokens (both bonding curve AND DEX)
4. Add to collection WITH FULL DATA

**How to execute:**
- API URL: `${API_URL}/order/creation_time?page=1&limit=50&is_nsfw=false&direction=DESC`
- GET request, decode base64 response (same as Method 6)
- Parse JSON: `data.tokens` array
- For each token:
  - Extract `token.token_info.token_id` (token address)
  - **CRITICAL**: Store FULL token object with both `token_info` AND `market_info`
  - **DO NOT filter by is_graduated** - include both bonding curve (is_graduated=false) AND DEX (is_graduated=true) tokens
  - Add to newestTokens array (store full objects, not just addresses)

**Example:**
```
API_URL = MONAD_NETWORK === 'mainnet' ? 'https://api.nadapp.net' : 'https://dev-api.nad.fun'
response = GET ${API_URL}/order/creation_time?page=1&limit=50&is_nsfw=false&direction=DESC
decoded = base64.b64decode(response.text).decode('utf-8')
data = json.loads(decoded)

newestTokens = []  # Array of full token objects
For each token in data.tokens:
  # Include ALL tokens - both bonding curve AND DEX
  # Store FULL token object with token_info + market_info
  newestTokens.append({
    'token_info': token.token_info,
    'market_info': token.market_info,
    'percent': token.percent,
    'address': token.token_info.token_id  # For easy access
  })
Print: "✅ Method 7: Found X tokens with market data (bonding curve + DEX)"
```

**Expected result:** Array of full token objects (with token_info + market_info) - newest tokens including both bonding curve AND DEX

**Response structure:**
- Same as Method 6: `tokens` array with `token_info` and `market_info`
- `direction=DESC` returns newest first
- **CRITICAL**: Include ALL tokens (both bonding curve AND DEX) - do NOT filter by is_graduated

#### Combine All Methods - CRITICAL STEP

**What to do:**
1. Collect ALL token addresses from Methods 5, 6, and 7 into one set (removes duplicates)
2. Count how many times each token appears across methods
3. Sort tokens by frequency (tokens found in more methods = higher priority/confidence)
4. Log summary of combination results

**How to execute:**
1. **Create collections:**
   - `allTokens = new Set()` or `allTokens = []` (use Set to avoid duplicates)
   - `tokenFrequency = new Map()` or `{}` to count occurrences

2. **Add tokens from each method:**
   - Method 5: Add all token addresses from tokensFromEvents (New Events API) - these are just addresses
   - Method 6: Add all tokens from topMarketCapTokens (Market Cap API) - these are FULL objects with token_info + market_info
   - Method 7: Add all tokens from newestTokens (Creation Time API) - these are FULL objects with token_info + market_info
   
   **IMPORTANT**: For Methods 6 & 7, store the FULL token objects (not just addresses) so you can use market_info directly for analysis!

3. **Count frequency and preserve full data:**
   - Use a Map/object: `allTokensMap = {}` where key = token address, value = token object with metadata
   - For Method 5 (addresses only): `allTokensMap[address] = {address, source: 'method5', data: null}`
   - For Method 6 (full objects): `allTokensMap[address] = {address, source: 'method6', data: fullTokenObject}`
   - For Method 7 (full objects): `allTokensMap[address] = {address, source: 'method7', data: fullTokenObject}`
   - Count frequency: `tokenFrequency[address] = (tokenFrequency[address] || 0) + 1`
   - **CRITICAL**: Preserve full token objects from Methods 6 & 7 - they contain market_info!

4. **Convert and sort:**
   - `candidateTokens = Object.values(allTokensMap)` or `Array.from(allTokensMap.values())`
   - Sort by frequency DESC, then by data availability:
     ```javascript
     candidateTokens.sort((a, b) => {
       const freqA = tokenFrequency[a.address] || 0
       const freqB = tokenFrequency[b.address] || 0
       if (freqB !== freqA) return freqB - freqA  // Higher frequency first
       // Prefer tokens with full data (market_info)
       const hasDataA = a.data && a.data.market_info ? 1 : 0
       const hasDataB = b.data && b.data.market_info ? 1 : 0
       return hasDataB - hasDataA
     })
     ```
   - `prioritizedTokens = candidateTokens`

5. **Log summary:**
   - Print: "📊 Combined results: Total unique tokens: N"
   - Print: "Tokens found in 2+ methods: X"
   - Print: "Tokens found in all 3 methods: Y"
   - Print: "Tokens with full market data: Z"
   - Print: "Top 10 prioritized tokens: <list with addresses>"

**Example:**
```
allTokensMap = {}  # Map: address -> {address, source, data}
tokenFrequency = {}

# Method 5: addresses only
for address in tokensFromEvents:
  allTokensMap[address] = {address: address, source: 'method5', data: null}
  tokenFrequency[address] = (tokenFrequency[address] || 0) + 1

# Method 6: full objects with market_info
for token in topMarketCapTokens:
  address = token.token_info.token_id
  allTokensMap[address] = {address: address, source: 'method6', data: token}
  tokenFrequency[address] = (tokenFrequency[address] || 0) + 1

# Method 7: full objects with market_info
for token in newestTokens:
  address = token.token_info.token_id
  allTokensMap[address] = {address: address, source: 'method7', data: token}
  tokenFrequency[address] = (tokenFrequency[address] || 0) + 1

# Sort by frequency and data availability
candidateTokens = Object.values(allTokensMap)
prioritizedTokens = candidateTokens.sort((a, b) => {
  freqDiff = tokenFrequency[b.address] - tokenFrequency[a.address]
  if (freqDiff !== 0) return freqDiff
  return (b.data && b.data.market_info ? 1 : 0) - (a.data && a.data.market_info ? 1 : 0)
})

Print: "📊 Combined: N unique tokens, X found in 2+ methods, Y found in all 3 methods, Z with full data"
```

**Expected result:** Prioritized array of token objects, each containing:
- `address`: token address
- `source`: which method(s) found it
- `data`: full token object with token_info + market_info (if available from Methods 6 or 7)
- `foundInMethods`: count from tokenFrequency

#### Save Found Tokens - CRITICAL STEP

**What to do:**
After combining all methods and getting prioritizedTokens, you MUST save them to file `$HOME/nadfunagent/found_tokens.json` for manual review.

**How to execute:**

1. **Prepare token list:**
   - Take top 50 tokens from prioritizedTokens
   - For each token, create object: `{address: token, foundInMethods: frequency_count}`
   - Create scan entry with timestamp, totalFound count, and tokens array

2. **Read existing file:**
   - File: `$HOME/nadfunagent/found_tokens.json`
   - If file doesn't exist or is empty: start with `[]`
   - If exists: parse JSON, get array

3. **Append and save:**
   - Add new scan entry to array
   - Keep only last 100 scans (remove oldest if > 100)
   - Write back as formatted JSON

**Example using Node.js script (RECOMMENDED):**
```bash
# From skill root or repo root: print token addresses (one per line) and pipe to script
# prioritizedTokens is the array of token addresses; take first 50 and pass to script
echo -e "0x...\n0x..." | node scripts/save_tokens.js
```
Or from the agent: write the list of addresses to a temp file or stdin and run `node scripts/save_tokens.js` (script reads from stdin). Data dir: `NADFUNAGENT_DATA_DIR` or `$HOME/nadfunagent`.

**Expected result:** File `$HOME/nadfunagent/found_tokens.json` updated with latest scan results

### 2. Token Analysis - CRITICAL: Use Data from Methods 6 & 7 Directly

**IMPORTANT**: Methods 6 (Market Cap API) and Method 7 (Creation Time API) already return COMPLETE token data with `market_info`. Use this data directly for analysis - DO NOT make additional API calls unless absolutely necessary!

**Data Structure from Methods 6 & 7:**
Each token in the response has this structure:
```json
{
  "token_info": {
    "token_id": "0x...",
    "name": "...",
    "symbol": "...",
    "is_graduated": true/false,
    "created_at": timestamp,
    ...
  },
  "market_info": {
    "market_type": "DEX" or "BONDING_CURVE",
    "reserve_native": "1625513352353765005672133",  // Liquidity in MON (wei format)
    "reserve_token": "51582894169959918089536846",
    "token_price": "0.000886889894056452",
    "price": "0.0415501242",
    "price_usd": "0.000886889894056452",
    "volume": "761848094037806233587694495",  // Total volume (wei format)
    "holder_count": 31580,  // Number of holders
    "ath_price": "0.0128807779",
    "ath_price_usd": "0.0128807779",
    ...
  },
  "percent": 8.797  // Market cap change percentage
}
```

**Analysis Steps:**

1. **Extract data from Methods 6 & 7:**
   - For each token in `data.tokens` array from Methods 6 & 7:
     - Extract `token_info.token_id` (token address)
     - Extract `market_info.reserve_native` (liquidity in wei, convert to MON: divide by 1e18)
     - Extract `market_info.holder_count` (number of holders)
     - Extract `market_info.volume` (total volume in wei, convert to MON: divide by 1e18)
     - Extract `market_info.market_type` ("DEX" or "BONDING_CURVE")
     - Extract `token_info.is_graduated` (true if graduated to DEX)
     - Extract `percent` (market cap change percentage)

2. **For Method 5 tokens (new-event API):**
   - This API returns only basic event data without full market_info
   - For tokens from Method 5, you can optionally query `/agent/market/:token_id` to get market_info
   - BUT prioritize tokens from Methods 6 & 7 first (they already have complete data)

3. **Calculate Liquidity Score (30% weight):**
   ```javascript
   liquidityMON = parseFloat(market_info.reserve_native) / 1e18
   
   // Score based on liquidity tiers
   if (liquidityMON >= 1000) liquidityScore = 100      // Excellent
   else if (liquidityMON >= 500) liquidityScore = 80     // Very good
   else if (liquidityMON >= 100) liquidityScore = 60    // Good
   else if (liquidityMON >= 50) liquidityScore = 40      // Fair
   else if (liquidityMON >= 10) liquidityScore = 20      // Low
   else liquidityScore = 0                              // Too low
   
   weightedLiquidity = liquidityScore * 0.30
   ```

4. **Calculate Momentum Score (25% weight):**
   ```javascript
   // Use percent (market cap change) as momentum indicator
   percentChange = parseFloat(token.percent) || 0
   
   // Score based on positive momentum
   if (percentChange >= 50) momentumScore = 100      // Strong growth
   else if (percentChange >= 20) momentumScore = 80
   else if (percentChange >= 10) momentumScore = 60
   else if (percentChange >= 5) momentumScore = 40
   else if (percentChange >= 0) momentumScore = 20
   else momentumScore = 0                           // Negative momentum
   
   weightedMomentum = momentumScore * 0.25
   ```

5. **Calculate Volume Score (20% weight):**
   ```javascript
   volumeMON = parseFloat(market_info.volume) / 1e18
   
   // Score based on volume tiers
   if (volumeMON >= 1000000) volumeScore = 100      // 1M+ MON volume
   else if (volumeMON >= 500000) volumeScore = 80
   else if (volumeMON >= 100000) volumeScore = 60
   else if (volumeMON >= 50000) volumeScore = 40
   else if (volumeMON >= 10000) volumeScore = 20
   else volumeScore = 0
   
   weightedVolume = volumeScore * 0.20
   ```

6. **Calculate Holder Score (15% weight):**
   ```javascript
   holderCount = parseInt(market_info.holder_count) || 0
   
   // Score based on holder count
   if (holderCount >= 10000) holderScore = 100      // Excellent distribution
   else if (holderCount >= 5000) holderScore = 80
   else if (holderCount >= 1000) holderScore = 60
   else if (holderCount >= 500) holderScore = 40
   else if (holderCount >= 100) holderScore = 20
   else holderScore = 0
   
   weightedHolders = holderScore * 0.15
   ```

7. **Calculate Progress Score (10% weight):**
   ```javascript
   isGraduated = token_info.is_graduated === true
   marketType = market_info.market_type
   
   // Score based on market stage
   if (isGraduated || marketType === "DEX") {
     progressScore = 100  // Fully graduated to DEX
   } else {
     // Still on bonding curve - use percent as progress indicator
     // Higher percent = closer to graduation
     percent = parseFloat(token.percent) || 0
     if (percent >= 80) progressScore = 80
     else if (percent >= 50) progressScore = 60
     else if (percent >= 30) progressScore = 40
     else progressScore = 20
   }
   
   weightedProgress = progressScore * 0.10
   ```

8. **Calculate Authority Score (Bonus - up to +10 points):**
   ```javascript
   // Check for social media presence and website (indicates legitimacy)
   hasTwitter = token_info.twitter && token_info.twitter.length > 0
   hasTelegram = token_info.telegram && token_info.telegram.length > 0
   hasWebsite = token_info.website && token_info.website.length > 0
   
   authorityScore = 0
   if (hasTwitter) authorityScore += 3
   if (hasTelegram) authorityScore += 3
   if (hasWebsite) authorityScore += 4
   
   // Maximum +10 bonus points for full social presence
   authorityBonus = Math.min(authorityScore, 10)
   ```

9. **Calculate Total Score:**
   ```javascript
   totalScore = weightedLiquidity + weightedMomentum + weightedVolume + weightedHolders + weightedProgress + authorityBonus
   
   // Round to 2 decimal places
   totalScore = Math.round(totalScore * 100) / 100
   ```

9. **Store Analysis Results:**
   For each token, store:
   ```javascript
   {
     address: token_info.token_id,
     name: token_info.name,
     symbol: token_info.symbol,
     liquidity: liquidityMON,
     holders: holderCount,
     volume: volumeMON,
     marketType: marketType,
     isGraduated: isGraduated,
     percentChange: percentChange,
     scores: {
       liquidity: liquidityScore,
       momentum: momentumScore,
       volume: volumeScore,
       holders: holderScore,
       progress: progressScore,
       total: totalScore
     },
     foundInMethods: tokenFrequency[token_info.token_id] || 1
   }
   ```

**CRITICAL INSTRUCTIONS:**
- Use data from Methods 6 & 7 DIRECTLY - they already contain all needed information
- DO NOT make additional API calls to `/agent/market/:token_id` for tokens from Methods 6 & 7
- Only for Method 5 tokens (if needed) make additional API calls
- Calculate scores immediately after combining methods, before filtering
- **Check authority (social media presence)**: Check `token_info.twitter`, `token_info.telegram`, `token_info.website` - add bonus points
- Log analysis results: Print "📊 Analysis: Token X has score Y (liquidity: A, momentum: B, volume: C, holders: D, progress: E, authority: +F)"

### 3. Filtering Criteria

Filter tokens based on:

- **Minimum liquidity**: 5 MON
- **Minimum holders**: 5
- **Bonding curve progress**: >= 10%
- **Score calculation**:
  - Liquidity: 30% weight
  - Momentum: 25% weight
  - Volume trend: 20% weight
  - Holder distribution: 15% weight
  - Bonding curve progress: 10% weight

### 4. Position Management - CRITICAL: Check Existing Positions FIRST

**BEFORE analyzing new tokens, you MUST check and manage existing positions!**

#### Step 1: Get Current Holdings

**What to do:**
1. Get trading wallet address from `MONAD_PRIVATE_KEY` in `.env` (derive address from private key)
2. Query current token holdings using Agent API: `/agent/holdings/${walletAddress}?limit=100`
3. Filter tokens where `balance > 0` (exclude zero balances)
4. For each token with balance > 0, get current market data

**How to execute:**
```javascript
// 1. Get wallet address from private key
const walletAddress = getAddressFromPrivateKey(MONAD_PRIVATE_KEY)

// 2. Query holdings
const holdingsResponse = await fetch(`${API_URL}/agent/holdings/${walletAddress}?limit=100`)
const holdings = await holdingsResponse.json()

// 3. Filter tokens with balance > 0
const activePositions = holdings.tokens.filter(token => {
  const balance = parseFloat(token.balance_info.balance) || 0
  return balance > 0
})

Print: "📊 Current positions: Found N tokens with balance > 0"
```

#### Step 2: Calculate P&L for Each Position

**CRITICAL**: Always use the `check-pnl.js` script from `nadfun-trading` skill for proper P&L calculation. This script:
- Reads entry price (`entryValueMON`) from `$HOME/nadfunagent/positions_report.json` (automatically recorded by `buy-token.js` when you purchase)
- Gets current value on-chain via nad.fun quote contract (or falls back to Agent API)
- Calculates P&L: `(currentValueMON - entryValueMON) / entryValueMON * 100`

**What to do:**
1. **Use the script**: Run `check-pnl.js` from nadfun-trading skill directory
2. The script reads entry prices from JSON (set by `buy-token.js` after purchases)
3. Gets current value on-chain via nad.fun quote contract
4. Calculates real P&L based on actual entry price

**How to execute:**
```bash
# Check P&L for all positions
cd $HOME/.openclaw/workspace/skills/nadfun-trading
node check-pnl.js

# Or with auto-sell (sells if P&L >= +5% or <= -10%)
node check-pnl.js --auto-sell
```

**Manual calculation (if script unavailable):**
```javascript
// Load entry prices from positions_report.json
const report = JSON.parse(await fs.readFile('$HOME/nadfunagent/positions_report.json', 'utf-8'))

for (const position of activePositions) {
  const tokenAddress = position.token_info.token_id || position.token_info.address
  const tokenBalance = parseFloat(position.balance_info.balance) || 0
  
  // Get entry price from JSON (recorded by buy-token.js)
  const prev = report.positions?.find(p => 
    (p.address || '').toLowerCase() === tokenAddress.toLowerCase()
  )
  const entryValueMON = prev?.entryValueMON || 0
  
  // Get current value on-chain via nad.fun quote contract
  const [router, amountOutWei] = await publicClient.readContract({
    address: '0x7e78A8DE94f21804F7a17F4E8BF9EC2c872187ea', // nad.fun quote contract
    abi: lensAbi,
    functionName: 'getAmountOut',
    args: [tokenAddress, parseEther(tokenBalance.toString()), false] // false = selling
  })
  const currentValueMON = Number(amountOutWei) / 1e18
  
  // Calculate P&L
  const pnlPercent = entryValueMON > 0
    ? ((currentValueMON - entryValueMON) / entryValueMON) * 100
    : 0
  
  positions.push({
    address: tokenAddress,
    balance: tokenBalance,
    entryValueMON: entryValueMON,
    currentValueMON: currentValueMON,
    pnlPercent: pnlPercent
  })
}

Print: "💰 Position P&L calculated for N positions (source: on-chain nad.fun quote + positions_report.json)"
```

**Entry Price Tracking:**
- Entry price is automatically recorded by `buy-token.js` after successful purchase
- Stored in `$HOME/nadfunagent/positions_report.json` as `entryValueMON`
- If entry price not found, `check-pnl.js` uses current value as fallback (P&L = 0%)

#### Step 3: Make Sell Decisions

**What to do:**
For each position, check sell conditions:

1. **Stop-Loss Check:**
   ```javascript
   if (pnlPercent <= -10) {  // STOP_LOSS_PERCENT = -10%
     // SELL ALL - stop loss triggered
     sellDecision = {
       action: 'SELL_ALL',
       reason: 'Stop-loss triggered',
       tokenAddress: position.address,
       amount: 'all'
     }
   }
   ```

2. **Take-Profit Check:**
   ```javascript
   if (pnlPercent >= 20) {  // PROFIT_TARGET_PERCENT = 20%
     // SELL HALF - take profit
     sellDecision = {
       action: 'SELL_HALF',
       reason: 'Take-profit triggered',
       tokenAddress: position.address,
       amount: position.balance / 2
     }
   }
   ```

3. **Trailing Stop (Optional):**
   ```javascript
   // If profit was > 15% but dropped to < 5%, sell to protect gains
   if (previousPnL > 15 && pnlPercent < 5) {
     sellDecision = {
       action: 'SELL_ALL',
       reason: 'Trailing stop - protecting gains',
       tokenAddress: position.address,
       amount: 'all'
     }
   }
   ```

**How to execute:**
```javascript
const sellDecisions = []

for (const position of positions) {
  // Stop-loss: sell all if down 10%+
  if (position.pnlPercent <= -10) {
    sellDecisions.push({
      tokenAddress: position.address,
      action: 'SELL_ALL',
      reason: `Stop-loss: ${position.pnlPercent.toFixed(2)}%`,
      amount: 'all'
    })
  }
  // Take-profit: sell half if up 20%+
  else if (position.pnlPercent >= 20) {
    sellDecisions.push({
      tokenAddress: position.address,
      action: 'SELL_HALF',
      reason: `Take-profit: ${position.pnlPercent.toFixed(2)}%`,
      amount: position.balance / 2
    })
  }
}

Print: "🔔 Sell decisions: N positions need action"
for (const decision of sellDecisions) {
  Print: `   ${decision.action}: ${decision.tokenAddress} - ${decision.reason}`
}
```

#### Step 4: Execute Sell Orders

**What to do:**
For each sell decision:
1. Use `nadfun-trading` skill with action `sell`
2. Parameters: token address, amount (from decision)
3. The skill handles: balance check, quote, approve, execution

**How to execute:**
```javascript
for (const decision of sellDecisions) {
  try {
    // Use nadfun-trading skill
    await useSkill('nadfun-trading', {
      action: 'sell',
      token: decision.tokenAddress,
      amount: decision.amount  // 'all' or specific amount
    })
    
    Print: `✅ Sold ${decision.amount} of ${decision.tokenAddress}: ${decision.reason}`
  } catch (error) {
    Print: `❌ Failed to sell ${decision.tokenAddress}: ${error.message}`
  }
}
```

### 5. Trading Execution - Buy New Tokens

**CRITICAL**: Only buy new tokens AFTER managing existing positions!

**Buy Decision Logic:**

1. **Prioritize tokens with authority (social media presence):**
   - Tokens with Twitter + Telegram + Website get priority
   - These are more legitimate and have better community support

2. **Consider both early-stage AND established tokens:**
   - Early-stage (5-50 MON liquidity): Higher risk, higher potential
   - Established (50k+ MON liquidity): Lower risk, steady growth
   - Both can be profitable if they meet score criteria

3. **Buy Criteria:**
   - Score >= 60 (or >= 55 if has social media)
   - Liquidity >= 5 MON
   - Holders >= 5
   - NOT already in portfolio (check existing positions first)

4. **Position Sizing:**
   - For tokens with authority (social media): up to 0.15 MON
   - For tokens without authority: up to 0.1 MON
   - Maximum total position per token: 0.15 MON

**CRITICAL**: Always use the `buy-token.js` script from `nadfun-trading` skill. This script:
- Automatically detects bonding curve vs DEX via nad.fun quote contract
- Handles DEX: wraps MON→WMON, approves, swaps
- **Automatically records entry price** in `$HOME/nadfunagent/positions_report.json` after successful purchase
- Works on bonding curve (MON) or DEX (MON) - all trading uses MON

**Buy tokens:**
```bash
cd $HOME/.openclaw/workspace/skills/nadfun-trading
NAD_PRIVATE_KEY=$MONAD_PRIVATE_KEY node buy-token.js <token-address> <MON-amount> [--slippage=300]
```

**Example:**
```bash
NAD_PRIVATE_KEY=0x... node buy-token.js 0x123...abc 0.15 --slippage=300
```

**After purchase:**
- Entry price (`entryValueMON`) is automatically recorded in `$HOME/nadfunagent/positions_report.json`
- This entry price is used by `check-pnl.js` for P&L calculation
- No manual tracking needed - everything is automated

**Risk management:**
- **CRITICAL**: Buy tokens on BOTH bonding curve AND DEX (don't filter by market_type)
- The `nadfun-trading` skill automatically detects market type and uses correct contract
- For all trades, use MON balance (no wrapping needed - all trading uses MON)
- Set slippage tolerance: 2-3% (increased for better execution, especially on DEX)
- Set deadline: 5 minutes from now
- Don't exceed MAX_POSITION_SIZE per token

### 6. Profit Distribution

**CRITICAL**: Use `MMIND_TOKEN_ADDRESS` from `$HOME/nadfunagent/.env` file.

When profit >= 0.1 MON:

```typescript
// Step 1: Load MMIND_TOKEN_ADDRESS from .env file
const envFile = await readFile('$HOME/nadfunagent/.env', 'utf-8')
const mmindMatch = envFile.match(/MMIND_TOKEN_ADDRESS=(0x[a-fA-F0-9]+)/)
if (!mmindMatch) {
  throw new Error('MMIND_TOKEN_ADDRESS not found in .env file')
}
const MMIND_TOKEN_ADDRESS = mmindMatch[1]

// Step 2: Get MMIND token holders via Indexer
// Query Transfer events to find all addresses that ever held MMIND
const latestBlock = await publicClient.getBlockNumber()
const safeLatest = latestBlock - 10n

// Query in chunks (RPC limit: ~100 blocks)
const transfers = []
for (let from = 0n; from < safeLatest; from += 10000n) {
  const to = from + 10000n > safeLatest ? safeLatest : from + 10000n
  try {
    const events = await useSkill('nadfun-indexer', {
      event: 'Transfer',
      token: MMIND_TOKEN_ADDRESS,
      fromBlock: from,
      toBlock: to
    })
    transfers.push(...events)
  } catch (err) {
    // Continue if chunk fails
  }
}

// Step 3: Collect unique addresses
const holderAddresses = new Set()
transfers.forEach(event => {
  if ('args' in event) {
    if (event.args.from && event.args.from !== '0x0000000000000000000000000000000000000000') {
      holderAddresses.add(event.args.from)
    }
    if (event.args.to && event.args.to !== '0x0000000000000000000000000000000000000000') {
      holderAddresses.add(event.args.to)
    }
  }
})

// Step 4: Get current balances for each holder
const distributions = []
for (const address of holderAddresses) {
  try {
    const balance = await publicClient.readContract({
      address: MMIND_TOKEN_ADDRESS,
      abi: erc20Abi,
      functionName: 'balanceOf',
      args: [address]
    })
    
    if (balance > 0n) {
      distributions.push({ address, balance })
    }
  } catch (err) {
    // Skip if balance check fails
  }
}

// Step 5: Get total supply
const totalSupply = await publicClient.readContract({
  address: MMIND_TOKEN_ADDRESS,
  abi: erc20Abi,
  functionName: 'totalSupply'
})

// Step 6: Calculate and distribute profit proportionally
const profitToDistribute = (profit * BigInt(PNL_DISTRIBUTION_PERCENT)) / 100n

for (const holder of distributions) {
  const share = (profitToDistribute * holder.balance) / totalSupply
  if (share >= parseEther('0.001')) { // Minimum 0.001 MON
    await transferMON(holder.address, share) // Transfer MON directly (all trading uses MON)
  }
}
```

## Autonomous Trading Loop

The agent runs continuously:

1. **Position Management FIRST** (CRITICAL - do this before scanning)
   - Get wallet address from `MONAD_PRIVATE_KEY`
   - Query current holdings: `/agent/holdings/${walletAddress}?limit=100`
   - Filter tokens with balance > 0
   - For each position: use `check-pnl.js` to get real P&L (reads entry price from `$HOME/nadfunagent/positions_report.json`, gets current value on-chain via nad.fun quote contract)
   - Execute sell orders: use `sell-token.js` or `check-pnl.js --auto-sell` for stop-loss (P&L <= -10%) or take-profit (P&L >= +5%)
   - Log: "📊 Positions: N checked, X sold; entry prices tracked in positions_report.json"

2. **Scan market** (after managing positions, every 10 minutes to avoid rate limits)
   - Method 5: Fetch new events API (`/api/token/new-event`) for real-time BUY/CREATE events
   - Method 6: Fetch top tokens by market cap (`api.nadapp.net/order/market_cap`, base64 decoded)
   - Method 7: Fetch newest tokens (`api.nadapp.net/order/creation_time`, base64 decoded)
   - Combine all methods and prioritize tokens found in multiple sources
   - Add 2-3 second delays between API calls to respect rate limits (CRITICAL to avoid HTTP 429)

2. **Analyze opportunities**
   - Use data DIRECTLY from Methods 6 & 7 (already contains complete market_info)
   - Calculate scores using market_info: liquidity (30%), momentum (25%), volume (20%), holders (15%), progress (10%)
   - Convert wei values to MON: reserve_native / 1e18, volume / 1e18
   - Filter by criteria (min liquidity 5 MON, min holders 5, min score 60)
   - Sort by score DESC, then by methods count, then by liquidity
   - Take top 20 candidates
   - Generate buy/sell signals

3. **Execute trades**
   - Buy on bonding curve (MON) or DEX (MON) - all trading uses MON
   - Monitor positions
   - Stop-loss and take-profit

4. **Distribute profits**
   - Calculate total profit
   - Get MMIND holders via Indexer (Transfer events)
   - Distribute proportionally (30% of profit) in MON

## Risk Management

- **Position sizing**: Based on confidence score (max 0.1 MON)
- **Stop-loss**: -10% (automatic sell)
- **Take-profit**: +20% (sell half position)
- **Slippage protection**: 1-2% tolerance
- **Minimum liquidity**: 5 MON required

## Usage Examples

**Start autonomous trading:**

```bash
# Via OpenClaw chat
"Start autonomous trading agent"

# Or via cron job (runs every minute). Paths: use NADFUN_ENV_PATH / NADFUNAGENT_DATA_DIR for .env and data; run scripts from nadfun-trading skill directory (clawhub install).
openclaw cron add \
  --name "Nad.fun Trading Agent" \
  --cron "* * * * *" \
  --session isolated \
  --message "Run autonomous trading cycle: 1) Load config from .env (path: NADFUN_ENV_PATH or NADFUNAGENT_DATA_DIR/.env; need MMIND_TOKEN_ADDRESS, MONAD_PRIVATE_KEY, MONAD_RPC_URL, MONAD_NETWORK). 2) From nadfun-trading skill directory run: node execute-bonding-v2.js (uses check-pnl.js for P&L from positions_report.json at POSITIONS_REPORT_PATH or NADFUNAGENT_DATA_DIR, auto-sells at +5% or -10%). 3) If there is positive PnL (profit >= 0.1 MON), distribute profits to MMIND token holders: use MMIND_TOKEN_ADDRESS from .env, get holders via indexer/Transfer events, distribute proportionally (e.g. 30%) in MON. Report output in English."
```

**Check agent status:**

```bash
# Via OpenClaw chat
"Show trading agent status and statistics"
```

**View found tokens:** (data dir: `NADFUNAGENT_DATA_DIR`, default `$HOME/nadfunagent`)

```bash
# View latest found tokens
cat "${NADFUNAGENT_DATA_DIR:-$HOME/nadfunagent}/found_tokens.json" | jq '.[-1]'

# View all tokens from last scan
cat "${NADFUNAGENT_DATA_DIR:-$HOME/nadfunagent}/found_tokens.json" | jq '.[-1].tokens[] | .address'

# View tokens found in multiple methods (higher confidence)
cat "${NADFUNAGENT_DATA_DIR:-$HOME/nadfunagent}/found_tokens.json" | jq '.[-1].tokens[] | select(.foundInMethods > 1) | .address'

# View summary of last 10 scans
cat "${NADFUNAGENT_DATA_DIR:-$HOME/nadfunagent}/found_tokens.json" | jq '.[-10:] | .[] | {timestamp, totalFound}'
```

**Manual trade:**

```bash
# Via OpenClaw chat
"Buy 0.1 MON worth of token 0x..."
"Sell all tokens for 0x..."
```

## Integration with OpenClaw

This skill integrates with:

- **Cron Jobs**: Schedule autonomous trading cycles
- **Skills**: Uses nadfun-trading, nadfun-indexer, nadfun-agent-api
- **Gateway**: Runs via OpenClaw Gateway
- **Channels**: Can send notifications via Telegram/WhatsApp/etc.

## Error Handling

- All errors are logged but don't stop the agent
- Failed trades are retried with exponential backoff
- API failures fall back to Indexer queries
- Network errors trigger fallback RPC providers

## Rate Limit Handling

**CRITICAL**: Handle rate limits gracefully to avoid HTTP 429 errors.

### API Rate Limits

**Nad.fun Agent API:**
- Without API Key: 10 requests/minute (IP-based)
- With API Key: 100 requests/minute (Key-based)
- **Solution**: Add delays between requests (min 2 seconds between calls)

**Nad.fun Public APIs (`nad.fun/api/*` and `api.nadapp.net/*`):**
- Rate limits are not publicly documented but appear to be IP-based
- **Solution**: Add 2-3 second delays between calls, especially for base64-decoded endpoints
- Handle HTTP 429 errors gracefully with exponential backoff

**Anthropic/Claude API (CRITICAL - This is the main source of HTTP 429):**
- Rate limits vary by tier (typically 50-200 requests per minute)
- **Problem**: Each agent execution makes multiple requests to Claude
- **Solution**: 
  - Cron job runs every 10 minutes (`*/10 * * * *`) to reduce frequency
  - Optimize agent logic to minimize token usage
  - Batch operations when possible
  - If still hitting limits, increase to 15 minutes (`*/15 * * * *`)

### Rate Limit Strategy

1. **Add delays between API calls (CRITICAL):**
   ```typescript
   // Wait 2-3 seconds between Nad.fun API calls
   await new Promise(resolve => setTimeout(resolve, 2000))
   
   // Wait 1 second between Indexer queries
   await new Promise(resolve => setTimeout(resolve, 1000))
   ```

2. **Limit parallel requests:**
   - Process tokens sequentially or in small batches (max 5 at a time)
   - Add delays between batches
   - Don't make all 7 methods run simultaneously - stagger them

3. **Handle 429 errors gracefully:**
   ```typescript
   async function fetchWithRetry(url, options, maxRetries = 2) {
     for (let i = 0; i < maxRetries; i++) {
       try {
         const result = await fetch(url, options)
         if (result.status === 429) {
           const retryAfter = parseInt(result.headers.get('Retry-After') || '60')
           console.log(`Rate limited, waiting ${retryAfter} seconds...`)
           await new Promise(resolve => setTimeout(resolve, retryAfter * 1000))
           continue
         }
         return result
       } catch (err) {
         if (i === maxRetries - 1) throw err
         await new Promise(resolve => setTimeout(resolve, 5000 * (i + 1)))
       }
     }
   }
   ```

4. **Optimize agent execution:**
   - Use Indexer methods (1-2) first (they're faster and don't hit API limits)
   - Only use API methods (3-7) if Indexer doesn't find enough tokens
   - Analyze ALL tokens that pass filters (no limit)
   - Skip detailed analysis if token doesn't meet basic filters

5. **Cron frequency:**
   - Current: every 10 minutes (`*/10 * * * *`)
   - If still hitting Claude API limits, increase to 15 minutes (`*/15 * * * *`)