solana-agent-kit-plugin-madeonsol 0.1.0

package/LICENSE

@@ -0,0 +1 @@
+MIT License

package/README.md

@@ -0,0 +1,45 @@
+# 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 via x402 micropayments.
+
+## Install
+
+```bash
+npm install solana-agent-kit-plugin-madeonsol @x402/fetch @x402/svm @x402/core @solana/kit @scure/base
+```
+
+## Usage
+
+```typescript
+import { SolanaAgentKit } from "solana-agent-kit";
+import MadeOnSolPlugin from "solana-agent-kit-plugin-madeonsol";
+
+const agent = new SolanaAgentKit(privateKey, rpcUrl, {
+  SVM_PRIVATE_KEY: "your_solana_private_key_base58",
+});
+
+agent.use(MadeOnSolPlugin);
+
+// Use via methods
+const trades = await agent.methods.kolFeed(agent, { limit: 10, action: "buy" });
+
+// Or let the LLM trigger actions via natural language
+// "What are KOLs buying right now?" → MADEONSOL_KOL_FEED_ACTION
+```
+
+## Actions
+
+| Action | Price | Triggers on |
+|---|---|---|
+| `MADEONSOL_KOL_FEED_ACTION` | $0.005 | "kol trades", "what are kols buying" |
+| `MADEONSOL_KOL_COORDINATION_ACTION` | $0.02 | "kol convergence", "tokens kols accumulating" |
+| `MADEONSOL_KOL_LEADERBOARD_ACTION` | $0.005 | "top kols", "kol rankings", "best kol" |
+| `MADEONSOL_DEPLOYER_ALERTS_ACTION` | $0.01 | "deployer alerts", "pump fun launches" |
+
+## Config
+
+Set `SVM_PRIVATE_KEY` in your agent config for automatic x402 USDC payments. The wallet needs SOL (fees) and USDC on Solana mainnet.
+
+## License
+
+MIT

package/dist/actions/deployerAlerts.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const deployerAlertsAction: {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        input: {
+            limit: number;
+        };
+        output: {
+            status: string;
+        };
+        explanation: string;
+    }[][];
+    schema: z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        offset: z.ZodDefault<z.ZodNumber>;
+        since: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        offset: number;
+        since?: string | undefined;
+    }, {
+        limit?: number | undefined;
+        offset?: number | undefined;
+        since?: string | undefined;
+    }>;
+    handler: (agent: unknown, input: {
+        limit?: number;
+        offset?: number;
+        since?: string;
+    }) => Promise<{
+        status: string;
+        result: any;
+        message?: undefined;
+    } | {
+        status: string;
+        message: string;
+        result?: undefined;
+    }>;
+};

package/dist/actions/deployerAlerts.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { deployerAlerts } from "../tools/index.js";
+export const deployerAlertsAction = {
+    name: "MADEONSOL_DEPLOYER_ALERTS_ACTION",
+    similes: ["deployer alerts", "pump fun launches", "new token alerts", "elite deployer tokens"],
+    description: "Get real-time alerts from elite Pump.fun deployers with KOL buy enrichment. Costs $0.01 USDC per request.",
+    examples: [
+        [{ input: { limit: 10 }, output: { status: "success" }, explanation: "Get the 10 most recent deployer alerts" }],
+    ],
+    schema: z.object({
+        limit: z.number().min(1).max(100).default(10).describe("Number of alerts"),
+        offset: z.number().min(0).default(0).describe("Pagination offset"),
+        since: z.string().optional().describe("ISO8601 timestamp to filter alerts after"),
+    }),
+    handler: async (agent, input) => {
+        try {
+            const data = await deployerAlerts(agent, input);
+            return { status: "success", result: data };
+        }
+        catch (err) {
+            return { status: "error", message: err.message };
+        }
+    },
+};

package/dist/actions/kolCoordination.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare const kolCoordinationAction: {
+    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<["1h", "6h", "24h", "7d"]>>;
+        min_kols: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        period: "24h" | "1h" | "6h" | "7d";
+        min_kols: number;
+    }, {
+        limit?: number | undefined;
+        period?: "24h" | "1h" | "6h" | "7d" | 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/kolCoordination.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { kolCoordination } from "../tools/index.js";
+export const kolCoordinationAction = {
+    name: "MADEONSOL_KOL_COORDINATION_ACTION",
+    similes: ["kol convergence", "what tokens are kols accumulating", "kol coordination", "smart money convergence"],
+    description: "Get KOL convergence signals — tokens being accumulated by multiple KOLs simultaneously. Costs $0.02 USDC per request.",
+    examples: [
+        [{ input: { period: "24h", min_kols: 3 }, output: { status: "success" }, explanation: "Get tokens where 3+ KOLs are converging in the last 24 hours" }],
+    ],
+    schema: z.object({
+        period: z.enum(["1h", "6h", "24h", "7d"]).default("24h").describe("Time period"),
+        min_kols: z.number().min(2).max(50).default(3).describe("Minimum KOLs converging"),
+        limit: z.number().min(1).max(50).default(20).describe("Number of results"),
+    }),
+    handler: async (agent, input) => {
+        try {
+            const data = await kolCoordination(agent, input);
+            return { status: "success", result: data };
+        }
+        catch (err) {
+            return { status: "error", message: err.message };
+        }
+    },
+};

package/dist/actions/kolFeed.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare const kolFeedAction: {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        input: {
+            limit: number;
+            action: string;
+        };
+        output: {
+            status: string;
+        };
+        explanation: string;
+    }[][];
+    schema: z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        action: z.ZodOptional<z.ZodEnum<["buy", "sell"]>>;
+        kol: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        action?: "buy" | "sell" | undefined;
+        kol?: string | undefined;
+    }, {
+        limit?: number | undefined;
+        action?: "buy" | "sell" | undefined;
+        kol?: string | undefined;
+    }>;
+    handler: (agent: unknown, input: {
+        limit?: number;
+        action?: string;
+        kol?: string;
+    }) => Promise<{
+        status: string;
+        result: any;
+        message?: undefined;
+    } | {
+        status: string;
+        message: string;
+        result?: undefined;
+    }>;
+};

package/dist/actions/kolFeed.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { kolFeed } from "../tools/index.js";
+export const kolFeedAction = {
+    name: "MADEONSOL_KOL_FEED_ACTION",
+    similes: ["kol trades", "what are kols buying", "kol feed", "smart money trades", "kol activity"],
+    description: "Get real-time Solana KOL trades from 946 tracked wallets via MadeOnSol x402 API. Costs $0.005 USDC per request.",
+    examples: [
+        [{ input: { limit: 10, action: "buy" }, output: { status: "success" }, explanation: "Fetch the 10 most recent KOL buy trades" }],
+    ],
+    schema: z.object({
+        limit: z.number().min(1).max(100).default(10).describe("Number of trades"),
+        action: z.enum(["buy", "sell"]).optional().describe("Filter by trade type"),
+        kol: z.string().optional().describe("Filter by KOL wallet address"),
+    }),
+    handler: async (agent, input) => {
+        try {
+            const data = await kolFeed(agent, input);
+            return { status: "success", result: data };
+        }
+        catch (err) {
+            return { status: "error", message: err.message };
+        }
+    },
+};

package/dist/actions/kolLeaderboard.d.ts

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

package/dist/actions/kolLeaderboard.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { kolLeaderboard } from "../tools/index.js";
+export const kolLeaderboardAction = {
+    name: "MADEONSOL_KOL_LEADERBOARD_ACTION",
+    similes: ["kol leaderboard", "top kols", "best performing kols", "kol rankings", "kol pnl"],
+    description: "Get KOL performance rankings by PnL and win rate. Costs $0.005 USDC per request.",
+    examples: [
+        [{ input: { period: "7d", limit: 10 }, output: { status: "success" }, explanation: "Get the top 10 KOLs by PnL this week" }],
+    ],
+    schema: z.object({
+        period: z.enum(["today", "7d", "30d"]).default("7d").describe("Time period"),
+        limit: z.number().min(1).max(50).default(20).describe("Number of KOLs"),
+    }),
+    handler: async (agent, input) => {
+        try {
+            const data = await kolLeaderboard(agent, input);
+            return { status: "success", result: data };
+        }
+        catch (err) {
+            return { status: "error", message: err.message };
+        }
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,174 @@
+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 } from "./tools/index.js";
+declare const MadeOnSolPlugin: {
+    name: string;
+    methods: {
+        kolFeed: typeof kolFeed;
+        kolCoordination: typeof kolCoordination;
+        kolLeaderboard: typeof kolLeaderboard;
+        deployerAlerts: typeof deployerAlerts;
+    };
+    actions: ({
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            input: {
+                limit: number;
+                action: string;
+            };
+            output: {
+                status: string;
+            };
+            explanation: string;
+        }[][];
+        schema: import("zod").ZodObject<{
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+            action: import("zod").ZodOptional<import("zod").ZodEnum<["buy", "sell"]>>;
+            kol: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            limit: number;
+            action?: "buy" | "sell" | undefined;
+            kol?: string | undefined;
+        }, {
+            limit?: number | undefined;
+            action?: "buy" | "sell" | undefined;
+            kol?: string | undefined;
+        }>;
+        handler: (agent: unknown, input: {
+            limit?: number;
+            action?: string;
+            kol?: 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<["1h", "6h", "24h", "7d"]>>;
+            min_kols: import("zod").ZodDefault<import("zod").ZodNumber>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            limit: number;
+            period: "24h" | "1h" | "6h" | "7d";
+            min_kols: number;
+        }, {
+            limit?: number | undefined;
+            period?: "24h" | "1h" | "6h" | "7d" | 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: {
+                period: string;
+                limit: number;
+            };
+            output: {
+                status: string;
+            };
+            explanation: string;
+        }[][];
+        schema: import("zod").ZodObject<{
+            period: import("zod").ZodDefault<import("zod").ZodEnum<["today", "7d", "30d"]>>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            limit: number;
+            period: "7d" | "today" | "30d";
+        }, {
+            limit?: number | undefined;
+            period?: "7d" | "today" | "30d" | undefined;
+        }>;
+        handler: (agent: unknown, input: {
+            period?: string;
+            limit?: number;
+        }) => 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<{
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+            offset: import("zod").ZodDefault<import("zod").ZodNumber>;
+            since: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            limit: number;
+            offset: number;
+            since?: string | undefined;
+        }, {
+            limit?: number | undefined;
+            offset?: number | undefined;
+            since?: string | undefined;
+        }>;
+        handler: (agent: unknown, input: {
+            limit?: number;
+            offset?: number;
+            since?: 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 };
+export { kolFeedAction, kolCoordinationAction, kolLeaderboardAction, deployerAlertsAction };

package/dist/index.js

@@ -0,0 +1,26 @@
+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 } from "./tools/index.js";
+const MadeOnSolPlugin = {
+    name: "madeonsol",
+    methods: {
+        kolFeed,
+        kolCoordination,
+        kolLeaderboard,
+        deployerAlerts,
+    },
+    actions: [
+        kolFeedAction,
+        kolCoordinationAction,
+        kolLeaderboardAction,
+        deployerAlertsAction,
+    ],
+    initialize(_agent) {
+        // No-op — payment setup is lazy in tool functions
+    },
+};
+export default MadeOnSolPlugin;
+export { kolFeed, kolCoordination, kolLeaderboard, deployerAlerts };
+export { kolFeedAction, kolCoordinationAction, kolLeaderboardAction, deployerAlertsAction };

package/dist/tools/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Tool functions — pure logic that calls MadeOnSol x402 API.
+ * These are called by Action handlers and can also be used directly via agent.methods.
+ */
+type Agent = any;
+export declare function initPaidFetch(agent: Agent): Promise<typeof fetch>;
+export declare function kolFeed(agent: Agent, params?: {
+    limit?: number;
+    action?: string;
+    kol?: string;
+}): Promise<any>;
+export declare function kolCoordination(agent: Agent, params?: {
+    period?: string;
+    min_kols?: number;
+    limit?: number;
+}): Promise<any>;
+export declare function kolLeaderboard(agent: Agent, params?: {
+    period?: string;
+    limit?: number;
+}): Promise<any>;
+export declare function deployerAlerts(agent: Agent, params?: {
+    limit?: number;
+    since?: string;
+    offset?: number;
+}): Promise<any>;
+export {};

package/dist/tools/index.js

@@ -0,0 +1,57 @@
+/**
+ * Tool functions — pure logic that calls MadeOnSol x402 API.
+ * These are called by Action handlers and can also be used directly via agent.methods.
+ */
+const BASE_URL = "https://madeonsol.com";
+async function query(paidFetch, path, params) {
+    const url = new URL(path, BASE_URL);
+    if (params) {
+        for (const [k, v] of Object.entries(params)) {
+            if (v !== undefined)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const res = await paidFetch(url.toString());
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`MadeOnSol API error ${res.status}: ${body}`);
+    }
+    return res.json();
+}
+let _paidFetch = null;
+export async function initPaidFetch(agent) {
+    if (_paidFetch)
+        return _paidFetch;
+    const privateKey = agent.config?.SVM_PRIVATE_KEY || agent.config?.OTHER_API_KEYS?.SVM_PRIVATE_KEY;
+    if (!privateKey) {
+        console.warn("[madeonsol] No SVM_PRIVATE_KEY in agent config — x402 payments disabled");
+        _paidFetch = fetch;
+        return _paidFetch;
+    }
+    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));
+    _paidFetch = wrapFetchWithPayment(fetch, client);
+    return _paidFetch;
+}
+export async function kolFeed(agent, params = {}) {
+    const f = await initPaidFetch(agent);
+    return query(f, "/api/x402/kol/feed", params);
+}
+export async function kolCoordination(agent, params = {}) {
+    const f = await initPaidFetch(agent);
+    return query(f, "/api/x402/kol/coordination", params);
+}
+export async function kolLeaderboard(agent, params = {}) {
+    const f = await initPaidFetch(agent);
+    return query(f, "/api/x402/kol/leaderboard", params);
+}
+export async function deployerAlerts(agent, params = {}) {
+    const f = await initPaidFetch(agent);
+    return query(f, "/api/x402/deployer-hunter/alerts", params);
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "solana-agent-kit-plugin-madeonsol",
+  "version": "0.1.0",
+  "description": "Solana Agent Kit plugin for MadeOnSol — KOL intelligence and deployer analytics via x402 micropayments",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": ""
+  },
+  "keywords": ["solana", "agent-kit", "x402", "kol", "trading", "madeonsol"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LamboPoewert/solana-agent-kit-plugin-madeonsol"
+  },
+  "peerDependencies": {
+    "solana-agent-kit": ">=2.0.0",
+    "@x402/fetch": ">=0.1.0",
+    "@x402/core": ">=0.1.0",
+    "@x402/svm": ">=0.1.0",
+    "@solana/kit": ">=2.0.0",
+    "@scure/base": ">=1.0.0"
+  },
+  "dependencies": {
+    "zod": "^3.24.0"
+  }
+}