perp-cli 0.3.3

package/dist/commands/withdraw.js

@@ -0,0 +1,187 @@
+import chalk from "chalk";
+import { printJson, formatUsd, jsonOk } from "../utils.js";
+import { PacificaAdapter } from "../exchanges/pacifica.js";
+import { HyperliquidAdapter } from "../exchanges/hyperliquid.js";
+import { logExecution } from "../execution-log.js";
+export function registerWithdrawCommands(program, getAdapter, isJson) {
+    const withdraw = program.command("withdraw").description("Withdraw funds from exchange accounts");
+    // ── Pacifica ──
+    withdraw
+        .command("pacifica <amount>")
+        .description("Withdraw USDC from Pacifica to your Solana wallet")
+        .option("--to <address>", "Destination Solana address (default: your wallet)")
+        .action(async (amount, opts) => {
+        const amountNum = parseFloat(amount);
+        if (isNaN(amountNum) || amountNum <= 0)
+            throw new Error("Invalid amount");
+        const adapter = await getAdapter();
+        if (!(adapter instanceof PacificaAdapter))
+            throw new Error("Requires --exchange pacifica");
+        const dest = opts.to || adapter.publicKey;
+        if (!isJson()) {
+            console.log(chalk.cyan(`\n  Withdrawing $${formatUsd(amountNum)} USDC from Pacifica...\n`));
+            console.log(`  Destination: ${dest}`);
+        }
+        try {
+            const result = await adapter.sdk.withdraw({ amount: String(amountNum), dest_address: dest }, adapter.publicKey, adapter.signer);
+            logExecution({
+                type: "bridge", exchange: "pacifica", symbol: "USDC", side: "withdraw",
+                size: String(amountNum), status: "success", dryRun: false,
+                meta: { action: "withdraw", destination: dest },
+            });
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.green(`\n  Withdrawal submitted!`));
+            console.log(`  Amount: $${formatUsd(amountNum)} USDC`);
+            console.log(chalk.gray(`\n  Funds arrive in your Solana wallet shortly.\n`));
+        }
+        catch (err) {
+            logExecution({
+                type: "bridge", exchange: "pacifica", symbol: "USDC", side: "withdraw",
+                size: String(amountNum), status: "failed", dryRun: false,
+                error: err instanceof Error ? err.message : String(err),
+                meta: { action: "withdraw", destination: dest },
+            });
+            throw err;
+        }
+    });
+    // ── Hyperliquid ──
+    withdraw
+        .command("hyperliquid <amount>")
+        .description("Withdraw USDC from Hyperliquid to your Arbitrum wallet")
+        .option("--to <address>", "Destination EVM address (default: your wallet)")
+        .action(async (amount, opts) => {
+        const amountNum = parseFloat(amount);
+        if (isNaN(amountNum) || amountNum <= 0)
+            throw new Error("Invalid amount");
+        const adapter = await getAdapter();
+        if (!(adapter instanceof HyperliquidAdapter))
+            throw new Error("Requires --exchange hyperliquid");
+        const dest = opts.to || adapter.address;
+        if (!isJson()) {
+            console.log(chalk.cyan(`\n  Withdrawing $${formatUsd(amountNum)} USDC from Hyperliquid...\n`));
+            console.log(`  Destination: ${dest}`);
+        }
+        // Check withdrawable balance
+        const balance = await adapter.getBalance();
+        const available = Number(balance.available);
+        if (amountNum > available) {
+            console.error(chalk.red(`  Insufficient withdrawable balance. Available: $${formatUsd(available)}`));
+            process.exit(1);
+        }
+        try {
+            const result = await adapter.withdraw(String(amountNum), dest);
+            logExecution({
+                type: "bridge", exchange: "hyperliquid", symbol: "USDC", side: "withdraw",
+                size: String(amountNum), status: "success", dryRun: false,
+                meta: { action: "withdraw", destination: dest },
+            });
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.green(`\n  Withdrawal submitted!`));
+            console.log(`  Amount: $${formatUsd(amountNum)} USDC`);
+            console.log(chalk.gray(`\n  Processing may take a few minutes.\n`));
+        }
+        catch (err) {
+            logExecution({
+                type: "bridge", exchange: "hyperliquid", symbol: "USDC", side: "withdraw",
+                size: String(amountNum), status: "failed", dryRun: false,
+                error: err instanceof Error ? err.message : String(err),
+                meta: { action: "withdraw", destination: dest },
+            });
+            throw err;
+        }
+    });
+    // ── Lighter ──
+    withdraw
+        .command("lighter <amount>")
+        .description("Withdraw USDC from Lighter to your Ethereum L1 wallet")
+        .option("--asset-id <id>", "Asset ID (default: 2 = USDC)", "2")
+        .option("--route <type>", "Route type: 0=perp, 1=spot (default: 0)", "0")
+        .action(async (amount, opts) => {
+        const amountNum = parseFloat(amount);
+        if (isNaN(amountNum) || amountNum <= 0)
+            throw new Error("Invalid amount");
+        const adapter = await getAdapter();
+        // Lazy-import to check instance
+        const { LighterAdapter } = await import("../exchanges/lighter.js");
+        if (!(adapter instanceof LighterAdapter))
+            throw new Error("Requires --exchange lighter");
+        if (!isJson()) {
+            console.log(chalk.cyan(`\n  Withdrawing $${formatUsd(amountNum)} USDC from Lighter...\n`));
+            console.log(`  Account Index: ${adapter.accountIndex}`);
+            console.log(`  Address: ${adapter.address}`);
+        }
+        try {
+            const result = await adapter.withdraw(amountNum, parseInt(opts.assetId), parseInt(opts.route));
+            logExecution({
+                type: "bridge", exchange: "lighter", symbol: "USDC", side: "withdraw",
+                size: String(amountNum), status: "success", dryRun: false,
+                meta: { action: "withdraw" },
+            });
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.green(`\n  Withdrawal submitted!`));
+            console.log(`  Amount: $${formatUsd(amountNum)} USDC`);
+            console.log(chalk.gray(`\n  Standard withdrawal takes ~12 hours. Use Lighter web for fast withdrawal.\n`));
+        }
+        catch (err) {
+            logExecution({
+                type: "bridge", exchange: "lighter", symbol: "USDC", side: "withdraw",
+                size: String(amountNum), status: "failed", dryRun: false,
+                error: err instanceof Error ? err.message : String(err),
+                meta: { action: "withdraw" },
+            });
+            throw err;
+        }
+    });
+    // ── Transfer (HL internal) ──
+    withdraw
+        .command("transfer <amount> <destination>")
+        .description("Transfer USDC between Hyperliquid accounts (internal, instant)")
+        .action(async (amount, destination) => {
+        const amountNum = parseFloat(amount);
+        if (isNaN(amountNum) || amountNum <= 0)
+            throw new Error("Invalid amount");
+        const adapter = await getAdapter();
+        if (!(adapter instanceof HyperliquidAdapter))
+            throw new Error("Requires --exchange hyperliquid");
+        if (!isJson())
+            console.log(chalk.cyan(`\n  Transferring $${formatUsd(amountNum)} USDC to ${destination}...\n`));
+        const result = await adapter.usdTransfer(amountNum, destination);
+        if (isJson())
+            return printJson(jsonOk(result));
+        console.log(chalk.green(`  Transfer complete!`));
+        console.log(`  Amount: $${formatUsd(amountNum)} USDC`);
+        console.log(`  To:     ${destination}\n`);
+    });
+    // ── Info ──
+    withdraw
+        .command("info")
+        .description("Show withdrawal info & limits")
+        .action(async () => {
+        if (isJson()) {
+            return printJson(jsonOk({
+                exchanges: {
+                    pacifica: { chain: "Solana", token: "USDC", speed: "~10s", fee: "none" },
+                    hyperliquid: { chain: "Arbitrum", token: "USDC", speed: "minutes", fee: "$1" },
+                    lighter: { chain: "Ethereum L1", token: "USDC", speed: "~12 hours (standard), minutes (fast)", fee: "varies" },
+                },
+            }));
+        }
+        console.log(chalk.cyan.bold("\n  Withdrawal Info\n"));
+        console.log(chalk.white.bold("  Pacifica") + chalk.gray(" → Solana"));
+        console.log(`  Speed: ~10s  |  Fee: none`);
+        console.log(`  Command: ${chalk.green("perp withdraw pacifica <amount>")}`);
+        console.log(chalk.white.bold("\n  Hyperliquid") + chalk.gray(" → Arbitrum"));
+        console.log(`  Speed: minutes  |  Fee: ~$1`);
+        console.log(`  Command: ${chalk.green("perp -e hyperliquid withdraw hyperliquid <amount>")}`);
+        console.log(chalk.white.bold("\n  Lighter") + chalk.gray(" → Ethereum L1"));
+        console.log(`  Speed: ~12h (standard)  |  Fee: varies`);
+        console.log(`  Command: ${chalk.green("perp -e lighter withdraw lighter <amount>")}`);
+        console.log(chalk.white.bold("\n  Internal Transfer") + chalk.gray(" (Hyperliquid → Hyperliquid)"));
+        console.log(`  Speed: instant  |  Fee: none`);
+        console.log(`  Command: ${chalk.green("perp -e hyperliquid withdraw transfer <amount> <address>")}`);
+        console.log();
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import { Keypair } from "@solana/web3.js";
+export type Exchange = "pacifica" | "hyperliquid" | "lighter";
+export declare function loadPrivateKey(exchange: Exchange, pkOverride?: string): Promise<string>;
+export declare function parseSolanaKeypair(input: string): Keypair;
+export declare function isEvmPrivateKey(input: string): boolean;

package/dist/config.js

@@ -0,0 +1,68 @@
+import { Keypair } from "@solana/web3.js";
+import bs58 from "bs58";
+import chalk from "chalk";
+import { resolve } from "path";
+import { existsSync, readFileSync } from "fs";
+export async function loadPrivateKey(exchange, pkOverride) {
+    // 1. CLI flag
+    if (pkOverride)
+        return pkOverride;
+    // 2. Exchange-specific env vars
+    const envMap = {
+        pacifica: ["PACIFICA_PRIVATE_KEY", "pk"],
+        hyperliquid: ["HYPERLIQUID_PRIVATE_KEY", "HL_PRIVATE_KEY"],
+        lighter: ["LIGHTER_PRIVATE_KEY"],
+    };
+    for (const envVar of envMap[exchange]) {
+        if (process.env[envVar])
+            return process.env[envVar];
+    }
+    // 3. Generic fallback
+    if (process.env.PRIVATE_KEY)
+        return process.env.PRIVATE_KEY;
+    // 4. Active wallet from wallets.json
+    try {
+        const { getActiveWalletKey } = await import("./commands/wallet.js");
+        const walletKey = getActiveWalletKey(exchange);
+        if (walletKey)
+            return walletKey;
+    }
+    catch {
+        // wallet module not available, skip
+    }
+    // 5. Legacy key file (~/.perp/<exchange>.key)
+    const keyFile = resolve(process.env.HOME || "~", ".perp", `${exchange}.key`);
+    if (existsSync(keyFile)) {
+        return readFileSync(keyFile, "utf-8").trim();
+    }
+    throw new Error(`No private key configured for ${exchange}.\n\n` +
+        `  Quick start:  ${chalk.cyan("perp init")}\n\n` +
+        `  Or manually:\n` +
+        `    perp wallet set ${exchange} <key>\n` +
+        `    ${envMap[exchange][0]}=<key> (env var)\n` +
+        `    --private-key <key> (per-command)`);
+}
+export function parseSolanaKeypair(input) {
+    // Try base58 first
+    try {
+        const bytes = bs58.decode(input);
+        return Keypair.fromSecretKey(bytes);
+    }
+    catch {
+        // noop
+    }
+    // Try JSON array (Solana CLI format)
+    try {
+        const arr = JSON.parse(input);
+        if (Array.isArray(arr)) {
+            return Keypair.fromSecretKey(Uint8Array.from(arr));
+        }
+    }
+    catch {
+        // noop
+    }
+    throw new Error("Invalid Solana private key. Expected base58 or JSON byte array.");
+}
+export function isEvmPrivateKey(input) {
+    return input.startsWith("0x") && input.length === 66;
+}

package/dist/cross-chain-margin.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Cross-chain margin monitoring and dynamic auto-sizing.
+ *
+ * Provides:
+ * - Per-exchange margin status checking
+ * - Auto-size computation based on orderbook depth and margin limits
+ */
+import type { ExchangeAdapter } from "./exchanges/interface.js";
+export interface ChainMarginStatus {
+    exchange: string;
+    chain: string;
+    equity: number;
+    usedMargin: number;
+    freeMargin: number;
+    marginRatio: number;
+    belowThreshold: boolean;
+}
+/**
+ * Check margin status across all configured exchanges.
+ *
+ * @param adapters - Map of exchange name to adapter
+ * @param minMarginPct - Warn when free margin / equity falls below this (default: 30%)
+ * @returns Per-exchange margin status array
+ */
+export declare function checkChainMargins(adapters: Map<string, ExchangeAdapter>, minMarginPct?: number): Promise<ChainMarginStatus[]>;
+/**
+ * Check if a specific exchange has critically low margin (below 15%).
+ */
+export declare function isCriticalMargin(status: ChainMarginStatus): boolean;
+/**
+ * Check if a specific exchange should block new entries (below threshold).
+ */
+export declare function shouldBlockEntries(status: ChainMarginStatus, minMarginPct?: number): boolean;
+/**
+ * Compute the optimal position size automatically based on:
+ * 1. Orderbook depth on both sides
+ * 2. Free margin constraints (max 50% per trade)
+ * 3. Risk config maxPositionUsd
+ *
+ * @param longAdapter - Adapter for the long side exchange
+ * @param shortAdapter - Adapter for the short side exchange
+ * @param symbol - Trading symbol
+ * @param maxSlippagePct - Max acceptable slippage (default: 0.3%)
+ * @returns USD size per leg, or 0 if not viable
+ */
+export declare function computeAutoSize(longAdapter: ExchangeAdapter, shortAdapter: ExchangeAdapter, symbol: string, maxSlippagePct?: number): Promise<number>;

package/dist/cross-chain-margin.js

@@ -0,0 +1,107 @@
+/**
+ * Cross-chain margin monitoring and dynamic auto-sizing.
+ *
+ * Provides:
+ * - Per-exchange margin status checking
+ * - Auto-size computation based on orderbook depth and margin limits
+ */
+import { computeExecutableSize } from "./liquidity.js";
+import { loadRiskLimits } from "./risk.js";
+const EXCHANGE_CHAIN_MAP = {
+    lighter: "arbitrum",
+    pacifica: "solana",
+    hyperliquid: "hyperliquid",
+};
+/**
+ * Check margin status across all configured exchanges.
+ *
+ * @param adapters - Map of exchange name to adapter
+ * @param minMarginPct - Warn when free margin / equity falls below this (default: 30%)
+ * @returns Per-exchange margin status array
+ */
+export async function checkChainMargins(adapters, minMarginPct = 30) {
+    const entries = [...adapters.entries()];
+    const results = await Promise.allSettled(entries.map(async ([name, adapter]) => {
+        const bal = await adapter.getBalance();
+        const equity = Number(bal.equity);
+        const usedMargin = Number(bal.marginUsed);
+        const freeMargin = equity - usedMargin;
+        // marginRatio = (freeMargin / equity) * 100
+        // If equity is 0, ratio is 0 (critical). If no margin used, ratio is 100.
+        const marginRatio = equity > 0 ? (freeMargin / equity) * 100 : 0;
+        return {
+            exchange: name,
+            chain: EXCHANGE_CHAIN_MAP[name.toLowerCase()] ?? "unknown",
+            equity,
+            usedMargin,
+            freeMargin,
+            marginRatio,
+            belowThreshold: marginRatio < minMarginPct,
+        };
+    }));
+    return results
+        .filter((r) => r.status === "fulfilled")
+        .map((r) => r.value);
+}
+/**
+ * Check if a specific exchange has critically low margin (below 15%).
+ */
+export function isCriticalMargin(status) {
+    return status.marginRatio < 15;
+}
+/**
+ * Check if a specific exchange should block new entries (below threshold).
+ */
+export function shouldBlockEntries(status, minMarginPct = 30) {
+    return status.marginRatio < minMarginPct;
+}
+// ── Dynamic Auto-Sizing ──
+/**
+ * Compute the optimal position size automatically based on:
+ * 1. Orderbook depth on both sides
+ * 2. Free margin constraints (max 50% per trade)
+ * 3. Risk config maxPositionUsd
+ *
+ * @param longAdapter - Adapter for the long side exchange
+ * @param shortAdapter - Adapter for the short side exchange
+ * @param symbol - Trading symbol
+ * @param maxSlippagePct - Max acceptable slippage (default: 0.3%)
+ * @returns USD size per leg, or 0 if not viable
+ */
+export async function computeAutoSize(longAdapter, shortAdapter, symbol, maxSlippagePct = 0.3) {
+    // Step 1: Get orderbooks from both sides
+    const [longOB, shortOB, longBal, shortBal] = await Promise.all([
+        longAdapter.getOrderbook(symbol),
+        shortAdapter.getOrderbook(symbol),
+        longAdapter.getBalance(),
+        shortAdapter.getBalance(),
+    ]);
+    // Step 2: Compute executable size on each side
+    // For long entry we consume asks, for short entry we consume bids
+    // Use a large requested size to discover the full depth available
+    const probeSize = 1_000_000; // $1M probe to find max depth
+    const longCheck = computeExecutableSize(longOB.asks, probeSize, maxSlippagePct);
+    const shortCheck = computeExecutableSize(shortOB.bids, probeSize, maxSlippagePct);
+    // Step 3: Take the minimum of both sides (in USD)
+    const longMaxUsd = longCheck.maxSize * longCheck.avgFillPrice;
+    const shortMaxUsd = shortCheck.maxSize * shortCheck.avgFillPrice;
+    let sizeUsd = Math.min(longMaxUsd, shortMaxUsd);
+    if (sizeUsd <= 0)
+        return 0;
+    // Step 4: Cap at 50% of free margin on either exchange
+    const longEquity = Number(longBal.equity);
+    const longUsed = Number(longBal.marginUsed);
+    const longFree = longEquity - longUsed;
+    const shortEquity = Number(shortBal.equity);
+    const shortUsed = Number(shortBal.marginUsed);
+    const shortFree = shortEquity - shortUsed;
+    const maxByMargin = Math.min(longFree, shortFree) * 0.5;
+    if (maxByMargin > 0) {
+        sizeUsd = Math.min(sizeUsd, maxByMargin);
+    }
+    // Step 5: Cap at maxPositionUsd from risk config
+    const riskLimits = loadRiskLimits();
+    sizeUsd = Math.min(sizeUsd, riskLimits.maxPositionUsd);
+    // Round to nearest dollar
+    return Math.floor(sizeUsd);
+}

package/dist/dashboard/server.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Live Dashboard Server — HTTP + WebSocket for real-time portfolio monitoring.
+ *
+ * Polls all configured exchange adapters and pushes updates to connected clients.
+ * Includes cross-exchange arb data: funding rate comparison + dex arb scan.
+ */
+import type { ExchangeAdapter, ExchangeBalance, ExchangePosition, ExchangeOrder, ExchangeMarketInfo } from "../exchanges/interface.js";
+export interface DashboardExchange {
+    name: string;
+    adapter: ExchangeAdapter;
+}
+export interface ArbOpportunity {
+    symbol: string;
+    longExchange: string;
+    shortExchange: string;
+    spreadAnnual: number;
+    estHourlyUsd: number;
+    rates: {
+        exchange: string;
+        annualizedPct: number;
+        hourlyRate: number;
+        markPrice: number;
+    }[];
+}
+export interface DexArbOpportunity {
+    underlying: string;
+    longDex: string;
+    shortDex: string;
+    annualSpread: number;
+    priceGapPct: number;
+    viability: string;
+}
+export interface DexAssetRow {
+    base: string;
+    dexes: {
+        dex: string;
+        rate: number;
+        annualizedPct: number;
+        markPrice: number;
+        oi: number;
+    }[];
+}
+export interface DashboardSnapshot {
+    timestamp: string;
+    exchanges: {
+        name: string;
+        balance: ExchangeBalance;
+        positions: ExchangePosition[];
+        orders: ExchangeOrder[];
+        topMarkets: ExchangeMarketInfo[];
+    }[];
+    totals: {
+        equity: number;
+        available: number;
+        marginUsed: number;
+        unrealizedPnl: number;
+        positionCount: number;
+        orderCount: number;
+    };
+    arb: {
+        opportunities: ArbOpportunity[];
+        dexArb: DexArbOpportunity[];
+        dexAssets: DexAssetRow[];
+        dexNames: string[];
+        exchangeStatus: Record<string, string>;
+    };
+}
+export interface DashboardOpts {
+    port?: number;
+    pollInterval?: number;
+    arbInterval?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Start the dashboard HTTP + WebSocket server.
+ */
+export declare function startDashboard(exchanges: DashboardExchange[], opts?: DashboardOpts): Promise<{
+    port: number;
+    close: () => void;
+}>;