@potswap_io/mcp 0.1.0 → 0.2.0

package/dist/strategies/tools.js

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+import { NO_WALLET } from '../config.js';
+import { redact, redactValue } from '../redact.js';
+import { newId, SOL_MINT, nextRunAfter } from './engine.js';
+import { findStrategy, runsOf } from './store.js';
+const MINT = z.string().regex(/^[1-9A-HJ-NP-Za-km-z]{32,44}$/);
+const MAX_STRATEGIES = Number(process.env.POTSWAP_MAX_STRATEGIES) || 10;
+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 });
+export function registerStrategyTools(server, deps) {
+    const { trade } = deps;
+    if (!deps.store)
+        return; // strategies disabled (no state dir)
+    const store = deps.store;
+    const scheduler = deps.scheduler;
+    const now = () => Date.now();
+    const base = (kind, maxSlippageBps) => ({
+        id: newId(kind, now()), createdAt: new Date(now()).toISOString(), status: 'active', nextRunAt: new Date(now()).toISOString(),
+        consecutiveFailures: 0, totals: { runs: 0, volumeUsd: 0, feeUsd: 0, pointsAdded: 0 }, maxSlippageBps,
+    });
+    const guard = (confirm) => {
+        if (!trade.signer)
+            return fail(NO_WALLET);
+        if (!confirm)
+            return fail('Set confirm=true to create a strategy. Nothing was created and no funds were debited.');
+        if (store.load().strategies.filter((s) => s.status === 'active').length >= MAX_STRATEGIES)
+            return fail(`Limit of ${MAX_STRATEGIES} active strategies reached. Pause or delete one first.`);
+        return null;
+    };
+    const created = async (s, summary) => {
+        store.update((st) => { st.strategies.push(s); });
+        // First leg right away (P11.1) when a scheduler is attached.
+        if (scheduler)
+            await scheduler.tick();
+        const fresh = findStrategy(store.load(), s.id) ?? s;
+        return ok({ strategy: fresh, schedulerActive: !!scheduler?.active, runs: runsOf(store.load(), s.id, 3) }, `${summary}\nid=${s.id}${scheduler?.active ? '' : '\nNote: no scheduler is running in this process; run `npx @potswap_io/mcp --daemon` to execute strategies 24/7.'}`);
+    };
+    server.registerTool('dca_create', {
+        title: 'Create a DCA strategy',
+        description: 'Buy a fixed amount of a token on a schedule (first run immediately). Every leg pays the Potswap fee and earns POT points. Runs while this host is open, or 24/7 with `npx @potswap_io/mcp --daemon`.',
+        inputSchema: {
+            inputMint: MINT, outputMint: MINT,
+            amountPerRun: z.number().positive().describe('UI units of the input token per run (1 = 1 SOL)'),
+            intervalMinutes: z.number().int().min(5).max(60 * 24 * 30),
+            totalRuns: z.number().int().min(1).max(1000).optional(),
+            maxSlippageBps: z.number().int().min(1).max(5000).optional(),
+            confirm: z.boolean().default(false),
+        },
+    }, async (a) => {
+        const g = guard(a.confirm);
+        if (g)
+            return g;
+        if (a.inputMint === a.outputMint)
+            return fail('inputMint and outputMint must differ. Nothing was created.');
+        const s = { ...base('dca', a.maxSlippageBps), kind: 'dca', inputMint: a.inputMint, outputMint: a.outputMint, amountPerRun: a.amountPerRun, intervalMinutes: a.intervalMinutes, totalRuns: a.totalRuns, runsDone: 0 };
+        return created(s, `DCA created: ${a.amountPerRun} per run every ${a.intervalMinutes} min${a.totalRuns ? ` × ${a.totalRuns}` : ''}.`);
+    });
+    server.registerTool('rebalance_create', {
+        title: 'Create a rebalance strategy',
+        description: 'Keep the wallet at target percentages (2–6 assets incl. SOL). Checks on an interval; trades only when an asset drifts more than driftPct, routing through SOL.',
+        inputSchema: {
+            targets: z.record(MINT, z.number().min(0).max(100)).describe('mint → percent; must sum to 100 and include SOL'),
+            driftPct: z.number().min(1).max(50).default(5),
+            checkIntervalMinutes: z.number().int().min(15).max(60 * 24 * 7).default(60),
+            minTradeUsd: z.number().min(1).default(5),
+            maxSlippageBps: z.number().int().min(1).max(5000).optional(),
+            confirm: z.boolean().default(false),
+        },
+    }, async (a) => {
+        const g = guard(a.confirm);
+        if (g)
+            return g;
+        const mints = Object.keys(a.targets);
+        const sum = Object.values(a.targets).reduce((x, y) => x + y, 0);
+        if (mints.length < 2 || mints.length > 6)
+            return fail('targets must list 2–6 assets. Nothing was created.');
+        if (Math.abs(sum - 100) > 0.5)
+            return fail(`targets must sum to 100 (got ${sum}). Nothing was created.`);
+        if (!(SOL_MINT in a.targets))
+            return fail('targets must include SOL (So11111111111111111111111111111111111111112). Nothing was created.');
+        const s = { ...base('rebalance', a.maxSlippageBps), kind: 'rebalance', targets: a.targets, driftPct: a.driftPct, checkIntervalMinutes: a.checkIntervalMinutes, minTradeUsd: a.minTradeUsd };
+        return created(s, `Rebalance created: ${mints.map((m) => `${m === SOL_MINT ? 'SOL' : m.slice(0, 4)} ${a.targets[m]}%`).join(' / ')}, drift ${a.driftPct}%, every ${a.checkIntervalMinutes} min.`);
+    });
+    server.registerTool('tpsl_create', {
+        title: 'Create a take-profit / stop-loss',
+        description: 'Sell a percentage of a position when its price reaches a take-profit, stop-loss or trailing-stop level (entry = price now). Checks every 30 s while a scheduler runs.',
+        inputSchema: {
+            mint: MINT, sellPct: z.number().min(1).max(100).default(100),
+            takeProfitPct: z.number().positive().optional(), stopLossPct: z.number().positive().max(99).optional(), trailingPct: z.number().positive().max(99).optional(),
+            exitMint: MINT.default(SOL_MINT), maxSlippageBps: z.number().int().min(1).max(5000).optional(),
+            confirm: z.boolean().default(false),
+        },
+    }, async (a) => {
+        const g = guard(a.confirm);
+        if (g)
+            return g;
+        if (a.takeProfitPct === undefined && a.stopLossPct === undefined && a.trailingPct === undefined)
+            return fail('Set at least one of takeProfitPct, stopLossPct, trailingPct. Nothing was created.');
+        if (a.mint === a.exitMint)
+            return fail('mint and exitMint must differ. Nothing was created.');
+        let entry;
+        try {
+            entry = (await trade.api.prices([a.mint]))[a.mint];
+        }
+        catch {
+            entry = undefined;
+        }
+        if (!entry)
+            return fail('No price available for this token right now; try again in a moment. Nothing was created.');
+        const s = { ...base('tpsl', a.maxSlippageBps), kind: 'tpsl', mint: a.mint, sellPct: a.sellPct, exitMint: a.exitMint, entryPrice: entry, highWater: entry, takeProfitPct: a.takeProfitPct, stopLossPct: a.stopLossPct, trailingPct: a.trailingPct, nextRunAt: null };
+        return created(s, `TP/SL created at entry ${entry}: ${[a.takeProfitPct && `TP +${a.takeProfitPct}%`, a.stopLossPct && `SL −${a.stopLossPct}%`, a.trailingPct && `trailing ${a.trailingPct}%`].filter(Boolean).join(', ')}, sells ${a.sellPct}%.`);
+    });
+    server.registerTool('strategy_list', { title: 'List strategies', description: 'All strategies with status, next run, totals and last result.', inputSchema: {} }, async () => {
+        const st = store.load();
+        const rows = st.strategies.map((s) => ({ ...s, lastRun: runsOf(st, s.id, 1)[0] ?? null }));
+        return ok({ schedulerActive: !!scheduler?.active, stateFile: store.location, strategies: rows }, rows.length ? rows.map((s) => `${s.id} ${s.kind} ${s.status}${s.pausedReason ? ` (${s.pausedReason})` : ''} next=${s.nextRunAt ?? '—'} runs=${s.totals.runs} fees=$${s.totals.feeUsd.toFixed(2)}`).join('\n') : 'No strategies yet.');
+    });
+    const byId = { id: z.string().min(3) };
+    server.registerTool('strategy_pause', { title: 'Pause a strategy', description: 'Stops future legs; keeps history.', inputSchema: byId }, async ({ id }) => mutate(id, (s) => { s.status = 'paused'; s.pausedReason = 'paused by user'; s.nextRunAt = null; }));
+    server.registerTool('strategy_resume', { title: 'Resume a strategy', description: 'Re-activates a paused strategy; the next run is scheduled from now.', inputSchema: byId }, async ({ id }) => mutate(id, (s) => { if (s.status === 'completed')
+        throw new Error('Completed strategies cannot be resumed; create a new one.'); s.status = 'active'; s.pausedReason = undefined; s.consecutiveFailures = 0; s.nextRunAt = s.kind === 'tpsl' ? null : nextRunAfter(s, now()); }));
+    server.registerTool('strategy_delete', { title: 'Delete a strategy', description: 'Removes the strategy; its run history is kept.', inputSchema: byId }, async ({ id }) => {
+        const existed = store.update((st) => { const n = st.strategies.length; st.strategies = st.strategies.filter((s) => s.id !== id); return n !== st.strategies.length; });
+        return existed ? ok({ deleted: id }, `Deleted ${id}.`) : fail(`No strategy ${id}.`);
+    });
+    server.registerTool('strategy_runs', { title: 'Strategy run log', description: 'Recent legs with amounts, signatures, fees, points, or the skip/fail reason.', inputSchema: { id: z.string().min(3), limit: z.number().int().min(1).max(200).default(20) } }, async ({ id, limit }) => {
+        const st = store.load();
+        if (!findStrategy(st, id))
+            return fail(`No strategy ${id}.`);
+        const runs = runsOf(st, id, limit);
+        return ok({ id, runs }, runs.length ? runs.map((r) => `${r.at} ${r.outcome}: ${r.action}${r.signature ? ` sig=${r.signature}` : ''}${r.message ? ` — ${r.message}` : ''}`).join('\n') : 'No runs yet.');
+    });
+    function mutate(id, fn) {
+        try {
+            const s = store.update((st) => { const cur = findStrategy(st, id); if (!cur)
+                return null; fn(cur); return cur; });
+            return s ? ok({ strategy: s }, `${s.id} is now ${s.status}.`) : fail(`No strategy ${id}.`);
+        }
+        catch (e) {
+            return fail(e instanceof Error ? e.message : String(e));
+        }
+    }
+}

package/dist/strategies/types.d.ts

@@ -0,0 +1,68 @@
+export type StrategyStatus = 'active' | 'paused' | 'completed';
+interface Base {
+    id: string;
+    createdAt: string;
+    status: StrategyStatus;
+    pausedReason?: string;
+    nextRunAt: string | null;
+    consecutiveFailures: number;
+    totals: {
+        runs: number;
+        volumeUsd: number;
+        feeUsd: number;
+        pointsAdded: number;
+    };
+    maxSlippageBps?: number;
+}
+export interface DcaStrategy extends Base {
+    kind: 'dca';
+    inputMint: string;
+    outputMint: string;
+    amountPerRun: number;
+    intervalMinutes: number;
+    totalRuns?: number;
+    runsDone: number;
+}
+export interface RebalanceStrategy extends Base {
+    kind: 'rebalance';
+    targets: Record<string, number>;
+    driftPct: number;
+    checkIntervalMinutes: number;
+    minTradeUsd: number;
+}
+export interface TpSlStrategy extends Base {
+    kind: 'tpsl';
+    mint: string;
+    sellPct: number;
+    exitMint: string;
+    entryPrice: number;
+    highWater: number;
+    takeProfitPct?: number;
+    stopLossPct?: number;
+    trailingPct?: number;
+}
+export type Strategy = DcaStrategy | RebalanceStrategy | TpSlStrategy;
+export type RunOutcome = 'ok' | 'skipped' | 'failed' | 'dry-run' | 'no-op' | 'completed';
+export interface Run {
+    id: string;
+    strategyId: string;
+    at: string;
+    action: string;
+    outcome: RunOutcome;
+    message?: string;
+    signature?: string;
+    inAmount?: number;
+    inputSymbol?: string;
+    outAmount?: number;
+    outputSymbol?: string;
+    feeUsd?: number;
+    pointsAdded?: number;
+    solEquivalent?: number;
+}
+export interface StrategyState {
+    version: 1;
+    strategies: Strategy[];
+    runs: Run[];
+}
+export declare const EMPTY_STATE: StrategyState;
+export {};

package/dist/strategies/types.js

@@ -0,0 +1,2 @@
+// PRD P11 — strategy definitions persisted in ~/.potswap/strategies.json.
+export const EMPTY_STATE = { version: 1, strategies: [], runs: [] };

package/dist/trade.d.ts

@@ -0,0 +1,86 @@
+import type { PotswapApi } from './api.js';
+import { type Config } from './config.js';
+import type { Signer } from './wallet.js';
+export type BalancesFn = (wallet: string) => Promise<Record<string, number>>;
+export interface TradeContext {
+    api: PotswapApi;
+    config: Config;
+    signer: Signer | null;
+    balances: BalancesFn;
+}
+export interface SwapArgs {
+    inputMint: string;
+    outputMint: string;
+    amount: number;
+    slippageBps?: number;
+    confirm?: boolean;
+    /** Extra SOL-equivalent already spent in the current window (strategies' daily cap). */
+    extraSolCap?: {
+        remainingSol: number;
+        label: string;
+    };
+}
+export interface Quote {
+    inputMint: string;
+    inputSymbol: string;
+    outputMint: string;
+    outputSymbol: string;
+    inAmount: number;
+    inAmountRaw: string;
+    outAmount: number;
+    price: number;
+    priceImpactPct?: number;
+    slippageBps?: number;
+    feeBps: number;
+    feeTier: string | null;
+    feeLabel: string | null;
+    scheduledFeeBps: number;
+    inputUsd?: number;
+    router: string;
+    requestId: string;
+    expiresAt: string | null;
+}
+export interface SwapOk {
+    signature: string;
+    explorerUrl: string;
+    inAmount: number;
+    inputSymbol: string;
+    outAmount: number;
+    outputSymbol: string;
+    router: string;
+    feeBps: number;
+    feeUsd?: number;
+    pointsAdded?: number;
+    solEquivalent?: number;
+}
+export type SwapOutcome = {
+    kind: 'no-wallet';
+    message: string;
+} | {
+    kind: 'refused';
+    message: string;
+    quote: Quote;
+} | {
+    kind: 'quote-only';
+    quote: Quote;
+} | {
+    kind: 'dry-run';
+    quote: Quote;
+} | {
+    kind: 'failed';
+    message: string;
+    quote?: Quote;
+    signature?: string;
+    explorerUrl?: string;
+} | {
+    kind: 'ok';
+    result: SwapOk;
+    quote: Quote;
+};
+export declare function buildQuote(api: PotswapApi, a: {
+    inputMint: string;
+    outputMint: string;
+    amount: number;
+    slippageBps?: number;
+}): Promise<Quote>;
+export declare function executeSwap(ctx: TradeContext, a: SwapArgs): Promise<SwapOutcome>;

package/dist/trade.js

@@ -0,0 +1,83 @@
+// Swap execution shared by the `swap` tool (P10) and the strategy scheduler (P11).
+// One path: quote → limits → fresh order as taker → local signature → execute.
+import { VersionedTransaction } from '@solana/web3.js';
+import { NO_WALLET, SOL_MINT } from './config.js';
+import { checkLimits } from './limits.js';
+import { explorer, fromRaw, toRaw } from './format.js';
+import { describeOrderError, friendlyError } from './shared/errors.js';
+import { feeBpsFor } from './shared/fee.js';
+export async function buildQuote(api, a) {
+    const [inTok, outTok, cfg, px] = await Promise.all([
+        api.token(a.inputMint), api.token(a.outputMint), api.config(), api.prices([a.inputMint]).catch(() => ({})),
+    ]);
+    const inAmountRaw = toRaw(a.amount, inTok.decimals);
+    // PRD P8.12–P8.15: the fee tier depends on the USD value of the input at quote time.
+    const inputUsd = px[a.inputMint] ? a.amount * px[a.inputMint] : undefined;
+    const feeDecision = feeBpsFor(cfg.fee, inputUsd);
+    const o = await api.order({ inputMint: a.inputMint, outputMint: a.outputMint, amount: inAmountRaw, slippageBps: a.slippageBps, feeBps: feeDecision.bps });
+    if (o.errorMessage && !o.outAmount)
+        throw new Error(`${describeOrderError(o)} No funds were debited.`);
+    const outAmount = fromRaw(o.outAmount, outTok.decimals);
+    return {
+        inputMint: a.inputMint, inputSymbol: inTok.symbol, outputMint: a.outputMint, outputSymbol: outTok.symbol,
+        inAmount: a.amount, inAmountRaw, outAmount, price: outAmount / a.amount,
+        priceImpactPct: o.priceImpactPct !== undefined ? Math.abs(Number(o.priceImpactPct)) : undefined,
+        slippageBps: o.slippageBps, feeBps: o.platformFee?.feeBps ?? o.feeBps ?? 0,
+        feeTier: cfg.referralAccount ? feeDecision.tier : null, feeLabel: cfg.referralAccount ? feeDecision.label : null,
+        scheduledFeeBps: feeDecision.bps, inputUsd, router: o.router, requestId: o.requestId, expiresAt: o.expireAt ?? null,
+    };
+}
+export async function executeSwap(ctx, a) {
+    const { api, config, signer } = ctx;
+    if (!signer)
+        return { kind: 'no-wallet', message: NO_WALLET };
+    try {
+        const quote = await buildQuote(api, a);
+        const prices = await api.prices([SOL_MINT, a.inputMint]).catch(() => ({}));
+        let balanceUi;
+        try {
+            balanceUi = (await ctx.balances(signer.publicKey))[a.inputMint] ?? 0;
+        }
+        catch {
+            balanceUi = undefined;
+        }
+        const inputUsd = prices[a.inputMint] ? a.amount * prices[a.inputMint] : undefined;
+        const solEquivalent = a.inputMint === SOL_MINT ? a.amount : inputUsd !== undefined && prices[SOL_MINT] ? inputUsd / prices[SOL_MINT] : undefined;
+        const refusal = checkLimits({
+            amountUi: a.amount, inputMint: a.inputMint, inputSymbol: quote.inputSymbol, isSol: a.inputMint === SOL_MINT,
+            inputUsd, solUsd: prices[SOL_MINT], slippageBps: a.slippageBps,
+            maxTradeSol: config.maxTradeSol, maxSlippageBps: config.maxSlippageBps, balanceUi,
+        });
+        if (refusal)
+            return { kind: 'refused', message: refusal, quote };
+        if (a.extraSolCap && solEquivalent !== undefined && solEquivalent > a.extraSolCap.remainingSol) {
+            return { kind: 'refused', message: `${a.extraSolCap.label} No funds were debited.`, quote };
+        }
+        if (!a.confirm)
+            return { kind: 'quote-only', quote };
+        if (config.dryRun)
+            return { kind: 'dry-run', quote };
+        const order = await api.order({ inputMint: a.inputMint, outputMint: a.outputMint, amount: quote.inAmountRaw, taker: signer.publicKey, slippageBps: a.slippageBps, feeBps: quote.scheduledFeeBps });
+        if (!order.transaction)
+            return { kind: 'failed', message: `${describeOrderError(order)} No funds were debited.`, quote };
+        const tx = VersionedTransaction.deserialize(Buffer.from(order.transaction, 'base64'));
+        signer.sign(tx);
+        const res = await api.execute(Buffer.from(tx.serialize()).toString('base64'), order.requestId);
+        if (res.status !== 'Success') {
+            return { kind: 'failed', message: friendlyError(res.error || `Swap failed (code ${res.code})`), quote, signature: res.signature, explorerUrl: res.signature ? explorer(res.signature) : undefined };
+        }
+        const outDec = (await api.token(a.outputMint)).decimals;
+        const outAmount = fromRaw(res.totalOutputAmount ?? order.outAmount, outDec);
+        const feeBps = order.platformFee?.feeBps ?? order.feeBps ?? 0;
+        const feeUsd = inputUsd !== undefined ? inputUsd * feeBps / 10_000 : undefined;
+        const cfg = await api.config();
+        const result = {
+            signature: res.signature, explorerUrl: explorer(res.signature), inAmount: a.amount, inputSymbol: quote.inputSymbol,
+            outAmount, outputSymbol: quote.outputSymbol, router: order.router, feeBps, feeUsd, pointsAdded: cfg.referralAccount ? feeUsd : 0, solEquivalent,
+        };
+        return { kind: 'ok', result, quote };
+    }
+    catch (e) {
+        return { kind: 'failed', message: friendlyError(e instanceof Error ? e.message : String(e)) };
+    }
+}

package/package.json

@@ -1,55 +1,58 @@
-{
-  "name": "@potswap_io/mcp",
-  "version": "0.1.0",
-  "description": "Potswap MCP server: best-route Solana swaps for AI agents, non-custodial, earns POT.",
-  "license": "MIT",
-  "type": "module",
-  "bin": {
-    "potswap-mcp": "dist/index.js"
-  },
-  "main": "dist/server.js",
-  "types": "dist/server.d.ts",
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "dev": "tsx src/index.ts",
-    "test": "vitest run",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "sync-shared": "node scripts/sync-shared.mjs",
-    "prepublishOnly": "npm run sync-shared && npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Nahargeva/potswap"
-  },
-  "homepage": "https://www.potswap.io",
-  "keywords": [
-    "mcp",
-    "solana",
-    "swap",
-    "jupiter",
-    "ai-agent",
-    "potswap",
-    "model-context-protocol"
-  ],
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.32.2",
-    "@solana/web3.js": "^1.99.0",
-    "bs58": "^6.0.0",
-    "zod": "^4.6.7"
-  },
-  "devDependencies": {
-    "@types/node": "^26.6.5",
-    "tsx": "^4.23.15",
-    "typescript": "^7.0.2",
-    "vite": "^8.3.5",
-    "vitest": "^5.0.5"
-  }
-}
+{
+  "name": "@potswap_io/mcp",
+  "version": "0.2.0",
+  "description": "Potswap MCP server: best-route Solana swaps, DCA / rebalance / take-profit strategies for AI agents, non-custodial, earns POT.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "potswap-mcp": "dist/index.js"
+  },
+  "main": "dist/server.js",
+  "types": "dist/server.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "sync-shared": "node scripts/sync-shared.mjs",
+    "prepublishOnly": "npm run sync-shared && npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/potswap-io/mcp.git"
+  },
+  "homepage": "https://www.potswap.io",
+  "keywords": [
+    "mcp",
+    "solana",
+    "swap",
+    "jupiter",
+    "ai-agent",
+    "potswap",
+    "model-context-protocol"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "@solana/web3.js": "^1.99.0",
+    "bs58": "^6.0.0",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.5",
+    "vitest": "^5.0.5"
+  },
+  "bugs": {
+    "url": "https://github.com/potswap-io/mcp/issues"
+  }
+}