agentpump-mcp 1.1.0

package/README.md

@@ -0,0 +1,73 @@
+# AgentPump MCP
+
+Give your AI agent its own **Solana wallet** and let it **launch and trade tokens** on [AgentPump](https://app.agents-coin.com) — a pump.fun-style bonding-curve launchpad on **Solana mainnet**. Works in Claude, Cursor, and any MCP client.
+
+🌐 **Website:** https://app.agents-coin.com  ·  🪙 **Launch & trade (web):** https://app.agents-coin.com/pump  ·  💬 **Telegram bot:** https://t.me/AgentsPumpBot
+
+The agent's key stays **local** (used only to sign — never sent to the model or the cloud). You fund the wallet with SOL, then it can create and trade tokens autonomously. 1% per trade. Tokens graduate to Raydium at 10 SOL — and your agent can keep trading them there too.
+
+---
+
+## Install
+
+### ⚡ Claude Desktop — one click (no npm, no terminal)
+1. Download **[`agentpump.mcpb`](https://github.com/axiosdevs/agentpump-mcp/releases/latest/download/agentpump.mcpb)**
+2. Open it with **Claude Desktop** → *Settings → Extensions → Install*
+3. That's it — a mainnet RPC is built in. (Optional: set your own Helius/QuickNode RPC in the extension settings.)
+
+### Any MCP client (Claude Code, Cursor, …) via npx
+```json
+{
+  "mcpServers": {
+    "agentpump": {
+      "command": "npx",
+      "args": ["-y", "agentpump-mcp@latest"]
+    }
+  }
+}
+```
+
+### From source
+```bash
+git clone https://github.com/axiosdevs/agentpump-mcp
+cd agentpump-mcp && npm install
+# then point your MCP client at:  node /path/to/agentpump-mcp/index.js
+```
+
+---
+
+## Talk to your agent
+```
+"create a Solana wallet"
+"show my address"                 ← send real SOL there (no faucet on mainnet)
+"launch a token called Doge AI (DOGEAI)"
+"buy 0.1 SOL of <mint>"           ← on the bonding curve
+"sell 50% of <mint>"
+"buy 0.2 SOL of <mint> on Raydium"   ← once it graduated/listed
+"sell 100% of <mint> on Raydium"
+```
+
+## Tools
+| Tool | What it does |
+|---|---|
+| `sol_create_wallet` | Create the agent's Solana wallet (saved locally, hidden) |
+| `sol_address` | Show the wallet address to deposit SOL into |
+| `sol_balance` | Check the SOL balance |
+| `sol_launch` | Launch a token (name, symbol) on the bonding curve |
+| `sol_buy` | Buy a token on its bonding curve (pre-graduation) |
+| `sol_sell` | Sell a % of a holding back to the bonding curve |
+| `sol_raydium_buy` | Buy a graduated/listed token on **Raydium** (1% fee) |
+| `sol_raydium_sell` | Sell a graduated/listed token on **Raydium** (1% fee) |
+
+## How it works
+- **Local key** — generated on your machine (`~/.agentpump/wallet.json`); only signatures hit the chain.
+- **Real money** — Solana **mainnet**. Fund the wallet with real SOL. Start small.
+- **Fair launch** — every token starts on a bonding curve (~80% of supply sold on the curve). 1% trade fee. Graduates to Raydium at 10 SOL, where liquidity is locked (LP burned).
+- **Then trade on Raydium** — after graduation the agent buys/sells on Raydium with `sol_raydium_*` (1% fee).
+- **Program:** `4M93xdyduoYj4W7LaLRmXrk5PqyGD6SoxzX8CwdKe3VM`
+
+## Also available (same launchpad, same 1% fee, auto-routed curve → Raydium)
+- 🪙 **Web (Phantom):** https://app.agents-coin.com/pump
+- 💬 **Telegram bot:** https://t.me/AgentsPumpBot — Buy/Sell auto-route to the bonding curve before graduation and to **Raydium** after.
+
+MIT licensed.

package/index.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+// AgentPump MCP — let an AI agent launch & trade tokens on the AgentPump launchpad (Solana mainnet).
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import {
+  Connection, Keypair, PublicKey, SystemProgram, Transaction,
+  TransactionInstruction, sendAndConfirmTransaction, LAMPORTS_PER_SOL,
+} from "@solana/web3.js";
+import {
+  createMint, getAssociatedTokenAddressSync, mintTo, getAccount,
+  createAssociatedTokenAccountIdempotentInstruction, TOKEN_PROGRAM_ID, NATIVE_MINT,
+} from "@solana/spl-token";
+import { Raydium, TxVersion, CurveCalculator, CREATE_CPMM_POOL_PROGRAM } from "@raydium-io/raydium-sdk-v2";
+import BN from "bn.js";
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync } from "fs";
+
+const RPC = process.env.AGENTPUMP_RPC || "https://mainnet.helius-rpc.com/?api-key=397a9216-3198-4f6b-8304-0bf3f62cf5bd";
+const PROGRAM = new PublicKey("4M93xdyduoYj4W7LaLRmXrk5PqyGD6SoxzX8CwdKe3VM");
+const FEE = new PublicKey("2tGTwpzcLLgp6D33Sns4cMZuz1Zg6rBnzjt3taqTmZz6");
+const conn = new Connection(RPC, "confirmed");
+const [CONFIG] = PublicKey.findProgramAddressSync([Buffer.from("config")], PROGRAM);
+const V_SOL = 2500000000n, SUPPLY = 1000000000n * 1000000n;
+const u64 = (n) => { const b = Buffer.alloc(8); b.writeBigUInt64LE(BigInt(n)); return b; };
+const WDIR = join(homedir(), ".agentpump"), WFILE = join(WDIR, "wallet.json");
+const curveOf = (m) => PublicKey.findProgramAddressSync([Buffer.from("curve"), m.toBuffer()], PROGRAM)[0];
+const ataOf = (m, o) => getAssociatedTokenAddressSync(m, o, true);
+
+function loadKp() { if (!existsSync(WFILE)) throw new Error("No wallet yet. Call sol_create_wallet first."); return Keypair.fromSecretKey(Uint8Array.from(JSON.parse(readFileSync(WFILE)))); }
+function tradeKeys(mint, curve, cAta, uAta, user) {
+  return [
+    { pubkey: CONFIG, isSigner: false, isWritable: false }, { pubkey: curve, isSigner: false, isWritable: true }, { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: cAta, isSigner: false, isWritable: true }, { pubkey: uAta, isSigner: false, isWritable: true }, { pubkey: curve, isSigner: false, isWritable: true },
+    { pubkey: FEE, isSigner: false, isWritable: true }, { pubkey: user, isSigner: true, isWritable: true },
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }, { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+  ];
+}
+const ok = (t) => ({ content: [{ type: "text", text: t }] });
+
+// --- Raydium CPMM helpers (trade graduated/listed tokens; 1% fee to treasury) ---
+let _ray;
+async function ray(kp) { if (!_ray) _ray = await Raydium.load({ connection: conn, owner: kp, cluster: "mainnet", disableLoadToken: true }); return _ray; }
+async function findCpmmPool(raydium, mint) {
+  const data = await raydium.api.fetchPoolByMints({ mint1: mint.toBase58(), mint2: NATIVE_MINT.toBase58() });
+  const pools = (data?.data || []).filter((p) => p.programId === CREATE_CPMM_POOL_PROGRAM.toBase58());
+  if (!pools.length) throw new Error("No Raydium pool found for this token yet — it may not have graduated/listed, or the pool was just created (indexing can take a few minutes).");
+  pools.sort((a, b) => (b.tvl || 0) - (a.tvl || 0));
+  return pools[0].id;
+}
+function estimate(inAmt, inRes, outRes, ci) {
+  return CurveCalculator.swapBaseInput(inAmt, inRes, outRes, ci.tradeFeeRate, ci.creatorFeeRate, ci.protocolFeeRate, ci.fundFeeRate, false);
+}
+
+const s = new McpServer({ name: "agentpump", version: "1.1.0" });
+
+s.tool("sol_create_wallet", "Create the agent's Solana wallet (saved locally, hidden). Returns the address to fund.", {}, { title: "Create wallet", readOnlyHint: false }, async () => {
+  if (existsSync(WFILE)) return ok("Wallet already exists: " + loadKp().publicKey.toBase58());
+  mkdirSync(WDIR, { recursive: true }); const kp = Keypair.generate();
+  writeFileSync(WFILE, JSON.stringify(Array.from(kp.secretKey))); chmodSync(WFILE, 0o600);
+  return ok("Wallet created: " + kp.publicKey.toBase58() + "\nFund it with SOL to start (no faucet on mainnet).");
+});
+s.tool("sol_address", "Show the agent's Solana wallet address to deposit SOL into.", {}, { title: "Address", readOnlyHint: true }, async () => ok(loadKp().publicKey.toBase58()));
+s.tool("sol_balance", "Check the wallet's SOL balance.", {}, { title: "Balance", readOnlyHint: true }, async () => {
+  const kp = loadKp(); const b = await conn.getBalance(kp.publicKey); return ok((b / LAMPORTS_PER_SOL).toFixed(4) + " SOL\n" + kp.publicKey.toBase58());
+});
+s.tool("sol_launch", "Launch a new token on AgentPump (bonding curve). Costs ~0.02 SOL in rent.", { name: z.string(), symbol: z.string() }, { title: "Launch token", readOnlyHint: false, openWorldHint: true }, async ({ name, symbol }) => {
+  const kp = loadKp(); const mint = await createMint(conn, kp, kp.publicKey, null, 6);
+  const curve = curveOf(mint.publicKey), cAta = ataOf(mint.publicKey, curve);
+  await sendAndConfirmTransaction(conn, new Transaction().add(createAssociatedTokenAccountIdempotentInstruction(kp.publicKey, cAta, curve, mint.publicKey)), [kp]);
+  await mintTo(conn, kp, mint, cAta, kp, SUPPLY);
+  const ix = new TransactionInstruction({ programId: PROGRAM, data: Buffer.concat([Buffer.from([1]), u64(V_SOL), u64(SUPPLY)]), keys: [
+    { pubkey: CONFIG, isSigner: false, isWritable: true }, { pubkey: curve, isSigner: false, isWritable: true }, { pubkey: mint.publicKey, isSigner: false, isWritable: false },
+    { pubkey: cAta, isSigner: false, isWritable: true }, { pubkey: kp.publicKey, isSigner: true, isWritable: true }, { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+  ] });
+  await sendAndConfirmTransaction(conn, new Transaction().add(ix), [kp]);
+  return ok(`Launched ${symbol}. Token: ${mint.publicKey.toBase58()}\nTradeable on the curve; graduates to Raydium at 10 SOL.`);
+});
+s.tool("sol_buy", "Buy a token on its bonding curve (pre-graduation). For graduated tokens use sol_raydium_buy.", { mint: z.string(), sol: z.number() }, { title: "Buy (curve)", readOnlyHint: false, openWorldHint: true }, async ({ mint: ms, sol: amt }) => {
+  const kp = loadKp(); const mint = new PublicKey(ms); const curve = curveOf(mint), cAta = ataOf(mint, curve), uAta = ataOf(mint, kp.publicKey);
+  const tx = new Transaction().add(createAssociatedTokenAccountIdempotentInstruction(kp.publicKey, uAta, kp.publicKey, mint))
+    .add(new TransactionInstruction({ programId: PROGRAM, keys: tradeKeys(mint, curve, cAta, uAta, kp.publicKey), data: Buffer.concat([Buffer.from([2]), u64(Math.round(amt * LAMPORTS_PER_SOL)), u64(0)]) }));
+  const sig = await sendAndConfirmTransaction(conn, tx, [kp]); return ok("Bought. " + sig);
+});
+s.tool("sol_sell", "Sell a percentage of a token holding back to the bonding curve (pre-graduation). For graduated tokens use sol_raydium_sell.", { mint: z.string(), percent: z.number() }, { title: "Sell (curve)", readOnlyHint: false, openWorldHint: true }, async ({ mint: ms, percent }) => {
+  const kp = loadKp(); const mint = new PublicKey(ms); const curve = curveOf(mint), cAta = ataOf(mint, curve), uAta = ataOf(mint, kp.publicKey);
+  const acc = await getAccount(conn, uAta); const amt = (acc.amount * BigInt(Math.round(percent))) / 100n;
+  if (amt <= 0n) throw new Error("nothing to sell");
+  const ix = new TransactionInstruction({ programId: PROGRAM, keys: tradeKeys(mint, curve, cAta, uAta, kp.publicKey), data: Buffer.concat([Buffer.from([3]), u64(amt), u64(0)]) });
+  const sig = await sendAndConfirmTransaction(conn, new Transaction().add(ix), [kp]); return ok("Sold. " + sig);
+});
+s.tool("sol_raydium_buy", "Buy any graduated/listed token on Raydium (after it leaves the bonding curve). Charges a 1% fee.", { mint: z.string(), sol: z.number() }, { title: "Buy (Raydium)", readOnlyHint: false, openWorldHint: true }, async ({ mint: ms, sol: amt }) => {
+  const kp = loadKp(); const mint = new PublicKey(ms);
+  const lamports = BigInt(Math.round(amt * LAMPORTS_PER_SOL));
+  const fee = lamports / 100n, swapIn = lamports - fee;
+  const uAta = ataOf(mint, kp.publicKey);
+  const raydium = await ray(kp);
+  const { poolInfo, poolKeys, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(await findCpmmPool(raydium, mint)); // throws before any fee is charged
+  await sendAndConfirmTransaction(conn, new Transaction()
+    .add(SystemProgram.transfer({ fromPubkey: kp.publicKey, toPubkey: FEE, lamports: Number(fee) }))
+    .add(createAssociatedTokenAccountIdempotentInstruction(kp.publicKey, uAta, kp.publicKey, mint)), [kp]);
+  const baseIn = NATIVE_MINT.toBase58() === poolInfo.mintA.address;
+  const inA = new BN(swapIn.toString());
+  const sr = estimate(inA, baseIn ? rpcData.baseReserve : rpcData.quoteReserve, baseIn ? rpcData.quoteReserve : rpcData.baseReserve, rpcData.configInfo);
+  const { execute } = await raydium.cpmm.swap({ poolInfo, poolKeys, inputAmount: inA, swapResult: sr, slippage: 0.1, baseIn, txVersion: TxVersion.V0 });
+  const r = await execute({ sendAndConfirm: true });
+  return ok(`Bought on Raydium. tx ${r.txId}\n1% fee (${(Number(fee) / LAMPORTS_PER_SOL).toFixed(5)} SOL) sent to treasury.`);
+});
+s.tool("sol_raydium_sell", "Sell a percentage of a graduated/listed token on Raydium. Charges a 1% fee on the SOL proceeds.", { mint: z.string(), percent: z.number() }, { title: "Sell (Raydium)", readOnlyHint: false, openWorldHint: true }, async ({ mint: ms, percent }) => {
+  const kp = loadKp(); const mint = new PublicKey(ms);
+  const uAta = ataOf(mint, kp.publicKey);
+  const acc = await getAccount(conn, uAta); const amt = (acc.amount * BigInt(Math.round(percent))) / 100n;
+  if (amt <= 0n) throw new Error("nothing to sell");
+  const raydium = await ray(kp);
+  const { poolInfo, poolKeys, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(await findCpmmPool(raydium, mint));
+  const baseIn = mint.toBase58() === poolInfo.mintA.address;
+  const inA = new BN(amt.toString());
+  const sr = estimate(inA, baseIn ? rpcData.baseReserve : rpcData.quoteReserve, baseIn ? rpcData.quoteReserve : rpcData.baseReserve, rpcData.configInfo);
+  const before = await conn.getBalance(kp.publicKey);
+  const { execute } = await raydium.cpmm.swap({ poolInfo, poolKeys, inputAmount: inA, swapResult: sr, slippage: 0.1, baseIn, txVersion: TxVersion.V0 });
+  const r = await execute({ sendAndConfirm: true });
+  const gained = (await conn.getBalance(kp.publicKey)) - before;
+  let feePaid = 0;
+  if (gained > 0) { feePaid = Math.floor(gained * 0.01); if (feePaid > 0) await sendAndConfirmTransaction(conn, new Transaction().add(SystemProgram.transfer({ fromPubkey: kp.publicKey, toPubkey: FEE, lamports: feePaid })), [kp]); }
+  return ok(`Sold on Raydium. tx ${r.txId}\n1% fee (${(feePaid / LAMPORTS_PER_SOL).toFixed(5)} SOL) sent to treasury.`);
+});
+
+await s.connect(new StdioServerTransport());

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "agentpump-mcp",
+  "version": "1.1.0",
+  "description": "MCP server to launch & trade tokens on AgentPump (Solana bonding-curve launchpad) from AI agents. Trade graduated tokens on Raydium.",
+  "type": "module",
+  "bin": {
+    "agentpump-mcp": "index.js"
+  },
+  "files": [
+    "index.js"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "solana",
+    "pump",
+    "launchpad",
+    "raydium",
+    "ai-agents",
+    "claude"
+  ],
+  "homepage": "https://app.agents-coin.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/axiosdevs/agentpump-mcp"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@raydium-io/raydium-sdk-v2": "^0.2.56-alpha",
+    "@solana/spl-token": "^0.4.8",
+    "@solana/web3.js": "^1.95.3",
+    "bn.js": "^5.2.4",
+    "zod": "^3.23.8"
+  }
+}