CRITICAL COMMUNICATION RULES:

1. 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:

1. 4. Initial Setup: When first invoked, ask user for:

1. 5. Missing variables: If .env is missing or any required variable (MONADPRIVATEKEY, MONADRPCURL, MMINDTOKENADDRESS, 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)
• INLINECODE2 skill installed (for buy/sell operations), or use the trading/ folder from this repo
• INLINECODE4 skill installed (for querying events)
• INLINECODE5 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)
• INLINECODE18: Private key for trading wallet (required)
• INLINECODE19: RPC endpoint URL (required)
• INLINECODE20: Network type - "mainnet" or "testnet" (required)
• INLINECODE21: Maximum position size in MON (default: 0.1)
• INLINECODE22: Take-profit threshold (default: 20%)
• INLINECODE23: Stop-loss threshold (default: 10%)
• INLINECODE24: % of profit to distribute (default: 30%)

Before starting trading cycle:

1. 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 MMINDTOKENADDRESS, MONADPRIVATEKEY, MONADRPCURL, 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. 1. Load config from $HOME/nadfunagent/.env (MMINDTOKENADDRESS, MONADPRIVATEKEY, MONADRPCURL, 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. 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. 1. Print: "✅ Method X executed: Found N tokens"
2. Print: "Method X token addresses: ..."
3. If method failed: Print: "❌ Method X failed: "
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. 1. Read $HOME/nadfunagent/.env to get MONAD_RPC_URL and INLINECODE36
2. Get current block number using RPC: INLINECODE37
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>, INLINECODE43
• Extract token addresses from events: event.args.token or event.args[1] (token is second argument)
• Collect all unique token addresses

Example command structure:
CODEBLOCK0

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. 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. 1. Use same RPC setup as Method 1: Get publicClient from monad-development skill
2. Query CurveBuy events: For each 100-block chunk:

1. 3. Extract data: From each event:

1. 4. Calculate volume: Group by token address, sum all amountIn values
2. Sort and filter: Sort by total volume DESC, take top 20
3. Log results: Print "✅ Method 2: Found top 20 trending tokens by volume"

Example:
CODEBLOCK1

Expected result: Top 20 token addresses sorted by trading volume

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

What to do:

1. 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 INLINECODE57
• For each token, make GET request: INLINECODE58
• Parse response JSON
• For each swap in response.swaps:

• - Keep tokens with total 24h volume >= 1 MON
• Add 1-2 second delay between API calls to avoid rate limits

Example:
CODEBLOCK2

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. 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. 1. From Method 2 results: Use CurveBuy events already queried
2. Filter large buyers:

1. 3. Query holdings: For each of 5 addresses:

1. 4. Parse and extract:

1. 5. Log results: Print "✅ Method 4: Found N active tokens from large trader holdings"

Example:
CODEBLOCK3

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. 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. 1. Determine base URL: Read MONAD_NETWORK from .env:

1. 2. Make GET request:

1. 3. Parse response: JSON array of event objects
2. Extract tokens:

1. 5. Log results: Print "✅ Method 5: Found N tokens from new events API"

Example:
CODEBLOCK4

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

Response structure:

• - type: "BUY" | "SELL" | "CREATE"
• INLINECODE86: Event amount (string)
• INLINECODE87: Complete token information (token_id, name, symbol, description, creator, etc.)
• INLINECODE88: 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. 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. 1. API URL: INLINECODE89

1. 2. GET request:

1. 3. Decode base64 PROPERLY:

1. 4. Parse decoded JSON:

1. 5. Extract tokens WITH FULL DATA:

1. 6. Log results: Print "✅ Method 6: Found N tokens with market data from market cap API"

Example:
CODEBLOCK5

Expected result: Array of full token objects (with tokeninfo + marketinfo) sorted by market cap

Response structure:

• - tokens: Array of token objects with token_info and INLINECODE103
• INLINECODE104: Total number of tokens
• Each token includes: token_info (tokenid, name, symbol, creator, etc.) and market_info (markettype, 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. 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: INLINECODE107
• GET request, decode base64 response (same as Method 6)
• Parse JSON: data.tokens array
• For each token:

Example:
CODEBLOCK6

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

Response structure:

• - Same as Method 6: tokens array with token_info and INLINECODE114
• INLINECODE115 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. 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. 1. Create collections:

1. 2. Add tokens from each method:

IMPORTANT: For Methods 6 & 7, store the FULL token objects (not just addresses) so you can use market_info directly for analysis!

1. 3. Count frequency and preserve full data:

1. 4. Convert and sort:

     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
     })
     

1. 5. Log summary:

# 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