@madeonsol/plugin-madeonsol 1.4.0 → 1.5.0

package/dist/actions/deployer-alerts.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "@elizaos/core";
+export declare const deployerAlertsAction: Action;

package/dist/actions/deployer-alerts.js

@@ -0,0 +1,55 @@
+import { MadeOnSolClient } from "../client.js";
+import { MADEONSOL_CLIENT_KEY } from "../index.js";
+function getClient(runtime) {
+    return runtime[MADEONSOL_CLIENT_KEY] ?? new MadeOnSolClient();
+}
+export const deployerAlertsAction = {
+    name: "GET_DEPLOYER_ALERTS",
+    description: "Get real-time Pump.fun deployer alerts from MadeOnSol. Shows new token launches from tracked elite/good deployers with stats, market cap, and KOL buy enrichment.",
+    similes: [
+        "deployer alerts",
+        "pump fun launches",
+        "new token alerts",
+        "deployer tracker",
+        "elite deployer tokens",
+    ],
+    validate: async (_runtime, message) => {
+        const text = (message.content?.text || "").toLowerCase();
+        return /\b(deployer|pump\.?fun|launch|new token)/i.test(text) && /\b(alert|track|monitor|latest|recent)/i.test(text);
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const client = getClient(runtime);
+        const text = (message.content?.text || "").toLowerCase();
+        const limit = text.match(/\b(\d+)\s*(alert|token|launch)/)?.[1] || "10";
+        // Best-effort tier inference from the user's prompt — only sent to the API
+        // when the user explicitly mentioned a tier. The tier filter requires
+        // PRO/ULTRA on the caller's API key.
+        const tierMatch = text.match(/\b(elite|good|moderate|rising|cold)\b/);
+        const tier = tierMatch?.[1];
+        const result = await client.getDeployerAlerts(tier ? { limit, tier } : { limit });
+        if (result.error) {
+            callback?.({ text: result.status === 402
+                    ? "Authentication required. Set MADEONSOL_API_KEY — free at https://madeonsol.com/developer — or SVM_PRIVATE_KEY."
+                    : `Error: ${result.error}` });
+            return undefined;
+        }
+        const data = result.data;
+        const lines = (data.alerts || []).slice(0, 10).map((a) => {
+            const deployer = a.deployers;
+            const mc = a.market_cap_at_alert ? `$${(a.market_cap_at_alert / 1000).toFixed(1)}k` : "?";
+            const kols = a.kol_buys ? `${a.kol_buys.count} KOLs buying` : "";
+            return `[${deployer?.tier}] ${a.token_symbol || "?"} — MC: ${mc}${kols ? ` | ${kols}` : ""}`;
+        });
+        callback?.({
+            text: `Deployer Alerts:\n${lines.join("\n") || "No recent alerts."}`,
+            content: data,
+        });
+        return undefined;
+    },
+    examples: [
+        [
+            { name: "user1", content: { text: "Show me the latest deployer alerts from Pump.fun" } },
+            { name: "assistant", content: { text: "Here are the latest deployer alerts..." } },
+        ],
+    ],
+};

package/dist/actions/kol-alerts-recent.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "@elizaos/core";
+export declare const kolAlertsRecentAction: Action;

package/dist/actions/kol-alerts-recent.js

@@ -0,0 +1,48 @@
+import { MadeOnSolClient } from "../client.js";
+import { MADEONSOL_CLIENT_KEY } from "../index.js";
+function getClient(runtime) {
+    return runtime[MADEONSOL_CLIENT_KEY] ?? new MadeOnSolClient();
+}
+export const kolAlertsRecentAction = {
+    name: "GET_KOL_ALERTS_RECENT",
+    description: "Get live KOL alerts from MadeOnSol — consensus clusters, fresh-token KOL buys, and heating-up wallets in one unified stream.",
+    similes: [
+        "kol alerts",
+        "recent alerts",
+        "kol signals",
+        "whats happening now",
+        "live kol feed",
+    ],
+    validate: async (_runtime, message) => {
+        const text = (message.content?.text || "").toLowerCase();
+        return /\b(kol|smart money)\b/.test(text) && /\b(alert|signal|recent|live|now)\b/.test(text);
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const client = getClient(runtime);
+        const text = (message.content?.text || "").toLowerCase();
+        const window = text.includes("1h") ? "1h" : text.includes("6h") ? "6h" : text.includes("24h") ? "24h" : text.includes("5m") ? "5m" : "15m";
+        const result = await client.getKolAlertsRecent({ window, limit: "20" });
+        if (result.error) {
+            callback?.({ text: result.status === 402
+                    ? "Authentication required. Set MADEONSOL_API_KEY — free at https://madeonsol.com/developer — or SVM_PRIVATE_KEY."
+                    : `Error: ${result.error}` });
+            return undefined;
+        }
+        const data = result.data;
+        const lines = (data.alerts || []).slice(0, 10).map((a) => {
+            const subject = a.token_symbol || a.kol_name || "—";
+            return `[${a.severity}] ${a.type}: ${subject}`;
+        });
+        callback?.({
+            text: `KOL alerts (${window}):\n${lines.join("\n") || "No alerts in window."}`,
+            content: data,
+        });
+        return undefined;
+    },
+    examples: [
+        [
+            { name: "user1", content: { text: "What are the recent KOL alerts?" } },
+            { name: "assistant", content: { text: "Here are the live KOL alerts..." } },
+        ],
+    ],
+};

package/dist/actions/kol-compare.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "@elizaos/core";
+export declare const kolCompareAction: Action;

package/dist/actions/kol-compare.js

@@ -0,0 +1,57 @@
+import { MadeOnSolClient } from "../client.js";
+import { MADEONSOL_CLIENT_KEY } from "../index.js";
+function getClient(runtime) {
+    return runtime[MADEONSOL_CLIENT_KEY] ?? new MadeOnSolClient();
+}
+const ADDR_RE = /\b[1-9A-HJ-NP-Za-km-z]{32,44}\b/g;
+export const kolCompareAction = {
+    name: "GET_KOL_COMPARE",
+    description: "Compare 2-5 Solana KOL wallets side-by-side on MadeOnSol — strategy, winrates, ROI, percentile. PRO+ adds overlap tokens (bought by 2+ in last 30d).",
+    similes: [
+        "compare kols",
+        "compare wallets",
+        "kol comparison",
+        "side by side kols",
+        "who is better kol",
+    ],
+    validate: async (_runtime, message) => {
+        const text = message.content?.text || "";
+        const matches = text.match(ADDR_RE) ?? [];
+        return /\bcompare\b/i.test(text) && matches.length >= 2;
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const client = getClient(runtime);
+        const wallets = ((message.content?.text || "").match(ADDR_RE) ?? []).slice(0, 5);
+        if (wallets.length < 2) {
+            callback?.({ text: "Please include at least 2 wallet addresses to compare." });
+            return undefined;
+        }
+        const result = await client.getKolCompare(wallets);
+        if (result.error) {
+            callback?.({ text: result.status === 402
+                    ? "Authentication required. Set MADEONSOL_API_KEY — free at https://madeonsol.com/developer — or SVM_PRIVATE_KEY."
+                    : `Error: ${result.error}` });
+            return undefined;
+        }
+        const data = result.data;
+        const lines = (data.profiles || []).map((p) => {
+            const who = p.name || `${p.wallet_address.slice(0, 4)}…${p.wallet_address.slice(-4)}`;
+            const wr = p.winrate_7d != null ? `${p.winrate_7d.toFixed(1)}%` : "—";
+            const pnl = p.pnl_30d != null ? `${p.pnl_30d > 0 ? "+" : ""}${p.pnl_30d.toFixed(1)} SOL` : "—";
+            return `${who} [${p.strategy_tag || "mixed"}] winrate 7d: ${wr}, PnL 30d: ${pnl}`;
+        });
+        const overlap = (data.overlap || []).slice(0, 5).map((o) => `${o.token_symbol || "?"} (${o.wallets.length} wallets)`);
+        callback?.({
+            text: `KOL comparison:\n${lines.join("\n")}` +
+                (overlap.length ? `\n\nOverlap (30d): ${overlap.join(", ")}` : ""),
+            content: data,
+        });
+        return undefined;
+    },
+    examples: [
+        [
+            { name: "user1", content: { text: "Compare these two KOLs: ABC...123 and DEF...456" } },
+            { name: "assistant", content: { text: "Here's the side-by-side comparison..." } },
+        ],
+    ],
+};

package/dist/actions/kol-coordination.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "@elizaos/core";
+export declare const kolCoordinationAction: Action;

package/dist/actions/kol-coordination.js

@@ -0,0 +1,50 @@
+import { MadeOnSolClient } from "../client.js";
+import { MADEONSOL_CLIENT_KEY } from "../index.js";
+function getClient(runtime) {
+    return runtime[MADEONSOL_CLIENT_KEY] ?? new MadeOnSolClient();
+}
+export const kolCoordinationAction = {
+    name: "GET_KOL_COORDINATION",
+    description: "Get KOL convergence signals from MadeOnSol — tokens being accumulated by multiple KOLs simultaneously. Shows which tokens smart money is converging on.",
+    similes: [
+        "kol convergence",
+        "what tokens are kols accumulating",
+        "kol coordination",
+        "smart money convergence",
+        "multiple kols buying",
+    ],
+    validate: async (_runtime, message) => {
+        const text = (message.content?.text || "").toLowerCase();
+        return /\b(kol|smart money)\b/.test(text) && /\b(converg|coordinat|accumul|same token|multiple)/i.test(text);
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const client = getClient(runtime);
+        const text = (message.content?.text || "").toLowerCase();
+        const period = text.includes("1h") ? "1h" : text.includes("7d") ? "7d" : text.includes("6h") ? "6h" : "24h";
+        const result = await client.getKolCoordination({ period, limit: "10" });
+        if (result.error) {
+            callback?.({ text: result.status === 402
+                    ? "Authentication required. Set MADEONSOL_API_KEY — free at https://madeonsol.com/developer — or SVM_PRIVATE_KEY."
+                    : `Error: ${result.error}` });
+            return undefined;
+        }
+        const data = result.data;
+        const lines = (data.coordination || []).map((t) => {
+            const score = t.coordination_score != null ? ` · score ${t.coordination_score}/100` : "";
+            const peak = t.peak_kols != null ? ` · peak ${t.peak_kols}` : "";
+            const exited = t.exited_count ? ` · ${t.exited_count} exited` : "";
+            return `${t.token_symbol}: ${t.kol_count} KOLs ${t.signal} (${t.net_sol_flow > 0 ? "+" : ""}${t.net_sol_flow.toFixed(2)} SOL net)${score}${peak}${exited}`;
+        });
+        callback?.({
+            text: `KOL convergence signals (${period}):\n${lines.join("\n") || "No coordination signals found."}`,
+            content: data,
+        });
+        return undefined;
+    },
+    examples: [
+        [
+            { name: "user1", content: { text: "What tokens are multiple KOLs accumulating?" } },
+            { name: "assistant", content: { text: "Here are the KOL convergence signals..." } },
+        ],
+    ],
+};

package/dist/actions/kol-feed.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "@elizaos/core";
+export declare const kolFeedAction: Action;

package/dist/actions/kol-feed.js

@@ -0,0 +1,55 @@
+import { MadeOnSolClient } from "../client.js";
+import { MADEONSOL_CLIENT_KEY } from "../index.js";
+function getClient(runtime) {
+    return runtime[MADEONSOL_CLIENT_KEY] ?? new MadeOnSolClient();
+}
+export const kolFeedAction = {
+    name: "GET_KOL_FEED",
+    description: "Get the real-time Solana KOL trade feed from MadeOnSol. Shows latest buys and sells from 1,000+ tracked KOL wallets with deployer enrichment.",
+    similes: [
+        "kol trades",
+        "what are kols buying",
+        "solana kol feed",
+        "kol activity",
+        "smart money trades",
+        "what did kols trade",
+    ],
+    validate: async (_runtime, message) => {
+        const text = (message.content?.text || "").toLowerCase();
+        return /\b(kol|smart money)\b/.test(text) && /\b(feed|trade|buy|sell|activit)/i.test(text);
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const client = getClient(runtime);
+        const text = (message.content?.text || "").toLowerCase();
+        const action = text.includes("buy") ? "buy" : text.includes("sell") ? "sell" : undefined;
+        const result = await client.getKolFeed({ limit: "10", ...(action ? { action } : {}) });
+        if (result.error) {
+            callback?.({ text: result.status === 402
+                    ? "Authentication required. Set MADEONSOL_API_KEY — free at https://madeonsol.com/developer — or SVM_PRIVATE_KEY."
+                    : `Error: ${result.error}` });
+            return undefined;
+        }
+        const data = result.data;
+        const fmtMc = (mc) => {
+            if (mc == null || !isFinite(mc) || mc <= 0)
+                return "";
+            if (mc >= 1e6)
+                return ` @ MC $${(mc / 1e6).toFixed(2)}M`;
+            if (mc >= 1e3)
+                return ` @ MC $${(mc / 1e3).toFixed(1)}K`;
+            return ` @ MC $${mc.toFixed(0)}`;
+        };
+        const lines = (data.trades || []).slice(0, 10).map((t) => `${t.kol_name || "Unknown"} ${t.action === "buy" ? "bought" : "sold"} ${t.token_symbol || "?"} for ${Number(t.sol_amount).toFixed(2)} SOL${fmtMc(t.market_cap_usd_at_trade)}`);
+        callback?.({
+            text: `Latest KOL trades:\n${lines.join("\n")}`,
+            content: data,
+        });
+        return undefined;
+    },
+    examples: [
+        [
+            { name: "user1", content: { text: "What are the latest KOL trades on Solana?" } },
+            { name: "assistant", content: { text: "Here are the latest KOL trades from MadeOnSol..." } },
+        ],
+    ],
+};

package/dist/actions/kol-leaderboard.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "@elizaos/core";
+export declare const kolLeaderboardAction: Action;

package/dist/actions/kol-leaderboard.js

@@ -0,0 +1,45 @@
+import { MadeOnSolClient } from "../client.js";
+import { MADEONSOL_CLIENT_KEY } from "../index.js";
+function getClient(runtime) {
+    return runtime[MADEONSOL_CLIENT_KEY] ?? new MadeOnSolClient();
+}
+export const kolLeaderboardAction = {
+    name: "GET_KOL_LEADERBOARD",
+    description: "Get KOL performance rankings from MadeOnSol — top Solana KOLs ranked by PnL, volume, and win rate.",
+    similes: [
+        "kol leaderboard",
+        "best performing kols",
+        "top kol traders",
+        "kol rankings",
+        "who is the best kol",
+    ],
+    validate: async (_runtime, message) => {
+        const text = (message.content?.text || "").toLowerCase();
+        return /\b(kol|smart money)\b/.test(text) && /\b(leaderboard|ranking|top|best|perform|pnl|win rate)/i.test(text);
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const client = getClient(runtime);
+        const text = (message.content?.text || "").toLowerCase();
+        const period = text.includes("today") ? "today" : text.includes("30d") || text.includes("month") ? "30d" : "7d";
+        const result = await client.getKolLeaderboard({ period, limit: "10" });
+        if (result.error) {
+            callback?.({ text: result.status === 402
+                    ? "Authentication required. Set MADEONSOL_API_KEY — free at https://madeonsol.com/developer — or SVM_PRIVATE_KEY."
+                    : `Error: ${result.error}` });
+            return undefined;
+        }
+        const data = result.data;
+        const lines = (data.leaderboard || []).map((k, i) => `${i + 1}. ${k.name}: ${k.pnl_sol > 0 ? "+" : ""}${k.pnl_sol.toFixed(2)} SOL PnL (${k.buy_count}B/${k.sell_count}S${k.win_rate != null ? `, ${(k.win_rate * 100).toFixed(0)}% WR` : ""})`);
+        callback?.({
+            text: `KOL Leaderboard (${period}):\n${lines.join("\n") || "No data for this period."}`,
+            content: data,
+        });
+        return undefined;
+    },
+    examples: [
+        [
+            { name: "user1", content: { text: "Show me the top performing KOLs this week" } },
+            { name: "assistant", content: { text: "Here are the top KOLs by PnL..." } },
+        ],
+    ],
+};

package/dist/actions/kol-token-entry-order.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "@elizaos/core";
+export declare const kolTokenEntryOrderAction: Action;

package/dist/actions/kol-token-entry-order.js

@@ -0,0 +1,53 @@
+import { MadeOnSolClient } from "../client.js";
+import { MADEONSOL_CLIENT_KEY } from "../index.js";
+function getClient(runtime) {
+    return runtime[MADEONSOL_CLIENT_KEY] ?? new MadeOnSolClient();
+}
+const MINT_RE = /\b([1-9A-HJ-NP-Za-km-z]{32,44})\b/;
+export const kolTokenEntryOrderAction = {
+    name: "GET_KOL_TOKEN_ENTRY_ORDER",
+    description: "Get the ranked order of KOL first-buyers for a specific Solana token from MadeOnSol. Shows who entered first and how quickly others followed.",
+    similes: [
+        "who bought first",
+        "first kol buyers",
+        "kol entry order",
+        "token entry ranking",
+        "who entered first",
+    ],
+    validate: async (_runtime, message) => {
+        const text = message.content?.text || "";
+        return /\b(first|entry|entered|order)\b/i.test(text) && MINT_RE.test(text);
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const client = getClient(runtime);
+        const mint = (message.content?.text || "").match(MINT_RE)?.[1];
+        if (!mint) {
+            callback?.({ text: "Please include a token mint address." });
+            return undefined;
+        }
+        const result = await client.getKolTokenEntryOrder(mint, { limit: "20" });
+        if (result.error) {
+            callback?.({ text: result.status === 402
+                    ? "Authentication required. Set MADEONSOL_API_KEY — free at https://madeonsol.com/developer — or SVM_PRIVATE_KEY."
+                    : `Error: ${result.error}` });
+            return undefined;
+        }
+        const data = result.data;
+        const lines = (data.entries || []).slice(0, 10).map((e) => {
+            const who = e.kol_name || `${e.wallet_address.slice(0, 4)}…${e.wallet_address.slice(-4)}`;
+            const when = e.seconds_after_first === 0 ? "first" : `+${e.seconds_after_first}s`;
+            return `#${e.rank} ${who} — ${e.sol_amount.toFixed(2)} SOL (${when})`;
+        });
+        callback?.({
+            text: `KOL entry order for ${mint.slice(0, 8)}…:\n${lines.join("\n") || "No KOL buys recorded."}`,
+            content: data,
+        });
+        return undefined;
+    },
+    examples: [
+        [
+            { name: "user1", content: { text: "Who were the first KOLs to buy 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU?" } },
+            { name: "assistant", content: { text: "Here's the KOL entry order for that token..." } },
+        ],
+    ],
+};

package/dist/actions/wallet-tracker.d.ts

@@ -0,0 +1,3 @@
+import type { Action } from "@elizaos/core";
+export declare const walletTrackerWatchlistAction: Action;
+export declare const walletTrackerTradesAction: Action;

package/dist/actions/wallet-tracker.js

@@ -0,0 +1,84 @@
+import { MadeOnSolClient } from "../client.js";
+import { MADEONSOL_CLIENT_KEY } from "../index.js";
+function getClient(runtime) {
+    return runtime[MADEONSOL_CLIENT_KEY] ?? new MadeOnSolClient();
+}
+export const walletTrackerWatchlistAction = {
+    name: "WALLET_TRACKER_WATCHLIST",
+    description: "List wallets in your MadeOnSol wallet watchlist with labels and remaining capacity.",
+    similes: [
+        "wallet watchlist",
+        "tracked wallets",
+        "my wallets",
+        "wallet tracker list",
+        "show tracked wallets",
+    ],
+    validate: async (_runtime, message) => {
+        const text = (message.content?.text || "").toLowerCase();
+        return /\b(wallet.tracker|watchlist|tracked wallet)/i.test(text) && /\b(list|show|get|my)\b/i.test(text);
+    },
+    handler: async (runtime, _message, _state, _options, callback) => {
+        const client = getClient(runtime);
+        const result = await client.getWalletTrackerWatchlist();
+        if (result.error) {
+            callback?.({ text: `Error: ${result.error}` });
+            return undefined;
+        }
+        const data = result.data;
+        const lines = (data.wallets || []).map((w) => `${w.label ? `[${w.label}] ` : ""}${w.wallet_address}`);
+        callback?.({
+            text: lines.length
+                ? `Tracked wallets (${data.count}/${data.limit}):\n${lines.join("\n")}\n${data.remaining} slot(s) remaining.`
+                : `No wallets tracked yet. Limit: ${data.limit}.`,
+            content: data,
+        });
+        return undefined;
+    },
+    examples: [
+        [
+            { name: "user1", content: { text: "Show my wallet tracker watchlist" } },
+            { name: "assistant", content: { text: "Here are your tracked wallets..." } },
+        ],
+    ],
+};
+export const walletTrackerTradesAction = {
+    name: "WALLET_TRACKER_TRADES",
+    description: "Get recent swap and transfer events from wallets in your MadeOnSol watchlist.",
+    similes: [
+        "wallet tracker trades",
+        "tracked wallet activity",
+        "watchlist trades",
+        "wallet swaps",
+        "wallet transfers",
+        "what did my tracked wallets do",
+    ],
+    validate: async (_runtime, message) => {
+        const text = (message.content?.text || "").toLowerCase();
+        return /\b(wallet.tracker|watchlist|tracked wallet)/i.test(text) && /\b(trade|swap|transfer|activity|buy|sell)\b/i.test(text);
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const client = getClient(runtime);
+        const text = (message.content?.text || "").toLowerCase();
+        const action = text.includes("buy") ? "buy" : text.includes("sell") ? "sell" : undefined;
+        const result = await client.getWalletTrackerTrades({ limit: "20", ...(action ? { action } : {}) });
+        if (result.error) {
+            callback?.({ text: `Error: ${result.error}` });
+            return undefined;
+        }
+        const data = result.data;
+        const lines = (data.events || []).slice(0, 15).map((e) => `${e.label || e.wallet_address.slice(0, 8)} ${e.action} ${e.token_symbol || "?"} for ${Number(e.sol_amount).toFixed(2)} SOL`);
+        callback?.({
+            text: lines.length
+                ? `Recent wallet tracker events:\n${lines.join("\n")}`
+                : "No recent events for your tracked wallets.",
+            content: data,
+        });
+        return undefined;
+    },
+    examples: [
+        [
+            { name: "user1", content: { text: "What did my tracked wallets trade recently?" } },
+            { name: "assistant", content: { text: "Here are the latest trades from your watchlist..." } },
+        ],
+    ],
+};

package/dist/client.d.ts

@@ -0,0 +1,404 @@
+/**
+ * MadeOnSol API client.
+ * Two auth modes: MadeOnSol API key (`msk_`, recommended) or x402 micropayments.
+ *
+ * v1.0 breaking change: RapidAPI auth has been removed (marketplace retired 2026-04-19).
+ * Get a free `msk_` key at https://madeonsol.com/developer.
+ */
+export interface MadeOnSolClientOptions {
+    baseUrl?: string;
+    /** MadeOnSol API key — get one free at https://madeonsol.com/developer. Preferred. */
+    apiKey?: string;
+    /** x402 payment-enabled fetch (for AI agents with SVM_PRIVATE_KEY). */
+    fetchFn?: typeof fetch;
+}
+export interface RateLimitInfo {
+    limit?: string;
+    remaining?: string;
+    reset?: string;
+    requestId?: string;
+}
+export declare class MadeOnSolClient {
+    private baseUrl;
+    private fetchFn;
+    private authMode;
+    private authHeaders;
+    /** Most recent rate-limit headers, populated by every request. */
+    lastRateLimit: RateLimitInfo;
+    constructor(options?: MadeOnSolClientOptions);
+    private captureRateLimit;
+    query<T = unknown>(path: string, params?: Record<string, string | undefined>): Promise<{
+        data?: T;
+        error?: string;
+        status: number;
+    }>;
+    getKolFeed(params?: {
+        limit?: string;
+        before?: string;
+        action?: string;
+        kol?: string;
+        min_sol?: string;
+        token_age_max_min?: string;
+        exclude_sells?: string;
+        min_kol_winrate?: string;
+        strategy?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getKolCoordination(params?: {
+        period?: string;
+        min_kols?: string;
+        limit?: string;
+        /** v1.1 — include WIF/BONK/POPCAT etc. ("true" | "false", default "false") */
+        include_majors?: string;
+        /** v1.1 — peak-density window in minutes (1-60, default 15) */
+        window_minutes?: string;
+        /** v1.1 — minimum composite coordination_score (0-100) */
+        min_score?: string;
+        min_avg_winrate?: string;
+        unique_strategies?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getKolLeaderboard(params?: {
+        period?: string;
+        limit?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    /**
+     * Get deployer alerts. The `tier` filter (elite/good/moderate/rising/cold)
+     * is PRO/ULTRA only — BASIC callers passing it receive HTTP 403.
+     * Cursor-paginated via `before` (preferred over `offset` at scale).
+     */
+    getDeployerAlerts(params?: {
+        since?: string;
+        before?: string;
+        limit?: string;
+        offset?: string;
+        tier?: string;
+        alert_type?: string;
+        priority?: string;
+        min_kol_buys?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getKolPairs(params?: {
+        period?: string;
+        min_shared?: string;
+        limit?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getKolHotTokens(params?: {
+        period?: string;
+        min_kols?: string;
+        limit?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getKolTrendingTokens(params?: {
+        period?: string;
+        min_kols?: string;
+        limit?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getKolTokenEntryOrder(mint: string, params?: {
+        limit?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getKolCompare(wallets: string[]): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getKolAlertsRecent(params?: {
+        window?: string;
+        types?: string;
+        min_severity?: string;
+        limit?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getKolPnl(wallet: string, params?: {
+        period?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getKolTiming(wallet: string, params?: {
+        period?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getDeployerTrajectory(wallet: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    private restRequest;
+    createWebhook(params: {
+        url: string;
+        events: string[];
+        filters?: Record<string, unknown>;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    listWebhooks(): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    deleteWebhook(id: number): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    testWebhook(webhookId: number): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getStreamToken(): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getWalletTrackerWatchlist(): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    addToWatchlist(walletAddress: string, label?: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    removeFromWatchlist(walletAddress: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getWalletTrackerTrades(params?: {
+        wallet?: string;
+        action?: string;
+        event_type?: string;
+        limit?: string;
+        before?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getWalletTrackerSummary(params?: {
+        period?: string;
+        wallet?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getAlphaLeaderboard(params?: {
+        limit?: string;
+        min_tokens?: string;
+        min_pnl?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getAlphaWallet(wallet: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getAlphaLinked(wallet: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getTokenCapTable(mint: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    getTokenBuyerQuality(mint: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    /** Bulk buyer-quality scoring for up to 50 mints. Shares the single-mint 5-min LRU cache. */
+    getTokenBuyerQualityBatch(mints: string[]): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    /** Comprehensive per-mint snapshot: price, MC, volume, deployer, KOL activity, age, blacklist. */
+    getToken(mint: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    /** Bulk lookup of up to 50 mints — same per-mint shape as getToken(). 10-20× cheaper than N sequential calls. */
+    getTokenBatch(mints: string[]): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    copyTradeList(): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    copyTradeCreate(params: {
+        name: string;
+        source_wallet: string;
+        is_active?: boolean;
+        webhook_url?: string;
+        delivery?: "webhook" | "websocket" | "both";
+        filters?: Record<string, unknown>;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    copyTradeGet(ruleId: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    copyTradeUpdate(ruleId: string, updates: Record<string, unknown>): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    copyTradeDelete(ruleId: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    coordinationAlertsList(): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    coordinationAlertsCreate(params: {
+        name?: string;
+        min_kols?: number;
+        window_minutes?: number;
+        min_score?: number;
+        include_majors?: boolean;
+        cooldown_min?: number;
+        score_jump_break?: number;
+        delivery_mode?: "websocket" | "webhook" | "both";
+        webhook_url?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    coordinationAlertsGet(ruleId: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    coordinationAlertsUpdate(ruleId: string, updates: Record<string, unknown>): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    coordinationAlertsDelete(ruleId: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    firstTouches(params?: {
+        since?: string;
+        before?: string;
+        limit?: number;
+        kol?: string;
+        min_kol_winrate_7d?: number;
+        min_scout_tier?: "S" | "A" | "B" | "C";
+        min_n_touches?: number;
+        strategy?: "scalper" | "day_trader" | "swing_trader" | "hodler" | "mixed";
+        token_age_max_min?: number;
+        min_first_buy_sol?: number;
+        mint_suffix?: string;
+        preset?: "scout" | "fresh_launch";
+        include?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    firstTouchSubscriptionsList(): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    firstTouchSubscriptionsCreate(params: {
+        name?: string;
+        filters?: {
+            kol?: string;
+            mint_suffix?: string;
+            min_first_buy_sol?: number;
+            min_scout_tier?: "S" | "A" | "B" | "C";
+            min_n_touches?: number;
+        };
+        delivery_mode?: "websocket" | "webhook" | "both";
+        webhook_url?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    firstTouchSubscriptionsGet(id: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    firstTouchSubscriptionsUpdate(id: string, updates: Record<string, unknown>): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    firstTouchSubscriptionsDelete(id: string): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+    copyTradeSignals(params?: {
+        rule_id?: string;
+        limit?: string;
+        since?: string;
+    }): Promise<{
+        data?: unknown;
+        error?: string;
+        status: number;
+    }>;
+}

package/dist/client.js

@@ -0,0 +1,282 @@
+/**
+ * MadeOnSol API client.
+ * Two auth modes: MadeOnSol API key (`msk_`, recommended) or x402 micropayments.
+ *
+ * v1.0 breaking change: RapidAPI auth has been removed (marketplace retired 2026-04-19).
+ * Get a free `msk_` key at https://madeonsol.com/developer.
+ */
+const DEFAULT_BASE = "https://madeonsol.com";
+export class MadeOnSolClient {
+    baseUrl;
+    fetchFn;
+    authMode;
+    authHeaders;
+    /** Most recent rate-limit headers, populated by every request. */
+    lastRateLimit = {};
+    constructor(options = {}) {
+        this.baseUrl = options.baseUrl || DEFAULT_BASE;
+        this.fetchFn = options.fetchFn || globalThis.fetch;
+        this.authHeaders = {};
+        if (options.apiKey) {
+            this.authMode = "madeonsol";
+            this.authHeaders = { Authorization: `Bearer ${options.apiKey}` };
+        }
+        else if (options.fetchFn) {
+            this.authMode = "x402";
+        }
+        else {
+            this.authMode = "none";
+            console.warn("\n[madeonsol] MadeOnSolClient constructed without apiKey or fetchFn — every request will fail.\n" +
+                "  → Get a free key (200 req/day, no card) at https://madeonsol.com/developer\n" +
+                "  → Then: new MadeOnSolClient({ apiKey: process.env.MADEONSOL_API_KEY })\n");
+        }
+    }
+    captureRateLimit(res) {
+        this.lastRateLimit = {
+            limit: res.headers.get("X-RateLimit-Limit") ?? undefined,
+            remaining: res.headers.get("X-RateLimit-Remaining") ?? undefined,
+            reset: res.headers.get("X-RateLimit-Reset") ?? undefined,
+            requestId: res.headers.get("X-Request-Id") ?? undefined,
+        };
+    }
+    async query(path, params) {
+        const apiPath = this.authMode === "x402" || this.authMode === "none"
+            ? path
+            : path.replace("/api/x402/", "/api/v1/");
+        const url = new URL(apiPath, this.baseUrl);
+        if (params) {
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined)
+                    url.searchParams.set(k, v);
+            }
+        }
+        const res = this.authMode === "x402"
+            ? await this.fetchFn(url.toString(), { method: "GET" })
+            : await this.fetchFn(url.toString(), { method: "GET", headers: this.authHeaders });
+        this.captureRateLimit(res);
+        if (res.status === 402) {
+            const body = await res.json();
+            return { error: `Payment required: ${JSON.stringify(body.accepts?.[0] || body)}`, status: 402 };
+        }
+        if (!res.ok) {
+            const text = await res.text().catch(() => "Unknown error");
+            return { error: text, status: res.status };
+        }
+        const data = await res.json();
+        return { data, status: res.status };
+    }
+    getKolFeed(params) {
+        return this.query("/api/x402/kol/feed", params);
+    }
+    getKolCoordination(params) {
+        return this.query("/api/x402/kol/coordination", params);
+    }
+    getKolLeaderboard(params) {
+        return this.query("/api/x402/kol/leaderboard", params);
+    }
+    /**
+     * Get deployer alerts. The `tier` filter (elite/good/moderate/rising/cold)
+     * is PRO/ULTRA only — BASIC callers passing it receive HTTP 403.
+     * Cursor-paginated via `before` (preferred over `offset` at scale).
+     */
+    getDeployerAlerts(params) {
+        return this.query("/api/x402/deployer-hunter/alerts", params);
+    }
+    getKolPairs(params) {
+        return this.query("/api/x402/kol/pairs", params);
+    }
+    getKolHotTokens(params) {
+        return this.query("/api/x402/kol/tokens/hot", params);
+    }
+    getKolTrendingTokens(params) {
+        return this.query("/api/x402/kol/tokens/trending", params);
+    }
+    getKolTokenEntryOrder(mint, params) {
+        return this.query(`/api/x402/kol/tokens/${encodeURIComponent(mint)}/entry-order`, params);
+    }
+    getKolCompare(wallets) {
+        return this.query("/api/x402/kol/compare", { wallets: wallets.join(",") });
+    }
+    getKolAlertsRecent(params) {
+        return this.query("/api/x402/kol/alerts/recent", params);
+    }
+    getKolPnl(wallet, params) {
+        const qs = params?.period ? `?period=${params.period}` : "";
+        return this.restRequest("GET", `/kol/${wallet}/pnl${qs}`);
+    }
+    getKolTiming(wallet, params) {
+        const qs = params?.period ? `?period=${params.period}` : "";
+        return this.restRequest("GET", `/kol/${wallet}/timing${qs}`);
+    }
+    getDeployerTrajectory(wallet) {
+        return this.restRequest("GET", `/deployer-hunter/${wallet}/trajectory`);
+    }
+    // ── REST helper (used by webhooks, streaming, alpha, copy-trade, wallet-tracker) ──
+    async restRequest(method, path, body) {
+        if (this.authMode !== "madeonsol") {
+            return { error: "MadeOnSol API key required for this endpoint. Get a free `msk_` key at https://madeonsol.com/developer", status: 401 };
+        }
+        const res = await this.fetchFn(`${this.baseUrl}/api/v1${path}`, {
+            method,
+            headers: {
+                "Content-Type": "application/json",
+                ...this.authHeaders,
+            },
+            ...(body ? { body: JSON.stringify(body) } : {}),
+        });
+        this.captureRateLimit(res);
+        if (!res.ok) {
+            const text = await res.text().catch(() => "Unknown error");
+            return { error: text, status: res.status };
+        }
+        return { data: await res.json(), status: res.status };
+    }
+    // ── Webhook management (PRO/ULTRA) ──
+    createWebhook(params) {
+        return this.restRequest("POST", "/webhooks", params);
+    }
+    listWebhooks() {
+        return this.restRequest("GET", "/webhooks");
+    }
+    deleteWebhook(id) {
+        return this.restRequest("DELETE", `/webhooks/${id}`);
+    }
+    testWebhook(webhookId) {
+        return this.restRequest("POST", "/webhooks/test", { webhook_id: webhookId });
+    }
+    getStreamToken() {
+        return this.restRequest("POST", "/stream/token");
+    }
+    // ── Wallet Tracker ──
+    getWalletTrackerWatchlist() {
+        return this.restRequest("GET", "/wallet-tracker/watchlist");
+    }
+    addToWatchlist(walletAddress, label) {
+        return this.restRequest("POST", "/wallet-tracker/watchlist", { wallet_address: walletAddress, ...(label ? { label } : {}) });
+    }
+    removeFromWatchlist(walletAddress) {
+        return this.restRequest("DELETE", `/wallet-tracker/watchlist/${encodeURIComponent(walletAddress)}`);
+    }
+    getWalletTrackerTrades(params) {
+        const qs = new URLSearchParams();
+        if (params) {
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined)
+                    qs.set(k, v);
+            }
+        }
+        const query = qs.toString() ? `?${qs.toString()}` : "";
+        return this.restRequest("GET", `/wallet-tracker/trades${query}`);
+    }
+    getWalletTrackerSummary(params) {
+        const qs = new URLSearchParams();
+        if (params?.period)
+            qs.set("period", params.period);
+        if (params?.wallet)
+            qs.set("wallet", params.wallet);
+        const query = qs.toString() ? `?${qs.toString()}` : "";
+        return this.restRequest("GET", `/wallet-tracker/summary${query}`);
+    }
+    // ── Alpha Wallet Intelligence ──
+    getAlphaLeaderboard(params) {
+        const qs = new URLSearchParams();
+        if (params)
+            for (const [k, v] of Object.entries(params))
+                if (v !== undefined)
+                    qs.set(k, v);
+        const query = qs.toString() ? `?${qs.toString()}` : "";
+        return this.restRequest("GET", `/alpha/leaderboard${query}`);
+    }
+    getAlphaWallet(wallet) {
+        return this.restRequest("GET", `/alpha/wallet/${encodeURIComponent(wallet)}`);
+    }
+    getAlphaLinked(wallet) {
+        return this.restRequest("GET", `/alpha/${encodeURIComponent(wallet)}/linked`);
+    }
+    // ── Token Quality ──
+    getTokenCapTable(mint) {
+        return this.restRequest("GET", `/tokens/${encodeURIComponent(mint)}/cap-table`);
+    }
+    getTokenBuyerQuality(mint) {
+        return this.restRequest("GET", `/tokens/${encodeURIComponent(mint)}/buyer-quality`);
+    }
+    /** Bulk buyer-quality scoring for up to 50 mints. Shares the single-mint 5-min LRU cache. */
+    getTokenBuyerQualityBatch(mints) {
+        return this.restRequest("POST", "/tokens/batch/buyer-quality", { mints });
+    }
+    // ── Token intelligence (/token/{mint}) ──
+    /** Comprehensive per-mint snapshot: price, MC, volume, deployer, KOL activity, age, blacklist. */
+    getToken(mint) {
+        return this.restRequest("GET", `/token/${encodeURIComponent(mint)}`);
+    }
+    /** Bulk lookup of up to 50 mints — same per-mint shape as getToken(). 10-20× cheaper than N sequential calls. */
+    getTokenBatch(mints) {
+        return this.restRequest("POST", "/token/batch", { mints });
+    }
+    // ── Copy-Trade Rules (PRO/ULTRA) ──
+    copyTradeList() {
+        return this.restRequest("GET", "/copy-trade/rules");
+    }
+    copyTradeCreate(params) {
+        return this.restRequest("POST", "/copy-trade/rules", params);
+    }
+    copyTradeGet(ruleId) {
+        return this.restRequest("GET", `/copy-trade/rules/${encodeURIComponent(ruleId)}`);
+    }
+    copyTradeUpdate(ruleId, updates) {
+        return this.restRequest("PATCH", `/copy-trade/rules/${encodeURIComponent(ruleId)}`, updates);
+    }
+    copyTradeDelete(ruleId) {
+        return this.restRequest("DELETE", `/copy-trade/rules/${encodeURIComponent(ruleId)}`);
+    }
+    // ── Coordination alerts (PRO/ULTRA, v1.1) ──
+    coordinationAlertsList() {
+        return this.restRequest("GET", "/kol/coordination/alerts");
+    }
+    coordinationAlertsCreate(params) {
+        return this.restRequest("POST", "/kol/coordination/alerts", params);
+    }
+    coordinationAlertsGet(ruleId) {
+        return this.restRequest("GET", `/kol/coordination/alerts/${encodeURIComponent(ruleId)}`);
+    }
+    coordinationAlertsUpdate(ruleId, updates) {
+        return this.restRequest("PATCH", `/kol/coordination/alerts/${encodeURIComponent(ruleId)}`, updates);
+    }
+    coordinationAlertsDelete(ruleId) {
+        return this.restRequest("DELETE", `/kol/coordination/alerts/${encodeURIComponent(ruleId)}`);
+    }
+    // ── First-touch signal ──
+    firstTouches(params) {
+        const qs = new URLSearchParams();
+        if (params)
+            for (const [k, v] of Object.entries(params))
+                if (v !== undefined)
+                    qs.set(k, String(v));
+        const query = qs.toString() ? `?${qs.toString()}` : "";
+        return this.restRequest("GET", `/kol/first-touches${query}`);
+    }
+    firstTouchSubscriptionsList() {
+        return this.restRequest("GET", "/kol/first-touches/subscriptions");
+    }
+    firstTouchSubscriptionsCreate(params) {
+        return this.restRequest("POST", "/kol/first-touches/subscriptions", params);
+    }
+    firstTouchSubscriptionsGet(id) {
+        return this.restRequest("GET", `/kol/first-touches/subscriptions/${encodeURIComponent(id)}`);
+    }
+    firstTouchSubscriptionsUpdate(id, updates) {
+        return this.restRequest("PATCH", `/kol/first-touches/subscriptions/${encodeURIComponent(id)}`, updates);
+    }
+    firstTouchSubscriptionsDelete(id) {
+        return this.restRequest("DELETE", `/kol/first-touches/subscriptions/${encodeURIComponent(id)}`);
+    }
+    copyTradeSignals(params) {
+        const qs = new URLSearchParams();
+        if (params)
+            for (const [k, v] of Object.entries(params))
+                if (v !== undefined)
+                    qs.set(k, v);
+        const query = qs.toString() ? `?${qs.toString()}` : "";
+        return this.restRequest("GET", `/copy-trade/signals${query}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import type { Plugin } from "@elizaos/core";
+import { kolFeedAction } from "./actions/kol-feed.js";
+import { kolCoordinationAction } from "./actions/kol-coordination.js";
+import { kolLeaderboardAction } from "./actions/kol-leaderboard.js";
+import { deployerAlertsAction } from "./actions/deployer-alerts.js";
+import { walletTrackerWatchlistAction, walletTrackerTradesAction } from "./actions/wallet-tracker.js";
+import { kolTokenEntryOrderAction } from "./actions/kol-token-entry-order.js";
+import { kolCompareAction } from "./actions/kol-compare.js";
+import { kolAlertsRecentAction } from "./actions/kol-alerts-recent.js";
+/** Key used to store the initialized client on the runtime */
+export declare const MADEONSOL_CLIENT_KEY = "madeonsol:client";
+export declare const madeOnSolPlugin: Plugin;
+export default madeOnSolPlugin;
+export { MadeOnSolClient } from "./client.js";
+export { kolFeedAction, kolCoordinationAction, kolLeaderboardAction, deployerAlertsAction };
+export { walletTrackerWatchlistAction, walletTrackerTradesAction };
+export { kolTokenEntryOrderAction, kolCompareAction, kolAlertsRecentAction };

package/dist/index.js

@@ -0,0 +1,72 @@
+import { kolFeedAction } from "./actions/kol-feed.js";
+import { kolCoordinationAction } from "./actions/kol-coordination.js";
+import { kolLeaderboardAction } from "./actions/kol-leaderboard.js";
+import { deployerAlertsAction } from "./actions/deployer-alerts.js";
+import { walletTrackerWatchlistAction, walletTrackerTradesAction } from "./actions/wallet-tracker.js";
+import { kolTokenEntryOrderAction } from "./actions/kol-token-entry-order.js";
+import { kolCompareAction } from "./actions/kol-compare.js";
+import { kolAlertsRecentAction } from "./actions/kol-alerts-recent.js";
+import { MadeOnSolClient } from "./client.js";
+/** Key used to store the initialized client on the runtime */
+export const MADEONSOL_CLIENT_KEY = "madeonsol:client";
+export const madeOnSolPlugin = {
+    name: "madeonsol",
+    description: "Query Solana KOL trading intelligence and deployer analytics from MadeOnSol. Tracks 1,000+ KOL wallets and 6,700+ Pump.fun deployers.",
+    actions: [
+        kolFeedAction,
+        kolCoordinationAction,
+        kolLeaderboardAction,
+        deployerAlertsAction,
+        walletTrackerWatchlistAction,
+        walletTrackerTradesAction,
+        kolTokenEntryOrderAction,
+        kolCompareAction,
+        kolAlertsRecentAction,
+    ],
+    /**
+     * Initialize the MadeOnSol client.
+     * Auth priority: MADEONSOL_API_KEY > SVM_PRIVATE_KEY (x402).
+     * Get a free `msk_` API key at madeonsol.com/developer — no wallet needed.
+     *
+     * v1.0 breaking change: RAPIDAPI_KEY support has been removed
+     * (MadeOnSol RapidAPI marketplace was retired 2026-04-19).
+     */
+    init: async (_config, runtime) => {
+        const baseUrl = String(runtime.getSetting?.("MADEONSOL_API_URL") || "https://madeonsol.com");
+        const apiKey = runtime.getSetting?.("MADEONSOL_API_KEY");
+        const privateKey = runtime.getSetting?.("SVM_PRIVATE_KEY");
+        let fetchFn;
+        if (apiKey) {
+            console.log("[madeonsol] Using MadeOnSol API key (Bearer auth)");
+        }
+        else if (privateKey) {
+            try {
+                const { wrapFetchWithPayment } = await import("@x402/fetch");
+                const { x402Client } = await import("@x402/core/client");
+                const { ExactSvmScheme } = await import("@x402/svm/exact/client");
+                const { createKeyPairSignerFromBytes } = await import("@solana/kit");
+                const { base58 } = await import("@scure/base");
+                const signer = await createKeyPairSignerFromBytes(base58.decode(privateKey));
+                const client = new x402Client();
+                client.register("solana:*", new ExactSvmScheme(signer));
+                fetchFn = wrapFetchWithPayment(fetch, client);
+                console.log(`[madeonsol] x402 payments enabled, wallet: ${signer.address}`);
+            }
+            catch (err) {
+                console.warn("[madeonsol] x402 payment setup failed:", err);
+            }
+        }
+        else {
+            console.warn("[madeonsol] No auth configured — every API call will fail.\n" +
+                "  → Get a free MADEONSOL_API_KEY (200 req/day, no card) at https://madeonsol.com/developer\n" +
+                "  → Or set SVM_PRIVATE_KEY for x402 micropayments.");
+        }
+        const madeOnSolClient = new MadeOnSolClient({ baseUrl, apiKey, fetchFn });
+        runtime[MADEONSOL_CLIENT_KEY] = madeOnSolClient;
+    },
+};
+export default madeOnSolPlugin;
+export { MadeOnSolClient } from "./client.js";
+export { kolFeedAction, kolCoordinationAction, kolLeaderboardAction, deployerAlertsAction };
+export { walletTrackerWatchlistAction, walletTrackerTradesAction };
+export { kolTokenEntryOrderAction, kolCompareAction, kolAlertsRecentAction };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@madeonsol/plugin-madeonsol",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "ElizaOS plugin for MadeOnSol — Solana KOL intelligence and deployer analytics via x402 micropayments",
   "type": "module",
   "main": "dist/index.js",