@potswap_io/mcp 0.7.0 → 0.8.1

package/README.md

@@ -80,6 +80,8 @@ Use a dedicated agent wallet with only the funds you want the agent to control.
 | `get_points {wallet?}` | Season 1 points, POT allocated / claimable, next unlock |
 | `get_leaderboard` | Top wallets by fee paid |
 | `observe_publish`, `observe_query`, `observe_verify`, `observe_consume` | Signed, slot-anchored market observations on the open index: publish with your wallet, read everyone's with a per-publisher median, verify locally, record that you used one (earns the publisher Season 2 rewards). `limit_order_create` can trigger on the observation median (`priceSource: observations`) |
+| `lend_markets`, `lend_positions`, `lend_deposit`, `lend_withdraw` | Jupiter Lend Earn: markets with APY, your positions, deposit (fee, points) and free withdrawal |
+| `lp_pools`, `lp_position`, `lp_deposit`, `lp_withdraw` | Raydium CPMM liquidity: pools with live reserves, your share, add (fee, points) and remove (free) |
 | `get_launch_status` | Launch-pool meter (SOL / 500 target, from chain), season and day, fee split, unclaimed reward balances and the public claim ladder |
 | `get_price_history {mint, timeframe, limit}` | OHLCV candles from the token's top pool (`1m`…`1d`) |
 
@@ -128,6 +130,10 @@ Each swap carries Potswap's 2.5% integrator fee via Jupiter's referral program (
 
 **Seasons 1+ (30 days each):** `20M × 0.85^(n−1)` POT per season shared daily by fee basis; 30% of the net fee buys and burns POT, 20% keeps feeding reward balances, 50% team and operations. Levels (Larva → Bee → Queen, up to ×1.25) persist across seasons. `get_points` shows your balance, level and season; `get_launch_status` shows the meter. Only protocol fees enter the pool: nothing can be deposited. Full documentation: https://potswap-docs.pages.dev (every tool, configuration, limits, economy; also as /llms.txt for agents).
 
+## Owner jobs
+
+`potswap admin sweep | claims | burn` (CLI) run the treasury split, the claims worker and the buy-and-burn with the owner's key; dry-run by default.
+
 ## Also available
 
 - **`@potswap_io/sdk`** — the same engine as a typed library for bots, scripts and other agent frameworks. The MCP server is built on it.

package/dist/defiTools.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type Config, type TradeContext } from '@potswap_io/sdk';
+export declare function registerDefiTools(server: McpServer, deps: {
+    trade: TradeContext;
+    config: Config;
+}): void;

package/dist/defiTools.js

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import { NO_WALLET, executeLend, executeLpDeposit, executeLpWithdraw, lpPools, lpPosition, normalizeMarkets, normalizePositions, redact, redactValue } from '@potswap_io/sdk';
+const ok = (data, summary) => ({ content: [{ type: 'text', text: redact(summary ?? JSON.stringify(data, null, 2)) }], structuredContent: redactValue(data) });
+const fail = (message, extra = {}) => ({ content: [{ type: 'text', text: redact(message) }], structuredContent: redactValue({ error: message, ...extra }), isError: true });
+const MINT = z.string().regex(/^[1-9A-HJ-NP-Za-km-z]{32,44}$/);
+export function registerDefiTools(server, deps) {
+    const { trade } = deps;
+    const api = trade.api;
+    const walletOr = (w) => w ?? trade.signer?.publicKey ?? null;
+    const outcome = (r, verb) => {
+        switch (r.kind) {
+            case 'no-wallet':
+            case 'refused':
+            case 'failed': return fail(r.message, 'signature' in r && r.signature ? { signature: r.signature, explorerUrl: r.explorerUrl } : {});
+            case 'plan': return ok({ confirmRequired: true, plan: r.plan }, `Plan (confirm=true to execute): ${JSON.stringify(r.plan)}`);
+            case 'dry-run': return ok({ dryRun: true, plan: r.plan }, `DRY RUN, nothing signed: ${JSON.stringify(r.plan)}`);
+            case 'ok': return ok(r.result, `${verb}. ${String(r.result.explorerUrl)}${'feeNote' in r.result && r.result.feeNote ? `\n${String(r.result.feeNote)}` : ''}`);
+        }
+    };
+    server.registerTool('lend_markets', {
+        title: 'Lending markets (Jupiter Lend Earn)',
+        description: 'Earn markets with supply APY and total deposits. No wallet needed.',
+        inputSchema: {},
+    }, async () => {
+        try {
+            const markets = normalizeMarkets(await api.lendTokens());
+            return ok({ markets }, markets.map((m) => `${m.assetSymbol.padEnd(6)} ${m.supplyApyPct.toFixed(2)}% APY${m.rewardsApyPct ? ` (+${m.rewardsApyPct.toFixed(2)}% rewards)` : ''} · ${m.totalAssets.toLocaleString(undefined, { maximumFractionDigits: 0 })} deposited · mint ${m.assetMint}`).join('\n'));
+        }
+        catch (e) {
+            return fail(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool('lend_positions', {
+        title: 'Lending positions',
+        description: 'The wallet\'s Jupiter Lend Earn positions: shares, underlying amount, USD.',
+        inputSchema: { wallet: MINT.optional() },
+    }, async ({ wallet }) => {
+        const w = walletOr(wallet);
+        if (!w)
+            return fail(NO_WALLET);
+        try {
+            const positions = normalizePositions(await api.lendPositions([w]));
+            return ok({ wallet: w, positions }, positions.length ? positions.map((p) => `${p.assetSymbol}: ${p.underlying}${p.underlyingUsd !== undefined ? ` ($${p.underlyingUsd.toFixed(2)})` : ''} · ${p.shares} ${p.symbol}`).join('\n') : 'No lending positions.');
+        }
+        catch (e) {
+            return fail(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool('lend_deposit', {
+        title: 'Deposit into Jupiter Lend Earn',
+        description: 'Deposits a token into its Earn market. Requires confirm=true; without it returns the plan. Pays the Potswap fee (sent after the deposit confirms) and earns points. Subject to POTSWAP_MAX_TRADE_SOL and POTSWAP_ALLOWED_TOKENS.',
+        inputSchema: { mint: MINT, amount: z.number().positive(), confirm: z.boolean().default(false) },
+    }, async (a) => outcome(await executeLend(trade, { action: 'deposit', mint: a.mint, amount: a.amount, confirm: a.confirm }), 'Deposited'));
+    server.registerTool('lend_withdraw', {
+        title: 'Withdraw from Jupiter Lend Earn',
+        description: 'Withdraws an amount (or everything with all=true) from an Earn market. Free. Requires confirm=true.',
+        inputSchema: { mint: MINT, amount: z.number().positive().optional(), all: z.boolean().default(false), confirm: z.boolean().default(false) },
+    }, async (a) => {
+        if (!a.all && a.amount === undefined)
+            return fail('Give amount or all=true. No funds were debited.');
+        return outcome(await executeLend(trade, { action: 'withdraw', mint: a.mint, amount: a.all ? 'all' : a.amount, confirm: a.confirm }), 'Withdrew');
+    });
+    server.registerTool('lp_pools', {
+        title: 'Raydium CPMM pools for a pair',
+        description: 'CPMM pools with live reserves (net of protocol fees), LP supply, trade fee and TVL. No wallet needed.',
+        inputSchema: { mintA: MINT, mintB: MINT },
+    }, async ({ mintA, mintB }) => {
+        if (!trade.rpc?.getAccountsData)
+            return fail('Liquidity operations need an RPC connection.');
+        try {
+            const pools = await lpPools(api, trade.rpc.getAccountsData.bind(trade.rpc), mintA, mintB);
+            return ok({ pools }, pools.length ? pools.map((p) => `${p.poolId}: ${p.reserve0} ${p.token0Mint.slice(0, 4)}… / ${p.reserve1} ${p.token1Mint.slice(0, 4)}… · fee ${p.tradeFeeBps} bps${p.tvlUsd ? ` · TVL $${p.tvlUsd.toFixed(0)}` : ''}${p.swapEnabled ? '' : ' · swaps disabled'}`).join('\n') : 'No CPMM pool for this pair.');
+        }
+        catch (e) {
+            return fail(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool('lp_position', {
+        title: 'LP position in a CPMM pool',
+        description: 'LP token balance for a pool and the token amounts it represents at current reserves.',
+        inputSchema: { poolId: MINT, wallet: MINT.optional() },
+    }, async ({ poolId, wallet }) => {
+        const w = walletOr(wallet);
+        if (!w)
+            return fail(NO_WALLET);
+        if (!trade.rpc?.getAccountsData)
+            return fail('Liquidity operations need an RPC connection.');
+        try {
+            const pos = await lpPosition(trade.rpc.getAccountsData.bind(trade.rpc), await trade.balances(w), poolId);
+            if (!pos)
+                return fail('Pool not found or not a Raydium CPMM pool.');
+            return ok({ wallet: w, ...pos, lpBalanceRaw: pos.lpBalanceRaw.toString() }, `${pos.lpBalance} LP (${pos.sharePct.toFixed(4)}% of the pool) ≈ ${pos.amount0} ${pos.token0Mint.slice(0, 4)}… + ${pos.amount1} ${pos.token1Mint.slice(0, 4)}…`);
+        }
+        catch (e) {
+            return fail(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool('lp_deposit', {
+        title: 'Add liquidity to a CPMM pool',
+        description: 'Deposits `amount` of `mint` (one of the pool tokens) plus the matching amount of the other token for LP tokens. The Potswap fee comes off the given side in the same transaction. Requires confirm=true; without it returns the plan.',
+        inputSchema: { poolId: MINT, mint: MINT, amount: z.number().positive(), maxSlippageBps: z.number().int().min(1).max(5000).optional(), confirm: z.boolean().default(false) },
+    }, async (a) => outcome(await executeLpDeposit(trade, { poolId: a.poolId, mint: a.mint, amount: a.amount, slippageBps: a.maxSlippageBps, confirm: a.confirm }), 'Liquidity added'));
+    server.registerTool('lp_withdraw', {
+        title: 'Remove liquidity from a CPMM pool',
+        description: 'Burns LP tokens (an amount or a percentage of the balance) for both pool tokens. Free. Requires confirm=true.',
+        inputSchema: { poolId: MINT, lpAmount: z.number().positive().optional(), pct: z.number().min(0.01).max(100).optional(), maxSlippageBps: z.number().int().min(1).max(5000).optional(), confirm: z.boolean().default(false) },
+    }, async (a) => outcome(await executeLpWithdraw(trade, { poolId: a.poolId, lpAmount: a.lpAmount, pct: a.pct, slippageBps: a.maxSlippageBps, confirm: a.confirm }), 'Liquidity removed'));
+}

package/dist/server.d.ts

@@ -8,7 +8,7 @@ import type { Rpc } from '@potswap_io/sdk';
 import { type OpsStore } from '@potswap_io/sdk';
 import type { StrategyStore } from '@potswap_io/sdk';
 import type { Scheduler } from '@potswap_io/sdk';
-export declare const VERSION = "0.7.0";
+export declare const VERSION = "0.8.1";
 export interface ServerDeps {
     config?: Config;
     signer?: Signer | null;

package/dist/server.js

@@ -11,8 +11,9 @@ import { riskBadges, riskLevel } from '@potswap_io/sdk';
 import { registerStrategyTools } from './strategies/tools.js';
 import { registerAgentTools } from './agentTools.js';
 import { registerObservationTools } from './observationTools.js';
+import { registerDefiTools } from './defiTools.js';
 import { FileOpsStore, rpcFromConnection } from '@potswap_io/sdk';
-export const VERSION = '0.7.0';
+export const VERSION = '0.8.1';
 const ok = (data, summary) => ({
     content: [{ type: 'text', text: redact(summary ?? JSON.stringify(data, null, 2)) }], structuredContent: redactValue(data),
 });
@@ -165,6 +166,7 @@ export function createServer(deps = {}) {
     registerAgentTools(server, { trade, config, rpc: deps.rpc, txRpc: deps.txRpc, schedulerActive: () => !!deps.scheduler?.active });
     registerStrategyTools(server, { trade, store: deps.strategyStore, scheduler: deps.scheduler });
     registerObservationTools(server, { trade, config, getSlot: deps.getSlot });
+    registerDefiTools(server, { trade, config });
     return server;
 }
 const quoteShape = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@potswap_io/mcp",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Potswap MCP server: best-route Solana swaps, wallet, transfers, staking, DCA / rebalance / take-profit / limit strategies and POT rewards for AI agents. Non-custodial; built on @potswap_io/sdk.",
   "license": "MIT",
   "type": "module",
@@ -26,7 +26,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/potswap-io/mcp.git"
+    "url": "git+https://github.com/potswap/potswap-io.git"
   },
   "homepage": "https://www.potswap.io",
   "keywords": [
@@ -40,7 +40,7 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.2",
-    "@potswap_io/sdk": "^0.3.0",
+    "@potswap_io/sdk": "^0.4.2",
     "@solana/web3.js": "^1.99.0",
     "zod": "^4.6.7"
   },
@@ -52,6 +52,6 @@
     "vitest": "^5.0.5"
   },
   "bugs": {
-    "url": "https://github.com/potswap-io/mcp/issues"
+    "url": "https://github.com/potswap/potswap-io/issues"
   }
 }