solana-agent-kit-plugin-madeonsol 0.4.0 → 0.6.0

package/README.md

@@ -1,17 +1,16 @@
 # solana-agent-kit-plugin-madeonsol
 
-[Solana Agent Kit](https://github.com/sendaifun/solana-agent-kit) plugin for [MadeOnSol](https://madeonsol.com) — Solana KOL intelligence and deployer analytics.
+[Solana Agent Kit](https://github.com/sendaifun/solana-agent-kit) plugin for [MadeOnSol](https://madeonsol.com) — Solana KOL intelligence, deployer analytics, and wallet tracking.
 
-> Real-time Solana trading intelligence: track 1,000+ KOL wallets with <3s latency, score 6,700+ Pump.fun deployers by reputation, detect multi-KOL coordination signals, and stream every DEX trade. Free tier: 200 requests/day at [madeonsol.com/developer](https://madeonsol.com/developer) — no credit card required.
+> Real-time Solana trading intelligence: track 1,000+ KOL wallets with <3s latency, score 6,700+ Pump.fun deployers by reputation, detect multi-KOL coordination signals, monitor any Solana wallet for swaps and transfers, and stream every DEX trade. Free tier: 200 requests/day at [madeonsol.com/developer](https://madeonsol.com/developer) — no credit card required.
 
 ## Authentication
 
-Three options (in priority order):
+Two options (in priority order):
 
 | Method | Config key | Best for |
 |---|---|---|
 | **MadeOnSol API key** (recommended) | `MADEONSOL_API_KEY` | Developers — [get a free key](https://madeonsol.com/developer) |
-| RapidAPI key | `RAPIDAPI_KEY` | RapidAPI subscribers |
 | x402 micropayments | `SVM_PRIVATE_KEY` | AI agents with Solana wallets |
 
 ## Install
@@ -29,14 +28,7 @@ import { SolanaAgentKit } from "solana-agent-kit";
 import MadeOnSolPlugin from "solana-agent-kit-plugin-madeonsol";
 
 const agent = new SolanaAgentKit(privateKey, rpcUrl, {
-  // Option 1: API key (simplest)
   MADEONSOL_API_KEY: "msk_your_api_key_here",
-
-  // Option 2: RapidAPI key
-  // RAPIDAPI_KEY: "your_rapidapi_key",
-
-  // Option 3: x402 micropayments
-  // SVM_PRIVATE_KEY: "your_solana_private_key_base58",
 });
 
 agent.use(MadeOnSolPlugin);
@@ -44,6 +36,11 @@ 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
 ```
@@ -54,16 +51,32 @@ const trades = await agent.methods.kolFeed(agent, { limit: 10, action: "buy" });
 |---|---|
 | `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", "best kol" — periods: today, 7d, 30d, 90d, 180d (180-day retention) |
-| `MADEONSOL_DEPLOYER_ALERTS_ACTION` | "deployer alerts", "pump fun launches" — PRO/ULTRA: filter by tier (elite/good/moderate/rising/cold) |
-| `MADEONSOL_TOKEN_INFO_ACTION` | "token info", "token price", "what is this token" |
+| `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_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" |
+
+## Tiers
+
+| Tier | Price | Wallets tracked | Requests/day |
+|------|-------|-----------------|--------------|
+| BASIC | Free | 10 | 200 |
+| PRO | $49/mo | 50 | 10,000 |
+| ULTRA | $199/mo | 100 + WS events | 100,000 |
+
+Get a key at [madeonsol.com/developer](https://madeonsol.com/developer).
 
 ## Also Available
 
 | Platform | Package |
 |---|---|
-| TypeScript SDK | [`madeonsol-x402`](https://www.npmjs.com/package/madeonsol-x402) |
-| Python (LangChain, CrewAI) | [`madeonsol-x402`](https://github.com/LamboPoewert/madeonsol-python) on PyPI |
+| TypeScript SDK | [`madeonsol`](https://www.npmjs.com/package/madeonsol) on npm |
+| Python (LangChain, CrewAI) | [`madeonsol-x402`](https://pypi.org/project/madeonsol-x402/) on PyPI |
 | MCP Server (Claude, Cursor) | [`mcp-server-madeonsol`](https://www.npmjs.com/package/mcp-server-madeonsol) |
 | ElizaOS | [`@madeonsol/plugin-madeonsol`](https://www.npmjs.com/package/@madeonsol/plugin-madeonsol) |
 

package/dist/actions/kolFeed.d.ts

@@ -22,8 +22,8 @@ export declare const kolFeedAction: {
         action?: "buy" | "sell" | undefined;
         kol?: string | undefined;
     }, {
-        limit?: number | undefined;
         action?: "buy" | "sell" | undefined;
+        limit?: number | undefined;
         kol?: string | undefined;
     }>;
     handler: (agent: unknown, input: {

package/dist/actions/kolPnl.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const kolPnlAction: {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        input: {
+            wallet: string;
+            period: string;
+        };
+        output: {
+            status: string;
+        };
+        explanation: string;
+    }[][];
+    schema: z.ZodObject<{
+        wallet: z.ZodString;
+        period: z.ZodDefault<z.ZodEnum<["7d", "30d", "90d", "180d"]>>;
+    }, "strip", z.ZodTypeAny, {
+        wallet: string;
+        period: "7d" | "30d" | "90d" | "180d";
+    }, {
+        wallet: string;
+        period?: "7d" | "30d" | "90d" | "180d" | undefined;
+    }>;
+    handler: (agent: unknown, input: {
+        wallet: string;
+        period?: string;
+    }) => Promise<{
+        status: string;
+        result: any;
+        message?: undefined;
+    } | {
+        status: string;
+        message: string;
+        result?: undefined;
+    }>;
+};

package/dist/actions/kolPnl.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { kolPnl } from "../tools/index.js";
+export const kolPnlAction = {
+    name: "MADEONSOL_KOL_PNL_ACTION",
+    similes: ["kol pnl", "kol profit", "kol performance", "wallet pnl", "kol win rate", "kol drawdown"],
+    description: "Get deep per-wallet PnL breakdown — realized PnL, win rate, profit factor, max drawdown, daily equity curve, and per-token positions via MadeOnSol API.",
+    examples: [
+        [{ input: { wallet: "ABC...xyz", period: "30d" }, output: { status: "success" }, explanation: "Get 30-day PnL breakdown for a KOL wallet" }],
+    ],
+    schema: z.object({
+        wallet: z.string().describe("KOL wallet address (base58)"),
+        period: z.enum(["7d", "30d", "90d", "180d"]).default("30d").describe("Time period"),
+    }),
+    handler: async (agent, input) => {
+        try {
+            const data = await kolPnl(agent, input);
+            return { status: "success", result: data };
+        }
+        catch (err) {
+            return { status: "error", message: err.message };
+        }
+    },
+};

package/dist/actions/kolTrendingTokens.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare const kolTrendingTokensAction: {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        input: {
+            period: string;
+            min_kols: number;
+        };
+        output: {
+            status: string;
+        };
+        explanation: string;
+    }[][];
+    schema: z.ZodObject<{
+        period: z.ZodDefault<z.ZodEnum<["5m", "15m", "30m", "1h", "2h", "4h", "12h"]>>;
+        min_kols: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        period: "1h" | "5m" | "15m" | "30m" | "2h" | "4h" | "12h";
+        min_kols: number;
+    }, {
+        limit?: number | undefined;
+        period?: "1h" | "5m" | "15m" | "30m" | "2h" | "4h" | "12h" | undefined;
+        min_kols?: number | undefined;
+    }>;
+    handler: (agent: unknown, input: {
+        period?: string;
+        min_kols?: number;
+        limit?: number;
+    }) => Promise<{
+        status: string;
+        result: any;
+        message?: undefined;
+    } | {
+        status: string;
+        message: string;
+        result?: undefined;
+    }>;
+};

package/dist/actions/kolTrendingTokens.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { kolTrendingTokens } from "../tools/index.js";
+export const kolTrendingTokensAction = {
+    name: "MADEONSOL_KOL_TRENDING_TOKENS_ACTION",
+    similes: ["trending tokens", "kol volume", "what are kols buying now", "hot buys", "kol capital flow"],
+    description: "Get tokens ranked by KOL buy volume — pure capital-flow signal. Sub-hour periods (5m/15m/30m) require PRO/ULTRA. Costs $0.005 USDC per request.",
+    examples: [
+        [{ input: { period: "1h", min_kols: 2 }, output: { status: "success" }, explanation: "Get tokens with highest KOL buy volume in the last hour, with at least 2 KOLs buying" }],
+    ],
+    schema: z.object({
+        period: z.enum(["5m", "15m", "30m", "1h", "2h", "4h", "12h"]).default("1h").describe("Time window"),
+        min_kols: z.number().min(1).max(20).default(1).describe("Minimum KOL buyers"),
+        limit: z.number().min(1).max(50).default(20).describe("Number of tokens"),
+    }),
+    handler: async (agent, input) => {
+        try {
+            const data = await kolTrendingTokens(agent, input);
+            return { status: "success", result: data };
+        }
+        catch (err) {
+            return { status: "error", message: err.message };
+        }
+    },
+};

package/dist/actions/walletTracker.d.ts

@@ -0,0 +1,176 @@
+import { z } from "zod";
+export declare const walletTrackerWatchlistAction: {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        input: {};
+        output: {
+            status: string;
+        };
+        explanation: string;
+    }[][];
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    handler: (agent: unknown) => Promise<{
+        status: string;
+        result: any;
+        message?: undefined;
+    } | {
+        status: string;
+        message: string;
+        result?: undefined;
+    }>;
+};
+export declare const walletTrackerAddAction: {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        input: {
+            wallet_address: string;
+            label: string;
+        };
+        output: {
+            status: string;
+        };
+        explanation: string;
+    }[][];
+    schema: z.ZodObject<{
+        wallet_address: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        wallet_address: string;
+        label?: string | undefined;
+    }, {
+        wallet_address: string;
+        label?: string | undefined;
+    }>;
+    handler: (agent: unknown, input: {
+        wallet_address: string;
+        label?: string;
+    }) => Promise<{
+        status: string;
+        result: any;
+        message?: undefined;
+    } | {
+        status: string;
+        message: string;
+        result?: undefined;
+    }>;
+};
+export declare const walletTrackerRemoveAction: {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        input: {
+            wallet_address: string;
+        };
+        output: {
+            status: string;
+        };
+        explanation: string;
+    }[][];
+    schema: z.ZodObject<{
+        wallet_address: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        wallet_address: string;
+    }, {
+        wallet_address: string;
+    }>;
+    handler: (agent: unknown, input: {
+        wallet_address: string;
+    }) => Promise<{
+        status: string;
+        result: any;
+        message?: undefined;
+    } | {
+        status: string;
+        message: string;
+        result?: undefined;
+    }>;
+};
+export declare const walletTrackerTradesAction: {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        input: {
+            limit: number;
+        };
+        output: {
+            status: string;
+        };
+        explanation: string;
+    }[][];
+    schema: z.ZodObject<{
+        wallet: z.ZodOptional<z.ZodString>;
+        action: z.ZodOptional<z.ZodEnum<["buy", "sell", "transfer_in", "transfer_out"]>>;
+        event_type: z.ZodOptional<z.ZodEnum<["swap", "transfer"]>>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        before: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        wallet?: string | undefined;
+        action?: "buy" | "sell" | "transfer_in" | "transfer_out" | undefined;
+        event_type?: "swap" | "transfer" | undefined;
+        before?: number | undefined;
+    }, {
+        wallet?: string | undefined;
+        action?: "buy" | "sell" | "transfer_in" | "transfer_out" | undefined;
+        event_type?: "swap" | "transfer" | undefined;
+        limit?: number | undefined;
+        before?: number | undefined;
+    }>;
+    handler: (agent: unknown, input: {
+        wallet?: string;
+        action?: string;
+        event_type?: string;
+        limit?: number;
+        before?: number;
+    }) => Promise<{
+        status: string;
+        result: any;
+        message?: undefined;
+    } | {
+        status: string;
+        message: string;
+        result?: undefined;
+    }>;
+};
+export declare const walletTrackerSummaryAction: {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        input: {
+            period: string;
+        };
+        output: {
+            status: string;
+        };
+        explanation: string;
+    }[][];
+    schema: z.ZodObject<{
+        period: z.ZodDefault<z.ZodEnum<["24h", "7d", "30d"]>>;
+        wallet: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        period: "24h" | "7d" | "30d";
+        wallet?: string | undefined;
+    }, {
+        wallet?: string | undefined;
+        period?: "24h" | "7d" | "30d" | undefined;
+    }>;
+    handler: (agent: unknown, input: {
+        period?: string;
+        wallet?: string;
+    }) => Promise<{
+        status: string;
+        result: any;
+        message?: undefined;
+    } | {
+        status: string;
+        message: string;
+        result?: undefined;
+    }>;
+};

package/dist/actions/walletTracker.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+import { walletTrackerWatchlist, walletTrackerAdd, walletTrackerRemove, walletTrackerTrades, walletTrackerSummary } from "../tools/index.js";
+export const walletTrackerWatchlistAction = {
+    name: "MADEONSOL_WALLET_TRACKER_WATCHLIST_ACTION",
+    similes: ["wallet watchlist", "tracked wallets", "my watchlist", "wallet tracker list"],
+    description: "List wallets in your MadeOnSol watchlist with labels and remaining capacity.",
+    examples: [
+        [{ input: {}, output: { status: "success" }, explanation: "Get your tracked wallet list" }],
+    ],
+    schema: z.object({}),
+    handler: async (agent) => {
+        try {
+            const data = await walletTrackerWatchlist(agent);
+            return { status: "success", result: data };
+        }
+        catch (err) {
+            return { status: "error", message: err.message };
+        }
+    },
+};
+export const walletTrackerAddAction = {
+    name: "MADEONSOL_WALLET_TRACKER_ADD_ACTION",
+    similes: ["track wallet", "add wallet to watchlist", "watch wallet", "monitor wallet"],
+    description: "Add a Solana wallet to your MadeOnSol watchlist for swap/transfer tracking.",
+    examples: [
+        [{ input: { wallet_address: "ABC...xyz", label: "whale #1" }, output: { status: "success" }, explanation: "Add a wallet to watchlist" }],
+    ],
+    schema: z.object({
+        wallet_address: z.string().describe("Solana wallet address (base58) to track"),
+        label: z.string().optional().describe("Optional human-readable label"),
+    }),
+    handler: async (agent, input) => {
+        try {
+            const data = await walletTrackerAdd(agent, input);
+            return { status: "success", result: data };
+        }
+        catch (err) {
+            return { status: "error", message: err.message };
+        }
+    },
+};
+export const walletTrackerRemoveAction = {
+    name: "MADEONSOL_WALLET_TRACKER_REMOVE_ACTION",
+    similes: ["untrack wallet", "remove wallet from watchlist", "stop watching wallet"],
+    description: "Remove a Solana wallet from your MadeOnSol watchlist.",
+    examples: [
+        [{ input: { wallet_address: "ABC...xyz" }, output: { status: "success" }, explanation: "Remove a wallet from watchlist" }],
+    ],
+    schema: z.object({
+        wallet_address: z.string().describe("Solana wallet address (base58) to remove"),
+    }),
+    handler: async (agent, input) => {
+        try {
+            const data = await walletTrackerRemove(agent, input);
+            return { status: "success", result: data };
+        }
+        catch (err) {
+            return { status: "error", message: err.message };
+        }
+    },
+};
+export const walletTrackerTradesAction = {
+    name: "MADEONSOL_WALLET_TRACKER_TRADES_ACTION",
+    similes: ["wallet tracker trades", "tracked wallet trades", "watchlist activity", "wallet swaps", "wallet transfers"],
+    description: "Get recent swap and transfer events from wallets in your MadeOnSol watchlist.",
+    examples: [
+        [{ input: { limit: 20 }, output: { status: "success" }, explanation: "Get recent trades from tracked wallets" }],
+    ],
+    schema: z.object({
+        wallet: z.string().optional().describe("Filter to a specific wallet address"),
+        action: z.enum(["buy", "sell", "transfer_in", "transfer_out"]).optional().describe("Filter by action type"),
+        event_type: z.enum(["swap", "transfer"]).optional().describe("Filter by event type"),
+        limit: z.number().min(1).max(200).default(50).describe("Max results (1-200)"),
+        before: z.number().optional().describe("Pagination cursor: block_time of last event"),
+    }),
+    handler: async (agent, input) => {
+        try {
+            const data = await walletTrackerTrades(agent, input);
+            return { status: "success", result: data };
+        }
+        catch (err) {
+            return { status: "error", message: err.message };
+        }
+    },
+};
+export const walletTrackerSummaryAction = {
+    name: "MADEONSOL_WALLET_TRACKER_SUMMARY_ACTION",
+    similes: ["wallet tracker summary", "tracked wallet stats", "watchlist summary", "wallet activity stats"],
+    description: "Get per-wallet stats (swap counts, SOL bought/sold, last activity) for your MadeOnSol watchlist.",
+    examples: [
+        [{ input: { period: "7d" }, output: { status: "success" }, explanation: "Get 7d stats for all tracked wallets" }],
+    ],
+    schema: z.object({
+        period: z.enum(["24h", "7d", "30d"]).default("7d").describe("Time window for stats"),
+        wallet: z.string().optional().describe("Filter to a specific wallet address"),
+    }),
+    handler: async (agent, input) => {
+        try {
+            const data = await walletTrackerSummary(agent, input);
+            return { status: "success", result: data };
+        }
+        catch (err) {
+            return { status: "error", message: err.message };
+        }
+    },
+};

package/dist/index.d.ts

@@ -2,7 +2,10 @@ import { kolFeedAction } from "./actions/kolFeed.js";
 import { kolCoordinationAction } from "./actions/kolCoordination.js";
 import { kolLeaderboardAction } from "./actions/kolLeaderboard.js";
 import { deployerAlertsAction } from "./actions/deployerAlerts.js";
-import { kolFeed, kolCoordination, kolLeaderboard, deployerAlerts, createWebhook, listWebhooks, deleteWebhook, testWebhook, getStreamToken } from "./tools/index.js";
+import { kolPnlAction } from "./actions/kolPnl.js";
+import { kolTrendingTokensAction } from "./actions/kolTrendingTokens.js";
+import { walletTrackerWatchlistAction, walletTrackerAddAction, walletTrackerRemoveAction, walletTrackerTradesAction, walletTrackerSummaryAction } from "./actions/walletTracker.js";
+import { kolFeed, kolCoordination, kolLeaderboard, deployerAlerts, kolPnl, kolTrendingTokens, createWebhook, listWebhooks, deleteWebhook, testWebhook, getStreamToken, walletTrackerWatchlist, walletTrackerAdd, walletTrackerRemove, walletTrackerTrades, walletTrackerSummary } from "./tools/index.js";
 declare const MadeOnSolPlugin: {
     name: string;
     methods: {
@@ -10,11 +13,18 @@ declare const MadeOnSolPlugin: {
         kolCoordination: typeof kolCoordination;
         kolLeaderboard: typeof kolLeaderboard;
         deployerAlerts: typeof deployerAlerts;
+        kolPnl: typeof kolPnl;
+        kolTrendingTokens: typeof kolTrendingTokens;
         createWebhook: typeof createWebhook;
         listWebhooks: typeof listWebhooks;
         deleteWebhook: typeof deleteWebhook;
         testWebhook: typeof testWebhook;
         getStreamToken: typeof getStreamToken;
+        walletTrackerWatchlist: typeof walletTrackerWatchlist;
+        walletTrackerAdd: typeof walletTrackerAdd;
+        walletTrackerRemove: typeof walletTrackerRemove;
+        walletTrackerTrades: typeof walletTrackerTrades;
+        walletTrackerSummary: typeof walletTrackerSummary;
     };
     actions: ({
         name: string;
@@ -39,8 +49,8 @@ declare const MadeOnSolPlugin: {
             action?: "buy" | "sell" | undefined;
             kol?: string | undefined;
         }, {
-            limit?: number | undefined;
             action?: "buy" | "sell" | undefined;
+            limit?: number | undefined;
             kol?: string | undefined;
         }>;
         handler: (agent: unknown, input: {
@@ -175,9 +185,256 @@ declare const MadeOnSolPlugin: {
             message: string;
             result?: undefined;
         }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            input: {
+                wallet: string;
+                period: string;
+            };
+            output: {
+                status: string;
+            };
+            explanation: string;
+        }[][];
+        schema: import("zod").ZodObject<{
+            wallet: import("zod").ZodString;
+            period: import("zod").ZodDefault<import("zod").ZodEnum<["7d", "30d", "90d", "180d"]>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            wallet: string;
+            period: "7d" | "30d" | "90d" | "180d";
+        }, {
+            wallet: string;
+            period?: "7d" | "30d" | "90d" | "180d" | undefined;
+        }>;
+        handler: (agent: unknown, input: {
+            wallet: string;
+            period?: string;
+        }) => Promise<{
+            status: string;
+            result: any;
+            message?: undefined;
+        } | {
+            status: string;
+            message: string;
+            result?: undefined;
+        }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            input: {
+                period: string;
+                min_kols: number;
+            };
+            output: {
+                status: string;
+            };
+            explanation: string;
+        }[][];
+        schema: import("zod").ZodObject<{
+            period: import("zod").ZodDefault<import("zod").ZodEnum<["5m", "15m", "30m", "1h", "2h", "4h", "12h"]>>;
+            min_kols: import("zod").ZodDefault<import("zod").ZodNumber>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            limit: number;
+            period: "1h" | "5m" | "15m" | "30m" | "2h" | "4h" | "12h";
+            min_kols: number;
+        }, {
+            limit?: number | undefined;
+            period?: "1h" | "5m" | "15m" | "30m" | "2h" | "4h" | "12h" | undefined;
+            min_kols?: number | undefined;
+        }>;
+        handler: (agent: unknown, input: {
+            period?: string;
+            min_kols?: number;
+            limit?: number;
+        }) => Promise<{
+            status: string;
+            result: any;
+            message?: undefined;
+        } | {
+            status: string;
+            message: string;
+            result?: undefined;
+        }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            input: {};
+            output: {
+                status: string;
+            };
+            explanation: string;
+        }[][];
+        schema: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+        handler: (agent: unknown) => Promise<{
+            status: string;
+            result: any;
+            message?: undefined;
+        } | {
+            status: string;
+            message: string;
+            result?: undefined;
+        }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            input: {
+                wallet_address: string;
+                label: string;
+            };
+            output: {
+                status: string;
+            };
+            explanation: string;
+        }[][];
+        schema: import("zod").ZodObject<{
+            wallet_address: import("zod").ZodString;
+            label: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            wallet_address: string;
+            label?: string | undefined;
+        }, {
+            wallet_address: string;
+            label?: string | undefined;
+        }>;
+        handler: (agent: unknown, input: {
+            wallet_address: string;
+            label?: string;
+        }) => Promise<{
+            status: string;
+            result: any;
+            message?: undefined;
+        } | {
+            status: string;
+            message: string;
+            result?: undefined;
+        }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            input: {
+                wallet_address: string;
+            };
+            output: {
+                status: string;
+            };
+            explanation: string;
+        }[][];
+        schema: import("zod").ZodObject<{
+            wallet_address: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            wallet_address: string;
+        }, {
+            wallet_address: string;
+        }>;
+        handler: (agent: unknown, input: {
+            wallet_address: string;
+        }) => Promise<{
+            status: string;
+            result: any;
+            message?: undefined;
+        } | {
+            status: string;
+            message: string;
+            result?: undefined;
+        }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            input: {
+                limit: number;
+            };
+            output: {
+                status: string;
+            };
+            explanation: string;
+        }[][];
+        schema: import("zod").ZodObject<{
+            wallet: import("zod").ZodOptional<import("zod").ZodString>;
+            action: import("zod").ZodOptional<import("zod").ZodEnum<["buy", "sell", "transfer_in", "transfer_out"]>>;
+            event_type: import("zod").ZodOptional<import("zod").ZodEnum<["swap", "transfer"]>>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+            before: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            limit: number;
+            wallet?: string | undefined;
+            action?: "buy" | "sell" | "transfer_in" | "transfer_out" | undefined;
+            event_type?: "swap" | "transfer" | undefined;
+            before?: number | undefined;
+        }, {
+            wallet?: string | undefined;
+            action?: "buy" | "sell" | "transfer_in" | "transfer_out" | undefined;
+            event_type?: "swap" | "transfer" | undefined;
+            limit?: number | undefined;
+            before?: number | undefined;
+        }>;
+        handler: (agent: unknown, input: {
+            wallet?: string;
+            action?: string;
+            event_type?: string;
+            limit?: number;
+            before?: number;
+        }) => Promise<{
+            status: string;
+            result: any;
+            message?: undefined;
+        } | {
+            status: string;
+            message: string;
+            result?: undefined;
+        }>;
+    } | {
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            input: {
+                period: string;
+            };
+            output: {
+                status: string;
+            };
+            explanation: string;
+        }[][];
+        schema: import("zod").ZodObject<{
+            period: import("zod").ZodDefault<import("zod").ZodEnum<["24h", "7d", "30d"]>>;
+            wallet: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            period: "24h" | "7d" | "30d";
+            wallet?: string | undefined;
+        }, {
+            wallet?: string | undefined;
+            period?: "24h" | "7d" | "30d" | undefined;
+        }>;
+        handler: (agent: unknown, input: {
+            period?: string;
+            wallet?: string;
+        }) => Promise<{
+            status: string;
+            result: any;
+            message?: undefined;
+        } | {
+            status: string;
+            message: string;
+            result?: undefined;
+        }>;
     })[];
     initialize(_agent: unknown): void;
 };
 export default MadeOnSolPlugin;
-export { kolFeed, kolCoordination, kolLeaderboard, deployerAlerts, createWebhook, listWebhooks, deleteWebhook, testWebhook, getStreamToken };
-export { kolFeedAction, kolCoordinationAction, kolLeaderboardAction, deployerAlertsAction };
+export { kolFeed, kolCoordination, kolLeaderboard, deployerAlerts, kolPnl, kolTrendingTokens, createWebhook, listWebhooks, deleteWebhook, testWebhook, getStreamToken, walletTrackerWatchlist, walletTrackerAdd, walletTrackerRemove, walletTrackerTrades, walletTrackerSummary };
+export { kolFeedAction, kolCoordinationAction, kolLeaderboardAction, deployerAlertsAction, kolPnlAction, kolTrendingTokensAction };
+export { walletTrackerWatchlistAction, walletTrackerAddAction, walletTrackerRemoveAction, walletTrackerTradesAction, walletTrackerSummaryAction };

package/dist/index.js

@@ -2,7 +2,10 @@ import { kolFeedAction } from "./actions/kolFeed.js";
 import { kolCoordinationAction } from "./actions/kolCoordination.js";
 import { kolLeaderboardAction } from "./actions/kolLeaderboard.js";
 import { deployerAlertsAction } from "./actions/deployerAlerts.js";
-import { kolFeed, kolCoordination, kolLeaderboard, deployerAlerts, createWebhook, listWebhooks, deleteWebhook, testWebhook, getStreamToken } from "./tools/index.js";
+import { kolPnlAction } from "./actions/kolPnl.js";
+import { kolTrendingTokensAction } from "./actions/kolTrendingTokens.js";
+import { walletTrackerWatchlistAction, walletTrackerAddAction, walletTrackerRemoveAction, walletTrackerTradesAction, walletTrackerSummaryAction } from "./actions/walletTracker.js";
+import { kolFeed, kolCoordination, kolLeaderboard, deployerAlerts, kolPnl, kolTrendingTokens, createWebhook, listWebhooks, deleteWebhook, testWebhook, getStreamToken, walletTrackerWatchlist, walletTrackerAdd, walletTrackerRemove, walletTrackerTrades, walletTrackerSummary } from "./tools/index.js";
 const MadeOnSolPlugin = {
     name: "madeonsol",
     methods: {
@@ -10,22 +13,37 @@ const MadeOnSolPlugin = {
         kolCoordination,
         kolLeaderboard,
         deployerAlerts,
+        kolPnl,
+        kolTrendingTokens,
         createWebhook,
         listWebhooks,
         deleteWebhook,
         testWebhook,
         getStreamToken,
+        walletTrackerWatchlist,
+        walletTrackerAdd,
+        walletTrackerRemove,
+        walletTrackerTrades,
+        walletTrackerSummary,
     },
     actions: [
         kolFeedAction,
         kolCoordinationAction,
         kolLeaderboardAction,
         deployerAlertsAction,
+        kolPnlAction,
+        kolTrendingTokensAction,
+        walletTrackerWatchlistAction,
+        walletTrackerAddAction,
+        walletTrackerRemoveAction,
+        walletTrackerTradesAction,
+        walletTrackerSummaryAction,
     ],
     initialize(_agent) {
         // No-op — payment setup is lazy in tool functions
     },
 };
 export default MadeOnSolPlugin;
-export { kolFeed, kolCoordination, kolLeaderboard, deployerAlerts, createWebhook, listWebhooks, deleteWebhook, testWebhook, getStreamToken };
-export { kolFeedAction, kolCoordinationAction, kolLeaderboardAction, deployerAlertsAction };
+export { kolFeed, kolCoordination, kolLeaderboard, deployerAlerts, kolPnl, kolTrendingTokens, createWebhook, listWebhooks, deleteWebhook, testWebhook, getStreamToken, walletTrackerWatchlist, walletTrackerAdd, walletTrackerRemove, walletTrackerTrades, walletTrackerSummary };
+export { kolFeedAction, kolCoordinationAction, kolLeaderboardAction, deployerAlertsAction, kolPnlAction, kolTrendingTokensAction };
+export { walletTrackerWatchlistAction, walletTrackerAddAction, walletTrackerRemoveAction, walletTrackerTradesAction, walletTrackerSummaryAction };

package/dist/tools/index.d.ts

@@ -42,6 +42,15 @@ export declare function kolHotTokens(agent: Agent, params?: {
     min_kols?: number;
     limit?: number;
 }): Promise<any>;
+export declare function kolTrendingTokens(agent: Agent, params?: {
+    period?: string;
+    min_kols?: number;
+    limit?: number;
+}): Promise<any>;
+export declare function kolPnl(agent: Agent, params: {
+    wallet: string;
+    period?: string;
+}): Promise<any>;
 export declare function kolTiming(agent: Agent, params: {
     wallet: string;
     period?: string;
@@ -62,4 +71,23 @@ export declare function testWebhook(agent: Agent, params: {
     webhook_id: number;
 }): Promise<any>;
 export declare function getStreamToken(agent: Agent): Promise<any>;
+export declare function walletTrackerWatchlist(agent: Agent): Promise<any>;
+export declare function walletTrackerAdd(agent: Agent, params: {
+    wallet_address: string;
+    label?: string;
+}): Promise<any>;
+export declare function walletTrackerRemove(agent: Agent, params: {
+    wallet_address: string;
+}): Promise<any>;
+export declare function walletTrackerTrades(agent: Agent, params?: {
+    wallet?: string;
+    action?: string;
+    event_type?: string;
+    limit?: number;
+    before?: number;
+}): Promise<any>;
+export declare function walletTrackerSummary(agent: Agent, params?: {
+    period?: string;
+    wallet?: string;
+}): Promise<any>;
 export {};

package/dist/tools/index.js

@@ -102,6 +102,14 @@ export async function kolHotTokens(agent, params = {}) {
     await initAuth(agent);
     return query("/api/x402/kol/tokens/hot", params);
 }
+export async function kolTrendingTokens(agent, params = {}) {
+    await initAuth(agent);
+    return query("/api/x402/kol/tokens/trending", params);
+}
+export async function kolPnl(agent, params) {
+    const qs = params.period ? `?period=${params.period}` : "";
+    return restQuery(agent, "GET", `/kol/${params.wallet}/pnl${qs}`);
+}
 export async function kolTiming(agent, params) {
     const qs = params.period ? `?period=${params.period}` : "";
     return restQuery(agent, "GET", `/kol/${params.wallet}/timing${qs}`);
@@ -144,3 +152,41 @@ export async function testWebhook(agent, params) {
 export async function getStreamToken(agent) {
     return restQuery(agent, "POST", "/stream/token");
 }
+// ── Wallet Tracker ──
+export async function walletTrackerWatchlist(agent) {
+    return restQuery(agent, "GET", "/wallet-tracker/watchlist");
+}
+export async function walletTrackerAdd(agent, params) {
+    return restQuery(agent, "POST", "/wallet-tracker/watchlist", params);
+}
+export async function walletTrackerRemove(agent, params) {
+    return restQuery(agent, "DELETE", `/wallet-tracker/watchlist/${encodeURIComponent(params.wallet_address)}`);
+}
+export async function walletTrackerTrades(agent, params = {}) {
+    await initAuth(agent);
+    const url = new URL(`${BASE_URL}/api/v1/wallet-tracker/trades`);
+    for (const [k, v] of Object.entries(params)) {
+        if (v !== undefined)
+            url.searchParams.set(k, String(v));
+    }
+    const res = await fetch(url.toString(), { headers: { "Content-Type": "application/json", ..._authHeaders } });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`MadeOnSol API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+export async function walletTrackerSummary(agent, params = {}) {
+    await initAuth(agent);
+    const url = new URL(`${BASE_URL}/api/v1/wallet-tracker/summary`);
+    for (const [k, v] of Object.entries(params)) {
+        if (v !== undefined)
+            url.searchParams.set(k, v);
+    }
+    const res = await fetch(url.toString(), { headers: { "Content-Type": "application/json", ..._authHeaders } });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`MadeOnSol API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solana-agent-kit-plugin-madeonsol",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Solana Agent Kit plugin for MadeOnSol \u00e2\u20ac\u201d KOL intelligence and deployer analytics via x402 micropayments",
   "type": "module",
   "main": "dist/index.js",