@potswap_io/mcp 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Potswap
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,114 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @potswap_io/mcp
+
+The Solana swap tool for AI agents. One MCP server gives your agent best-route swaps across every Solana DEX (Metis, JupiterZ, DFlow and OKX compete on each order, MEV-protected), token research with risk flags, balances, and POT rewards for every trade.
+
+- **Non-custodial.** Transactions are signed on your machine with your own keypair. The key never leaves the process and is redacted from every output.
+- **Safe by default.** `swap` needs `confirm: true`; per-trade cap 1 SOL; slippage cap 3%; dry-run mode; a 0.01 SOL reserve is always kept. Every error says whether funds were debited.
+- **Pays you back.** Potswap charges a 2.5% fee inside the swap (1% on swaps of $1,000 or more). Half of its net fees buy and burn POT every epoch, and the fee you paid is credited to your wallet as POT points (Season 1). Agents earn exactly like humans.
+- **$0 to run.** Talks only to `potswap.io`; no API keys needed.
+
+## Install
+
+Node 20+. No install step; run it with `npx`.
+
+### Claude Desktop
+
+`claude_desktop_config.json` (Settings → Developer → Edit Config):
+
+```json
+{
+  "mcpServers": {
+    "potswap": {
+      "command": "npx",
+      "args": ["-y", "@potswap_io/mcp"],
+      "env": {
+        "SOLANA_PRIVATE_KEY": "<base58 secret or JSON byte array>",
+        "POTSWAP_MAX_TRADE_SOL": "0.5"
+      }
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add potswap -e SOLANA_KEYPAIR_PATH=~/.config/solana/id.json -- npx -y @potswap_io/mcp
+```
+
+### Cursor
+
+`.cursor/mcp.json` in your project:
+
+```json
+{ "mcpServers": { "potswap": { "command": "npx", "args": ["-y", "@potswap_io/mcp"], "env": { "SOLANA_KEYPAIR_PATH": "/home/you/.config/solana/id.json" } } } }
+```
+
+Without a key the server still runs in read-only mode (search, quotes, trending, points of any wallet).
+
+## Configuration
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `SOLANA_PRIVATE_KEY` | — | base58 secret key (64 bytes) or JSON byte array, as exported by Phantom / `solana-keygen` |
+| `SOLANA_KEYPAIR_PATH` | — | path to a `solana-keygen` JSON file; used when `SOLANA_PRIVATE_KEY` is unset |
+| `SOLANA_RPC_URL` | Potswap's RPC proxy | your own RPC if you trade a lot |
+| `POTSWAP_MAX_TRADE_SOL` | `1` | refuse any swap whose input is worth more than this many SOL |
+| `POTSWAP_MAX_SLIPPAGE_BPS` | `300` | refuse requested slippage above this |
+| `POTSWAP_MAX_DAILY_SOL` | `5` | daily SOL-equivalent cap across all strategies |
+| `POTSWAP_STATE_DIR` | `~/.potswap` | where strategies and run logs are stored |
+| `POTSWAP_DRY_RUN` | `false` | `true` = `swap` never signs; returns what it would have done |
+| `POTSWAP_API` | `https://www.potswap.io` | base URL |
+
+Use a dedicated agent wallet with only the funds you want the agent to control. Keep the caps low until you trust the agent's behaviour.
+
+## Tools
+
+| Tool | Does |
+|---|---|
+| `search_tokens {query}` | Find tokens by name/symbol/mint |
+| `get_token {mint}` | Price, mcap, liquidity, holders, audit data, **risk badges** (`riskLevel` 0 safe → 3 danger) |
+| `get_trending {kind}` | `new`, `trending`, `top`, `graduating` lists |
+| `get_quote {inputMint, outputMint, amount}` | Best route, fee, impact, router. `amount` is in UI units (1 = 1 SOL) |
+| `swap {…, confirm: true}` | Executes at the best route and returns the signature, amounts, fee and POT points |
+| `get_balances {wallet?}` | SOL + SPL balances with USD |
+| `get_positions {wallet?}` | Holdings with USD; PnL coming |
+| `get_points {wallet?}` | Season 1 points, POT allocated / claimable, next unlock |
+| `get_leaderboard` | Top wallets by fee paid |
+
+Example prompt: *"Check BONK's risk flags, and if riskLevel is 0 or 1 buy 0.1 SOL worth."* The agent calls `get_token`, then `swap` with `confirm: true`; you can require that it shows you the quote first by leaving `POTSWAP_DRY_RUN=true` until you are comfortable.
+
+## Strategies: DCA, rebalance, take-profit / stop-loss
+
+Standing orders that keep running without you. Every leg is an ordinary Potswap swap (fee + POT points).
+
+| Tool | Example |
+|---|---|
+| `dca_create` | `{ inputMint: SOL, outputMint: USDC, amountPerRun: 0.1, intervalMinutes: 60, totalRuns: 24, confirm: true }` |
+| `rebalance_create` | `{ targets: { SOL: 60, USDC: 40 }, driftPct: 5, checkIntervalMinutes: 60, confirm: true }` (mints, not symbols) |
+| `tpsl_create` | `{ mint: BONK, sellPct: 50, takeProfitPct: 50, stopLossPct: 20, trailingPct: 15, confirm: true }` |
+| `strategy_list`, `strategy_runs {id}`, `strategy_pause/resume/delete {id}` | manage and audit |
+
+**Who runs the clock.** Strategies execute inside the MCP server while your host app is open. For 24/7 operation run the daemon on any always-on machine:
+
+```bash
+POTSWAP_STATE_DIR=~/.potswap SOLANA_KEYPAIR_PATH=~/.config/solana/id.json npx -y @potswap_io/mcp --daemon
+```
+
+State lives in `~/.potswap/strategies.json` (override with `POTSWAP_STATE_DIR`); a PID lock makes sure only one process trades. The first leg runs at creation; a window missed during downtime runs once, never as a burst.
+
+**Extra limits.** `POTSWAP_MAX_DAILY_SOL` (default `5`) caps the SOL-equivalent all strategies may spend per UTC day; `POTSWAP_MAX_STRATEGIES` (default `10`). After three consecutive failed legs a strategy pauses itself and tells you why. `POTSWAP_DRY_RUN=true` turns every leg into a logged quote.
+
+## Fees and rewards
+
+Each swap carries Potswap's 2.5% integrator fee via Jupiter's referral program; Jupiter keeps 20% of it, and 50% of what remains buys and burns POT each epoch. The fee basis is credited to the trading wallet as Season 1 points, split daily: 666,666 POT per epoch, by `fee^1.1`, capped at 10% per wallet. Points become POT tokens after the token launch; unlock 7 days after each epoch. Details: https://www.potswap.io
+
+## Development
+
+```bash
+cd mcp && npm i && npm test      # unit tests over the real MCP protocol (in-memory transport)
+npm run dev                       # run from source
+npm run sync-shared && npm run build
+```
+
+MIT © Potswap

package/dist/api.d.ts

@@ -0,0 +1,41 @@
+import type { ExecuteResponse, OrderResponse, Token } from './shared/lib-types.js';
+import type { TerminalToken } from './shared/types.js';
+import { type FeeSchedule } from './shared/fee.js';
+export type FetchFn = typeof fetch;
+export declare class ApiError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export interface PublicConfig {
+    referralAccount: string | null;
+    referralFeeBps: number;
+    fee: FeeSchedule;
+    burnShare: number;
+    seasonStart: string | null;
+    pointsEnabled: boolean;
+}
+export declare class PotswapApi {
+    private base;
+    private fetchFn;
+    private configCache;
+    private tokenCache;
+    constructor(base: string, fetchFn?: FetchFn);
+    private req;
+    config(): Promise<PublicConfig>;
+    order(p: {
+        inputMint: string;
+        outputMint: string;
+        amount: string;
+        taker?: string;
+        slippageBps?: number;
+        feeBps?: number;
+    }): Promise<OrderResponse>;
+    execute(signedTransaction: string, requestId: string): Promise<ExecuteResponse>;
+    searchTokens(query: string): Promise<Token[]>;
+    token(mint: string): Promise<Token>;
+    prices(mints: string[]): Promise<Record<string, number>>;
+    list(kind: string): Promise<TerminalToken[]>;
+    terminalToken(mint: string): Promise<TerminalToken>;
+    points(wallet: string): Promise<Record<string, unknown>>;
+    leaderboard(): Promise<Record<string, unknown>>;
+}

package/dist/api.js

@@ -0,0 +1,91 @@
+import { DEFAULT_FEE_SCHEDULE, parseFeeSchedule } from './shared/fee.js';
+export class ApiError extends Error {
+    status;
+    constructor(status, message) { super(message); this.status = status; }
+}
+export class PotswapApi {
+    base;
+    fetchFn;
+    configCache = null;
+    tokenCache = new Map();
+    constructor(base, fetchFn = fetch) { this.base = base; this.fetchFn = fetchFn; }
+    async req(path, init, retry = true) {
+        const res = await this.fetchFn(this.base + path, { ...init, headers: { accept: 'application/json', ...init?.headers } });
+        if (res.status === 429 || res.status === 503) {
+            if (retry) {
+                await new Promise((r) => setTimeout(r, 1100));
+                return this.req(path, init, false);
+            }
+            throw new ApiError(res.status, 'Potswap is busy; retry in a few seconds. No funds were debited.');
+        }
+        const text = await res.text();
+        let data = null;
+        try {
+            data = text ? JSON.parse(text) : null;
+        }
+        catch {
+            data = { error: text };
+        }
+        if (!res.ok) {
+            const msg = data?.error ?? data?.message ?? `HTTP ${res.status}`;
+            throw new ApiError(res.status, msg);
+        }
+        return data;
+    }
+    async config() {
+        if (this.configCache && Date.now() - this.configCache.at < 300_000)
+            return this.configCache.value;
+        let value;
+        try {
+            const raw = await this.req('/api/config');
+            value = { referralAccount: raw.referralAccount ?? null, referralFeeBps: raw.referralFeeBps ?? 0, fee: parseFeeSchedule(raw.fee), burnShare: raw.burnShare ?? 0.5, seasonStart: raw.seasonStart ?? null, pointsEnabled: !!raw.pointsEnabled };
+        }
+        catch {
+            value = { referralAccount: null, referralFeeBps: 0, fee: DEFAULT_FEE_SCHEDULE, burnShare: 0.5, seasonStart: null, pointsEnabled: false };
+        }
+        this.configCache = { value, at: Date.now() };
+        return value;
+    }
+    async order(p) {
+        const cfg = await this.config();
+        const q = new URLSearchParams({ inputMint: p.inputMint, outputMint: p.outputMint, amount: p.amount });
+        if (p.taker)
+            q.set('taker', p.taker);
+        if (p.slippageBps !== undefined)
+            q.set('slippageBps', String(p.slippageBps));
+        if (cfg.referralAccount) {
+            q.set('referralAccount', cfg.referralAccount);
+            q.set('referralFee', String(p.feeBps ?? cfg.fee.standardBps));
+        }
+        return this.req(`/api/jup/swap/v2/order?${q}`);
+    }
+    execute(signedTransaction, requestId) {
+        return this.req('/api/jup/swap/v2/execute', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ signedTransaction, requestId }) });
+    }
+    async searchTokens(query) {
+        const list = await this.req(`/api/jup/tokens/v2/search?query=${encodeURIComponent(query)}`);
+        for (const t of list)
+            this.tokenCache.set(t.id, t);
+        return list;
+    }
+    async token(mint) {
+        const hit = this.tokenCache.get(mint);
+        if (hit)
+            return hit;
+        const list = await this.searchTokens(mint);
+        const t = list.find((x) => x.id === mint);
+        if (!t)
+            throw new ApiError(404, `Unknown token ${mint}`);
+        return t;
+    }
+    async prices(mints) {
+        if (!mints.length)
+            return {};
+        const d = await this.req(`/api/price/v3?ids=${mints.join(',')}`.replace('/api/price', '/api/jup/price'));
+        return Object.fromEntries(Object.entries(d).map(([k, v]) => [k, v.usdPrice]));
+    }
+    list(kind) { return this.req(`/api/terminal/list/${kind}`); }
+    terminalToken(mint) { return this.req(`/api/terminal/token/${mint}`); }
+    points(wallet) { return this.req(`/api/points/${wallet}`); }
+    leaderboard() { return this.req('/api/leaderboard'); }
+}

package/dist/config.d.ts

@@ -0,0 +1,22 @@
+export interface Config {
+    apiBase: string;
+    rpcUrl: string;
+    maxTradeSol: number;
+    /** SOL-equivalent all strategies together may spend per UTC day (PRD P11.6). */
+    maxDailySol: number;
+    maxSlippageBps: number;
+    dryRun: boolean;
+    privateKey?: string;
+    keypairPath?: string;
+}
+export declare const DEFAULTS: {
+    apiBase: string;
+    maxTradeSol: number;
+    maxDailySol: number;
+    maxSlippageBps: number;
+    solReserve: number;
+};
+export declare function loadConfig(env?: NodeJS.ProcessEnv): Config;
+export declare const SOL_MINT = "So11111111111111111111111111111111111111112";
+export declare const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+export declare const NO_WALLET = "Wallet not configured. Set SOLANA_PRIVATE_KEY or SOLANA_KEYPAIR_PATH. No funds were debited.";

package/dist/config.js

@@ -0,0 +1,24 @@
+export const DEFAULTS = {
+    apiBase: 'https://www.potswap.io',
+    maxTradeSol: 1,
+    maxDailySol: 5,
+    maxSlippageBps: 300,
+    solReserve: 0.01,
+};
+export function loadConfig(env = process.env) {
+    const apiBase = (env.POTSWAP_API || DEFAULTS.apiBase).replace(/\/$/, '');
+    const num = (v, d) => { const n = Number(v); return v !== undefined && v !== '' && Number.isFinite(n) && n > 0 ? n : d; };
+    return {
+        apiBase,
+        rpcUrl: env.SOLANA_RPC_URL || `${apiBase}/api/rpc`,
+        maxTradeSol: num(env.POTSWAP_MAX_TRADE_SOL, DEFAULTS.maxTradeSol),
+        maxDailySol: num(env.POTSWAP_MAX_DAILY_SOL, DEFAULTS.maxDailySol),
+        maxSlippageBps: num(env.POTSWAP_MAX_SLIPPAGE_BPS, DEFAULTS.maxSlippageBps),
+        dryRun: /^(1|true|yes)$/i.test(env.POTSWAP_DRY_RUN ?? ''),
+        privateKey: env.SOLANA_PRIVATE_KEY || undefined,
+        keypairPath: env.SOLANA_KEYPAIR_PATH || undefined,
+    };
+}
+export const SOL_MINT = 'So11111111111111111111111111111111111111112';
+export const USDC_MINT = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
+export const NO_WALLET = 'Wallet not configured. Set SOLANA_PRIVATE_KEY or SOLANA_KEYPAIR_PATH. No funds were debited.';

package/dist/format.d.ts

@@ -0,0 +1,3 @@
+export declare function toRaw(amount: number | string, decimals: number): string;
+export declare const fromRaw: (raw: string | number | bigint, decimals: number) => number;
+export declare const explorer: (sig: string) => string;

package/dist/format.js

@@ -0,0 +1,7 @@
+export function toRaw(amount, decimals) {
+    const [i = '0', f = ''] = String(amount).replace(/,/g, '.').split('.');
+    const frac = (f + '0'.repeat(decimals)).slice(0, decimals);
+    return (BigInt(i || '0') * 10n ** BigInt(decimals) + BigInt(frac || '0')).toString();
+}
+export const fromRaw = (raw, decimals) => Number(BigInt(raw)) / 10 ** decimals;
+export const explorer = (sig) => `https://solscan.io/tx/${sig}`;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// Potswap MCP server over stdio, or `--daemon` to run strategies headlessly (PRD P11.11).
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createServer, VERSION } from './server.js';
+import { loadConfig } from './config.js';
+import { log } from './redact.js';
+import { createRuntime } from './runtime.js';
+const config = loadConfig();
+const daemon = process.argv.includes('--daemon');
+const rt = createRuntime(config);
+if (daemon) {
+    if (!rt.scheduler) {
+        log(`potswap-mcp v${VERSION}: another scheduler (pid ${rt.lockOwner}) already runs on ${rt.store.location}; exiting.`);
+        process.exit(2);
+    }
+    rt.scheduler.start();
+    log(`potswap-mcp v${VERSION} daemon · state=${rt.store.location} · maxTradeSol=${config.maxTradeSol} · maxDailySol=${config.maxDailySol}${config.dryRun ? ' · DRY RUN' : ''}${rt.signer ? ` · wallet=${rt.signer.publicKey}` : ' · no wallet (strategies cannot execute)'}`);
+    const shutdown = async () => { log('stopping after the in-flight leg…'); await rt.scheduler.stop(); rt.release(); process.exit(0); };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+else {
+    const server = createServer({ config, signer: rt.signer, strategyStore: rt.store, scheduler: rt.scheduler ?? undefined });
+    rt.scheduler?.start();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    log(`potswap-mcp v${VERSION} ready · api=${config.apiBase} · maxTradeSol=${config.maxTradeSol} · maxSlippageBps=${config.maxSlippageBps}${config.dryRun ? ' · DRY RUN' : ''}${rt.signer ? '' : ' · no wallet (read-only)'}${rt.scheduler ? ' · scheduler on' : ` · scheduler owned by pid ${rt.lockOwner}`}`);
+    process.on('exit', () => rt.release());
+}

package/dist/limits.d.ts

@@ -0,0 +1,13 @@
+export interface LimitInput {
+    amountUi: number;
+    inputMint: string;
+    inputSymbol: string;
+    inputUsd?: number;
+    solUsd?: number;
+    isSol: boolean;
+    slippageBps?: number;
+    maxTradeSol: number;
+    maxSlippageBps: number;
+    balanceUi?: number;
+}
+export declare function checkLimits(i: LimitInput): string | null;

package/dist/limits.js

@@ -0,0 +1,23 @@
+// PRD P10.6 — safety limits applied before anything is signed.
+import { DEFAULTS } from './config.js';
+export function checkLimits(i) {
+    if (!(i.amountUi > 0))
+        return 'Amount must be a positive number in UI units (1 = 1 SOL). No funds were debited.';
+    if (i.slippageBps !== undefined && i.slippageBps > i.maxSlippageBps) {
+        return `Refused by safety limit: slippage ${i.slippageBps / 100}% is above POTSWAP_MAX_SLIPPAGE_BPS (${i.maxSlippageBps / 100}%). No funds were debited.`;
+    }
+    const solEquivalent = i.isSol ? i.amountUi : i.inputUsd !== undefined && i.solUsd ? i.inputUsd / i.solUsd : undefined;
+    if (solEquivalent !== undefined && solEquivalent > i.maxTradeSol) {
+        const hint = i.amountUi >= 1_000_000 ? ' Hint: amount is in UI units (1 = 1 SOL), not lamports.' : '';
+        return `Refused by safety limit: ${i.amountUi} ${i.inputSymbol} ≈ ${solEquivalent.toFixed(3)} SOL is above POTSWAP_MAX_TRADE_SOL (${i.maxTradeSol}).${hint} No funds were debited.`;
+    }
+    if (i.balanceUi !== undefined) {
+        const spendable = i.isSol ? Math.max(i.balanceUi - DEFAULTS.solReserve, 0) : i.balanceUi;
+        if (i.amountUi > spendable) {
+            return i.isSol
+                ? `Insufficient SOL: balance ${i.balanceUi.toFixed(4)}, keep at least ${DEFAULTS.solReserve} SOL for fees. No funds were debited.`
+                : `Insufficient ${i.inputSymbol} balance (${i.balanceUi}). No funds were debited.`;
+        }
+    }
+    return null;
+}

package/dist/redact.d.ts

@@ -0,0 +1,5 @@
+export declare function registerSecret(s: string): void;
+export declare function redact(text: string): string;
+export declare function redactValue<T>(v: T): T;
+/** stderr logger (stdout is the MCP transport); always redacted. */
+export declare function log(...parts: unknown[]): void;

package/dist/redact.js

@@ -0,0 +1,23 @@
+// PRD P10.9 — anything that might contain a secret passes through redact() before leaving the process.
+const secrets = new Set();
+export function registerSecret(s) { if (s && s.length >= 16)
+    secrets.add(s); }
+export function redact(text) {
+    let out = text;
+    for (const s of secrets) {
+        if (out.includes(s))
+            out = out.split(s).join('[REDACTED]');
+        // JSON byte arrays can be re-serialised with different spacing: compare whitespace-free.
+        if (s.startsWith('[') && out.replace(/\s+/g, '').includes(s.replace(/\s+/g, ''))) {
+            out = out.replace(/\[\s*(?:\d{1,3}\s*,\s*){63}\d{1,3}\s*\]/g, '[REDACTED]');
+        }
+    }
+    return out;
+}
+export function redactValue(v) {
+    return JSON.parse(redact(JSON.stringify(v)));
+}
+/** stderr logger (stdout is the MCP transport); always redacted. */
+export function log(...parts) {
+    process.stderr.write(redact(parts.map((p) => (typeof p === 'string' ? p : JSON.stringify(p))).join(' ')) + '\n');
+}

package/dist/runtime.d.ts

@@ -0,0 +1,15 @@
+import type { Config } from './config.js';
+import { type Signer } from './wallet.js';
+import { type StrategyStore } from './strategies/store.js';
+import { Scheduler } from './strategies/scheduler.js';
+import type { BalancesFn, TradeContext } from './trade.js';
+export interface Runtime {
+    signer: Signer | null;
+    store: StrategyStore;
+    scheduler: Scheduler | null;
+    lockOwner: number | null;
+    trade: TradeContext;
+    release(): void;
+}
+export declare function createRuntime(config: Config): Runtime;
+export declare function rpcBalances(rpcUrl: string): BalancesFn;

package/dist/runtime.js

@@ -0,0 +1,39 @@
+// Wires config → signer, API, balances, strategy store, lock and scheduler. Used by index.ts (both modes).
+import { Connection, PublicKey } from '@solana/web3.js';
+import { PotswapApi } from './api.js';
+import { loadSigner } from './wallet.js';
+import { FileStore, defaultStateDir } from './strategies/store.js';
+import { acquireLock } from './strategies/lock.js';
+import { Scheduler } from './strategies/scheduler.js';
+export function createRuntime(config) {
+    const signer = loadSigner(config);
+    const api = new PotswapApi(config.apiBase);
+    const balances = rpcBalances(config.rpcUrl);
+    const trade = { api, config, signer, balances };
+    const dir = defaultStateDir();
+    const store = new FileStore(dir);
+    const lock = acquireLock(dir);
+    const scheduler = lock.acquired ? new Scheduler({ store, trade, maxDailySol: config.maxDailySol }) : null;
+    return { signer, store, scheduler, lockOwner: lock.ownerPid, trade, release: () => lock.release() };
+}
+export function rpcBalances(rpcUrl) {
+    const SOL = 'So11111111111111111111111111111111111111112';
+    return async (wallet) => {
+        const conn = new Connection(rpcUrl, 'confirmed');
+        const owner = new PublicKey(wallet);
+        const out = {};
+        const [lamports, spl, t22] = await Promise.all([
+            conn.getBalance(owner),
+            conn.getParsedTokenAccountsByOwner(owner, { programId: new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA') }),
+            conn.getParsedTokenAccountsByOwner(owner, { programId: new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb') }).catch(() => ({ value: [] })),
+        ]);
+        out[SOL] = lamports / 1e9;
+        for (const { account } of [...spl.value, ...t22.value]) {
+            const info = account.data.parsed?.info;
+            const ui = Number(info?.tokenAmount?.uiAmount ?? 0);
+            if (info && ui > 0)
+                out[info.mint] = (out[info.mint] ?? 0) + ui;
+        }
+        return out;
+    };
+}

package/dist/server.d.ts

@@ -0,0 +1,20 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type FetchFn } from './api.js';
+import { SOL_MINT, USDC_MINT, type Config } from './config.js';
+import { type BalancesFn } from './trade.js';
+import { type Signer } from './wallet.js';
+import type { StrategyStore } from './strategies/store.js';
+import type { Scheduler } from './strategies/scheduler.js';
+export declare const VERSION = "0.2.0";
+export interface ServerDeps {
+    config?: Config;
+    signer?: Signer | null;
+    fetchFn?: FetchFn;
+    /** Balance reader; defaults to an RPC connection. Injectable for tests. */
+    balances?: BalancesFn;
+    /** Strategy persistence and scheduler (P11); defaults are created from config when omitted. */
+    strategyStore?: StrategyStore;
+    scheduler?: Scheduler;
+}
+export declare function createServer(deps?: ServerDeps): McpServer;
+export { SOL_MINT, USDC_MINT };