@raintree-technology/perps 0.1.0

package/dist/commands/account/ls.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, render } from "ink";
+import { getOutputOptions } from "../../cli/program.js";
+import { output } from "../../cli/output.js";
+import { getAllAccounts } from "../../lib/db/index.js";
+import { AppShell, MetricStrip, Panel, Table, toBar, } from "../../cli/ink/index.js";
+import { colors } from "../../cli/ink/theme.js";
+function formatAddress(address) {
+    if (address.length <= 14) {
+        return address;
+    }
+    return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function buildExchangeCoverage(accounts) {
+    const counts = new Map();
+    for (const account of accounts) {
+        counts.set(account.exchange, (counts.get(account.exchange) || 0) + 1);
+    }
+    const rows = Array.from(counts.entries())
+        .map(([exchange, count]) => ({ exchange, count, bar: "" }))
+        .sort((left, right) => right.count - left.count || left.exchange.localeCompare(right.exchange));
+    const maxCount = Math.max(1, ...rows.map((row) => row.count));
+    return rows.map((row) => ({
+        ...row,
+        bar: toBar(row.count, maxCount, 16, "#", "."),
+    }));
+}
+function AccountsList({ accounts }) {
+    const hasAccounts = accounts.length > 0;
+    const exchangeCoverage = hasAccounts ? buildExchangeCoverage(accounts) : [];
+    const defaultCount = accounts.filter((account) => account.isDefault).length;
+    const apiWalletCount = accounts.filter((account) => Boolean(account.apiWalletPublicKey)).length;
+    const metrics = [
+        { label: "Accounts", value: String(accounts.length), tone: hasAccounts ? "info" : "neutral" },
+        { label: "Default", value: String(defaultCount), tone: defaultCount > 0 ? "success" : "warning" },
+        { label: "API Wallets", value: String(apiWalletCount), tone: "neutral" },
+        { label: "Exchanges", value: String(exchangeCoverage.length), tone: "neutral" },
+    ];
+    if (accounts.length === 0) {
+        return (_jsxs(AppShell, { title: "Accounts", subtitle: "Local account profiles", status: [{ label: "EMPTY", tone: "warning" }], children: [_jsx(MetricStrip, { metrics: metrics }), _jsx(Panel, { title: "Profiles", subtitle: "No accounts are configured yet.", children: _jsx(Text, { color: colors.muted, children: "Run `perps account add` to add your first account." }) })] }));
+    }
+    const rows = accounts.map((acc) => ({
+        alias: acc.alias,
+        exchange: acc.exchange,
+        address: formatAddress(acc.userAddress),
+        type: acc.type,
+        apiWallet: acc.apiWalletPublicKey
+            ? formatAddress(acc.apiWalletPublicKey)
+            : "-",
+        default: acc.isDefault ? "*" : "",
+    }));
+    const columns = [
+        { key: "default", header: "", width: 2 },
+        { key: "alias", header: "Alias" },
+        { key: "exchange", header: "Exchange" },
+        { key: "address", header: "Address" },
+        { key: "type", header: "Type" },
+        { key: "apiWallet", header: "API Wallet" },
+    ];
+    const exchangeColumns = [
+        { key: "exchange", header: "Exchange", width: 14 },
+        { key: "count", header: "Count", align: "right", width: 5 },
+        { key: "bar", header: "Coverage", width: 16 },
+    ];
+    return (_jsxs(AppShell, { title: "Accounts", subtitle: "Local account profiles", status: [{ label: `${accounts.length} PROFILES`, tone: "info" }], children: [_jsx(MetricStrip, { metrics: metrics }), _jsx(Box, { flexDirection: "column", marginBottom: 1, children: _jsxs(Panel, { title: "Profiles", subtitle: "Saved accounts and default selection", children: [_jsx(Table, { data: rows, columns: columns }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, children: "* = default account" }) })] }) }), _jsx(Panel, { title: "Exchange Coverage", subtitle: "Account distribution by exchange", children: _jsx(Table, { data: exchangeCoverage, columns: exchangeColumns }) })] }));
+}
+export function registerLsCommand(account) {
+    account
+        .command("ls")
+        .description("List all accounts")
+        .action(async function () {
+        const outputOpts = getOutputOptions(this);
+        const accounts = getAllAccounts();
+        if (outputOpts.json) {
+            // For JSON output, include full addresses but redact private keys
+            const jsonAccounts = accounts.map((acc) => ({
+                id: acc.id,
+                alias: acc.alias,
+                userAddress: acc.userAddress,
+                type: acc.type,
+                source: acc.source,
+                apiWalletPublicKey: acc.apiWalletPublicKey,
+                isDefault: acc.isDefault,
+                createdAt: acc.createdAt,
+                updatedAt: acc.updatedAt,
+            }));
+            output(jsonAccounts, outputOpts);
+        }
+        else {
+            const { unmount, waitUntilExit } = render(_jsx(AccountsList, { accounts: accounts }));
+            await waitUntilExit();
+            unmount();
+        }
+    });
+}

package/dist/commands/account/positions-simple.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple positions command using the adapter interface
+ */
+import { Command } from "commander";
+export declare function registerPositionsSimpleCommand(account: Command): void;

package/dist/commands/account/positions-simple.js

@@ -0,0 +1,77 @@
+/**
+ * Simple positions command using the adapter interface
+ */
+import { getContext, getOutputOptions, getSelectedExchange } from "../../cli/program.js";
+import { output, outputError } from "../../cli/output.js";
+import { getExchangeAdapter } from "../../lib/exchange.js";
+import { getExchangeCredentials } from "../../lib/config.js";
+export function registerPositionsSimpleCommand(account) {
+    account
+        .command("positions")
+        .alias("pos")
+        .description("Show open positions")
+        .action(async function () {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const exchangeId = getSelectedExchange(this);
+        const adapter = getExchangeAdapter();
+        let connected = false;
+        try {
+            const credentials = getExchangeCredentials(ctx.config, exchangeId, {
+                requireReadAccess: true,
+            });
+            await adapter.connect({
+                testnet: ctx.config.testnet,
+                rpcUrl: credentials.fullnodeUrl,
+                wsUrl: credentials.wsUrl,
+                credentials,
+            });
+            connected = true;
+            const positions = await adapter.getPositions();
+            if (outputOpts.json) {
+                output(positions, outputOpts);
+            }
+            else {
+                if (positions.length === 0) {
+                    console.log("\nNo open positions.\n");
+                }
+                else {
+                    console.log(`\n${adapter.info.name} Positions (${positions.length}):\n`);
+                    console.log("  " +
+                        "Market".padEnd(12) +
+                        "Side".padEnd(7) +
+                        "Size".padEnd(12) +
+                        "Entry".padEnd(12) +
+                        "Mark".padEnd(12) +
+                        "uPnL".padEnd(14) +
+                        "Lev");
+                    console.log("  " + "─".repeat(80));
+                    for (const pos of positions) {
+                        const pnl = parseFloat(pos.unrealizedPnl);
+                        const pnlColor = pnl >= 0 ? "\x1b[32m" : "\x1b[31m";
+                        const pnlStr = `${pnl >= 0 ? "+" : ""}$${pnl.toFixed(2)}`;
+                        const sideColor = pos.side === "long" ? "\x1b[32m" : "\x1b[31m";
+                        console.log("  " +
+                            pos.market.replace("-PERP", "").padEnd(12) +
+                            `${sideColor}${pos.side.toUpperCase().padEnd(6)}\x1b[0m ` +
+                            parseFloat(pos.size).toFixed(4).padEnd(12) +
+                            `$${parseFloat(pos.entryPrice).toFixed(2)}`.padEnd(12) +
+                            `$${parseFloat(pos.markPrice).toFixed(2)}`.padEnd(12) +
+                            `${pnlColor}${pnlStr.padEnd(13)}\x1b[0m ` +
+                            `${pos.leverage}x`);
+                    }
+                    console.log("");
+                }
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+        finally {
+            if (connected) {
+                await adapter.disconnect().catch(() => undefined);
+            }
+        }
+    });
+}

package/dist/commands/account/remove.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerRemoveCommand(account: Command): void;

package/dist/commands/account/remove.js

@@ -0,0 +1,47 @@
+import { getOutputOptions } from "../../cli/program.js";
+import { output, outputError, outputSuccess } from "../../cli/output.js";
+import { deleteAccount, getAccountByAlias } from "../../lib/db/index.js";
+import { getExchangeId } from "../../lib/exchange.js";
+import { confirm } from "../../lib/prompts.js";
+export function registerRemoveCommand(account) {
+    account
+        .command("remove")
+        .description("Remove an account")
+        .argument("<alias>", "Account alias to remove")
+        .option("-f, --force", "Skip confirmation prompt")
+        .action(async function (alias, options) {
+        const outputOpts = getOutputOptions(this);
+        const exchangeId = getExchangeId();
+        try {
+            // Check if account exists
+            const existingAccount = getAccountByAlias(alias, exchangeId);
+            if (!existingAccount) {
+                throw new Error(`Account with alias "${alias}" not found for exchange "${exchangeId}". Run 'perps account ls' to see available accounts.`);
+            }
+            // Confirm deletion unless --force is used
+            if (!options.force) {
+                const confirmed = await confirm(`Are you sure you want to remove account "${alias}" (${existingAccount.userAddress})?`, false);
+                if (!confirmed) {
+                    console.log("Cancelled.");
+                    return;
+                }
+            }
+            const deleted = deleteAccount(alias, exchangeId);
+            if (deleted) {
+                if (outputOpts.json) {
+                    output({ message: `Account "${alias}" removed`, deleted: true }, outputOpts);
+                }
+                else {
+                    outputSuccess(`Account "${alias}" removed.`);
+                }
+            }
+            else {
+                throw new Error(`Failed to remove account "${alias}"`);
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/account/set-default.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerSetDefaultCommand(account: Command): void;

package/dist/commands/account/set-default.js

@@ -0,0 +1,47 @@
+import { getOutputOptions } from "../../cli/program.js";
+import { output, outputError, outputSuccess } from "../../cli/output.js";
+import { setDefaultAccount, getAccountByAlias } from "../../lib/db/index.js";
+import { getExchangeId } from "../../lib/exchange.js";
+export function registerSetDefaultCommand(account) {
+    account
+        .command("set-default")
+        .description("Set an account as the default")
+        .argument("<alias>", "Account alias to set as default")
+        .action(async function (alias) {
+        const outputOpts = getOutputOptions(this);
+        const exchangeId = getExchangeId();
+        try {
+            // Check if account exists
+            const existingAccount = getAccountByAlias(alias, exchangeId);
+            if (!existingAccount) {
+                throw new Error(`Account with alias "${alias}" not found for exchange "${exchangeId}". Run 'perps account ls' to see available accounts.`);
+            }
+            if (existingAccount.isDefault) {
+                if (outputOpts.json) {
+                    output({ message: `Account "${alias}" is already the default` }, outputOpts);
+                }
+                else {
+                    console.log(`Account "${alias}" is already the default.`);
+                }
+                return;
+            }
+            const updatedAccount = setDefaultAccount(alias, exchangeId);
+            if (outputOpts.json) {
+                output({
+                    id: updatedAccount.id,
+                    alias: updatedAccount.alias,
+                    userAddress: updatedAccount.userAddress,
+                    type: updatedAccount.type,
+                    isDefault: updatedAccount.isDefault,
+                }, outputOpts);
+            }
+            else {
+                outputSuccess(`Account "${alias}" is now the default.`);
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/agent/index.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerAgentCommands(program: Command): void;

package/dist/commands/agent/index.js

@@ -0,0 +1,126 @@
+import { getContext, getOutputOptions, getSelectedExchange } from "../../cli/program.js";
+import { output, outputError } from "../../cli/output.js";
+import { withJsonContract } from "../../lib/contracts.js";
+import { createAgentGateway } from "../../lib/agent/gateway.js";
+export function registerAgentCommands(program) {
+    const agent = program
+        .command("agent")
+        .description("Agent gateway controls and metadata");
+    agent
+        .command("serve")
+        .description("Start the HTTP agent gateway")
+        .option("--host <host>", "Bind host", process.env.PERPS_AGENT_HOST ?? "127.0.0.1")
+        .option("--port <port>", "Bind port", process.env.PERPS_AGENT_PORT ?? "4020")
+        .option("--allow-mainnet", "Allow mainnet execute requests")
+        .action(async function () {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const exchange = getSelectedExchange(this);
+        const opts = this.opts();
+        const port = Number.parseInt(opts.port, 10);
+        if (!Number.isFinite(port) || port <= 0 || port > 65535) {
+            throw new Error("port must be a valid integer between 1 and 65535");
+        }
+        const allowMainnet = opts.allowMainnet === true ||
+            process.env.PERPS_AGENT_ALLOW_MAINNET === "1";
+        const gateway = createAgentGateway({
+            host: opts.host,
+            port,
+            defaultExchange: exchange,
+            defaultTestnet: ctx.config.testnet,
+            allowMainnetExecution: allowMainnet,
+        });
+        await gateway.start();
+        const baseUrl = `http://${opts.host}:${port}`;
+        if (outputOpts.json) {
+            output(withJsonContract("agent.gateway.started", {
+                status: "running",
+                baseUrl,
+                defaultExchange: exchange,
+                defaultTestnet: ctx.config.testnet,
+                allowMainnetExecution: allowMainnet,
+            }), outputOpts);
+        }
+        else {
+            console.log("");
+            console.log(`Agent gateway running at ${baseUrl}`);
+            console.log(`  GET  ${baseUrl}/capabilities`);
+            console.log(`  POST ${baseUrl}/quote`);
+            console.log(`  POST ${baseUrl}/execute`);
+            console.log(`  POST ${baseUrl}/acp/intent`);
+            console.log(``);
+            console.log("Press Ctrl+C to stop.");
+            console.log("");
+        }
+        await new Promise((resolve) => {
+            let stopping = false;
+            const shutdown = async () => {
+                if (stopping)
+                    return;
+                stopping = true;
+                await gateway.stop().catch(() => { });
+                resolve();
+            };
+            process.once("SIGINT", () => {
+                void shutdown();
+            });
+            process.once("SIGTERM", () => {
+                void shutdown();
+            });
+        });
+    });
+    agent
+        .command("status")
+        .description("Check whether agent gateway is reachable")
+        .option("--host <host>", "Host", process.env.PERPS_AGENT_HOST ?? "127.0.0.1")
+        .option("--port <port>", "Port", process.env.PERPS_AGENT_PORT ?? "4020")
+        .action(async function () {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        const baseUrl = `http://${opts.host}:${opts.port}`;
+        try {
+            const res = await fetch(`${baseUrl}/status`);
+            const payload = await res.json();
+            if (outputOpts.json) {
+                output(payload, outputOpts);
+                return;
+            }
+            output(`Gateway is reachable at ${baseUrl}`, outputOpts);
+        }
+        catch (err) {
+            if (outputOpts.json) {
+                output(withJsonContract("agent.gateway.status", {
+                    status: "unreachable",
+                    baseUrl,
+                    error: err instanceof Error ? err.message : String(err),
+                }), outputOpts);
+                return;
+            }
+            outputError(`Gateway is not reachable at ${baseUrl}`);
+        }
+    });
+    agent
+        .command("manifest")
+        .description("Print endpoint summary for agent orchestration")
+        .option("--host <host>", "Host", process.env.PERPS_AGENT_HOST ?? "127.0.0.1")
+        .option("--port <port>", "Port", process.env.PERPS_AGENT_PORT ?? "4020")
+        .action(function () {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        const baseUrl = `http://${opts.host}:${opts.port}`;
+        output(withJsonContract("agent.gateway.manifest", {
+            baseUrl,
+            endpoints: [
+                { method: "GET", path: "/capabilities" },
+                { method: "GET", path: "/status" },
+                { method: "GET", path: "/metrics" },
+                { method: "GET", path: "/reputation" },
+                { method: "POST", path: "/quote" },
+                { method: "POST", path: "/execute" },
+                { method: "POST", path: "/acp/intent" },
+            ],
+            paymentProtocol: "x402",
+            note: "POST /execute requires idempotencyKey and payment proof by default",
+        }), outputOpts);
+    });
+}

package/dist/commands/arb/alert.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Arb Alert Command
+ * Set up alerts for funding rate arbitrage opportunities
+ */
+import { Command } from "commander";
+export declare function registerArbAlertCommand(arb: Command): void;

package/dist/commands/arb/alert.js

@@ -0,0 +1,88 @@
+/**
+ * Arb Alert Command
+ * Set up alerts for funding rate arbitrage opportunities
+ */
+import { getContext } from "../../cli/program.js";
+import { pollFundingRates } from "../../lib/funding-tracker.js";
+import { getAvailableExchanges } from "../../lib/exchange.js";
+import { COMMON_ASSETS, MIN_PROFITABLE_SPREAD_PCT, DEFAULT_ALERT_INTERVAL_MS } from "../../lib/constants.js";
+import { parseAssetList, parsePositiveNumber, parsePositiveInt } from "../../lib/validate.js";
+export function registerArbAlertCommand(arb) {
+    arb
+        .command("alert")
+        .description("Monitor for funding arbitrage opportunities")
+        .option("-a, --assets <assets>", "Comma-separated assets to monitor", "BTC,ETH,SOL")
+        .option("-t, --threshold <percent>", "Minimum annualized spread to alert on", String(MIN_PROFITABLE_SPREAD_PCT))
+        .option("-i, --interval <minutes>", "Check interval in minutes", String(DEFAULT_ALERT_INTERVAL_MS / 60000))
+        .action(async function () {
+        const ctx = getContext(this);
+        const opts = this.opts();
+        const config = {
+            assets: parseAssetList(opts.assets, COMMON_ASSETS.slice(0, 3)),
+            threshold: parsePositiveNumber(opts.threshold, "threshold", MIN_PROFITABLE_SPREAD_PCT),
+            intervalMin: parsePositiveInt(opts.interval, "interval", 5),
+        };
+        const exchanges = getAvailableExchanges();
+        const isTestnet = ctx.config.testnet;
+        console.log("\n  \x1b[1mFunding Rate Alert Monitor\x1b[0m");
+        console.log(`  Assets:     ${config.assets.join(", ")}`);
+        console.log(`  Threshold:  ${config.threshold}% annualized`);
+        console.log(`  Interval:   ${config.intervalMin} minutes`);
+        console.log(`  Exchanges:  ${exchanges.join(", ")}`);
+        console.log("\n  Monitoring... (Ctrl+C to stop)\n");
+        console.log("  " + "─".repeat(60));
+        // Check immediately
+        await checkAndAlert(config.assets, exchanges, config.threshold, isTestnet);
+        // Then check on interval
+        const interval = setInterval(async () => {
+            await checkAndAlert(config.assets, exchanges, config.threshold, isTestnet);
+        }, config.intervalMin * 60 * 1000);
+        // Handle Ctrl+C
+        process.once("SIGINT", () => {
+            clearInterval(interval);
+            console.log("\n\n  Alert monitor stopped.\n");
+            process.exit(0);
+        });
+        // Keep running
+        await new Promise(() => { });
+    });
+}
+async function checkAndAlert(assets, exchanges, threshold, isTestnet) {
+    try {
+        const records = await pollFundingRates(assets, exchanges, undefined, isTestnet);
+        const now = new Date().toLocaleTimeString();
+        // Group by asset and find opportunities
+        const byAsset = new Map();
+        for (const r of records) {
+            const asset = r.market.replace("-PERP", "");
+            const existing = byAsset.get(asset) || [];
+            existing.push(r);
+            byAsset.set(asset, existing);
+        }
+        let foundAny = false;
+        for (const [asset, assetRecords] of byAsset) {
+            if (assetRecords.length < 2)
+                continue;
+            const sorted = [...assetRecords].sort((a, b) => b.rate - a.rate);
+            const high = sorted[0];
+            const low = sorted[sorted.length - 1];
+            const spread = high.rate - low.rate;
+            const annualized = spread * 24 * 365 * 100;
+            if (annualized >= threshold) {
+                foundAny = true;
+                const dailyOn10k = spread * 24 * 10000;
+                console.log(`\n  \x1b[32m🔔 ${now} - ${asset} OPPORTUNITY\x1b[0m`);
+                console.log(`     Short ${high.exchange} (${(high.rate * 100).toFixed(4)}%)`);
+                console.log(`     Long  ${low.exchange} (${(low.rate * 100).toFixed(4)}%)`);
+                console.log(`     Spread: \x1b[32m${annualized.toFixed(1)}%\x1b[0m annualized (~$${dailyOn10k.toFixed(2)}/day on $10k)`);
+                // Could add external notifications here (Discord, Telegram, etc.)
+            }
+        }
+        if (!foundAny) {
+            process.stdout.write(`\r  ${now} - No opportunities above ${threshold}%`);
+        }
+    }
+    catch (err) {
+        console.error(`\n  \x1b[31mError:\x1b[0m ${err instanceof Error ? err.message : err}`);
+    }
+}

package/dist/commands/arb/basis-execute.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Arb Basis Execute Command
+ * Execute basis trades (cash-and-carry arbitrage) on a single exchange
+ */
+import { Command } from "commander";
+export declare function registerArbBasisExecuteCommand(arb: Command): void;