solana-agent-kit-plugin-madeonsol

📚 API docs · 💰 Free API key · 🤖 Solana Agent Kit

Solana Agent Kit plugin for MadeOnSol — Solana KOL intelligence, deployer analytics, bundle-cohort held-% signals, and wallet tracking.

Real-time Solana trading intelligence: track 2,000+ KOL wallets with <3s latency on paid keys and x402 pay-per-call (free-tier live feeds are 5-min delayed), score 85K+ Pump.fun deployers, verify any wallet's CURRENT on-chain holdings straight from its token accounts, surface deshred deploy signals ~500ms before on-chain confirmation, detect multi-KOL coordination, and stream every DEX trade. Free tier: 200 requests/day across 40+ endpoints (live feeds 5-min delayed) — no signup payment. Get a key at madeonsol.com/pricing.

New in 1.26.1 — credentials are isolated per agent (security fix, SEC-03). Fixed: this plugin used to cache the resolved API key / wallet signer at module scope, so if a process ran more than one agent instance, a second initAuth() call could silently overwrite or borrow the first agent's credentials — including mid-flight, during concurrent calls. Auth is now cached per agent object; credential rotation, concurrent initialization, and a failed setup on one agent are all race-safe and cannot leak into or clobber another agent's session. No public API change — initAuth() / initPaidFetch() keep their existing signatures and behavior for single-agent use. Only affects processes that run multiple SolanaAgentKit instances with different credentials side by side.

New in 1.26.0 — top traders, sniper detection, and two update tools. Found by an internal agentic-infra coverage audit; also fixes a real bug from 1.25.0 where deployerAsOf/deployerRewards were registered as actions but never wired into agent.methods or the package's exports. agent.methods.tokenTopTraders(mint, params?) / MADEONSOL_TOKEN_TOP_TRADERS_ACTION ranks a token's wallets by realized PnL or ROI. sniperRecent / sniperByDeployer / sniperWatchlist / sniperWatchlistAdd / sniperWatchlistRemove bring the deshred pre-confirm deploy feed to this plugin for the first time. updateWebhook(id, params) and walletTrackerRelabel(address, label) (both PATCH) round out the CRUD surface.

New in 1.25.0 — deployer reputation as-of a date, and creator-fee rewards. Two new tools + actions (PRO+, keyed msk_ API only — no x402 route). agent.methods.deployerAsOf({ wallet, date? }) / MADEONSOL_DEPLOYER_AS_OF_ACTION binds GET /deployer-hunter/{wallet}/as-of: the deployer's reputation exactly as it stood on date (default today, UTC) — the latest write-on-change snapshot at or before it, so a backtest sees only what was knowable then. snapshot.snapshot_date can predate date (write-on-change); snapshot.carried: true marks that. No snapshot at or before date → as_of: false, snapshot: null — nothing is ever synthesized. date must be ≥ 2026-04-07 and not in the future. agent.methods.deployerRewards({ wallet }) / MADEONSOL_DEPLOYER_REWARDS_ACTION binds GET /deployer-hunter/{wallet}/rewards: pump.fun creator-fee rewards, answered two ways that are never merged — collected (what actually reached the wallet: direct vault claims kept 90 days, social-handle claims, shareholder payouts on any token) and attributed (every payout on the tokens it deployed, split to_self/to_others + redirected_pct). Every money field is {sol, usdc, usd}; usd is null (never a silent 0) when a SOL amount exists and no SOL price was available. top_tokens/top_recipients (≤10, USD-sorted) show where attributed fees went. Works for non-deployers too (is_deployer: false, attributed empty).

New in 1.24.0 — token surges & revivals: momentum fires with the honest half attached. agent.methods.tokenSurges(agent, params?) / MADEONSOL_TOKEN_SURGES_ACTION binds GET /tokens/surges (PRO+, keyed msk_ API only — no x402 route): every token momentum fire, newest first. Two kinds, one row shape. surge — a token < 30 min old whose market cap runs hard against its launch MC, in three tiers that each fire at most once per mint: early (≤10 min, ≥$12k, ≥3× launch), strong (≤30 min, ≥$30k, ≥6× launch and ≥2× the lowest sample of the last 3 min — it is climbing now), breakout (≤2 min, ≥$45k, ≥8×). A tier must be sustained (current tick and a sample ≥10 s older; nothing fires before 20 s of age) — a same-slot bundle marked to $475k at age 1 s is a spike, not a surge. revival — a token with no 1-minute trade candle for ≥24 h that starts trading again, confirmed only by the tape (≥5 buys, ≥$500 buy volume, MC ≥1.5× the pre-dormancy close), never by the price mark; tier is null. Hard gates on both: liquidity ≥$1.5k and ≥2 % of MC, and the MC gained must be paid for by buy volume (a price mark in a spoof pool moves MC on ~$0). Every row carries the burst tape (source candles / wallet_trades; unique_buyers only where the mint is in trade coverage — wallet_data_available:false otherwise, never an inferred zero), kol buyers, the first-20 early_buyers cohort (bundled / sold / sniper wallets), deployer reputation and risk_flags[] (bundled_launch, few_buyers, wash_pattern, thin_liquidity, cold_deployer, sniper_heavy, early_buyers_exiting, sell_pressure, no_tape_trades, no_prior_price, mint_authority_active, transfer_fee — empty means no flag raised, not verified clean). Rows ≥65 min old carry the +1 h outcome; stats: "1" prints per-(kind, tier) hit-rates (up_1h_pct, median_peak_multiple, doubled_1h_pct) — out-of-sample by construction. Filters kind, tier, mint, launchpad, deployer_tier, min_mc_usd / max_mc_usd, min_buys, exclude_flags, only_clean; cursors since / before. Pushed live on the new token:surges WS channel (events token:surge / token:revival; subscribe filters kinds[], tiers[], launchpads[], exclude_flags[], min_mc_usd / max_mc_usd, deployer_tier[]) and accepted by createWebhook as events token:surge / token:revival with the same filters.

New in 1.23.1 — stream tokens never expire. agent.methods.getStreamToken() (POST /stream/token) now returns the same token on every call, forever. It stops working only if your subscription lapses or you call agent.methods.getStreamToken(agent, { rotate: true }) to replace it (the previous value keeps working for 60 s). expires_at and the new next_refresh_at are always null (kept for wire compatibility — do not schedule refreshes on them); the response gains rotated (boolean) and lifetime (string). The server never rotates on its own and never sends token_refresh unless you rotated; a 4001 close means "mint again" (lapsed or rotated), never a timer. Prefer Authorization: Bearer <token> on the WebSocket handshake — ?token= still works and is masked in access logs.

New in 1.23.0 — token locks & vesting, upcoming unlocks, and pump.fun creator-fee sharing / claims. Five new tools + actions (all PRO+, keyed msk_ API only — no x402 route). agent.methods.tokenLocks({ mint }) / MADEONSOL_TOKEN_LOCKS_ACTION binds GET /tokens/{mint}/locks: every on-chain lock / vesting contract on a mint (Streamflow, Jupiter Lock, Bonfida vesting) with the schedule, the terms (cancelable_by_sender = the locker can pull it — funds are locked against the recipient, not the locker) and a live-derived view (locked_*, claimable_*, next_unlock) plus a summary with 7d / 30d forward unlock totals. tokenLocksFeed() / MADEONSOL_TOKEN_LOCKS_FEED_ACTION (GET /tokens/locks) is the cross-token feed of NEW contracts (cursor pagination.next_since, or push on WS channel token:locks, event token:lock); tokenUnlocks() / MADEONSOL_TOKEN_UNLOCKS_ACTION (GET /tokens/unlocks) lists upcoming unlock EVENTS (cliff / period / final / tranche) inside a 1h–90d window sorted by soonest / largest_usd / largest_pct. LP locks are not included — token/vesting locks only. tokenFeeShares({ mint }) / MADEONSOL_TOKEN_FEE_SHARES_ACTION (GET /tokens/{mint}/fee-shares) decodes a pump.fun coin's on-chain SharingConfig — shareholders with share_bps, is_admin, is_social_pda (fees earmarked for an X identity: social.platform 2 = X, user_id = the numeric platform id, not the handle), redirected_bps, is_default: true = 100% to the creator — plus a distributions rollup and config history; tokenFeeClaims() / MADEONSOL_TOKEN_FEE_CLAIMS_ACTION (GET /tokens/fee-claims) is the fee-event feed (distribution with per-address payouts[], social_claim, shares_created/updated/reset, creator_transferred, creator_claim only when asked via type), pushed on WS channel token:fee_claims (event token:fee_claim). Fee-event history starts 2026-08-17. All base-unit amounts are digit strings; ui / usd / pct are null when decimals or price are unknown.

New in 1.22.0 — live holder census: exact holder count, labelled holders, and pools that are named, not just excluded. agent.methods.tokenHolders({ mint }) / MADEONSOL_TOKEN_HOLDERS_ACTION binds GET /tokens/{mint}/holders (PRO+): every token account of the mint read from the ledger at confirmed and merged per owner, so concentration.holder_count is EXACT (distinct non-zero owners minus pools / bonding curves / burns) — never a trade-derived estimate; it is null only when the provider refuses the census for a mega-cap, in which case you get the top-20 view and source.census_fallback_reason says so. Each disclosed owner carries our labels (deployer / kol / early_buyer / bundle / bot / dump_cluster — empty means unknown to us, not clean), and excluded[] NAMES what was taken out of the circulating denominator: reason = pool (with dex + pool_address), bonding_curve (pump.fun / LaunchLab), burn, or program_account only when we genuinely cannot attribute the PDA; pool_pct / burned_pct / program_pct split the exclusion. Amounts are raw u64 strings. Disclosure: PRO ranks 1–10, ULTRA 1–50, BUSINESS 1–100 — the maths is tier-independent. Big tokens take 5–30 s upstream: you get 503 holder_scan_in_progress with retry_after_seconds: 20 while the scan finishes into the cache, and the retry is instant.

New in 1.21.0 — two prices on the trade tape, and the right one is now the default. The trade tape now tells you what a trade actually cost. price_sol/price_usd on each trade are THIS trade's executed price — sol_amount / token_amount, reconciling exactly with the amounts on the same row and with the PnL endpoints. Because sol_amount is the wallet's net SOL movement, that is the trader's all-in effective rate: swap fee and any account rent included, not the pool mid. The market-cap tracker's canonical pool price moved to the new market_price_sol/market_price_usd fields — it is sampled once per token per pool update, so every trade in the same slot shares it. Until now price_sol carried that canonical value and disagreed with the row's own amounts by a 7.9% median (p90 ~74%): a stale market price reads low in a pump and high in a dump, so anything you averaged out of the tape inherited the bias instead of cancelling it. Use price_sol for cost basis, fills and PnL; market_price_sol for a per-token series independent of trade size and direction. tokenTrades() / MADEONSOL_TOKEN_TRADES_ACTION expose all four fields, with the two prices distinguished in the action description.

New in 1.20.0 — the Deployer Hunter surface completed. Seven new operations that existed on the API but had no SDK binding: MADEONSOL_DEPLOYER_LEADERBOARD_ACTION, MADEONSOL_DEPLOYER_STATS_ACTION, MADEONSOL_DEPLOYER_PROFILE_ACTION, MADEONSOL_DEPLOYER_TOKENS_ACTION, MADEONSOL_DEPLOYER_ALERT_STATS_ACTION, MADEONSOL_DEPLOYER_BEST_TOKENS_ACTION and MADEONSOL_DEPLOYER_RECENT_BONDS_ACTION. Read bonding_rate (lifetime) against recent_bond_rate (rolling) — the gap between them is the signal, not either number alone. runner_rate only means something once labeled_tokens >= 3, and an untracked wallet returns a profile with zeroed counters, not a 404, so check total_deployed before reading a 0% bond rate as a track record. Dependency ranges are now bounded to the versions actually tested (@x402/* ^2.x, @solana/kit ^5.5.1) instead of open-ended >=0.0.1, and the lazily-imported x402 peers are marked optional — a keyed install no longer pulls the whole Solana stack.

New in 1.19.0 — Token depth / price impact + deployer self-activity on risk. New tool tokenDepth() + action MADEONSOL_TOKEN_DEPTH_ACTION (GET /tokens/{mint}/depth) — per-pool price-impact / slippage: "how much SOL moves this token's price N%", per pool (NOT router-optimal). Pass up to 8 SOL buy sizes (each >0 and ≤10000; default [0.5, 1, 5, 10]); every computable pool returns spot_price_sol, fee_pct, a quotes[] entry per size (size_sol, tokens_out, avg_price_sol, price_impact_pct), and to_move_price — the SOL required to move price 1% / 5% / 10%. Constant-product AMMs are served from stream reserves (source: "stream" with reserves_age_ms); pump.fun/bonk bonding curves from a live read of the curve's virtual reserves (source: "live_rpc"). Pools that can't be priced honestly — concentrated CLMM/Orca/DLMM, Meteora-DBC curves, unclassified models — come back in unsupported_pools[] with a reason (e.g. concentrated_liquidity_depth_not_supported, curve_graduated_use_amm_pool) instead of a wrong number; primary_pool names the deepest computable pool, found: false means no pools tracked. PRO/ULTRA only. And tokenRisk() (MADEONSOL_TOKEN_RISK_ACTION) now returns a top-level dev block (deployer self-activity; null when the mint has no deployer-pipeline row): the create-tx self-buy snapshot (buy_sol, buy_tokens, buy_supply_pct), the post-create rollup (bought_tokens_after — catches the same-second-separate-tx dev buy the create snapshot reads as 0 — sold_tokens, sold_sol, first_sell_at/last_sell_at), live on-chain holdings (holdings_tokens, holdings_supply_pct — pump.fun 1B denominator, null elsewhere — wallet_empty: is the dev wallet empty NOW), and transferred_out (tokens left without a sell; null = unknown, never a guess), plus as_of. deployer:alert webhook/WS payloads gain dev_buy_sol + dev_buy_supply_pct.

New in 1.18.0 — Wallet batch classify + token trade tape. New tool walletClassify() + action MADEONSOL_WALLET_CLASSIFY_ACTION — bulk reputation flags for 1–100 wallets in one call (POST /wallet/batch/classify): per wallet is_sniper, is_bundler (lifetime flag), is_dumper (rolling 42-day window), is_kol + kol_name, bot_confidence (string enum "none"/"low"/"medium"/"high" | null — never a number), and dump_cluster cohort stats (dump_cohorts, runner_cohorts, total_cohorts, as_of). Flags are pump.fun-pipeline scoped — false = not observed, NOT verified clean. New tool tokenTrades() + action MADEONSOL_TOKEN_TRADES_ACTION — the mint-scoped trade tape (GET /tokens/{mint}/trades): cursor-paginated raw trades with price_sol/price_usd, early_buyer_rank, and slot, filterable by action/wallet/since/until; the default window is the full history (tape starts 2026-04-12; the response coverage block carries history_start + scope). walletStats flags gain the same is_sniper/is_bundler/is_dumper + dump_cluster fields, and flags.bot_confidence is confirmed as a string enum (the old numeric reading never matched a real value — the API returned null unconditionally due to a bug, now fixed server-side). Both PRO/ULTRA only.

New in 1.17.0 — Verified on-chain wallet holdings. New tool walletHoldings() + action MADEONSOL_WALLET_HOLDINGS_ACTION — the wallet's CURRENT holdings read straight from chain: its actual SPL + Token-2022 token accounts and SOL balance, each enriched with price_usd / value_usd / market_cap_usd / name / symbol / is_bonded, plus transfer_delta (on-chain amount − trade-derived net position — exposes non-swap flows like airdrops, insider funding, wallet-hopping). Distinct from walletPositions() (trade-derived FIFO): this is what the wallet actually holds right now. Params: limit (1–500, default 200), min_value_usd (default 0). Returns { address, sol_balance, holdings[], summary, verified_at, trade_window_days, cache_hit, ttl_seconds }. ULTRA only.

New in 1.16.2 — Per-venue liquidity map + deployer reputation history. New tool tokenPools() + action MADEONSOL_TOKEN_POOLS_ACTION — every DEX pool a token trades in (live vs parked), with fragmentation and top-pool share. Returns a pools[] list (pool_address, dex, quote_mint, liquidity_usd, last_price_sol, last_swap_at, amm_id, is_active) and a summary (pool_count, active_pool_count, dex_count, dexes, total_liquidity_usd, primary_pool, primary_dex, top_pool_share_pct). New tool deployerHistory() + action MADEONSOL_DEPLOYER_HISTORY_ACTION — a deployer's daily reputation time-series to backtest "was this deployer elite when it launched token X?" without look-ahead bias. Returns { is_deployer, wallet, snapshots[] } where each snapshot has date, tier, is_tracked, total_deployed, total_bonded, bonding_rate, recent_bond_rate, avg_peak_mc, best_token_peak_mc (limit = 1–365 days, default 90). Both PRO/ULTRA only.

New in 1.16.0 — Bundle-cohort holdings. New tool tokenBundle() + action MADEONSOL_TOKEN_BUNDLE_ACTION — which same-slot "bundle" wallets (≥3 buying in one slot) bought a token and how much of supply they STILL hold, from confirmed on-chain data. Returns a bundle summary (wallet_count, bundle_kind [atomic_tx/same_slot/none], held_ratio, held_pct_of_supply [the headline rug/insider signal], fully_exited, buy_volume, tokens_held) plus a wallets[] list (rank, wallet, held_ratio, has_sold, atomic, is_kol). BASIC get the bundle block only (wallets: []); PRO gets top-10 flags-only; ULTRA adds full holdings + wallet identity (kol_name, win_rate, bot_confidence, tokens_held). PRO/ULTRA only.

New in 1.15.0 — Batch risk scoring + WebSocket session control. New tool tokenRiskBatch() + action MADEONSOL_TOKEN_RISK_BATCH_ACTION — bulk 0–100 rug-risk/safety scoring for 1–50 mints in one call ({ tokens, count }, same per-mint shape as tokenRisk() plus an as_of ISO string; untracked mints come back as { mint, error: "not_tracked" } without failing the batch; counts as one request). New tools streamSessions() / streamSessionKill({ id }) + actions MADEONSOL_STREAM_SESSIONS_ACTION / MADEONSOL_STREAM_SESSION_KILL_ACTION — list your live ws-streaming/dex-stream sessions (id, service, tier, channels[], connected_at, remote_ip, messages_sent) and evict one by id to free a connection slot. PRO/ULTRA only.

New in 1.14.0 — Almost-bonded discovery + trending sorts. New tool almostBonded() + action MADEONSOL_ALMOST_BONDED_ACTION — pre-bond pump.fun tokens near graduation, ranked by velocity (Δprogress/min): "95% and accelerating" beats "92% stalled". Each token carries progress_pct, velocity_pct_per_min, eta_minutes, stalled, real_sol_reserves, market_cap_usd, liquidity_usd, authorities_revoked, deployer_tier, and age_minutes. Params: min_progress, max_progress, min_velocity_pct_per_min, max_age_minutes, deployer_tier, authority_revoked, min_liq, sort (velocity_desc / progress_desc / eta_asc), limit. PRO/ULTRA only. Plus tokensList({ sort }) gains four momentum sorts — mc_change_5m_desc, mc_change_1h_desc, volume_1h_desc, and trending (composite recent-volume × positive-momentum rank).

New in 1.13.0 — Token net flow. New tool tokenFlow() + action MADEONSOL_TOKEN_FLOW_ACTION — net buy/sell flow over a rolling window (1h default, or 24h): unique_wallets, unique_buyers, unique_sellers, buy_count, sell_count, total_trades, buy_sol, sell_sol, net_sol, trades_per_wallet. PRO/ULTRA only. Deployer alerts now also surface deployer_sol_balance — the deployer wallet's SOL balance at alert time (null for historical rows).

New in 1.12.0 — Token OHLCV candles. New tool tokenCandles() + action MADEONSOL_TOKEN_CANDLES_ACTION — historical price candles (1m/5m/15m/1h/4h/1d) aggregated from the on-chain trade firehose. Each candle has t/open/high/low/close/volume_usd/trades/market_cap_usd. PRO returns OHLCV for the last 30 days; ULTRA adds buy/sell volume + count splits, net flow, MEV volume, open/close liquidity, high/low MC, and full history. PRO/ULTRA only.

New in 1.11.0 — Token risk score. New tool tokenRisk() + action MADEONSOL_TOKEN_RISK_ACTION — a transparent 0–100 rug-risk/safety score (higher = riskier) with a band (safe/caution/danger), an explainable factors[] array, and the raw inputs (mint/freeze authority, liquidity, liq-to-MC ratio, transfer fee, launch cohort, deployer bond rate, KOL signal, blacklist). PRO/ULTRA only.

New in 1.9.3 — Deployer alerts now surface runner_rate + labeled_tokens (fraction of a deployer's labeled tokens that ran vs dumped, gate on labeled_tokens ≥3) and avg_time_to_bond_minutes.

New in 1.9.2 — Dump-cluster detection. Buyer-quality breakdown now includes dump_cluster_count (3+ dump-cluster wallets in the first-20 → 94% historical dump rate vs 61% base) and recycled_early_buyer_count, on all tiers. The API also pushes every pump.fun graduation in real time (token:graduations WS channel).

New in 1.9 — Price alerts, scout leaderboard, coordination history. agent.methods.priceAlertsCreate() (PRO=5, ULTRA=25). agent.methods.scoutLeaderboard(), kolConsensus(), peakHistory(), coordinationHistory(). walletStats now returns derived: win_rate, roi, verdict, biggest_miss.

New in 1.8 — Universal Wallet API. agent.methods.walletStats(), walletPnl(), walletPositions(), walletTrades() — FIFO cost-basis PnL for any wallet. PRO+. Cache hits free.

New in 1.7.0 (2026-05-12) — Account introspection + filtered token directory. Two new actions: meAction (GET /me) returns your tier, daily/burst quota state, remaining requests, and per-feature usage so the agent can self-throttle; tokensListAction (GET /tokens, PRO+) exposes the full filtered/sortable token directory with MC band, liquidity floor, recent-activity window, primary DEX, authority flags, computed 1h volume floor, MEV-share ceiling, and MC change deltas — defaults to min_liq=2000 to skip dust. Token responses now carry velocity / MEV-share fields. /token/{mint} returns structured 400 errors (code, reason, example, docs) instead of bare 400s. Deprecated avg_entry_mc_usd removed from leaderboards.

Quick start (10 seconds)

npm install solana-agent-kit-plugin-madeonsol

import { SolanaAgentKit } from "solana-agent-kit";
import MadeOnSolPlugin from "solana-agent-kit-plugin-madeonsol";
const agent = new SolanaAgentKit(privateKey, rpcUrl, { MADEONSOL_API_KEY: "msk_..." }); // free tier at https://madeonsol.com/pricing
agent.use(MadeOnSolPlugin);
const trades = await agent.methods.kolFeed(agent, { limit: 5, action: "buy" });

Authentication

Two options (in priority order):

| Method | Config key | Best for | |---|---|---| | MadeOnSol API key (recommended) | MADEONSOL_API_KEY | Developers — get a free key | | x402 micropayments | SVM_PRIVATE_KEY | AI agents with Solana wallets |

v1.0 breaking change: RapidAPI auth (RAPIDAPI_KEY) has been removed. The MadeOnSol RapidAPI marketplace was retired on 2026-04-19. Get a free msk_ key at madeonsol.com/pricing.

Install

npm install solana-agent-kit-plugin-madeonsol

x402 peer deps (@x402/fetch @x402/svm @x402/core @solana/kit @scure/base) are only needed when using SVM_PRIVATE_KEY.

Usage

import { SolanaAgentKit } from "solana-agent-kit";
import MadeOnSolPlugin from "solana-agent-kit-plugin-madeonsol";

const agent = new SolanaAgentKit(privateKey, rpcUrl, {
  MADEONSOL_API_KEY: "msk_your_api_key_here",
});

agent.use(MadeOnSolPlugin);

// Use via methods
const trades = await agent.methods.kolFeed(agent, { limit: 10, action: "buy" });

// Wallet tracker
const watchlist = await agent.methods.walletTrackerWatchlist(agent);
await agent.methods.walletTrackerAdd(agent, { wallet_address: "WALLET", label: "whale" });
const events = await agent.methods.walletTrackerTrades(agent, { limit: 50 });

// Or let the LLM trigger actions via natural language
// "What are KOLs buying right now?" → MADEONSOL_KOL_FEED_ACTION

Actions

| Action | Triggers on | |---|---| | MADEONSOL_KOL_FEED_ACTION | "kol trades", "what are kols buying" | | MADEONSOL_KOL_COORDINATION_ACTION | "kol convergence", "tokens kols accumulating" | | MADEONSOL_KOL_LEADERBOARD_ACTION | "top kols", "kol rankings" — periods: today, 7d, 30d, 90d, 180d | | MADEONSOL_DEPLOYER_ALERTS_ACTION | "deployer alerts", "pump fun launches" | | MADEONSOL_KOL_PNL_ACTION | "kol pnl", "kol profit", "wallet pnl" | | MADEONSOL_KOL_TRENDING_TOKENS_ACTION | "kol trending tokens", "kol volume" | | MADEONSOL_KOL_FIRST_TOUCHES_ACTION | "kol first touch", "first kol buyer", "scout signal" — backtested first-mover signal (new in 1.3) | | MADEONSOL_WALLET_TRACKER_WATCHLIST_ACTION | "wallet watchlist", "tracked wallets" | | MADEONSOL_WALLET_TRACKER_ADD_ACTION | "track wallet", "watch wallet", "add to watchlist" | | MADEONSOL_WALLET_TRACKER_REMOVE_ACTION | "untrack wallet", "remove from watchlist" | | MADEONSOL_WALLET_TRACKER_TRADES_ACTION | "wallet tracker trades", "watchlist activity" | | MADEONSOL_WALLET_TRACKER_SUMMARY_ACTION | "wallet tracker summary", "tracked wallet stats" | | MADEONSOL_ME_ACTION | "my api account", "api quota", "remaining requests" — tier + quota introspection (new in 1.7) | | MADEONSOL_TOKENS_LIST_ACTION | "filter tokens", "tokens by market cap", "scan tokens" — filtered/sortable token directory + momentum/trending sorts, PRO+ (new in 1.7) | | MADEONSOL_ALMOST_BONDED_ACTION | New 1.14 · "almost bonded", "about to graduate", "near graduation" — pre-bond pump.fun tokens ranked by velocity (Δprogress/min): progress, ETA, stalled, deployer tier (PRO+) | | MADEONSOL_WALLET_STATS_ACTION | New 1.8 · "wallet stats", "wallet info", "check wallet" — aggregate 90d stats + cross-product flags (KOL/alpha/deployer) for any Solana wallet (PRO+) | | MADEONSOL_WALLET_PNL_ACTION | New 1.8 · "wallet pnl", "wallet profit", "wallet performance" — FIFO cost-basis PnL with profit factor, drawdown, daily curve, closed + open positions (PRO+) | | MADEONSOL_WALLET_POSITIONS_ACTION | New 1.8 · "wallet positions", "wallet bags", "open positions" — open lots with live unrealized SOL (PRO+) | | MADEONSOL_WALLET_HOLDINGS_ACTION | New 1.17 · "wallet holdings", "current holdings", "what does wallet actually hold" — verified CURRENT on-chain holdings (real SPL + Token-2022 accounts + SOL) enriched with price/MC/name, plus transfer_delta vs trade-derived position (ULTRA only) | | MADEONSOL_WALLET_TRADES_ACTION | New 1.8 · "wallet trades", "wallet history" — cursor-paginated raw trades with filters (PRO+) | | MADEONSOL_TOKEN_FLOW_ACTION | New 1.13 · "token flow", "net flow", "buy/sell pressure" — net buy/sell flow over a 1h/24h window (PRO+) | | MADEONSOL_TOKEN_RISK_BATCH_ACTION | New 1.15 · "batch token risk", "bulk rug risk", "score many tokens" — rug-risk scoring for 1–50 mints in one call; untracked mints don't fail the batch (PRO+) | | MADEONSOL_STREAM_SESSIONS_ACTION | New 1.15 · "list stream sessions", "live websocket sessions", "active ws sessions" — your live ws-streaming/dex-stream sessions (PRO+) | | MADEONSOL_STREAM_SESSION_KILL_ACTION | New 1.15 · "kill stream session", "evict session", "free a connection slot" — evict a live streaming session by id (PRO+) | | MADEONSOL_TOKEN_POOLS_ACTION | New 1.16.2 · "token pools", "liquidity map", "which dex pools", "pool fragmentation" — per-venue liquidity map (live vs parked pools) + top-pool share (PRO+) | | MADEONSOL_DEPLOYER_HISTORY_ACTION | New 1.16.2 · "deployer history", "deployer reputation over time", "was this deployer elite" — a deployer's daily reputation time-series, backtest without look-ahead bias (PRO+) | | MADEONSOL_TOKEN_TRADES_ACTION | New 1.18 · "token trades", "trade tape", "who bought this token" — cursor-paginated raw trade tape with price + early-buyer rank, full history (starts 2026-04-12, pump.fun-pipeline scoped) (PRO+) | | MADEONSOL_WALLET_CLASSIFY_ACTION | New 1.18 · "classify wallets", "check wallets for snipers", "are these wallets bots" — bulk reputation flags (sniper/bundler lifetime/dumper 42d/KOL/bot confidence/dump cluster) for 1–100 wallets; false = not observed, NOT verified clean (PRO+) | | MADEONSOL_TOKEN_HOLDERS_ACTION | New · "token holders", "holder count", "top holders", "holder concentration" — live holder census + concentration, who holds NOW. concentration.holder_count is EXACT (mint-scoped getProgramAccounts census; null only when the provider refuses a mega-cap → top-20 fallback with source.census_fallback_reason, never trade-estimated). Owners labelled deployer / kol / early_buyer / bundle / bot / dump_cluster (empty = unknown, not clean); pools / bonding curves / burns EXCLUDED from circulating and NAMED in excluded[] (pool + dex + pool_address, bonding_curve, burn, program_account); amount_raw is a raw u64 STRING. Disclosure PRO 10 / ULTRA 50 / BUSINESS 100. Big tokens: first call may be HTTP 503 holder_scan_in_progress (retry in 20 s — scan continues + cached). PRO+ | | MADEONSOL_TOKEN_LOCKS_ACTION | New 1.23 · "token locks", "is the supply locked", "did the team lock", "vesting schedule" — every Streamflow / Jupiter Lock / Bonfida lock or vesting contract on a mint: program, kind, derived status, sender / recipient, schedule, terms (cancelable_by_sender — the locker can pull it), live locked_* / claimable_* / next_unlock, plus summary (unlocking_7d_* / unlocking_30d_*, nearest next_unlock, active_cancelable_by_sender). Base-unit amounts are STRINGS; ui/usd/pct null when unknown. LP locks not included (PRO+, keyed only) | | MADEONSOL_TOKEN_LOCKS_FEED_ACTION | New 1.23 · "new token locks", "who just locked tokens", "lock feed" — cross-token feed of NEW lock / vesting contracts, newest first; filters mint, sender, recipient, program, kind, status, min_usd, min_pct_of_supply, include_estimated; cursors since / before. Push: WS channel token:locks (event token:lock) (PRO+, keyed only) | | MADEONSOL_TOKEN_UNLOCKS_ACTION | New 1.23 · "upcoming unlocks", "unlocks this week", "biggest unlocks" — upcoming unlock EVENTS across all active contracts inside within = 1h–90d: one entry per contract = its next event (cliff / period / final / tranche) with amount_* + window_amount_*, token, lock; sort soonest / largest_usd / largest_pct (PRO+, keyed only) | | MADEONSOL_TOKEN_FEE_SHARES_ACTION | New 1.23 · "who gets the creator fees", "fee split", "sharing config" — pump.fun creator-fee SharingConfig on a coin: shareholders[] (share_bps, is_admin, is_social_pda + social {platform (2 = X), user_id, lifetime_claimed}, received_*), redirected_bps, is_default, source stream / chain; distributions rollup, history[], recent_distributions[]. Event history starts 2026-08-17 (PRO+, keyed only) | | MADEONSOL_TOKEN_FEE_CLAIMS_ACTION | New 1.23 · "fee claims", "creator fee distributions", "social fee claims" — pump.fun fee-event feed, newest first: type distribution (with payouts[]) / social_claim / shares_created / shares_updated / shares_reset / creator_transferred / creator_claim (excluded unless type asks); filters mint, recipient, actor, social_platform, social_user_id, min_sol, since / before. Push: WS channel token:fee_claims (event token:fee_claim). History starts 2026-08-17 (PRO+, keyed only) | | MADEONSOL_TOKEN_SURGES_ACTION | New 1.24 · "token surges", "what is pumping right now", "breakout tokens", "revived tokens", "surge hit rate" — token momentum fires, newest first: kind surge (token < 30 min old vs its LAUNCH MC; tier early ≤10 min ≥$12k ≥3× · strong ≤30 min ≥$30k ≥6× and ≥2× the 3-min low · breakout ≤2 min ≥$45k ≥8×; each once per mint, sustained ≥10 s) or revival (no trade candle ≥24 h, then ≥5 buys / ≥$500 buy volume / ≥1.5× the pre-dormancy MC on the tape — never a price mark; tier null). Each row: burst tape (unique_buyers null outside trade coverage), kol, early_buyers (bundled / sold / sniper), deployer, risk_flags[] (empty = no flag raised, not verified clean), outcome (+1 h) once ≥65 min old; stats: "1" = per-(kind, tier) hit-rates. Filters kind, tier, mint, launchpad, deployer_tier, min_mc_usd / max_mc_usd, min_buys, exclude_flags, only_clean; cursors since / before. Push: WS channel token:surges (events token:surge / token:revival) (PRO+, keyed only) |

Additional methods (v1.0+)

These are exposed via agent.methods.* (no LLM action wrappers — call directly):

Alpha Wallet Intelligence

Scored from 1.5M+ early-buyer records (wallets seen in the first 20 buyers of Pump.fun tokens).

await agent.methods.alphaLeaderboard(agent, { limit: 100 });            // Free/Pro=100, ULTRA=500 + bot signals
await agent.methods.alphaWallet(agent, { wallet: "WALLET" });           // ULTRA only — full breakdown + bot signals
await agent.methods.alphaLinked(agent, { wallet: "WALLET" });           // ULTRA only — co-bought 3+ tokens within 2s

Token Quality

await agent.methods.tokenCapTable(agent, { mint: "MINT" });             // PRO=10, ULTRA=20 first non-deployer buyers
await agent.methods.tokenBuyerQuality(agent, { mint: "MINT" });         // 0–100 buyer-quality score (5-min cached)
await agent.methods.tokenRisk(agent, { mint: "MINT" });                 // PRO+ 0–100 rug-risk/safety score + band + factors + dev block (self-buy, sells, live holdings, wallet_empty, transferred_out)
await agent.methods.tokenRiskBatch(agent, { mints: ["MINT_A", "MINT_B"] }); // PRO+ bulk rug-risk for 1–50 mints → { tokens, count }; one request
await agent.methods.tokenBundle(agent, { mint: "MINT" });               // PRO+ bundle-cohort holdings: held_pct_of_supply signal; ULTRA=+wallet identity
await agent.methods.tokenPools(agent, { mint: "MINT" });                // PRO+ per-venue liquidity map: live vs parked pools, fragmentation, top-pool share
await agent.methods.tokenDepth(agent, { mint: "MINT", sizes: [1, 5] }); // PRO+ per-pool price impact: quotes per SOL size + SOL to move price 1%/5%/10%; unsupported pools flagged
await agent.methods.tokenHolders(agent, { mint: "MINT" });              // PRO+ live holder census: exact holder_count, labelled top holders, pools/curves/burns excluded + named; 503 holder_scan_in_progress → retry in 20 s
await agent.methods.tokenLocks(agent, { mint: "MINT", status: "active" }); // PRO+ token locks & vesting on a mint: contracts + summary (7d/30d unlock schedule, cancelable_by_sender). LP locks NOT included; keyed only
await agent.methods.tokenLocksFeed(agent, { min_usd: 10000, limit: 50 });   // PRO+ newest lock/vesting contracts across all mints; since/before cursors; WS channel token:locks
await agent.methods.tokenUnlocks(agent, { within: "7d", sort: "largest_usd" }); // PRO+ upcoming unlock EVENTS (cliff/period/final/tranche) inside 1h–90d, with window_amount_*
await agent.methods.tokenFeeShares(agent, { mint: "MINT" });               // PRO+ pump.fun creator-fee SharingConfig: shareholders (bps, is_admin, is_social_pda / X id), redirected_bps, distributions, history (from 2026-08-17)
await agent.methods.tokenFeeClaims(agent, { type: "distribution,social_claim", min_sol: 0.5 }); // PRO+ pump.fun fee-event feed; since cursor; WS channel token:fee_claims (history from 2026-08-17)
await agent.methods.tokenSurges(agent, { kind: "surge", tier: "strong", only_clean: "1" }); // PRO+ token momentum fires: surge tiers early/strong/breakout vs launch MC + revivals confirmed by tape buys, with tape / kol / early_buyers / deployer / risk_flags[] and +1 h outcome; stats: "1" = per-tier hit-rates; WS channel token:surges
await agent.methods.tokenCandles(agent, { mint: "MINT", tf: "1h" });    // PRO+ OHLCV candles (1m–1d); ULTRA=+net flow, liquidity, full history
await agent.methods.tokenFlow(agent, { mint: "MINT", window: "24h" });  // PRO+ net buy/sell flow (1h/24h): unique wallets, buy/sell/net SOL, trades-per-wallet
await agent.methods.tokenTrades(agent, { mint: "MINT", action: "buy", limit: 100 }); // PRO+ mint-scoped trade tape (full history from 2026-04-12, pump.fun-pipeline scoped); cursor-paginated
await agent.methods.walletClassify(agent, { wallets: ["W1", "W2"] });   // PRO+ bulk reputation flags for 1–100 wallets: sniper/bundler(lifetime)/dumper(42d)/KOL/bot_confidence/dump_cluster
await agent.methods.almostBonded(agent, { min_progress: 90, sort: "eta_asc" }); // PRO+ pre-bond pump.fun tokens by velocity: progress, ETA, stalled, deployer tier
await agent.methods.deployerHistory(agent, { wallet: "WALLET", limit: 90 }); // PRO+ deployer daily reputation time-series (1–365d): tier, bonding_rate, peak MC — no look-ahead

Deployer alerts (MADEONSOL_DEPLOYER_ALERTS_ACTION / agent.methods.deployerAlerts()) now include deployer_sol_balance — the deployer wallet's SOL balance at alert time (null for historical rows).

Copy-Trade Rules (PRO/ULTRA)

Server-side rules that fire signals when a watched source wallet trades. Delivered via webhook (HMAC-signed) and/or WebSocket.

await agent.methods.copyTradeList(agent);
await agent.methods.copyTradeCreate(agent, {
  name: "Track Whales",
  source_wallets: ["WALLET_A", "WALLET_B"],  // 1-50 wallets
  sizing_mode: "fixed",
  sizing_amount: 0.5,                          // required
  only_action: "buy",
  delivery_mode: "webhook",
  webhook_url: "https://you.com/hook",
});
await agent.methods.copyTradeSignals(agent, { limit: 50 });             // up to 7 days

Streaming Sessions (new in 1.15)

List and kill your live WebSocket streaming sessions (ws-streaming + dex-stream). Handy when a ghost socket is holding a connection slot. PRO/ULTRA only.

const { sessions, count } = await agent.methods.streamSessions(agent);   // id, service, tier, channels[], connected_at, remote_ip, messages_sent
await agent.methods.streamSessionKill(agent, { id: "123" });             // → { evicted: true, id }

Also exposed as MADEONSOL_STREAM_SESSIONS_ACTION and MADEONSOL_STREAM_SESSION_KILL_ACTION.

KOL Coordination Alerts (PRO/ULTRA — v1.1 push signals)

Real-time push alerts when a KOL cluster co-buys the same token. Fires within ~1s of the triggering trade (pg_notify push, not polling). Delivered via WebSocket (kol:coordination channel, user-scoped) and/or HMAC-signed webhook. PRO=5 rules, ULTRA=20.

const res = await agent.methods.coordinationAlertsCreate(agent, {
  name: "fresh pump cluster",
  min_kols: 4,
  window_minutes: 15,     // peak-density window (1-60)
  min_score: 70,          // 0-100 composite score cutoff
  include_majors: false,  // filter WIF/BONK/POPCAT
  cooldown_min: 60,
  score_jump_break: 10,
  delivery_mode: "both",
  webhook_url: "https://you.com/hooks/coord",
});
// store res.webhook_secret — shown ONCE

await agent.methods.coordinationAlertsList(agent);
await agent.methods.coordinationAlertsGet(agent, { rule_id: "uuid..." });
await agent.methods.coordinationAlertsUpdate(agent, { rule_id: "uuid...", updates: { is_active: false } });
await agent.methods.coordinationAlertsDelete(agent, { rule_id: "uuid..." });

The v1.1 kolCoordination() response also includes peak_kols, peak_buys, exited_count, and coordination_score (0-100). Pass { min_score, window_minutes, include_majors } to filter.

KOL First-Touch Signal (new in 1.3)

Every "first KOL buy on a token mint" event — when a tracked KOL is the first of the cohort to touch a token. Filterable by scout tier (S/A/B/C from mv_kol_scout_score), KOL winrate, token age, mint suffix.

Backtest: S-tier scouts attract ≥3 follow-on KOLs within 4h ~50% of the time vs ~14% baseline (38d / 491k buys / 72,549 events). Public leaderboard at madeonsol.com/kol/scouts.

// REST query — also exposed as MADEONSOL_KOL_FIRST_TOUCHES_ACTION for the agent
const { events } = await agent.methods.kolFirstTouches(agent, {
  preset: "scout",
  min_scout_tier: "S",
  limit: 20,
});

// Webhook subscription (Ultra only) — push delivery, HMAC-signed
const res = await agent.methods.firstTouchSubscriptionsCreate(agent, {
  name: "S-tier scouts on pump tokens",
  filters: { min_scout_tier: "S", mint_suffix: "pump" },
  delivery_mode: "webhook",
  webhook_url: "https://you.com/hooks/scout",
});
// store res.webhook_secret — shown ONCE

await agent.methods.firstTouchSubscriptionsList(agent);
await agent.methods.firstTouchSubscriptionsGet(agent, { subscription_id: "uuid..." });
await agent.methods.firstTouchSubscriptionsUpdate(agent, { subscription_id: "uuid...", updates: { is_active: false } });
await agent.methods.firstTouchSubscriptionsDelete(agent, { subscription_id: "uuid..." });

ULTRA only for subscriptions — up to 10 active per user.

Don't poll — push. Median lead time before the second KOL is 12 seconds. WebSocket channel: kol:first_touches (PRO+).

Price Alerts (new in 1.9)

CRUD for token dip/recovery price alerts. Fires when a token's market cap crosses your threshold. PRO=5 rules, ULTRA=25.

const { alert, webhook_secret } = await agent.methods.priceAlertsCreate(agent, {
  name: "SOL dip buy",
  token_mint: "So11111111111111111111111111111111111111112",
  condition: "below",
  threshold_mc_usd: 5_000_000_000,
  cooldown_min: 120,
  delivery_mode: "both",
  webhook_url: "https://you.com/hooks/price",
});
// store webhook_secret — shown ONCE

await agent.methods.priceAlertsList(agent);
await agent.methods.priceAlertsGet(agent, { alert_id: "uuid..." });
await agent.methods.priceAlertsUpdate(agent, { alert_id: "uuid...", updates: { is_active: false } });
await agent.methods.priceAlertsDelete(agent, { alert_id: "uuid..." });

Also exposed as MADEONSOL_PRICE_ALERTS_LIST_ACTION ("my price alerts") and MADEONSOL_PRICE_ALERTS_CREATE_ACTION ("alert me when token dips below").

Scout Leaderboard & KOL Consensus (new in 1.9)

| Method / Action | Description | |---|---| | agent.methods.scoutLeaderboard(agent, params) | Top scout-tier KOLs ranked by first-touch follow-on rate, win rate, and ROI (PRO+) | | agent.methods.kolConsensus(agent, params) | Tokens with the strongest KOL agreement signal (PRO+) | | agent.methods.peakHistory(agent, { mint }) | Historical peak-density windows for a token (PRO+) | | agent.methods.coordinationHistory(agent, params) | Global coordination event log (PRO+) |

const { leaderboard } = await agent.methods.scoutLeaderboard(agent, { period: "30d", limit: 25 });
const { tokens } = await agent.methods.kolConsensus(agent, { min_kols: 5, period: "24h" });

Also exposed as MADEONSOL_SCOUT_LEADERBOARD_ACTION and MADEONSOL_KOL_CONSENSUS_ACTION.

Wallet Derived Stats (new in 1.9)

walletStats now returns a stats object with derived fields: win_rate (0-1), roi, verdict ("strong" | "profitable" | "neutral" | "losing"), and biggest_miss (token with the highest post-exit gain the wallet missed).

const { stats } = await agent.methods.walletStats(agent, { address: "WALLET_ADDRESS" });
// stats.win_rate, stats.roi, stats.verdict, stats.biggest_miss

Rate-limit headers

Every successful request populates a module-level lastRateLimit (limit / remaining / reset / requestId):

import { lastRateLimit } from "solana-agent-kit-plugin-madeonsol";
await agent.methods.kolFeed(agent, { limit: 10 });
console.log(lastRateLimit); // { limit: "10000", remaining: "9999", reset: "...", requestId: "..." }

Tiers

| Tier | Price | Wallets tracked | Requests/day | |------|-------|-----------------|--------------| | BASIC (free) | $0 | 10 | 200 | | PRO | €43/mo (€430/yr) ≈ $49 | 50 | 10,000 | | ULTRA | €131/mo (€1310/yr) ≈ $149 | 100 + WS events | 100,000 | | BUSINESS | €400/mo (€4000/yr) ≈ $449 | 500 + WS events | 500,000 |

Free tier returns the full REST response shape on 40+ endpoints — real wallets, TX signatures, full precision — with live feeds delayed 5 minutes (delayed responses carry delay/as_of and an X-Data-Delay header). Paid tiers are real-time and unlock webhooks, WebSockets, rule engines, and ULTRA-only data depth; x402 pay-per-call is always real-time. Get a key at madeonsol.com/pricing.

Also Available

| Platform | Package | |---|---| | TypeScript SDK | madeonsol on npm | | Rust SDK | madeonsol on crates.io | | Python (LangChain, CrewAI) | madeonsol-x402 on PyPI | | MCP Server (Claude, Cursor) | mcp-server-madeonsol · Smithery · Glama | | ElizaOS | @madeonsol/plugin-madeonsol |

License

MIT