@potswap_io/mcp 0.0.0-stage → 0.2.0

package/dist/strategies/scheduler.d.ts

@@ -0,0 +1,38 @@
+import type { TradeContext } from '../trade.js';
+import type { StrategyStore } from './store.js';
+import type { Run } from './types.js';
+export interface SchedulerOptions {
+    store: StrategyStore;
+    trade: TradeContext;
+    maxDailySol: number;
+    now?: () => number;
+    tickMs?: number;
+    onRun?: (run: Run) => void;
+}
+export declare class Scheduler {
+    private store;
+    private trade;
+    private maxDailySol;
+    private now;
+    private tickMs;
+    private onRun?;
+    private timer;
+    private running;
+    /** Set while a leg executes so a stop() can wait for it (P11.11). */
+    inFlight: Promise<void> | null;
+    active: boolean;
+    constructor(o: SchedulerOptions);
+    start(): void;
+    stop(): Promise<void>;
+    /** One pass over all strategies. Safe to call concurrently; overlapping calls are skipped. */
+    tick(): Promise<void>;
+    private runTick;
+    private runDca;
+    private runRebalance;
+    private checkTpSl;
+    private execute;
+    private record;
+    private bumpFailure;
+    private advance;
+    private complete;
+}

package/dist/strategies/scheduler.js

@@ -0,0 +1,219 @@
+import { executeSwap } from '../trade.js';
+import { log } from '../redact.js';
+import { dcaIsComplete, dcaLegFor, isDue, MAX_CONSECUTIVE_FAILURES, nextRunAfter, newId, rebalancePlan, solSpentToday, tpslDecision } from './engine.js';
+export class Scheduler {
+    store;
+    trade;
+    maxDailySol;
+    now;
+    tickMs;
+    onRun;
+    timer = null;
+    running = false;
+    /** Set while a leg executes so a stop() can wait for it (P11.11). */
+    inFlight = null;
+    active = false;
+    constructor(o) {
+        this.store = o.store;
+        this.trade = o.trade;
+        this.maxDailySol = o.maxDailySol;
+        this.now = o.now ?? Date.now;
+        this.tickMs = o.tickMs ?? 30_000;
+        this.onRun = o.onRun;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.active = true;
+        this.timer = setInterval(() => { void this.tick(); }, this.tickMs);
+        void this.tick();
+    }
+    async stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        this.active = false;
+        if (this.inFlight)
+            await this.inFlight;
+    }
+    /** One pass over all strategies. Safe to call concurrently; overlapping calls are skipped. */
+    async tick() {
+        if (this.running)
+            return;
+        this.running = true;
+        const p = this.runTick().catch((e) => log('scheduler tick error', e instanceof Error ? e.message : String(e)));
+        this.inFlight = p;
+        try {
+            await p;
+        }
+        finally {
+            this.running = false;
+            this.inFlight = null;
+        }
+    }
+    async runTick() {
+        const now = this.now();
+        const state = this.store.load();
+        for (const s of state.strategies) {
+            if (s.status !== 'active')
+                continue;
+            if (s.kind === 'tpsl')
+                await this.checkTpSl(s);
+            else if (isDue(s, now))
+                await (s.kind === 'dca' ? this.runDca(s) : this.runRebalance(s));
+        }
+    }
+    // ---- DCA (P11.1–P11.3)
+    async runDca(s) {
+        const leg = dcaLegFor(s);
+        const out = await this.execute(s, leg);
+        this.store.update((st) => {
+            const cur = st.strategies.find((x) => x.id === s.id);
+            if (!cur || cur.status !== 'active')
+                return;
+            const now = this.now();
+            if (out.kind === 'ok' || out.kind === 'dry-run')
+                cur.runsDone++;
+            cur.nextRunAt = nextRunAfter(cur, now);
+            if (dcaIsComplete(cur)) {
+                cur.status = 'completed';
+                cur.nextRunAt = null;
+            }
+        });
+    }
+    // ---- Rebalance (P11.4)
+    async runRebalance(s) {
+        const wallet = this.trade.signer?.publicKey;
+        let balances = {}, prices = {};
+        try {
+            balances = wallet ? await this.trade.balances(wallet) : {};
+            prices = await this.trade.api.prices(Object.keys(s.targets));
+        }
+        catch (e) {
+            this.record(s, 'check', 'failed', `Could not read balances or prices: ${e instanceof Error ? e.message : String(e)}. No funds were debited.`);
+            this.bumpFailure(s.id);
+            this.advance(s.id);
+            return;
+        }
+        const plan = rebalancePlan(s, balances, prices);
+        for (const w of plan.warnings)
+            this.record(s, 'check', 'skipped', w);
+        if (plan.legs.length === 0) {
+            this.record(s, 'check', 'no-op', `Within ${s.driftPct}% of target: ${Object.entries(plan.weights).map(([m, w]) => `${short(m)} ${w.toFixed(1)}%`).join(', ')}`);
+        }
+        else {
+            for (const leg of plan.legs)
+                await this.execute(s, leg);
+        }
+        this.advance(s.id);
+    }
+    // ---- TP/SL (P11.5)
+    async checkTpSl(s) {
+        let price;
+        try {
+            price = (await this.trade.api.prices([s.mint]))[s.mint];
+        }
+        catch {
+            price = undefined;
+        }
+        if (price === undefined) {
+            this.record(s, 'check', 'skipped', 'price unavailable');
+            return;
+        }
+        const { trigger, highWater } = tpslDecision(s, price);
+        this.store.update((st) => { const cur = st.strategies.find((x) => x.id === s.id); if (cur)
+            cur.highWater = highWater; });
+        if (!trigger)
+            return;
+        const wallet = this.trade.signer?.publicKey;
+        const held = wallet ? (await this.trade.balances(wallet).catch(() => ({})))[s.mint] ?? 0 : 0;
+        const amount = Math.floor(held * (s.sellPct / 100) * 1e9) / 1e9;
+        if (amount <= 0) {
+            this.record(s, `sell ${s.sellPct}% (${trigger.trigger})`, 'completed', 'Nothing to sell; completing.');
+            this.complete(s.id);
+            return;
+        }
+        const out = await this.execute(s, { inputMint: s.mint, outputMint: s.exitMint, amount, reason: `${trigger.trigger} at ${price} (threshold ${trigger.threshold.toPrecision(6)})` });
+        if (out.kind === 'ok' || out.kind === 'dry-run')
+            this.complete(s.id);
+    }
+    // ---- shared leg execution with caps, run log, failure counting (P11.6–P11.8, P11.13)
+    async execute(s, leg) {
+        const now = this.now();
+        const spent = solSpentToday(this.store.load().runs, now);
+        const remainingSol = Math.max(0, this.maxDailySol - spent);
+        const out = await executeSwap(this.trade, {
+            inputMint: leg.inputMint, outputMint: leg.outputMint, amount: leg.amount, slippageBps: s.maxSlippageBps, confirm: true,
+            extraSolCap: { remainingSol, label: `Daily cap reached (${this.maxDailySol} SOL). Next legs resume at 00:00 UTC.` },
+        });
+        const action = `${leg.amount} ${short(leg.inputMint)} → ${short(leg.outputMint)} (${leg.reason})`;
+        switch (out.kind) {
+            case 'ok': {
+                const r = out.result;
+                this.record(s, action, 'ok', undefined, { signature: r.signature, inAmount: r.inAmount, inputSymbol: r.inputSymbol, outAmount: r.outAmount, outputSymbol: r.outputSymbol, feeUsd: r.feeUsd, pointsAdded: r.pointsAdded, solEquivalent: r.solEquivalent });
+                this.store.update((st) => {
+                    const cur = st.strategies.find((x) => x.id === s.id);
+                    if (!cur)
+                        return;
+                    cur.consecutiveFailures = 0;
+                    cur.totals.runs++;
+                    cur.totals.feeUsd += r.feeUsd ?? 0;
+                    cur.totals.pointsAdded += r.pointsAdded ?? 0;
+                    cur.totals.volumeUsd += out.quote.inputUsd ?? 0;
+                });
+                break;
+            }
+            case 'dry-run':
+                this.record(s, action, 'dry-run', `Would swap for ${out.quote.outAmount} ${out.quote.outputSymbol} via ${out.quote.router}`);
+                break;
+            case 'refused':
+                this.record(s, action, 'skipped', out.message);
+                break;
+            case 'quote-only':
+                this.record(s, action, 'skipped', 'internal: confirm missing');
+                break;
+            case 'no-wallet':
+                this.record(s, action, 'failed', out.message);
+                this.bumpFailure(s.id);
+                break;
+            case 'failed':
+                this.record(s, action, 'failed', out.message, { signature: out.signature });
+                this.bumpFailure(s.id);
+                break;
+        }
+        return out;
+    }
+    record(s, action, outcome, message, extra = {}) {
+        const run = { id: newId('run', this.now()), strategyId: s.id, at: new Date(this.now()).toISOString(), action, outcome, message, ...extra };
+        this.store.update((st) => { st.runs.push(run); });
+        this.onRun?.(run);
+        log(`[${s.kind} ${s.id}] ${outcome}: ${action}${message ? ` — ${message}` : ''}`);
+    }
+    bumpFailure(id) {
+        this.store.update((st) => {
+            const cur = st.strategies.find((x) => x.id === id);
+            if (!cur)
+                return;
+            cur.consecutiveFailures++;
+            if (cur.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                cur.status = 'paused';
+                cur.pausedReason = `${MAX_CONSECUTIVE_FAILURES} consecutive failures; resume after checking the wallet and route.`;
+                cur.nextRunAt = null;
+            }
+        });
+    }
+    advance(id) {
+        this.store.update((st) => {
+            const cur = st.strategies.find((x) => x.id === id);
+            if (cur && cur.status === 'active' && cur.kind !== 'tpsl')
+                cur.nextRunAt = nextRunAfter(cur, this.now());
+        });
+    }
+    complete(id) {
+        this.store.update((st) => { const cur = st.strategies.find((x) => x.id === id); if (cur) {
+            cur.status = 'completed';
+            cur.nextRunAt = null;
+        } });
+    }
+}
+const short = (m) => (m === 'So11111111111111111111111111111111111111112' ? 'SOL' : m.slice(0, 4) + '…' + m.slice(-4));

package/dist/strategies/store.d.ts

@@ -0,0 +1,26 @@
+import { type Run, type Strategy, type StrategyState } from './types.js';
+export interface StrategyStore {
+    load(): StrategyState;
+    save(state: StrategyState): void;
+    /** Convenience: read-modify-write. */
+    update<T>(fn: (state: StrategyState) => T): T;
+    readonly location: string;
+}
+export declare const MAX_RUNS_KEPT = 2000;
+export declare class MemoryStore implements StrategyStore {
+    private state;
+    location: string;
+    load(): StrategyState;
+    save(state: StrategyState): void;
+    update<T>(fn: (state: StrategyState) => T): T;
+}
+export declare class FileStore implements StrategyStore {
+    location: string;
+    constructor(dir?: string);
+    load(): StrategyState;
+    save(state: StrategyState): void;
+    update<T>(fn: (state: StrategyState) => T): T;
+}
+export declare function defaultStateDir(env?: NodeJS.ProcessEnv): string;
+export declare const findStrategy: (state: StrategyState, id: string) => Strategy | undefined;
+export declare const runsOf: (state: StrategyState, id: string, limit?: number) => Run[];

package/dist/strategies/store.js

@@ -0,0 +1,53 @@
+// PRD P11 — persistence: a JSON file with atomic writes (tmp + rename), plus an in-memory store for tests.
+import { mkdirSync, readFileSync, renameSync, writeFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { redact } from '../redact.js';
+import { EMPTY_STATE } from './types.js';
+export const MAX_RUNS_KEPT = 2000;
+export class MemoryStore {
+    state = structuredClone(EMPTY_STATE);
+    location = 'memory';
+    load() { return structuredClone(this.state); }
+    save(state) { this.state = structuredClone(trim(state)); }
+    update(fn) { const s = this.load(); const r = fn(s); this.save(s); return r; }
+}
+export class FileStore {
+    location;
+    constructor(dir = defaultStateDir()) {
+        mkdirSync(dir, { recursive: true });
+        this.location = join(dir, 'strategies.json');
+    }
+    load() {
+        if (!existsSync(this.location))
+            return structuredClone(EMPTY_STATE);
+        try {
+            const parsed = JSON.parse(readFileSync(this.location, 'utf8'));
+            if (parsed.version !== 1 || !Array.isArray(parsed.strategies))
+                return structuredClone(EMPTY_STATE);
+            parsed.runs ??= [];
+            return parsed;
+        }
+        catch {
+            return structuredClone(EMPTY_STATE);
+        }
+    }
+    save(state) {
+        // Redaction is belt and braces: nothing here should hold a key, but the file is on disk forever.
+        const body = redact(JSON.stringify(trim(state), null, 2));
+        const tmp = `${this.location}.${process.pid}.tmp`;
+        writeFileSync(tmp, body);
+        renameSync(tmp, this.location);
+    }
+    update(fn) { const s = this.load(); const r = fn(s); this.save(s); return r; }
+}
+export function defaultStateDir(env = process.env) {
+    return env.POTSWAP_STATE_DIR || join(homedir(), '.potswap');
+}
+function trim(state) {
+    if (state.runs.length > MAX_RUNS_KEPT)
+        state.runs = state.runs.slice(-MAX_RUNS_KEPT);
+    return state;
+}
+export const findStrategy = (state, id) => state.strategies.find((s) => s.id === id);
+export const runsOf = (state, id, limit = 50) => state.runs.filter((r) => r.strategyId === id).slice(-limit).reverse();

package/dist/strategies/tools.d.ts

@@ -0,0 +1,10 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { TradeContext } from '../trade.js';
+import { type StrategyStore } from './store.js';
+import type { Scheduler } from './scheduler.js';
+export interface StrategyDeps {
+    trade: TradeContext;
+    store?: StrategyStore;
+    scheduler?: Scheduler;
+}
+export declare function registerStrategyTools(server: McpServer, deps: StrategyDeps): void;

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>;