@openpump/mcp 1.0.0

package/dist/chunk-J3BWHCCH.js

@@ -0,0 +1,1691 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/token-tools.ts
+import { z } from "zod";
+
+// src/lib/api-client.ts
+function createApiClient(apiKey, baseUrl) {
+  const authHeader = "Bearer " + apiKey;
+  return {
+    async get(path) {
+      return fetch(baseUrl + path, {
+        headers: { Authorization: authHeader }
+      });
+    },
+    async post(path, body) {
+      return fetch(baseUrl + path, {
+        method: "POST",
+        headers: {
+          Authorization: authHeader,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+    }
+  };
+}
+
+// src/tools/token-tools.ts
+function agentError(code, message, suggestion) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ error: true, code, message, suggestion })
+      }
+    ]
+  };
+}
+function detectImageMimeType(contentType, imageUrl) {
+  const validTypes = ["image/png", "image/jpeg", "image/jpg", "image/gif", "image/webp"];
+  if (contentType) {
+    const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+    if (validTypes.includes(normalized)) {
+      return normalized;
+    }
+  }
+  const lower = imageUrl.toLowerCase();
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+  if (lower.endsWith(".gif")) return "image/gif";
+  if (lower.endsWith(".webp")) return "image/webp";
+  return "image/png";
+}
+function registerTokenTools(server, userContext, apiBaseUrl) {
+  server.tool(
+    "create-token",
+    [
+      "Create a new token on PumpFun with a bonding curve.",
+      "Uploads token metadata and image to IPFS then submits the creation transaction.",
+      "Returns the mint address and transaction signature on success.",
+      "Typical confirmation: 2-5 seconds.",
+      "Not available to US persons. Use at own risk."
+    ].join(" "),
+    {
+      walletId: z.string().describe("ID of the creator/dev wallet"),
+      name: z.string().min(1).max(32).describe("Token name (max 32 chars)"),
+      symbol: z.string().min(1).max(10).describe("Token ticker symbol (max 10 chars)"),
+      description: z.string().max(500).describe("Token description (max 500 chars)"),
+      imageUrl: z.string().url().describe("Publicly accessible image URL (will be fetched and uploaded to IPFS)"),
+      initialBuyAmountSol: z.number().min(0).optional().describe("Optional: SOL amount for dev initial buy at creation"),
+      twitter: z.string().optional().describe("Twitter handle (optional)"),
+      telegram: z.string().optional().describe("Telegram link (optional)"),
+      website: z.string().url().optional().describe("Website URL (optional)")
+    },
+    async ({ walletId, name, symbol, description, imageUrl, initialBuyAmountSol, twitter, telegram, website }) => {
+      const wallet = userContext.wallets.find((w) => w.id === walletId);
+      if (!wallet) {
+        return agentError(
+          "WALLET_NOT_FOUND",
+          `Wallet "${walletId}" not found for this account.`,
+          "Use list-wallets to see available wallet IDs."
+        );
+      }
+      let imageBase64;
+      let imageType;
+      try {
+        const imageRes = await fetch(imageUrl);
+        if (!imageRes.ok) {
+          return agentError(
+            "IMAGE_FETCH_FAILED",
+            `Failed to fetch image from URL "${imageUrl}" (HTTP ${imageRes.status.toString()}).`,
+            "Ensure the image URL is publicly accessible and returns a valid image."
+          );
+        }
+        const contentType = imageRes.headers.get("content-type");
+        imageType = detectImageMimeType(contentType, imageUrl);
+        const imageBuffer = await imageRes.arrayBuffer();
+        imageBase64 = Buffer.from(imageBuffer).toString("base64");
+      } catch (error) {
+        return agentError(
+          "IMAGE_FETCH_FAILED",
+          `Failed to fetch image: ${error instanceof Error ? error.message : String(error)}`,
+          "Ensure the image URL is publicly accessible."
+        );
+      }
+      const requestBody = {
+        walletIndex: wallet.index,
+        name,
+        symbol,
+        description,
+        imageBase64,
+        imageType
+      };
+      if (initialBuyAmountSol !== void 0 && initialBuyAmountSol > 0) {
+        requestBody["initialBuyAmountSol"] = initialBuyAmountSol;
+      }
+      if (twitter !== void 0) requestBody["twitter"] = twitter;
+      if (telegram !== void 0) requestBody["telegram"] = telegram;
+      if (website !== void 0) requestBody["website"] = website;
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const res = await api.post("/api/tokens/create", requestBody);
+        if (!res.ok) {
+          const errBody = await res.text();
+          return agentError(
+            "TOKEN_CREATION_FAILED",
+            `Token creation failed (HTTP ${res.status.toString()}): ${errBody}`,
+            "Check the wallet has sufficient SOL and try again."
+          );
+        }
+        const data = await res.json();
+        return {
+          content: [{ type: "text", text: JSON.stringify(data) }]
+        };
+      } catch (error) {
+        return agentError(
+          "API_ERROR",
+          `Token creation request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+}
+
+// src/tools/trading-tools.ts
+import { z as z2 } from "zod";
+var DISCLAIMER = "Not available to US persons. Use at own risk.";
+var PRIORITY_LEVEL_SCHEMA = z2.enum(["economy", "normal", "fast", "turbo"]).optional().default("normal").describe(
+  "Transaction priority tier. Maps to Jito tip floor percentiles: 'economy' (25th), 'normal' (50th EMA, default), 'fast' (75th), 'turbo' (95th). Higher = faster inclusion, higher fee."
+);
+var APPROX_TIP_LAMPORTS = {
+  economy: 1e3,
+  normal: 5e4,
+  fast: 2e5,
+  turbo: 1e6
+};
+var RICO_WARNING = "LEGAL DISCLAIMER: Coordinated bundle buying (wash trading / simultaneous multi-wallet purchase at token creation) may be subject to legal restrictions in your jurisdiction. A RICO lawsuit filed July 2025 is active against bundling services. By setting confirm=true you acknowledge awareness of these risks. " + DISCLAIMER;
+function agentError2(code, message, suggestion) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ error: true, code, message, suggestion })
+      }
+    ]
+  };
+}
+async function fetchUpdatedBalance(api, walletId) {
+  try {
+    const res = await api.post(`/api/wallets/${walletId}/refresh-balance`, {});
+    if (!res.ok) return null;
+    const body = await res.json();
+    const d = body.data;
+    if (!d) return null;
+    return {
+      solBalance: d.solBalance ?? "0",
+      lamports: d.lamports ?? "0",
+      tokenBalances: d.tokenBalances ?? []
+    };
+  } catch {
+    return null;
+  }
+}
+var LAMPORTS_PER_SOL = 1e9;
+function registerTradingTools(server, userContext, apiBaseUrl) {
+  server.tool(
+    "bundle-buy",
+    [
+      RICO_WARNING,
+      "Atomically create a new PumpFun token and execute coordinated buys from multiple wallets using Jito MEV bundles.",
+      "Bundle 1 (token creation + up to 3 buy wallets) is atomic and same-block guaranteed.",
+      "Additional buyers use separate bundles and are NOT guaranteed same-block execution.",
+      "Requires confirm: true to execute.",
+      "Always run estimate-bundle-cost before this tool to verify sufficient SOL balance.",
+      "Returns jobId for async tracking."
+    ].join(" "),
+    {
+      devWalletId: z2.string().describe("ID of the dev/creator wallet"),
+      buyWalletIds: z2.array(z2.string()).max(20).describe("IDs of wallets to participate in the bundle buy (max 20)"),
+      tokenParams: z2.object({
+        name: z2.string().max(32).describe("Token name (max 32 chars)"),
+        symbol: z2.string().max(10).describe("Token ticker symbol (max 10 chars)"),
+        description: z2.string().max(500).describe("Token description (max 500 chars)"),
+        imageUrl: z2.string().url().describe("Token image URL")
+      }),
+      devBuyAmountSol: z2.string().regex(/^\d+$/, "Must be a decimal integer string").describe('SOL amount for the dev wallet initial buy in lamports (decimal string, e.g. "100000000" = 0.1 SOL)'),
+      walletBuyAmounts: z2.array(z2.string().regex(/^\d+$/, "Must be a decimal integer string")).describe("SOL amount per wallet in lamports (decimal strings), same order as buyWalletIds"),
+      priorityLevel: PRIORITY_LEVEL_SCHEMA,
+      confirm: z2.boolean().describe(
+        "REQUIRED: Must be true to execute. Run estimate-bundle-cost first to see total SOL required."
+      )
+    },
+    async ({ devWalletId, buyWalletIds, tokenParams, devBuyAmountSol, walletBuyAmounts, priorityLevel, confirm }) => {
+      if (!confirm) {
+        return agentError2(
+          "CONFIRMATION_REQUIRED",
+          "bundle-buy requires explicit confirmation (confirm: true) before execution.",
+          "First run estimate-bundle-cost to see total SOL required. Then call bundle-buy again with confirm: true."
+        );
+      }
+      const devWallet = userContext.wallets.find((w) => w.id === devWalletId);
+      if (!devWallet) {
+        return agentError2(
+          "WALLET_NOT_FOUND",
+          `Dev wallet "${devWalletId}" not found for this account.`,
+          "Use list-wallets to see available wallet IDs."
+        );
+      }
+      const missingWallets = buyWalletIds.filter(
+        (id) => !userContext.wallets.some((w) => w.id === id)
+      );
+      if (missingWallets.length > 0) {
+        return agentError2(
+          "WALLET_NOT_FOUND",
+          `Buy wallets not found: ${missingWallets.join(", ")}.`,
+          "Use list-wallets to see available wallet IDs."
+        );
+      }
+      if (walletBuyAmounts.length !== buyWalletIds.length) {
+        return agentError2(
+          "INVALID_INPUT",
+          `walletBuyAmounts length (${walletBuyAmounts.length.toString()}) must match buyWalletIds length (${buyWalletIds.length.toString()}).`,
+          "Provide one SOL amount per wallet in buyWalletIds, in the same order."
+        );
+      }
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const imageRes = await fetch(tokenParams.imageUrl);
+        if (!imageRes.ok) {
+          return agentError2(
+            "IMAGE_FETCH_FAILED",
+            `Failed to fetch token image from ${tokenParams.imageUrl}: HTTP ${imageRes.status.toString()}`,
+            "Provide a publicly accessible image URL."
+          );
+        }
+        const imageBuffer = await imageRes.arrayBuffer();
+        const imageBase64 = Buffer.from(imageBuffer).toString("base64");
+        const contentType = imageRes.headers.get("content-type") ?? "image/png";
+        const ACCEPTED_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+        const imageType = ACCEPTED_MIME_TYPES.find((m) => contentType.includes(m.split("/")[1] ?? "")) ?? "image/png";
+        const approxTipLamports = APPROX_TIP_LAMPORTS[priorityLevel] ?? APPROX_TIP_LAMPORTS["normal"] ?? 5e4;
+        const requestBody = {
+          devWalletId,
+          buyWalletIds,
+          name: tokenParams.name,
+          symbol: tokenParams.symbol,
+          description: tokenParams.description,
+          imageBase64,
+          imageType,
+          devBuyAmountLamports: devBuyAmountSol,
+          walletBuyAmounts,
+          tipLamports: approxTipLamports
+        };
+        const res = await api.post("/api/tokens/bundle-launch", requestBody);
+        if (!res.ok) {
+          const errBody = await res.text();
+          return agentError2(
+            "BUNDLE_LAUNCH_FAILED",
+            `Bundle launch failed (HTTP ${res.status.toString()}): ${errBody}`,
+            "Check wallet balances and try again."
+          );
+        }
+        const data = await res.json();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                jobId: data.jobId,
+                message: "Bundle launch submitted. Use poll-job to track progress.",
+                note: RICO_WARNING
+              })
+            }
+          ]
+        };
+      } catch (error) {
+        return agentError2(
+          "API_ERROR",
+          `Bundle launch request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "bundle-sell",
+    [
+      `Sell a PumpFun token from multiple wallets simultaneously using Jito MEV bundles.`,
+      "Groups as many wallet sell instructions as possible into each transaction (up to the 1232-byte Solana limit),",
+      "then packs transactions into Jito bundles (max 5 txs each). One Jito tip is paid per bundle.",
+      "Only supported for bonding curve tokens (not yet graduated to PumpSwap).",
+      "Returns bundle statuses and per-wallet warnings.",
+      DISCLAIMER
+    ].join(" "),
+    {
+      mint: z2.string().describe("Token mint address (base58)"),
+      walletSells: z2.array(
+        z2.object({
+          walletId: z2.string().describe("ID of the wallet holding the token"),
+          tokenAmount: z2.union([
+            z2.string().regex(/^\d+$/, "Must be a decimal integer string").describe('Raw token base units as a decimal string (e.g. "435541983646")'),
+            z2.literal("all")
+          ]).describe('Amount to sell as raw base units, or "all" to sell entire balance')
+        })
+      ).min(1).max(20).describe("Per-wallet sell amounts (1-20 wallets)"),
+      tipWalletId: z2.string().optional().describe("Wallet ID that pays the Jito tip (default: first wallet in walletSells)"),
+      slippageBps: z2.number().int().min(0).max(1e4).optional().describe("Slippage tolerance in basis points (default: 500 = 5%)"),
+      priorityLevel: PRIORITY_LEVEL_SCHEMA,
+      confirm: z2.boolean().describe("REQUIRED: Must be true to execute the bundle sell.")
+    },
+    async ({ mint, walletSells, tipWalletId, slippageBps, priorityLevel, confirm }) => {
+      if (!confirm) {
+        return agentError2(
+          "CONFIRMATION_REQUIRED",
+          "bundle-sell requires explicit confirmation (confirm: true) before execution.",
+          "Call bundle-sell again with confirm: true to proceed."
+        );
+      }
+      const missingWallets = walletSells.map((ws) => ws.walletId).filter((id) => !userContext.wallets.some((w) => w.id === id));
+      if (missingWallets.length > 0) {
+        return agentError2(
+          "WALLET_NOT_FOUND",
+          `Wallets not found: ${missingWallets.join(", ")}.`,
+          "Use list-wallets to see available wallet IDs."
+        );
+      }
+      if (tipWalletId !== void 0 && !userContext.wallets.some((w) => w.id === tipWalletId)) {
+        return agentError2(
+          "WALLET_NOT_FOUND",
+          `Tip wallet "${tipWalletId}" not found for this account.`,
+          "Use list-wallets to see available wallet IDs."
+        );
+      }
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const body = {
+          walletSells,
+          priorityLevel
+        };
+        if (tipWalletId !== void 0) body["tipWalletId"] = tipWalletId;
+        if (slippageBps !== void 0) body["slippageBps"] = slippageBps;
+        const res = await api.post(`/api/tokens/${mint}/bundle-sell`, body);
+        if (!res.ok) {
+          const errBody = await res.text();
+          return agentError2(
+            "BUNDLE_SELL_FAILED",
+            `Bundle sell failed (HTTP ${res.status.toString()}): ${errBody}`,
+            "Check wallet balances and that the token is still on the bonding curve."
+          );
+        }
+        const data = await res.json();
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (error) {
+        return agentError2(
+          "API_ERROR",
+          `Bundle sell request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "buy-token",
+    `Buy a PumpFun token with SOL from the specified wallet. Submits a swap transaction on the bonding curve. Returns the transaction result directly. ${DISCLAIMER}`,
+    {
+      walletId: z2.string().describe("ID of the wallet to buy with"),
+      mint: z2.string().describe("Token mint address (base58)"),
+      amountSol: z2.string().regex(/^\d+$/, "Must be a decimal integer string").describe(
+        'Amount of SOL to spend in lamports (decimal string, e.g. "100000000" = 0.1 SOL). IMPORTANT: use the exact integer string -- do NOT use floats or decimals.'
+      ),
+      slippageBps: z2.number().int().min(0).max(1e4).optional().describe("Slippage tolerance in basis points (default: 500 = 5%)"),
+      priorityLevel: PRIORITY_LEVEL_SCHEMA
+    },
+    async ({ walletId, mint, amountSol, slippageBps, priorityLevel }) => {
+      const wallet = userContext.wallets.find((w) => w.id === walletId);
+      if (!wallet) {
+        return agentError2(
+          "WALLET_NOT_FOUND",
+          `Wallet "${walletId}" not found.`,
+          "Use list-wallets to see available wallet IDs."
+        );
+      }
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const body = {
+          walletId,
+          amountLamports: amountSol,
+          // API expects lamports as decimal string
+          priorityLevel
+        };
+        if (slippageBps !== void 0) {
+          body["slippageBps"] = slippageBps;
+        }
+        const res = await api.post(`/api/tokens/${mint}/buy`, body);
+        if (res.status === 404) {
+          return agentError2(
+            "WALLET_NOT_FOUND",
+            `Wallet "${walletId}" could not be resolved by the API.`,
+            "Ensure the wallet keypair is configured on the server."
+          );
+        }
+        if (!res.ok) {
+          const errBody = await res.text();
+          return agentError2(
+            "BUY_FAILED",
+            `Buy transaction failed (HTTP ${res.status.toString()}): ${errBody}`,
+            "Check the wallet has sufficient SOL and try again."
+          );
+        }
+        const data = await res.json();
+        const updatedBalance = await fetchUpdatedBalance(api, walletId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ ...data, updatedWalletBalance: updatedBalance })
+            }
+          ]
+        };
+      } catch (error) {
+        return agentError2(
+          "API_ERROR",
+          `Buy request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "sell-token",
+    `Sell a PumpFun token back to SOL from the specified wallet. Use tokenAmount: "all" to sell the entire balance. Returns the transaction result directly. ${DISCLAIMER}`,
+    {
+      walletId: z2.string().describe("ID of the wallet holding the token"),
+      mint: z2.string().describe("Token mint address (base58)"),
+      tokenAmount: z2.union([
+        z2.string().regex(/^\d+$/, "Must be a decimal integer string").describe(
+          'Raw token base units as a decimal string (same as the "amount" field from get-wallet-balance/get-token-holdings, e.g. "435541983646"). IMPORTANT: use the exact string -- do NOT convert to a JS number.'
+        ),
+        z2.literal("all")
+      ]).describe('Raw token base units as a decimal string, or "all" to sell the entire balance. Use get-token-holdings to get the raw "amount" string for a specific wallet.'),
+      slippageBps: z2.number().int().min(0).max(1e4).optional().describe("Slippage tolerance in basis points (default: 500 = 5%)"),
+      priorityLevel: PRIORITY_LEVEL_SCHEMA
+    },
+    async ({ walletId, mint, tokenAmount, slippageBps, priorityLevel }) => {
+      const wallet = userContext.wallets.find((w) => w.id === walletId);
+      if (!wallet) {
+        return agentError2(
+          "WALLET_NOT_FOUND",
+          `Wallet "${walletId}" not found.`,
+          "Use list-wallets to see available wallet IDs."
+        );
+      }
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const body = {
+          walletId,
+          tokenAmount,
+          priorityLevel
+        };
+        if (slippageBps !== void 0) {
+          body["slippageBps"] = slippageBps;
+        }
+        const res = await api.post(`/api/tokens/${mint}/sell`, body);
+        if (res.status === 404) {
+          return agentError2(
+            "WALLET_NOT_FOUND",
+            `Wallet "${walletId}" could not be resolved by the API.`,
+            "Ensure the wallet keypair is configured on the server."
+          );
+        }
+        if (!res.ok) {
+          const errBody = await res.text();
+          return agentError2(
+            "SELL_FAILED",
+            `Sell transaction failed (HTTP ${res.status.toString()}): ${errBody}`,
+            "Check the wallet has sufficient token balance and try again."
+          );
+        }
+        const data = await res.json();
+        const updatedBalance = await fetchUpdatedBalance(api, walletId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ ...data, updatedWalletBalance: updatedBalance })
+            }
+          ]
+        };
+      } catch (error) {
+        return agentError2(
+          "API_ERROR",
+          `Sell request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "estimate-bundle-cost",
+    [
+      "Estimate the total SOL required for a bundle launch before executing.",
+      "Run this before bundle-buy to verify sufficient wallet balances.",
+      "Returns a breakdown of tip, network fees, and buy amounts.",
+      DISCLAIMER
+    ].join(" "),
+    {
+      buyWalletCount: z2.number().int().min(1).max(20).describe("Number of buy wallets (max 20)"),
+      devBuyAmountSol: z2.string().regex(/^\d+$/, "Must be a decimal integer string").describe('Dev wallet buy amount in lamports (decimal string, e.g. "100000000" = 0.1 SOL)'),
+      walletBuyAmounts: z2.array(z2.string().regex(/^\d+$/, "Must be a decimal integer string")).describe("SOL amount per buy wallet in lamports (decimal strings), in the same order as buyWalletIds will be"),
+      tipLamports: z2.number().int().min(1e3).optional().describe("Jito MEV tip in lamports (default: 1,000,000 = 0.001 SOL)"),
+      priorityLevel: PRIORITY_LEVEL_SCHEMA
+    },
+    ({ buyWalletCount, devBuyAmountSol, walletBuyAmounts, tipLamports: customTipLamports, priorityLevel }) => {
+      const approxTipLamports = customTipLamports ?? APPROX_TIP_LAMPORTS[priorityLevel] ?? APPROX_TIP_LAMPORTS["normal"] ?? 5e4;
+      const tipBI = BigInt(approxTipLamports);
+      const TOKEN_CREATION_FEE_LAMPORTS = 20000000n;
+      const TOKEN_ACCOUNT_RENT_LAMPORTS2 = 2049280n;
+      const NETWORK_FEE_PER_TX_LAMPORTS2 = 5000n;
+      const txCount = BigInt(1 + buyWalletCount);
+      const networkFeesLamports = txCount * NETWORK_FEE_PER_TX_LAMPORTS2;
+      const devBuyLamports = BigInt(devBuyAmountSol);
+      const walletBuysLamports = walletBuyAmounts.reduce((sum, amt) => sum + BigInt(amt), 0n);
+      const rentLamports = BigInt(buyWalletCount + 1) * TOKEN_ACCOUNT_RENT_LAMPORTS2;
+      const totalLamports = tipBI + networkFeesLamports + devBuyLamports + walletBuysLamports + rentLamports + TOKEN_CREATION_FEE_LAMPORTS;
+      const warnings = [];
+      if (buyWalletCount > 3) {
+        warnings.push(
+          "Wallets beyond index 3 are NOT guaranteed same-block as creation (not atomic). Consider whether this is acceptable."
+        );
+      }
+      if (walletBuyAmounts.some((amt) => BigInt(amt) < 10000000n)) {
+        warnings.push(
+          "Some wallet buy amounts are below 10000000 lamports (0.01 SOL). Very small buys may fail due to minimum transaction size requirements."
+        );
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              totalLamports: totalLamports.toString(),
+              totalSolApprox: (Number(totalLamports) / LAMPORTS_PER_SOL).toFixed(9),
+              breakdown: {
+                tipCostLamports: tipBI.toString(),
+                networkFeesLamports: networkFeesLamports.toString(),
+                tokenCreationFeeLamports: TOKEN_CREATION_FEE_LAMPORTS.toString(),
+                devBuyLamports: devBuyLamports.toString(),
+                walletBuysLamports: walletBuysLamports.toString(),
+                tokenAccountRentsLamports: rentLamports.toString()
+              },
+              warnings,
+              note: `Estimates are approximate. Jito tip for '${priorityLevel}' tier uses ~${approxTipLamports.toLocaleString()} lamports (live values fetched at execution time may differ). Total fees may vary by +/-20% based on network congestion.`
+            })
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "claim-creator-fees",
+    [
+      "Claim all accumulated creator fees for a wallet address.",
+      "Fees are per creator wallet (covering ALL tokens launched from that address) -- one transaction claims everything.",
+      "Run get-creator-fees first to check the claimable balance.",
+      `Returns signature and amount claimed. ${DISCLAIMER}`
+    ].join(" "),
+    {
+      creatorAddress: z2.string().describe(
+        "Creator wallet address (base58) to claim fees for. Must be one of your platform wallets."
+      )
+    },
+    async ({ creatorAddress }) => {
+      const wallet = userContext.wallets.find((w) => w.publicKey === creatorAddress);
+      if (!wallet) {
+        return agentError2(
+          "WALLET_NOT_FOUND",
+          `Address "${creatorAddress}" is not one of your platform wallets.`,
+          "Use get-creator-fees (no address) to see all your wallets and their claimable fees."
+        );
+      }
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const res = await api.post("/api/creator-fees/claim", { creatorAddress });
+        if (!res.ok) {
+          const errBody = await res.text();
+          return agentError2(
+            "CLAIM_FEES_FAILED",
+            `Claim fees failed (HTTP ${res.status.toString()}): ${errBody}`,
+            "Ensure the wallet has accumulated fees. Run get-creator-fees to check."
+          );
+        }
+        const data = await res.json();
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (error) {
+        return agentError2(
+          "API_ERROR",
+          `Claim fees request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+}
+
+// src/tools/transfer-tools.ts
+import { z as z3 } from "zod";
+var DISCLAIMER2 = "Not available to US persons. Use at own risk.";
+var LAMPORTS_PER_SOL2 = 1e9;
+var TRANSFER_CAP_LAMPORTS = 10000000000n;
+var RENT_EXEMPT_MINIMUM_LAMPORTS = 1000000n;
+var NETWORK_FEE_PER_TX_LAMPORTS = 5000n;
+var TOKEN_ACCOUNT_RENT_LAMPORTS = 2049280n;
+var TRANSFER_ANNOTATIONS = {
+  destructiveHint: true,
+  idempotentHint: false,
+  readOnlyHint: false,
+  openWorldHint: true
+};
+function agentError3(code, message, suggestion) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ error: true, code, message, suggestion })
+      }
+    ]
+  };
+}
+async function parseApiError(res) {
+  const text = await res.text();
+  try {
+    const parsed = JSON.parse(text);
+    return {
+      code: parsed.code ?? parsed.error ?? "TRANSFER_FAILED",
+      message: parsed.message ?? text
+    };
+  } catch {
+    return { code: "TRANSFER_FAILED", message: text };
+  }
+}
+function registerTransferTools(server, userContext, apiBaseUrl) {
+  server.tool(
+    "transfer-sol",
+    [
+      "Send SOL from a custodial wallet to any Solana address (internal or external).",
+      "Use get-wallet-balance before calling to verify sufficient balance.",
+      "Sender balance after transfer must remain above 0.001 SOL (Solana rent-exempt minimum).",
+      `Maximum transfer: ${TRANSFER_CAP_LAMPORTS.toString()} lamports (10 SOL) per call.`,
+      "Use dryRun: true to validate and estimate fees without submitting.",
+      "Requires confirm: true to execute.",
+      DISCLAIMER2
+    ].join(" "),
+    {
+      fromWalletId: z3.string().describe("ID of the source wallet (from list-wallets)"),
+      toAddress: z3.string().describe(
+        "Destination Solana address (base58). Accepts any valid address -- internal wallet public keys or external addresses."
+      ),
+      amountSol: z3.string().regex(/^\d+$/, "Must be a decimal integer string").describe(
+        `Amount of SOL to send in lamports (decimal string, e.g. "500000000" = 0.5 SOL). Maximum ${TRANSFER_CAP_LAMPORTS.toString()} lamports (10 SOL) per call.`
+      ),
+      memo: z3.string().max(256).optional().describe("Optional on-chain memo attached to the transaction (max 256 chars)."),
+      priorityFeeMicroLamports: z3.number().int().min(0).max(1e6).optional().describe("Priority fee in micro-lamports per compute unit. Omit to use the API default."),
+      dryRun: z3.boolean().optional().default(false).describe("If true, validates inputs and estimates fees without submitting. confirm is not required."),
+      confirm: z3.boolean().describe(
+        "REQUIRED: Must be true to execute. Run with dryRun: true first to preview the transfer."
+      )
+    },
+    TRANSFER_ANNOTATIONS,
+    async ({ fromWalletId, toAddress, amountSol, memo, priorityFeeMicroLamports, dryRun, confirm }) => {
+      const fromWallet = userContext.wallets.find((w) => w.id === fromWalletId);
+      if (!fromWallet) {
+        return agentError3(
+          "WALLET_NOT_FOUND",
+          `Source wallet "${fromWalletId}" not found for this account.`,
+          "Use list-wallets to see available wallet IDs."
+        );
+      }
+      if (fromWallet.publicKey === toAddress) {
+        return agentError3(
+          "INVALID_INPUT",
+          "Cannot transfer SOL to the same wallet (fromWalletId and toAddress resolve to the same public key).",
+          "Provide a different destination address."
+        );
+      }
+      const amountLamports = BigInt(amountSol);
+      if (amountLamports > TRANSFER_CAP_LAMPORTS) {
+        return agentError3(
+          "INVALID_INPUT",
+          `amountSol (${amountLamports.toString()} lamports) exceeds maximum of ${TRANSFER_CAP_LAMPORTS.toString()} lamports (10 SOL) per call.`,
+          "Split into multiple smaller transfers."
+        );
+      }
+      if (fromWallet.solBalance !== void 0) {
+        const balanceLamports = BigInt(Math.round(fromWallet.solBalance * LAMPORTS_PER_SOL2));
+        const remainingLamports = balanceLamports - amountLamports - NETWORK_FEE_PER_TX_LAMPORTS;
+        if (remainingLamports < RENT_EXEMPT_MINIMUM_LAMPORTS) {
+          return agentError3(
+            "INSUFFICIENT_BALANCE",
+            `Transfer would leave ${remainingLamports.toString()} lamports in the source wallet, below the Solana rent-exempt minimum of ${RENT_EXEMPT_MINIMUM_LAMPORTS.toString()} lamports. Current balance: ${balanceLamports.toString()} lamports.`,
+            "Reduce the transfer amount to keep at least 1000000 lamports (0.001 SOL) in the source wallet."
+          );
+        }
+      }
+      if (dryRun) {
+        const balanceLamports = fromWallet.solBalance === void 0 ? null : BigInt(Math.round(fromWallet.solBalance * LAMPORTS_PER_SOL2));
+        const remainingLamports = balanceLamports === null ? null : balanceLamports - amountLamports - NETWORK_FEE_PER_TX_LAMPORTS;
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                dryRun: true,
+                valid: true,
+                amountLamports: amountLamports.toString(),
+                fromAddress: fromWallet.publicKey,
+                toAddress,
+                estimatedNetworkFeeLamports: NETWORK_FEE_PER_TX_LAMPORTS.toString(),
+                remainingLamportsAfterTransfer: remainingLamports?.toString() ?? null,
+                rentExemptWarning: remainingLamports !== null && remainingLamports < RENT_EXEMPT_MINIMUM_LAMPORTS,
+                message: "Transfer would succeed. Call again with confirm: true to execute."
+              })
+            }
+          ]
+        };
+      }
+      if (!confirm) {
+        return agentError3(
+          "CONFIRMATION_REQUIRED",
+          "transfer-sol requires confirm: true to execute.",
+          "Run with dryRun: true to preview the transfer, then call again with confirm: true."
+        );
+      }
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const body = {
+          toAddress,
+          amountLamports: amountSol
+          // already a lamports decimal string
+        };
+        if (memo !== void 0) body["memo"] = memo;
+        if (priorityFeeMicroLamports !== void 0)
+          body["priorityFeeMicroLamports"] = priorityFeeMicroLamports;
+        const res = await api.post(`/api/wallets/${fromWalletId}/transfer`, body);
+        if (!res.ok) {
+          const { code, message } = await parseApiError(res);
+          return agentError3(
+            code,
+            `SOL transfer failed (HTTP ${res.status.toString()}): ${message}`,
+            "Verify the destination address is valid and the wallet has sufficient SOL."
+          );
+        }
+        const data = await res.json();
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (error) {
+        return agentError3(
+          "API_ERROR",
+          `Transfer request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "transfer-token",
+    [
+      "Send SPL tokens from a custodial wallet to any Solana address (internal or external).",
+      'tokenAmount is the raw base-unit amount string (same as the "amount" field from get-token-holdings), or "all" to send the entire balance.',
+      "If the destination lacks a token account for this mint, the transaction creates one (~0.002 SOL rent, paid by the sender).",
+      "Use dryRun: true to validate and estimate fees without submitting.",
+      "Requires confirm: true to execute.",
+      DISCLAIMER2
+    ].join(" "),
+    {
+      fromWalletId: z3.string().describe("ID of the source wallet holding the token (from list-wallets)"),
+      toAddress: z3.string().describe(
+        "Destination Solana address (base58). Accepts any valid address -- internal wallet public keys or external addresses."
+      ),
+      mint: z3.string().describe("SPL token mint address (base58)"),
+      tokenAmount: z3.union([
+        z3.string().regex(/^\d+$/, "Must be a non-negative integer string").describe(
+          'Raw token base units as a string (same format as get-token-holdings "amount" field, e.g. "1000000" for 1 token with 6 decimals)'
+        ),
+        z3.literal("all")
+      ]).describe(
+        'Raw token base units as a decimal string, or "all" to transfer the entire balance. Use get-token-holdings to get the raw "amount" string for a specific wallet.'
+      ),
+      memo: z3.string().max(256).optional().describe("Optional on-chain memo attached to the transaction (max 256 chars)."),
+      priorityFeeMicroLamports: z3.number().int().min(0).max(1e6).optional().describe("Priority fee in micro-lamports per compute unit. Omit to use the API default."),
+      dryRun: z3.boolean().optional().default(false).describe("If true, validates inputs and estimates fees without submitting."),
+      confirm: z3.boolean().describe("REQUIRED: Must be true to execute the token transfer.")
+    },
+    TRANSFER_ANNOTATIONS,
+    async ({
+      fromWalletId,
+      toAddress,
+      mint,
+      tokenAmount,
+      memo,
+      priorityFeeMicroLamports,
+      dryRun,
+      confirm
+    }) => {
+      const fromWallet = userContext.wallets.find((w) => w.id === fromWalletId);
+      if (!fromWallet) {
+        return agentError3(
+          "WALLET_NOT_FOUND",
+          `Source wallet "${fromWalletId}" not found for this account.`,
+          "Use list-wallets to see available wallet IDs."
+        );
+      }
+      if (fromWallet.publicKey === toAddress) {
+        return agentError3(
+          "INVALID_INPUT",
+          "Cannot transfer tokens to the same wallet.",
+          "Provide a different destination address."
+        );
+      }
+      const api = createApiClient(userContext.apiKey, apiBaseUrl);
+      let resolvedAmountLamports;
+      if (tokenAmount === "all") {
+        try {
+          const balRes = await api.get(`/api/wallets/${fromWalletId}/balance`);
+          if (!balRes.ok) {
+            return agentError3(
+              "API_ERROR",
+              `Failed to fetch balance to resolve "all" (HTTP ${balRes.status.toString()}).`,
+              "Use get-wallet-balance to check holdings, then pass the raw amount string directly."
+            );
+          }
+          const balData = await balRes.json();
+          const entry = balData.data.tokenBalances.find((tb) => tb.mint === mint);
+          if (!entry || entry.amount === "0") {
+            return agentError3(
+              "NO_TOKEN_BALANCE",
+              `Wallet "${fromWalletId}" holds no balance of token ${mint}.`,
+              "Use get-token-holdings to check which wallets hold this token."
+            );
+          }
+          resolvedAmountLamports = entry.amount;
+        } catch (error) {
+          return agentError3(
+            "API_ERROR",
+            `Balance fetch failed: ${error instanceof Error ? error.message : String(error)}`,
+            "Try again in a few seconds."
+          );
+        }
+      } else {
+        resolvedAmountLamports = tokenAmount;
+      }
+      if (dryRun) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                dryRun: true,
+                valid: true,
+                fromAddress: fromWallet.publicKey,
+                toAddress,
+                mint,
+                tokenAmountRaw: resolvedAmountLamports,
+                estimatedNetworkFeeLamports: NETWORK_FEE_PER_TX_LAMPORTS.toString(),
+                tokenAccountCreationCostLamports: TOKEN_ACCOUNT_RENT_LAMPORTS.toString(),
+                message: "Token transfer would proceed. If destination lacks a token account, ~0.002 SOL rent will be deducted from the source wallet. Call again with confirm: true to execute."
+              })
+            }
+          ]
+        };
+      }
+      if (!confirm) {
+        return agentError3(
+          "CONFIRMATION_REQUIRED",
+          "transfer-token requires confirm: true to execute.",
+          "Run with dryRun: true to preview the transfer, then call again with confirm: true."
+        );
+      }
+      try {
+        const body = {
+          toAddress,
+          amountLamports: resolvedAmountLamports,
+          mint
+        };
+        if (memo !== void 0) body["memo"] = memo;
+        if (priorityFeeMicroLamports !== void 0)
+          body["priorityFeeMicroLamports"] = priorityFeeMicroLamports;
+        const res = await api.post(`/api/wallets/${fromWalletId}/transfer`, body);
+        if (!res.ok) {
+          const { code, message } = await parseApiError(res);
+          return agentError3(
+            code,
+            `Token transfer failed (HTTP ${res.status.toString()}): ${message}`,
+            "Verify the destination address is valid and the wallet holds sufficient token balance."
+          );
+        }
+        const data = await res.json();
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (error) {
+        return agentError3(
+          "API_ERROR",
+          `Transfer request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+}
+
+// src/tools/wallet-tools.ts
+import { z as z4 } from "zod";
+var DISCLAIMER3 = "Not available to US persons. Use at own risk.";
+function agentError4(code, message, suggestion) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ error: true, code, message, suggestion })
+      }
+    ]
+  };
+}
+function registerWalletTools(server, userContext, apiBaseUrl) {
+  server.tool(
+    "create-wallet",
+    [
+      "Create a new HD-derived custodial wallet for this account.",
+      "The wallet is generated from the account master seed using BIP44 derivation (Phantom-compatible).",
+      "Returns the new wallet ID, public key, and derivation index.",
+      "Use list-wallets after creation to see the updated wallet list.",
+      DISCLAIMER3
+    ].join(" "),
+    {
+      label: z4.string().max(100).optional().describe('Optional human-readable label for the wallet (e.g. "sniper-1", "launch-wallet").')
+    },
+    async ({ label }) => {
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const body = {};
+        if (label !== void 0) body["label"] = label;
+        const res = await api.post("/api/wallets", body);
+        if (!res.ok) {
+          const text = await res.text();
+          return agentError4(
+            "CREATE_WALLET_FAILED",
+            `Failed to create wallet (HTTP ${res.status.toString()}): ${text}`,
+            "Try again in a few seconds."
+          );
+        }
+        const data = await res.json();
+        if (data?.data?.id && data.data.publicKey !== void 0) {
+          userContext.wallets.push({
+            id: data.data.id,
+            publicKey: data.data.publicKey,
+            label: data.data.label ?? null,
+            index: data.data.walletIndex ?? userContext.wallets.length
+          });
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (error) {
+        return agentError4(
+          "API_ERROR",
+          `Create wallet request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "get-aggregate-balance",
+    [
+      "Get the total SOL balance across all wallets in this account.",
+      "Returns totalSol, totalLamports, and walletCount.",
+      "Use this to quickly check how much SOL is available across all wallets before a bundle buy or large operation.",
+      DISCLAIMER3
+    ].join(" "),
+    {},
+    // No parameters -- aggregates all wallets for the authenticated user
+    async () => {
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const res = await api.get("/api/wallets/aggregate-balance");
+        if (!res.ok) {
+          const text = await res.text();
+          return agentError4(
+            "API_ERROR",
+            `Failed to fetch aggregate balance (HTTP ${res.status.toString()}): ${text}`,
+            "Try again in a few seconds."
+          );
+        }
+        const data = await res.json();
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (error) {
+        return agentError4(
+          "API_ERROR",
+          `Aggregate balance request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "get-wallet-deposit-address",
+    [
+      "Get the deposit address and funding instructions for a custodial wallet.",
+      "Returns the public key (deposit address), minimum SOL amounts for common operations, and instructions for sending SOL from an external wallet.",
+      "Use this when you need to tell the user how to fund a wallet from Phantom, Solflare, or any other external source.",
+      DISCLAIMER3
+    ].join(" "),
+    {
+      walletId: z4.string().describe("ID of the wallet to get the deposit address for")
+    },
+    async ({ walletId }) => {
+      const wallet = userContext.wallets.find((w) => w.id === walletId);
+      if (!wallet) {
+        return agentError4(
+          "WALLET_NOT_FOUND",
+          `Wallet "${walletId}" not found for this account.`,
+          "Use list-wallets to see available wallet IDs."
+        );
+      }
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const res = await api.get(`/api/wallets/${walletId}/deposit-instructions`);
+        if (!res.ok) {
+          const text = await res.text();
+          return agentError4(
+            "API_ERROR",
+            `Failed to fetch deposit instructions (HTTP ${res.status.toString()}): ${text}`,
+            "Try again in a few seconds."
+          );
+        }
+        const data = await res.json();
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (error) {
+        return agentError4(
+          "API_ERROR",
+          `Deposit instructions request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "get-wallet-transactions",
+    [
+      "Get the paginated transfer history for a wallet.",
+      "Returns buy, sell, and transfer transactions ordered newest-first.",
+      "Use type filter to narrow to a specific transaction type.",
+      "Use limit and offset for pagination (max 100 per page).",
+      DISCLAIMER3
+    ].join(" "),
+    {
+      walletId: z4.string().describe("ID of the wallet to fetch transaction history for"),
+      type: z4.enum(["buy", "sell", "transfer"]).optional().describe("Filter by transaction type. Omit to return all types."),
+      limit: z4.number().int().min(1).max(100).optional().default(50).describe("Number of transactions to return (default 50, max 100)."),
+      offset: z4.number().int().min(0).optional().default(0).describe("Number of transactions to skip for pagination (default 0).")
+    },
+    async ({ walletId, type, limit, offset }) => {
+      const wallet = userContext.wallets.find((w) => w.id === walletId);
+      if (!wallet) {
+        return agentError4(
+          "WALLET_NOT_FOUND",
+          `Wallet "${walletId}" not found for this account.`,
+          "Use list-wallets to see available wallet IDs."
+        );
+      }
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const params = new URLSearchParams({
+          limit: limit.toString(),
+          offset: offset.toString()
+        });
+        if (type !== void 0) params.set("type", type);
+        const res = await api.get(`/api/wallets/${walletId}/transactions?${params.toString()}`);
+        if (!res.ok) {
+          const text = await res.text();
+          return agentError4(
+            "API_ERROR",
+            `Failed to fetch transactions (HTTP ${res.status.toString()}): ${text}`,
+            "Try again in a few seconds."
+          );
+        }
+        const data = await res.json();
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (error) {
+        return agentError4(
+          "API_ERROR",
+          `Transactions request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+}
+
+// src/tools/info-tools.ts
+import { z as z5 } from "zod";
+var DISCLAIMER4 = "Not available to US persons. Use at own risk.";
+function agentError5(code, message, suggestion) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ error: true, code, message, suggestion })
+      }
+    ]
+  };
+}
+function registerInfoTools(server, userContext, apiBaseUrl) {
+  server.tool(
+    "get-token-info",
+    `Get current info about a PumpFun token: name, symbol, price, market cap, bonding curve progress, and graduation status. This is a public read -- no authentication required. ${DISCLAIMER4}`,
+    {
+      mint: z5.string().describe("Token mint address (base58)")
+    },
+    async ({ mint }) => {
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const res = await api.get(`/api/tokens/${mint}/curve-state`);
+        if (res.status === 404) {
+          return agentError5(
+            "TOKEN_NOT_FOUND",
+            `Token with mint "${mint}" was not found on PumpFun.`,
+            "Verify the mint address is correct and the token exists on pump.fun."
+          );
+        }
+        if (!res.ok) {
+          const errBody = await res.text();
+          return agentError5(
+            "API_ERROR",
+            `Failed to fetch token info (HTTP ${res.status.toString()}): ${errBody}`,
+            "Try again in a few seconds. If the error persists, the API may be unavailable."
+          );
+        }
+        const data = await res.json();
+        return {
+          content: [{ type: "text", text: JSON.stringify(data) }]
+        };
+      } catch (error) {
+        return agentError5(
+          "RPC_ERROR",
+          `Failed to fetch token info: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds. If the error persists, the Solana RPC may be degraded."
+        );
+      }
+    }
+  );
+  server.tool(
+    "get-token-market-info",
+    [
+      "Get rich market analytics for any Solana token: price (SOL + USD), market cap, 24h volume, buy/sell counts, price change percentages, and risk metrics (snipers, bundlers, insiders).",
+      "Mainnet only -- returns null data on devnet.",
+      "Use this before deciding when to sell: high sniper count or unusual price action may signal a rug.",
+      DISCLAIMER4
+    ].join(" "),
+    {
+      mint: z5.string().describe("Token mint address (base58)")
+    },
+    async ({ mint }) => {
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const res = await api.get(`/api/tokens/${mint}/market-info`);
+        if (!res.ok) {
+          const errBody = await res.text();
+          return agentError5(
+            "API_ERROR",
+            `Failed to fetch market info (HTTP ${res.status.toString()}): ${errBody}`,
+            "Try again in a few seconds."
+          );
+        }
+        const data = await res.json();
+        return {
+          content: [{ type: "text", text: JSON.stringify(data) }]
+        };
+      } catch (error) {
+        return agentError5(
+          "API_ERROR",
+          `Market info request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "list-my-tokens",
+    [
+      "List all tokens launched by the authenticated user.",
+      "Returns mint address, name, symbol, graduation status (active/graduated), metadata URI, and creation timestamp.",
+      "Combine with get-token-market-info to enrich each token with live price and volume data.",
+      DISCLAIMER4
+    ].join(" "),
+    {},
+    // No parameters -- scoped to authenticated user automatically
+    async () => {
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const res = await api.get("/api/tokens");
+        if (!res.ok) {
+          const errBody = await res.text();
+          return agentError5(
+            "API_ERROR",
+            `Failed to fetch token list (HTTP ${res.status.toString()}): ${errBody}`,
+            "Try again in a few seconds."
+          );
+        }
+        const data = await res.json();
+        return {
+          content: [{ type: "text", text: JSON.stringify(data) }]
+        };
+      } catch (error) {
+        return agentError5(
+          "API_ERROR",
+          `Token list request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "get-token-holdings",
+    [
+      "Check which of the user's platform wallets hold a specific token, and how much.",
+      "Omit mint to see ALL tokens held across every wallet -- useful when you know the symbol/name but not the mint address.",
+      "Provide mint to filter to that specific token only.",
+      "Returns wallets with a positive balance.",
+      "Use this before sell-token to know which walletIds and amounts to sell.",
+      DISCLAIMER4
+    ].join(" "),
+    {
+      mint: z5.string().optional().describe("Token mint address (base58) to check holdings for. Omit to return ALL token holdings across all wallets.")
+    },
+    async ({ mint }) => {
+      const wallets = userContext.wallets;
+      if (wallets.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ holdings: [], note: "No platform wallets configured." })
+            }
+          ]
+        };
+      }
+      const api = createApiClient(userContext.apiKey, apiBaseUrl);
+      const balanceResults = await Promise.allSettled(
+        wallets.map(async (w) => {
+          const res = await api.get(`/api/wallets/${w.id}/balance`);
+          if (!res.ok) throw new Error(`HTTP ${res.status.toString()} for wallet ${w.id}`);
+          const body = await res.json();
+          return { wallet: w, tokenBalances: body.data.tokenBalances };
+        })
+      );
+      if (mint !== void 0) {
+        const holdings = [];
+        for (const result of balanceResults) {
+          if (result.status !== "fulfilled") continue;
+          const { wallet, tokenBalances } = result.value;
+          const entry = tokenBalances.find((tb) => tb.mint === mint);
+          if (!entry) continue;
+          const hasBalance = entry.uiAmount === null ? entry.amount !== "0" : entry.uiAmount > 0;
+          if (!hasBalance) continue;
+          holdings.push({
+            walletId: wallet.id,
+            walletLabel: wallet.label ?? "",
+            publicKey: wallet.publicKey,
+            amount: entry.amount,
+            uiAmount: entry.uiAmount,
+            decimals: entry.decimals
+          });
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                mint,
+                holdings,
+                totalHoldingWallets: holdings.length,
+                note: holdings.length === 0 ? "No platform wallets hold this token." : `${holdings.length.toString()} wallet(s) hold this token. Pass the "amount" string directly to sell-token as tokenAmount to sell the exact on-chain balance with no float rounding.`
+              })
+            }
+          ]
+        };
+      }
+      const allHoldings = [];
+      for (const result of balanceResults) {
+        if (result.status !== "fulfilled") continue;
+        const { wallet, tokenBalances } = result.value;
+        for (const entry of tokenBalances) {
+          const hasBalance = entry.uiAmount === null ? entry.amount !== "0" : entry.uiAmount > 0;
+          if (!hasBalance) continue;
+          allHoldings.push({
+            mint: entry.mint,
+            walletId: wallet.id,
+            walletLabel: wallet.label ?? "",
+            publicKey: wallet.publicKey,
+            amount: entry.amount,
+            uiAmount: entry.uiAmount,
+            decimals: entry.decimals
+          });
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              holdings: allHoldings,
+              totalTokenPositions: allHoldings.length,
+              note: allHoldings.length === 0 ? "No token holdings found across any platform wallet." : `${allHoldings.length.toString()} token position(s) found. Use the "mint" field with sell-token, and "amount" as tokenAmount for exact on-chain sells with no float rounding.`
+            })
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "get-wallet-balance",
+    `Get the SOL balance and all token balances held by the specified wallet. Returns real-time on-chain data. ${DISCLAIMER4}`,
+    {
+      walletId: z5.string().describe("ID of the wallet to check balance for")
+    },
+    async ({ walletId }) => {
+      const wallet = userContext.wallets.find((w) => w.id === walletId);
+      if (!wallet) {
+        return agentError5(
+          "WALLET_NOT_FOUND",
+          `Wallet "${walletId}" not found for this account.`,
+          "Use list-wallets to see available wallet IDs and their public keys."
+        );
+      }
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const res = await api.get(`/api/wallets/${walletId}/balance`);
+        if (res.status === 404) {
+          return agentError5(
+            "WALLET_NOT_FOUND",
+            `Wallet "${walletId}" not found or not accessible.`,
+            "Use list-wallets to see available wallet IDs."
+          );
+        }
+        if (!res.ok) {
+          const errBody = await res.text();
+          return agentError5(
+            "API_ERROR",
+            `Failed to fetch wallet balance (HTTP ${res.status.toString()}): ${errBody}`,
+            "Try again in a few seconds."
+          );
+        }
+        const data = await res.json();
+        return {
+          content: [{ type: "text", text: JSON.stringify(data) }]
+        };
+      } catch (error) {
+        return agentError5(
+          "RPC_ERROR",
+          `Failed to fetch balance for wallet ${wallet.publicKey}: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "get-creator-fees",
+    [
+      "Check accumulated PumpFun creator fees for one or all wallets.",
+      "Fees accumulate in a single creator vault per wallet address, covering ALL tokens launched from that wallet.",
+      "Omit address to check fees across all of your platform wallets at once.",
+      "Provide an address to check a specific creator (including wallets not on this platform).",
+      DISCLAIMER4
+    ].join(" "),
+    {
+      address: z5.string().optional().describe(
+        "Creator wallet address (base58) to check fees for. Omit to check all your wallets."
+      )
+    },
+    async ({ address }) => {
+      const api = createApiClient(userContext.apiKey, apiBaseUrl);
+      if (address) {
+        try {
+          const res = await api.get(`/api/creator-fees?address=${address}`);
+          if (!res.ok) {
+            const errBody = await res.text();
+            return agentError5(
+              "API_ERROR",
+              `Failed to fetch creator fees (HTTP ${res.status.toString()}): ${errBody}`,
+              "Verify the address is a valid base58 Solana public key."
+            );
+          }
+          const data = await res.json();
+          return { content: [{ type: "text", text: JSON.stringify(data) }] };
+        } catch (error) {
+          return agentError5(
+            "API_ERROR",
+            `Creator fees request failed: ${error instanceof Error ? error.message : String(error)}`,
+            "Try again in a few seconds."
+          );
+        }
+      }
+      const wallets = userContext.wallets;
+      if (wallets.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                wallets: [],
+                totalAccumulatedSOL: 0,
+                note: "No platform wallets found."
+              })
+            }
+          ]
+        };
+      }
+      const results = await Promise.allSettled(
+        wallets.map(async (w) => {
+          const res = await api.get(`/api/creator-fees?address=${w.publicKey}`);
+          if (!res.ok) throw new Error(`HTTP ${res.status.toString()} for ${w.publicKey}`);
+          return {
+            wallet: w,
+            fees: await res.json()
+          };
+        })
+      );
+      const walletFees = results.filter((r) => r.status === "fulfilled").map(({ value: { wallet, fees } }) => ({
+        walletId: wallet.id,
+        publicKey: wallet.publicKey,
+        label: wallet.label,
+        accumulatedLamports: fees.accumulatedLamports,
+        accumulatedSOL: fees.accumulatedSOL,
+        creatorVaultAddress: fees.creatorVaultAddress
+      }));
+      const totalAccumulatedSOL = walletFees.reduce((sum, w) => sum + w.accumulatedSOL, 0);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              wallets: walletFees,
+              totalAccumulatedSOL,
+              note: totalAccumulatedSOL > 0 ? `${totalAccumulatedSOL.toFixed(9)} SOL claimable. Use claim-creator-fees with the relevant creatorAddress.` : "No pending creator fees across any of your wallets."
+            })
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list-wallets",
+    `List all wallets belonging to the authenticated user, including their public keys, labels, and derivation index. Use get-wallet-balance for live SOL and token balances. ${DISCLAIMER4}`,
+    {},
+    // No parameters -- returns all wallets for the authenticated user
+    () => {
+      const wallets = userContext.wallets.map((w) => ({
+        walletId: w.id,
+        publicKey: w.publicKey,
+        label: w.label,
+        walletIndex: w.index,
+        solBalance: w.solBalance ?? null
+      }));
+      return {
+        content: [{ type: "text", text: JSON.stringify(wallets) }]
+      };
+    }
+  );
+  server.tool(
+    "get-token-quote",
+    [
+      "Get a price quote for buying or selling a PumpFun token without submitting a transaction.",
+      'For buy: set action="buy" and solAmount (SOL to spend in lamports) -> returns expectedTokens.',
+      'For sell: set action="sell" and tokenAmount (raw base units, from get-token-holdings) -> returns expectedSol.',
+      "Also returns route (bonding_curve or pumpswap), priceImpact %, and fee in basis points.",
+      "Use this before buy-token or sell-token to preview the trade.",
+      DISCLAIMER4
+    ].join(" "),
+    {
+      mint: z5.string().describe("Token mint address (base58)"),
+      action: z5.enum(["buy", "sell"]).describe('"buy" to quote a purchase, "sell" to quote a sale'),
+      solAmount: z5.string().regex(/^\d+$/, "Must be a decimal integer string").optional().describe(
+        'SOL to spend on a buy in lamports (decimal string, e.g. "100000000" = 0.1 SOL). Required when action="buy".'
+      ),
+      tokenAmount: z5.string().regex(/^\d+$/, "Must be a decimal integer string").optional().describe(
+        'Raw token base units to sell as a decimal string (same as the "amount" field from get-token-holdings, e.g. "435541983646"). Required when action="sell".'
+      )
+    },
+    async ({ mint, action, solAmount, tokenAmount }) => {
+      if (action === "buy" && solAmount === void 0) {
+        return agentError5(
+          "MISSING_PARAM",
+          'solAmount is required when action="buy".',
+          'Set solAmount to the SOL you want to spend in lamports (e.g. "100000000" = 0.1 SOL).'
+        );
+      }
+      if (action === "sell" && tokenAmount === void 0) {
+        return agentError5(
+          "MISSING_PARAM",
+          'tokenAmount is required when action="sell".',
+          'Set tokenAmount to the raw base-unit string from get-token-holdings (e.g. "435541983646").'
+        );
+      }
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const params = new URLSearchParams({ action });
+        if (action === "buy") {
+          params.set("solAmount", solAmount);
+        } else {
+          params.set("tokenAmount", tokenAmount);
+        }
+        const res = await api.get(`/api/tokens/${mint}/quote?${params.toString()}`);
+        if (!res.ok) {
+          const text = await res.text();
+          return agentError5(
+            "QUOTE_FAILED",
+            `Quote failed (HTTP ${res.status.toString()}): ${text}`,
+            "Verify the mint address is correct and try again."
+          );
+        }
+        const data = await res.json();
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (error) {
+        return agentError5(
+          "API_ERROR",
+          `Quote request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+  server.tool(
+    "get-jito-tip-levels",
+    [
+      "Get current Jito MEV bundle tip amounts in lamports for each priority level (economy, normal, fast, turbo).",
+      "Values are refreshed every 20 seconds from the Jito tip percentile API.",
+      "Use this to pick an appropriate tipLamports for bundle-buy or to understand current MEV costs.",
+      DISCLAIMER4
+    ].join(" "),
+    {},
+    // No parameters -- public market data
+    async () => {
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const res = await api.get("/api/jito/tip");
+        if (!res.ok) {
+          const text = await res.text();
+          return agentError5(
+            "API_ERROR",
+            `Failed to fetch Jito tip levels (HTTP ${res.status.toString()}): ${text}`,
+            "Try again in a few seconds."
+          );
+        }
+        const data = await res.json();
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (error) {
+        return agentError5(
+          "API_ERROR",
+          `Jito tip levels request failed: ${error instanceof Error ? error.message : String(error)}`,
+          "Try again in a few seconds."
+        );
+      }
+    }
+  );
+}
+
+// src/tools/job-tools.ts
+import { z as z6 } from "zod";
+function registerJobTools(server, userContext, apiBaseUrl) {
+  server.tool(
+    "poll-job",
+    'Check the status of an async operation (create-token, bundle-buy, buy-token, sell-token, claim-creator-fees, transfer-sol, transfer-token). Call repeatedly until status is "completed" or "failed". Suggested polling interval: 2 seconds. Jobs expire after 10 minutes.',
+    {
+      jobId: z6.string().describe("Job ID returned by a previous async tool call")
+    },
+    async ({ jobId }) => {
+      try {
+        const api = createApiClient(userContext.apiKey, apiBaseUrl);
+        const res = await api.get(`/api/jobs/${jobId}`);
+        if (res.status === 404) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  error: true,
+                  code: "JOB_NOT_FOUND",
+                  message: `Job "${jobId}" was not found. It may have expired or the ID is incorrect.`,
+                  suggestion: "Verify the jobId from a recent async tool call. Jobs expire after 10 minutes."
+                })
+              }
+            ]
+          };
+        }
+        if (!res.ok) {
+          const errBody = await res.text();
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  error: true,
+                  code: "API_ERROR",
+                  message: `Failed to fetch job status (HTTP ${res.status.toString()}): ${errBody}`,
+                  suggestion: "Try again in a few seconds."
+                })
+              }
+            ]
+          };
+        }
+        const data = await res.json();
+        const response = {
+          jobId: data.jobId,
+          status: data.status,
+          progress: data.progress,
+          result: data.result ?? null,
+          warnings: data.warnings,
+          error: data.error ?? null
+        };
+        if (data.status === "pending" || data.status === "running" || data.status === "active" || data.status === "waiting") {
+          response.hint = "Job is still processing. Poll again in 2 seconds.";
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: true,
+                code: "API_ERROR",
+                message: `Job poll request failed: ${error instanceof Error ? error.message : String(error)}`,
+                suggestion: "Try again in a few seconds."
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(server, userContext, apiBaseUrl) {
+  registerTokenTools(server, userContext, apiBaseUrl);
+  registerTradingTools(server, userContext, apiBaseUrl);
+  registerTransferTools(server, userContext, apiBaseUrl);
+  registerWalletTools(server, userContext, apiBaseUrl);
+  registerInfoTools(server, userContext, apiBaseUrl);
+  registerJobTools(server, userContext, apiBaseUrl);
+}
+
+// src/server.ts
+function createMcpServer(userContext, apiBaseUrl) {
+  const server = new McpServer({
+    name: "openpump",
+    version: "1.0.0"
+  });
+  registerAllTools(server, userContext, apiBaseUrl);
+  return server;
+}
+
+export {
+  createMcpServer
+};