@potswap_io/mcp 0.1.0 → 0.2.0

package/README.md

@@ -1,91 +1,114 @@
-# @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 0.5% fee inside the swap and returns it to the trading 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_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.
-
-## Fees and rewards
-
-Each swap carries Potswap's 0.5% integrator fee via Jupiter's referral program; Jupiter keeps 20% of it. 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
+# @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

@@ -1,5 +1,6 @@
 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;
@@ -8,6 +9,8 @@ export declare class ApiError extends Error {
 export interface PublicConfig {
     referralAccount: string | null;
     referralFeeBps: number;
+    fee: FeeSchedule;
+    burnShare: number;
     seasonStart: string | null;
     pointsEnabled: boolean;
 }
@@ -25,6 +28,7 @@ export declare class PotswapApi {
         amount: string;
         taker?: string;
         slippageBps?: number;
+        feeBps?: number;
     }): Promise<OrderResponse>;
     execute(signedTransaction: string, requestId: string): Promise<ExecuteResponse>;
     searchTokens(query: string): Promise<Token[]>;

package/dist/api.js

@@ -1,3 +1,4 @@
+import { DEFAULT_FEE_SCHEDULE, parseFeeSchedule } from './shared/fee.js';
 export class ApiError extends Error {
     status;
     constructor(status, message) { super(message); this.status = status; }
@@ -36,10 +37,11 @@ export class PotswapApi {
             return this.configCache.value;
         let value;
         try {
-            value = await this.req('/api/config');
+            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, seasonStart: null, pointsEnabled: false };
+            value = { referralAccount: null, referralFeeBps: 0, fee: DEFAULT_FEE_SCHEDULE, burnShare: 0.5, seasonStart: null, pointsEnabled: false };
         }
         this.configCache = { value, at: Date.now() };
         return value;
@@ -53,7 +55,7 @@ export class PotswapApi {
             q.set('slippageBps', String(p.slippageBps));
         if (cfg.referralAccount) {
             q.set('referralAccount', cfg.referralAccount);
-            q.set('referralFee', String(cfg.referralFeeBps));
+            q.set('referralFee', String(p.feeBps ?? cfg.fee.standardBps));
         }
         return this.req(`/api/jup/swap/v2/order?${q}`);
     }

package/dist/config.d.ts

@@ -2,6 +2,8 @@ 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;
@@ -10,6 +12,7 @@ export interface Config {
 export declare const DEFAULTS: {
     apiBase: string;
     maxTradeSol: number;
+    maxDailySol: number;
     maxSlippageBps: number;
     solReserve: number;
 };

package/dist/config.js

@@ -1,6 +1,7 @@
 export const DEFAULTS = {
     apiBase: 'https://www.potswap.io',
     maxTradeSol: 1,
+    maxDailySol: 5,
     maxSlippageBps: 300,
     solReserve: 0.01,
 };
@@ -11,6 +12,7 @@ export function loadConfig(env = process.env) {
         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,

package/dist/index.js

@@ -1,11 +1,29 @@
 #!/usr/bin/env node
-// Potswap MCP server over stdio. Configure via env (see README).
+// 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 server = createServer({ config });
-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' : ''}${config.privateKey || config.keypairPath ? '' : ' · no wallet (read-only)'}`);
+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/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

@@ -1,14 +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';
-export declare const VERSION = "0.1.0";
+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?: (wallet: string) => Promise<Record<string, number>>;
+    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 };

package/dist/server.js

@@ -1,16 +1,15 @@
 // PRD P10 — the Potswap MCP server. Tools are thin, safe wrappers over the Potswap API.
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { Connection, PublicKey, VersionedTransaction } from '@solana/web3.js';
+import { Connection, PublicKey } from '@solana/web3.js';
 import { z } from 'zod';
 import { PotswapApi, ApiError } from './api.js';
 import { loadConfig, NO_WALLET, SOL_MINT, USDC_MINT } from './config.js';
-import { checkLimits } from './limits.js';
-import { explorer, fromRaw, toRaw } from './format.js';
+import { buildQuote, executeSwap } from './trade.js';
 import { redact, redactValue } from './redact.js';
 import { loadSigner } from './wallet.js';
-import { describeOrderError, friendlyError } from './shared/errors.js';
 import { riskBadges, riskLevel } from './shared/risk.js';
-export const VERSION = '0.1.0';
+import { registerStrategyTools } from './strategies/tools.js';
+export const VERSION = '0.2.0';
 const ok = (data, summary) => ({
     content: [{ type: 'text', text: redact(summary ?? JSON.stringify(data, null, 2)) }], structuredContent: redactValue(data),
 });
@@ -22,6 +21,7 @@ export function createServer(deps = {}) {
     const signer = deps.signer !== undefined ? deps.signer : loadSigner(config);
     const api = new PotswapApi(config.apiBase, deps.fetchFn);
     const readBalances = deps.balances ?? rpcBalances(config.rpcUrl);
+    const trade = { api, config, signer, balances: readBalances };
     const server = new McpServer({ name: 'potswap', version: VERSION });
     const walletOr = (w) => w ?? signer?.publicKey ?? null;
     server.registerTool('search_tokens', {
@@ -73,7 +73,7 @@ export function createServer(deps = {}) {
     }, async (a) => {
         try {
             const q = await buildQuote(api, a);
-            return ok(q, `${a.amount} ${q.inputSymbol} → ${q.outAmount} ${q.outputSymbol} via ${q.router} (fee ${q.feeBps} bps, impact ${q.priceImpactPct}%)`);
+            return ok({ ...q }, `${a.amount} ${q.inputSymbol} → ${q.outAmount} ${q.outputSymbol} via ${q.router} (fee ${q.feeLabel ?? `${q.feeBps} bps`}, impact ${q.priceImpactPct}%)`);
         }
         catch (e) {
             return fail(msg(e));
@@ -84,48 +84,14 @@ export function createServer(deps = {}) {
         description: 'Executes a swap at the best route. Requires confirm=true; otherwise returns the quote only. Protected by POTSWAP_MAX_TRADE_SOL and POTSWAP_MAX_SLIPPAGE_BPS. Every error states whether funds were debited.',
         inputSchema: { ...quoteShape, confirm: z.boolean().default(false), maxSlippageBps: z.number().int().min(1).max(5000).optional() },
     }, async (a) => {
-        if (!signer)
-            return fail(NO_WALLET);
-        try {
-            const q = await buildQuote(api, a);
-            const slippageBps = a.slippageBps ?? a.maxSlippageBps;
-            const prices = await api.prices([SOL_MINT, a.inputMint]).catch(() => ({}));
-            let balanceUi;
-            try {
-                balanceUi = (await readBalances(signer.publicKey))[a.inputMint] ?? 0;
-            }
-            catch {
-                balanceUi = undefined;
-            }
-            const refusal = checkLimits({
-                amountUi: a.amount, inputMint: a.inputMint, inputSymbol: q.inputSymbol, isSol: a.inputMint === SOL_MINT,
-                inputUsd: prices[a.inputMint] ? a.amount * prices[a.inputMint] : undefined, solUsd: prices[SOL_MINT],
-                slippageBps, maxTradeSol: config.maxTradeSol, maxSlippageBps: config.maxSlippageBps, balanceUi,
-            });
-            if (refusal)
-                return fail(refusal, { quote: q });
-            if (!a.confirm)
-                return ok({ confirmRequired: true, quote: q }, `Quote only (confirm=true to execute): ${a.amount} ${q.inputSymbol} → ${q.outAmount} ${q.outputSymbol} via ${q.router}`);
-            if (config.dryRun)
-                return ok({ dryRun: true, quote: q }, `DRY RUN, nothing signed: ${a.amount} ${q.inputSymbol} → ${q.outAmount} ${q.outputSymbol}`);
-            const order = await api.order({ inputMint: a.inputMint, outputMint: a.outputMint, amount: q.inAmountRaw, taker: signer.publicKey, slippageBps });
-            if (!order.transaction)
-                return fail(`${describeOrderError(order)} No funds were debited.`, { quote: q });
-            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 fail(friendlyError(res.error || `Swap failed (code ${res.code})`), { 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 = prices[a.inputMint] ? a.amount * prices[a.inputMint] * feeBps / 10_000 : undefined;
-            const cfg = await api.config();
-            const result = { signature: res.signature, explorerUrl: explorer(res.signature), inAmount: a.amount, inputSymbol: q.inputSymbol, outAmount, outputSymbol: q.outputSymbol, router: order.router, feeBps, feeUsd, pointsAdded: cfg.referralAccount ? feeUsd : 0 };
-            return ok(result, `Swapped ${a.amount} ${q.inputSymbol} → ${outAmount} ${q.outputSymbol} via ${order.router}. ${explorer(res.signature)}`);
-        }
-        catch (e) {
-            return fail(friendlyError(msg(e)));
+        const out = await executeSwap(trade, { inputMint: a.inputMint, outputMint: a.outputMint, amount: a.amount, slippageBps: a.slippageBps ?? a.maxSlippageBps, confirm: a.confirm });
+        switch (out.kind) {
+            case 'no-wallet': return fail(out.message);
+            case 'refused': return fail(out.message, { quote: out.quote });
+            case 'quote-only': return ok({ confirmRequired: true, quote: out.quote }, `Quote only (confirm=true to execute): ${a.amount} ${out.quote.inputSymbol} → ${out.quote.outAmount} ${out.quote.outputSymbol} via ${out.quote.router}`);
+            case 'dry-run': return ok({ dryRun: true, quote: out.quote }, `DRY RUN, nothing signed: ${a.amount} ${out.quote.inputSymbol} → ${out.quote.outAmount} ${out.quote.outputSymbol}`);
+            case 'failed': return fail(out.message, { signature: out.signature, explorerUrl: out.explorerUrl, quote: out.quote });
+            case 'ok': return ok({ ...out.result }, `Swapped ${a.amount} ${out.result.inputSymbol} → ${out.result.outAmount} ${out.result.outputSymbol} via ${out.result.router}. ${out.result.explorerUrl}`);
         }
     });
     server.registerTool('get_balances', {
@@ -199,6 +165,7 @@ export function createServer(deps = {}) {
             return fail(msg(e));
         }
     });
+    registerStrategyTools(server, { trade, store: deps.strategyStore, scheduler: deps.scheduler });
     return server;
 }
 const quoteShape = {
@@ -207,21 +174,6 @@ const quoteShape = {
     amount: z.number().positive().describe('Amount in UI units of the input token (1 = 1 SOL)'),
     slippageBps: z.number().int().min(1).max(5000).optional().describe('Fixed slippage in bps; omit for auto'),
 };
-async function buildQuote(api, a) {
-    const [inTok, outTok] = await Promise.all([api.token(a.inputMint), api.token(a.outputMint)]);
-    const inAmountRaw = toRaw(a.amount, inTok.decimals);
-    const o = await api.order({ inputMint: a.inputMint, outputMint: a.outputMint, amount: inAmountRaw, slippageBps: a.slippageBps });
-    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, router: o.router, requestId: o.requestId,
-        expiresAt: o.expireAt ?? null,
-    };
-}
 function slimToken(t) {
     return { mint: t.id, symbol: t.symbol, name: t.name, decimals: t.decimals, usdPrice: t.usdPrice, mcap: t.mcap, liquidity: t.liquidity, isVerified: t.isVerified ?? false };
 }

package/dist/shared/fee.d.ts

@@ -0,0 +1,24 @@
+export interface FeeSchedule {
+    standardBps: number;
+    sizeBps: number;
+    sizeThresholdUsd: number;
+    stakerDiscountBps: number;
+    /** POT that must be staked for the discount; null until TGE (discount disabled). */
+    stakerMinPot: number | null;
+}
+export declare const JUP_MIN_BPS = 50;
+export declare const JUP_MAX_BPS = 255;
+export declare const DEFAULT_FEE_SCHEDULE: FeeSchedule;
+export type FeeTier = 'standard' | 'size' | 'staker';
+export interface FeeDecision {
+    bps: number;
+    tier: FeeTier;
+    label: string;
+}
+/**
+ * @param inputUsd USD value of the input amount at quote time; undefined when no price is known (→ standard tier)
+ * @param stakedPot POT staked by the wallet; 0 / undefined when unknown
+ */
+export declare function feeBpsFor(schedule: FeeSchedule, inputUsd?: number, stakedPot?: number): FeeDecision;
+/** Parses the schedule from /api/config, falling back to defaults field by field. */
+export declare function parseFeeSchedule(raw: unknown): FeeSchedule;

package/dist/shared/fee.js

@@ -0,0 +1,42 @@
+// GENERATED by scripts/sync-shared.mjs from app/src/lib/fee.ts. Do not edit here.
+// PRD P8.12–P8.15 — the fee schedule. One pure function shared by the web app and the MCP
+// (mcp/src/shared/fee.ts is a generated copy). Jupiter allows 50–255 bps.
+export const JUP_MIN_BPS = 50;
+export const JUP_MAX_BPS = 255;
+export const DEFAULT_FEE_SCHEDULE = {
+    standardBps: 250,
+    sizeBps: 100,
+    sizeThresholdUsd: 1000,
+    stakerDiscountBps: 100,
+    stakerMinPot: null,
+};
+const clamp = (bps) => Math.min(JUP_MAX_BPS, Math.max(JUP_MIN_BPS, Math.round(bps)));
+/**
+ * @param inputUsd USD value of the input amount at quote time; undefined when no price is known (→ standard tier)
+ * @param stakedPot POT staked by the wallet; 0 / undefined when unknown
+ */
+export function feeBpsFor(schedule, inputUsd, stakedPot = 0) {
+    const size = inputUsd !== undefined && inputUsd >= schedule.sizeThresholdUsd;
+    let bps = size ? schedule.sizeBps : schedule.standardBps;
+    let tier = size ? 'size' : 'standard';
+    if (schedule.stakerMinPot !== null && stakedPot >= schedule.stakerMinPot) {
+        bps -= schedule.stakerDiscountBps;
+        tier = 'staker';
+    }
+    bps = clamp(bps);
+    const pct = `${bps / 100}%`;
+    const label = tier === 'standard' ? pct : tier === 'size' ? `${pct} (size tier)` : `${pct} (staker)`;
+    return { bps, tier, label };
+}
+/** Parses the schedule from /api/config, falling back to defaults field by field. */
+export function parseFeeSchedule(raw) {
+    const r = (raw ?? {});
+    const num = (v, d) => (typeof v === 'number' && Number.isFinite(v) ? v : d);
+    return {
+        standardBps: clamp(num(r.standardBps, DEFAULT_FEE_SCHEDULE.standardBps)),
+        sizeBps: clamp(num(r.sizeBps, DEFAULT_FEE_SCHEDULE.sizeBps)),
+        sizeThresholdUsd: num(r.sizeThresholdUsd, DEFAULT_FEE_SCHEDULE.sizeThresholdUsd),
+        stakerDiscountBps: num(r.stakerDiscountBps, DEFAULT_FEE_SCHEDULE.stakerDiscountBps),
+        stakerMinPot: typeof r.stakerMinPot === 'number' && r.stakerMinPot > 0 ? r.stakerMinPot : null,
+    };
+}