agentpump-mcp 1.1.3 → 1.1.5

package/README.md

@@ -1,73 +1,61 @@
-# AgentPump MCP
+# AgentPump — give your AI agent a Solana wallet 🤖
 
-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.
+**Open-source MCP server that lets an AI agent launch and trade tokens on Solana — autonomously, from plain-language chat.**
 
-🌐 **Website:** https://app.agents-coin.com  ·  🪙 **Launch & trade (web):** https://app.agents-coin.com/pump  ·  💬 **Telegram bot:** https://t.me/AgentsPumpBot
+Add one MCP server to **Claude Code, Cursor, or any MCP client**, then just tell your agent to launch and trade tokens on [AgentPump](https://app.agents-coin.com/agentpump), a fair bonding-curve launchpad on **Solana mainnet**. The private key is generated **locally** and never leaves your machine — it's never sent to the model or any server, only signatures hit the chain.
 
-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.
+> Live on Solana mainnet. Real money — start small.
+
+🌐 [Website](https://app.agents-coin.com/agents) · 📦 [npm: agentpump-mcp](https://www.npmjs.com/package/agentpump-mcp) · 🪙 [Trade on the web](https://app.agents-coin.com/pump) · 💬 [Telegram bot](https://t.me/AgentsPumpBot)
 
 ---
 
 ## 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.)
+### Claude Code
+```
+claude mcp add agentpump -- npx -y agentpump-mcp
+```
 
-### Any MCP client (Claude Code, Cursor, …) via npx
+### Any MCP client (Cursor, Claude Code, …)
+Add to your MCP config:
 ```json
 {
   "mcpServers": {
-    "agentpump": {
-      "command": "npx",
-      "args": ["-y", "agentpump-mcp@latest"]
-    }
+    "agentpump": { "command": "npx", "args": ["-y", "agentpump-mcp"] }
   }
 }
 ```
+Also in the official MCP Registry as `io.github.axiosdevs/agentpump-mcp`. A mainnet RPC is built in — nothing to configure.
 
-### 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
+## Then just chat
+Talk to your agent in plain language — it calls the tools:
 ```
-
----
-
-## 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
+"create a Solana wallet and show me the address"     ← then fund it with a little SOL
+"launch a token called Doge AI (DOGEAI), then buy 0.05 SOL of it"
 "sell 50% of <mint>"
-"buy 0.2 SOL of <mint> on Raydium"   ← once it graduated/listed
-"sell 100% of <mint> on Raydium"
+"buy 0.2 SOL of <mint> on Raydium"     ← after it graduates
 ```
 
 ## Tools
-| Tool | What it does |
+| Tool | 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) |
+| `sol_create_wallet` / `sol_address` / `sol_balance` | Local agent wallet (`~/.agentpump/wallet.json`) |
+| `sol_launch` | Launch a token on the bonding curve |
+| `sol_buy` / `sol_sell` | Trade on the curve (pre-graduation) |
+| `sol_raydium_buy` / `sol_raydium_sell` | Trade graduated tokens on Raydium |
+
+The whole client is one [`index.js`](index.js) — exactly what `npx agentpump-mcp` runs. No build step, no hidden network calls. Read every line before funding it.
+
+## How the launchpad works
+1. **Mint** — launching is free (~0.008 SOL network rent, none to the protocol). 1B supply, all on the curve. No presale, no team allocation.
+2. **Pump** — constant-product bonding curve; ~80% of supply sells on it. **1% fee per trade**, shared with the token creator (+ referrer).
+3. **Graduate** — at **10 SOL** the curve closes, a **Raydium** pool is created and the **LP is burned** — liquidity locked forever. Then it trades everywhere (Raydium, Jupiter, DexScreener…).
 
-## 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`
+On-chain program: [`4M93xdyduoYj4W7LaLRmXrk5PqyGD6SoxzX8CwdKe3VM`](https://solscan.io/account/4M93xdyduoYj4W7LaLRmXrk5PqyGD6SoxzX8CwdKe3VM) (verifiable on Solscan).
 
-## Also available (same launchpad, same 1% fee, auto-routed curve → Raydium)
+## Also for people (no MCP needed)
 - 🪙 **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.
+- 💬 **Telegram bot:** https://t.me/AgentsPumpBot
 
 MIT licensed.

package/index.js

@@ -13,6 +13,7 @@ import {
 } from "@solana/spl-token";
 import { Raydium, TxVersion, CurveCalculator, CREATE_CPMM_POOL_PROGRAM } from "@raydium-io/raydium-sdk-v2";
 import BN from "bn.js";
+import bs58 from "bs58";
 import { homedir } from "os";
 import { join } from "path";
 import { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync } from "fs";
@@ -50,6 +51,15 @@ function tradeKeys(mint, curve, cAta, uAta, user) {
   ];
 }
 const ok = (t) => ({ content: [{ type: "text", text: t }] });
+// retry once on transient RPC/simulation flaps (stale blockhash, rate-limit, node hiccup) — the tx didn't land, so it's safe
+async function retryTransient(fn) {
+  try { return await fn(); }
+  catch (e) { const m = ((e && e.message) || "") + "";
+    if (/custom program error/i.test(m)) throw e; // deterministic on-chain rejection — a retry can't fix it
+    if (/simulat|blockhash|not found|expired|timed out|timeout|429|too many|fetch failed|ECONN|socket|rate limit/i.test(m)) { await new Promise((r) => setTimeout(r, 1000)); return await fn(); }
+    throw e; }
+}
+const send = (tx, signers) => retryTransient(() => sendAndConfirmTransaction(conn, tx, signers));
 
 // --- Raydium CPMM helpers (trade graduated/listed tokens; 1% fee to treasury) ---
 let _ray;
@@ -65,7 +75,7 @@ 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" });
+const s = new McpServer({ name: "agentpump", version: "1.1.5" });
 
 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());
@@ -78,30 +88,30 @@ s.tool("sol_balance", "Check the wallet's SOL balance.", {}, { title: "Balance",
   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); // returns a PublicKey
-  await sendAndConfirmTransaction(conn, new Transaction().add(metaIx(mint, kp.publicKey, kp.publicKey, name, symbol)), [kp]); // on-chain name/symbol so it shows on the launchpad
+  const kp = loadKp(); const mint = await retryTransient(() => createMint(conn, kp, kp.publicKey, null, 6)); // returns a PublicKey
+  await send(new Transaction().add(metaIx(mint, kp.publicKey, kp.publicKey, name, symbol)), [kp]); // on-chain name/symbol so it shows on the launchpad
   const curve = curveOf(mint), cAta = ataOf(mint, curve);
-  await sendAndConfirmTransaction(conn, new Transaction().add(createAssociatedTokenAccountIdempotentInstruction(kp.publicKey, cAta, curve, mint)), [kp]);
-  await mintTo(conn, kp, mint, cAta, kp, SUPPLY);
+  await send(new Transaction().add(createAssociatedTokenAccountIdempotentInstruction(kp.publicKey, cAta, curve, mint)), [kp]);
+  await retryTransient(() => 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, 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]);
+  await send(new Transaction().add(ix), [kp]);
   return ok(`Launched ${symbol}. Token: ${mint.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);
+  const sig = await send(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);
+  const sig = await send(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);
@@ -139,4 +149,18 @@ s.tool("sol_raydium_sell", "Sell a percentage of a graduated/listed token on Ray
   return ok(`Sold on Raydium. tx ${r.txId}\n1% fee (${(feePaid / LAMPORTS_PER_SOL).toFixed(5)} SOL) sent to treasury.`);
 });
 
+s.tool("sol_withdraw", "Send SOL out of the agent wallet to any address. Omit 'sol' to send the whole balance (minus the network fee).", { to: z.string(), sol: z.number().optional() }, { title: "Withdraw SOL", readOnlyHint: false, openWorldHint: true }, async ({ to, sol }) => {
+  const kp = loadKp(); const dest = new PublicKey(to);
+  const bal = await conn.getBalance(kp.publicKey); const FEE_L = 5000;
+  let lamports = (sol == null) ? bal - FEE_L : Math.round(sol * LAMPORTS_PER_SOL);
+  if (lamports > bal - FEE_L) lamports = bal - FEE_L;
+  if (lamports <= 0) throw new Error("balance too low to withdraw (need to cover the ~0.000005 SOL network fee)");
+  const sig = await send(new Transaction().add(SystemProgram.transfer({ fromPubkey: kp.publicKey, toPubkey: dest, lamports })), [kp]);
+  return ok(`Sent ${(lamports / LAMPORTS_PER_SOL).toFixed(6)} SOL to ${to}\n${sig}`);
+});
+s.tool("sol_export_key", "Reveal the agent wallet's private key (base58) so it can be imported into Phantom/Solflare. Anyone with this key controls the funds — only show it to the wallet owner.", {}, { title: "Export private key", readOnlyHint: true }, async () => {
+  const kp = loadKp();
+  return ok("Private key (import into Phantom → 'Import Private Key'):\n" + bs58.encode(kp.secretKey) + "\n\n⚠️ Anyone with this key controls the wallet. Keep it secret.");
+});
+
 await s.connect(new StdioServerTransport());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentpump-mcp",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "MCP server to launch & trade tokens on AgentPump (Solana bonding-curve launchpad) from AI agents. Trade graduated tokens on Raydium.",
   "type": "module",
   "bin": {