@potswap_io/mcp 0.1.0 → 0.3.0

package/dist/history.d.ts

@@ -0,0 +1,72 @@
+export interface HeliusTx {
+    signature: string;
+    timestamp: number;
+    type?: string;
+    source?: string;
+    fee?: number;
+    feePayer?: string;
+    transactionError?: unknown;
+    nativeTransfers?: {
+        fromUserAccount?: string;
+        toUserAccount?: string;
+        amount?: number;
+    }[];
+    tokenTransfers?: {
+        fromUserAccount?: string;
+        toUserAccount?: string;
+        tokenAmount?: number;
+        mint?: string;
+    }[];
+    events?: {
+        swap?: {
+            nativeInput?: {
+                account: string;
+                amount: string;
+            } | null;
+            nativeOutput?: {
+                account: string;
+                amount: string;
+            } | null;
+            tokenInputs?: {
+                userAccount: string;
+                mint: string;
+                rawTokenAmount: {
+                    tokenAmount: string;
+                    decimals: number;
+                };
+            }[];
+            tokenOutputs?: {
+                userAccount: string;
+                mint: string;
+                rawTokenAmount: {
+                    tokenAmount: string;
+                    decimals: number;
+                };
+            }[];
+        };
+    };
+}
+export declare const SOL = "So11111111111111111111111111111111111111112";
+export interface HistoryItem {
+    signature: string;
+    time: string;
+    kind: 'swap' | 'transfer' | 'other';
+    source?: string;
+    feeSol: number;
+    failed: boolean;
+    /** For swaps: what the wallet gave and got. For transfers: amount and direction. */
+    inMint?: string;
+    inAmount?: number;
+    outMint?: string;
+    outAmount?: number;
+    direction?: 'in' | 'out';
+    counterparty?: string;
+    mint?: string;
+    amount?: number;
+}
+export declare function normalizeHistory(txs: HeliusTx[], wallet: string): HistoryItem[];
+export type TxStatus = 'not found' | 'processed' | 'confirmed' | 'finalized' | 'failed';
+export declare function mapSignatureStatus(s: {
+    confirmationStatus?: string;
+    err?: unknown;
+} | null): TxStatus;

package/dist/history.js

@@ -0,0 +1,53 @@
+export const SOL = 'So11111111111111111111111111111111111111112';
+export function normalizeHistory(txs, wallet) {
+    return txs.map((t) => {
+        const base = { signature: t.signature, time: new Date((t.timestamp ?? 0) * 1000).toISOString(), kind: 'other', source: t.source, feeSol: (t.fee ?? 0) / 1e9, failed: !!t.transactionError };
+        const sw = t.events?.swap;
+        if (sw) {
+            // Determine what this wallet put in and took out.
+            let inMint, inAmount = 0, outMint, outAmount = 0;
+            if (sw.nativeInput && sw.nativeInput.account === wallet) {
+                inMint = SOL;
+                inAmount = Number(sw.nativeInput.amount) / 1e9;
+            }
+            if (sw.nativeOutput && sw.nativeOutput.account === wallet) {
+                outMint = SOL;
+                outAmount = Number(sw.nativeOutput.amount) / 1e9;
+            }
+            for (const i of sw.tokenInputs ?? [])
+                if (i.userAccount === wallet) {
+                    inMint = i.mint;
+                    inAmount += Number(i.rawTokenAmount.tokenAmount) / 10 ** i.rawTokenAmount.decimals;
+                }
+            for (const o of sw.tokenOutputs ?? [])
+                if (o.userAccount === wallet) {
+                    outMint = o.mint;
+                    outAmount += Number(o.rawTokenAmount.tokenAmount) / 10 ** o.rawTokenAmount.decimals;
+                }
+            if (inMint || outMint)
+                return { ...base, kind: 'swap', inMint, inAmount, outMint, outAmount };
+        }
+        const tt = (t.tokenTransfers ?? []).find((x) => x.fromUserAccount === wallet || x.toUserAccount === wallet);
+        if (tt && tt.mint && tt.tokenAmount) {
+            const out = tt.fromUserAccount === wallet;
+            return { ...base, kind: 'transfer', direction: out ? 'out' : 'in', counterparty: out ? tt.toUserAccount : tt.fromUserAccount, mint: tt.mint, amount: tt.tokenAmount };
+        }
+        const nt = (t.nativeTransfers ?? []).find((x) => (x.fromUserAccount === wallet || x.toUserAccount === wallet) && (x.amount ?? 0) > 0);
+        if (nt) {
+            const out = nt.fromUserAccount === wallet;
+            return { ...base, kind: 'transfer', direction: out ? 'out' : 'in', counterparty: out ? nt.toUserAccount : nt.fromUserAccount, mint: SOL, amount: (nt.amount ?? 0) / 1e9 };
+        }
+        return base;
+    });
+}
+export function mapSignatureStatus(s) {
+    if (!s)
+        return 'not found';
+    if (s.err)
+        return 'failed';
+    if (s.confirmationStatus === 'finalized')
+        return 'finalized';
+    if (s.confirmationStatus === 'confirmed')
+        return 'confirmed';
+    return 'processed';
+}

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/pnl.d.ts

@@ -0,0 +1,16 @@
+import type { HistoryItem } from './history.js';
+export interface Position {
+    mint: string;
+    amount: number;
+    avgCostUsd?: number;
+    costBasisUsd?: number;
+    valueUsd?: number;
+    unrealisedUsd?: number;
+    realisedUsd: number;
+}
+/**
+ * Walks swaps oldest→newest. A swap "buys" its outMint at (inAmount × price(inMint at the time)) and
+ * "sells" its inMint. Price history is approximated with current prices unless the item carries `inUsd`.
+ * Good enough for an agent dashboard; exact fills come from the on-chain record.
+ */
+export declare function computePositions(history: HistoryItem[], balances: Record<string, number>, prices: Record<string, number>, quoteMints?: Set<string>): Position[];

package/dist/pnl.js

@@ -0,0 +1,45 @@
+import { SOL } from './history.js';
+/**
+ * Walks swaps oldest→newest. A swap "buys" its outMint at (inAmount × price(inMint at the time)) and
+ * "sells" its inMint. Price history is approximated with current prices unless the item carries `inUsd`.
+ * Good enough for an agent dashboard; exact fills come from the on-chain record.
+ */
+export function computePositions(history, balances, prices, quoteMints = new Set([SOL])) {
+    const lots = {};
+    const items = [...history].filter((h) => h.kind === 'swap' && !h.failed).sort((a, b) => a.time.localeCompare(b.time));
+    for (const h of items) {
+        const inUsd = h.inUsd ?? (h.inMint && prices[h.inMint] ? (h.inAmount ?? 0) * prices[h.inMint] : undefined);
+        // sell side
+        if (h.inMint && !quoteMints.has(h.inMint) && h.inAmount) {
+            const l = (lots[h.inMint] ??= { amount: 0, cost: 0, realised: 0 });
+            const avg = l.amount > 0 ? l.cost / l.amount : 0;
+            const sold = Math.min(h.inAmount, l.amount);
+            const proceeds = h.outMint && prices[h.outMint] ? (h.outAmount ?? 0) * prices[h.outMint] : inUsd ?? 0;
+            l.realised += proceeds - sold * avg;
+            l.amount -= sold;
+            l.cost -= sold * avg;
+            if (l.amount < 1e-12) {
+                l.amount = 0;
+                l.cost = 0;
+            }
+        }
+        // buy side
+        if (h.outMint && !quoteMints.has(h.outMint) && h.outAmount && inUsd !== undefined) {
+            const l = (lots[h.outMint] ??= { amount: 0, cost: 0, realised: 0 });
+            l.amount += h.outAmount;
+            l.cost += inUsd;
+        }
+    }
+    const mints = new Set([...Object.keys(balances), ...Object.keys(lots)].filter((m) => !quoteMints.has(m)));
+    return [...mints].map((mint) => {
+        const amount = balances[mint] ?? 0;
+        const l = lots[mint];
+        const avg = l && l.amount > 0 ? l.cost / l.amount : undefined;
+        const price = prices[mint];
+        const value = price !== undefined ? amount * price : undefined;
+        return {
+            mint, amount, avgCostUsd: avg, costBasisUsd: avg !== undefined ? amount * avg : undefined, valueUsd: value,
+            unrealisedUsd: value !== undefined && avg !== undefined ? value - amount * avg : undefined, realisedUsd: l?.realised ?? 0,
+        };
+    }).filter((p) => p.amount > 0 || p.realisedUsd !== 0).sort((a, b) => (b.valueUsd ?? 0) - (a.valueUsd ?? 0));
+}

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 } from './strategies/store.js';
+import { acquireLock } from './strategies/lock.js';
+import { Scheduler } from './strategies/scheduler.js';
+export function createRuntime(config) {
+    const signer = loadSigner({ privateKey: config.privateKey, keypairPath: config.keypairPath, stateDir: config.stateDir });
+    const api = new PotswapApi(config.apiBase);
+    const balances = rpcBalances(config.rpcUrl);
+    const trade = { api, config, signer, balances };
+    const dir = config.stateDir;
+    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,25 @@
 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 TxRpc } from './agentTools.js';
+import type { Rpc } from './transfer.js';
+import type { StrategyStore } from './strategies/store.js';
+import type { Scheduler } from './strategies/scheduler.js';
+export declare const VERSION = "0.3.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;
+    /** Transfer / transaction RPC surfaces; injectable for tests (P13). */
+    rpc?: Rpc;
+    txRpc?: TxRpc;
 }
 export declare function createServer(deps?: ServerDeps): McpServer;
 export { SOL_MINT, USDC_MINT };

package/dist/server.js

@@ -1,16 +1,16 @@
 // 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';
+import { registerAgentTools } from './agentTools.js';
+export const VERSION = '0.3.0';
 const ok = (data, summary) => ({
     content: [{ type: 'text', text: redact(summary ?? JSON.stringify(data, null, 2)) }], structuredContent: redactValue(data),
 });
@@ -19,9 +19,10 @@ const fail = (message, extra = {}) => ({
 });
 export function createServer(deps = {}) {
     const config = deps.config ?? loadConfig();
-    const signer = deps.signer !== undefined ? deps.signer : loadSigner(config);
+    const signer = deps.signer !== undefined ? deps.signer : loadSigner({ privateKey: config.privateKey, keypairPath: config.keypairPath, stateDir: config.stateDir });
     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 +74,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 +85,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', {
@@ -148,26 +115,6 @@ export function createServer(deps = {}) {
             return fail(msg(e));
         }
     });
-    server.registerTool('get_positions', {
-        title: 'Positions',
-        description: 'Token holdings with 24h price change (PnL arrives in a later version).',
-        inputSchema: { wallet: z.string().regex(/^[1-9A-HJ-NP-Za-km-z]{32,44}$/).optional() },
-    }, async ({ wallet }) => {
-        const w = walletOr(wallet);
-        if (!w)
-            return fail(NO_WALLET);
-        try {
-            const bal = await readBalances(w);
-            const mints = Object.keys(bal).filter((m) => m !== SOL_MINT).slice(0, 20);
-            const infos = mints.length ? await api.searchTokens(mints.join(',')).catch(() => []) : [];
-            const prices = await api.prices([SOL_MINT, ...mints]).catch(() => ({}));
-            const positions = mints.map((m) => { const t = infos.find((x) => x.id === m); return { mint: m, symbol: t?.symbol ?? m.slice(0, 4), amount: bal[m], usd: prices[m] ? bal[m] * prices[m] : undefined }; });
-            return ok({ wallet: w, sol: bal[SOL_MINT] ?? 0, solUsd: prices[SOL_MINT] ? (bal[SOL_MINT] ?? 0) * prices[SOL_MINT] : undefined, positions });
-        }
-        catch (e) {
-            return fail(msg(e));
-        }
-    });
     server.registerTool('get_points', {
         title: 'POT points',
         description: "Season 1 points for a wallet: this epoch, all-time, POT allocated and claimable, next unlock. Defaults to the agent wallet.",
@@ -199,6 +146,8 @@ export function createServer(deps = {}) {
             return fail(msg(e));
         }
     });
+    registerAgentTools(server, { trade, config, rpc: deps.rpc, txRpc: deps.txRpc, schedulerActive: () => !!deps.scheduler?.active });
+    registerStrategyTools(server, { trade, store: deps.strategyStore, scheduler: deps.scheduler });
     return server;
 }
 const quoteShape = {
@@ -207,21 +156,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,
+    };
+}

package/dist/strategies/engine.d.ts

@@ -0,0 +1,43 @@
+import type { DcaStrategy, LimitStrategy, RebalanceStrategy, Run, Strategy, TpSlStrategy } from './types.js';
+export declare const SOL_MINT = "So11111111111111111111111111111111111111112";
+/** True when a time-based strategy should run at `now`. */
+export declare function isDue(s: Strategy, now: number): boolean;
+/**
+ * Next run after a run at `now`. A missed window runs once; the next slot is
+ * always in the future (P11.2), never a catch-up burst.
+ */
+export declare function nextRunAfter(s: DcaStrategy | RebalanceStrategy, now: number): string;
+export declare function dcaIsComplete(s: DcaStrategy): boolean;
+export interface Leg {
+    inputMint: string;
+    outputMint: string;
+    amount: number;
+    reason: string;
+}
+/**
+ * Rebalance plan (P11.4): weights from balances × prices; assets drifting more than
+ * `driftPct` points are brought back via SOL. Returns [] when nothing drifts.
+ * Unpriced targets are excluded and reported in `warnings`.
+ */
+export declare function rebalancePlan(s: RebalanceStrategy, balances: Record<string, number>, prices: Record<string, number>): {
+    legs: Leg[];
+    warnings: string[];
+    weights: Record<string, number>;
+};
+export type TpSlTrigger = {
+    trigger: 'take-profit' | 'stop-loss' | 'trailing-stop';
+    threshold: number;
+} | null;
+/** TP/SL decision (P11.5). `price` undefined = no decision. Returns the updated high-water mark too. */
+export declare function tpslDecision(s: TpSlStrategy, price: number | undefined): {
+    trigger: TpSlTrigger;
+    highWater: number;
+};
+/** SOL-equivalent spent by all strategies in the UTC day containing `now` (P11.6). */
+export declare function solSpentToday(runs: Run[], now: number): number;
+export declare function dcaLegFor(s: DcaStrategy): Leg;
+/** Limit order decision (P13.10): 'fill' when the condition holds, 'expired' past expiresAt, else null. */
+export declare function limitDecision(s: LimitStrategy, price: number | undefined, now: number): 'fill' | 'expired' | null;
+export declare function limitLegFor(s: LimitStrategy): Leg;
+export declare const MAX_CONSECUTIVE_FAILURES = 3;
+export declare function newId(prefix: string, now?: number): string;