perp-cli 0.3.3

package/dist/rebalance.js

@@ -0,0 +1,142 @@
+import { EXCHANGE_TO_CHAIN } from "./bridge-engine.js";
+// Re-export for backward compat
+const EXCHANGE_CHAINS = Object.fromEntries(Object.entries(EXCHANGE_TO_CHAIN).map(([ex, chain]) => [ex, { chain }]));
+/**
+ * Fetch balances from all exchanges in parallel.
+ */
+export async function fetchAllBalances(adapters) {
+    const entries = [...adapters.entries()];
+    const results = await Promise.allSettled(entries.map(async ([name, adapter]) => {
+        const bal = await adapter.getBalance();
+        return {
+            exchange: name,
+            equity: Number(bal.equity),
+            available: Number(bal.available),
+            marginUsed: Number(bal.marginUsed),
+            unrealizedPnl: Number(bal.unrealizedPnl),
+        };
+    }));
+    return results
+        .filter((r) => r.status === "fulfilled")
+        .map((r) => r.value);
+}
+/**
+ * Compute a rebalancing plan to equalize available balance across exchanges.
+ *
+ * Strategy: equal-weight — target = totalAvailable / numExchanges
+ * Only moves from exchanges with surplus to those with deficit.
+ * Respects a minimum move threshold to avoid tiny transfers.
+ */
+export function computeRebalancePlan(snapshots, opts = {}) {
+    const minMove = opts.minMove ?? 50;
+    const reserve = opts.reserve ?? 20;
+    const totalEquity = snapshots.reduce((s, e) => s + e.equity, 0);
+    const totalAvailable = snapshots.reduce((s, e) => s + e.available, 0);
+    // Calculate targets
+    const weights = opts.weights ?? Object.fromEntries(snapshots.map((s) => [s.exchange, 1 / snapshots.length]));
+    const targets = new Map();
+    for (const snap of snapshots) {
+        const w = weights[snap.exchange] ?? 1 / snapshots.length;
+        targets.set(snap.exchange, totalAvailable * w);
+    }
+    // Calculate deltas (positive = surplus, negative = deficit)
+    const deltas = new Map();
+    for (const snap of snapshots) {
+        const target = targets.get(snap.exchange) ?? 0;
+        const movable = Math.max(0, snap.available - reserve);
+        const delta = movable - Math.max(0, target - reserve);
+        deltas.set(snap.exchange, delta);
+    }
+    // Match surplus → deficit
+    const moves = [];
+    const surpluses = [...deltas.entries()].filter(([, d]) => d > minMove).sort((a, b) => b[1] - a[1]);
+    const deficits = [...deltas.entries()].filter(([, d]) => d < -minMove).sort((a, b) => a[1] - b[1]);
+    for (const [fromEx, surplus] of surpluses) {
+        let remaining = surplus;
+        for (const deficit of deficits) {
+            if (remaining < minMove)
+                break;
+            const [toEx, deficitAmt] = deficit;
+            if (deficitAmt >= -minMove)
+                continue;
+            const moveAmt = Math.min(remaining, Math.abs(deficitAmt));
+            if (moveAmt < minMove)
+                continue;
+            moves.push({
+                from: fromEx,
+                to: toEx,
+                amount: Math.floor(moveAmt),
+                reason: `Rebalance: ${fromEx} has $${Math.floor(surplus)} surplus, ${toEx} needs $${Math.floor(Math.abs(deficitAmt))}`,
+            });
+            remaining -= moveAmt;
+            deficit[1] += moveAmt; // reduce deficit
+        }
+    }
+    const summary = moves.length === 0
+        ? "Balanced — no moves needed"
+        : `${moves.length} move(s): ${moves.map((m) => `$${m.amount} ${m.from}→${m.to}`).join(", ")}`;
+    return {
+        snapshots,
+        totalEquity,
+        targetPerExchange: totalAvailable / snapshots.length,
+        moves,
+        summary,
+    };
+}
+/**
+ * Check if an exchange has enough available balance for a given trade size.
+ */
+export function hasEnoughBalance(snapshots, exchange, requiredUsd, marginBuffer = 1.5) {
+    const snap = snapshots.find((s) => s.exchange === exchange);
+    if (!snap)
+        return false;
+    return snap.available >= requiredUsd * marginBuffer;
+}
+/**
+ * Get the chain/bridge info for an exchange.
+ */
+export function getExchangeChain(exchange) {
+    return EXCHANGE_CHAINS[exchange];
+}
+/**
+ * Describe the bridge route for a rebalance move.
+ */
+export function describeBridgeRoute(move) {
+    const from = EXCHANGE_CHAINS[move.from];
+    const to = EXCHANGE_CHAINS[move.to];
+    if (!from || !to)
+        return `${move.from} → ${move.to} (unknown route)`;
+    if (from.chain === to.chain)
+        return `Internal transfer on ${from.chain}`;
+    // All cross-chain moves go through USDC bridging
+    const steps = [];
+    steps.push(`1. Withdraw $${move.amount} USDC from ${move.from} (${from.chain})`);
+    // Determine bridge method
+    if (from.chain === "solana" || to.chain === "solana") {
+        steps.push(`2. Bridge via CCTP/Wormhole (${from.chain} → ${to.chain})`);
+    }
+    else {
+        steps.push(`2. Bridge via CCTP (${from.chain} → ${to.chain})`);
+    }
+    steps.push(`3. Deposit into ${move.to} (${to.chain})`);
+    return steps.join("\n    ");
+}
+/**
+ * Estimate total time for a rebalance move.
+ */
+export function estimateMoveTime(move) {
+    const from = EXCHANGE_CHAINS[move.from]?.chain;
+    const to = EXCHANGE_CHAINS[move.to]?.chain;
+    // Withdrawal times
+    const withdrawTime = {
+        pacifica: "~10s",
+        hyperliquid: "~5min",
+        lighter: "~12h (standard)",
+    };
+    // Bridge times
+    let bridgeTime = "~1-3min (CCTP)";
+    if (from === "solana" || to === "solana") {
+        bridgeTime = "~15min (Wormhole/CCTP)";
+    }
+    return `Withdraw: ${withdrawTime[move.from] ?? "?"} → Bridge: ${bridgeTime} → Deposit: ~1min`;
+}

package/dist/retry.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Auto-retry middleware for exchange operations.
+ * Retries operations that fail with retryable error codes.
+ */
+import { type StructuredError } from "./errors.js";
+import type { ExchangeAdapter } from "./exchanges/interface.js";
+export interface RetryOptions {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    backoffMultiplier?: number;
+    onRetry?: (attempt: number, error: StructuredError, delayMs: number) => void;
+}
+export interface RetryResult<T> {
+    data: T;
+    attempts: number;
+    totalDelayMs: number;
+    retries: {
+        attempt: number;
+        error: StructuredError;
+        delayMs: number;
+    }[];
+}
+/** Error thrown when all retries are exhausted */
+export declare class RetriesExhaustedError extends Error {
+    readonly lastError: StructuredError;
+    readonly attempts: number;
+    readonly retries: {
+        attempt: number;
+        error: StructuredError;
+        delayMs: number;
+    }[];
+    constructor(lastError: StructuredError, attempts: number, retries: {
+        attempt: number;
+        error: StructuredError;
+        delayMs: number;
+    }[]);
+}
+/**
+ * Apply jitter of +/-20% to a delay value.
+ * Returns a value in [delay * 0.8, delay * 1.2].
+ */
+export declare function applyJitter(delayMs: number): number;
+/**
+ * Compute the delay for a given retry attempt.
+ * Uses exponential backoff, respects retryAfterMs from the error code,
+ * applies jitter, and caps at maxDelayMs.
+ */
+export declare function computeDelay(attempt: number, error: StructuredError, opts: Required<Omit<RetryOptions, "onRetry">>): number;
+/**
+ * Execute `fn` with automatic retry on retryable errors.
+ *
+ * - On failure, classifies the error via `classifyError`.
+ * - If `retryable: true`, waits with exponential backoff and retries.
+ * - If `retryable: false`, throws immediately.
+ * - Uses `retryAfterMs` from the error code if available (e.g., rate limit = 1000ms).
+ * - Caps delay at `maxDelayMs`.
+ * - Adds jitter (+/-20%) to prevent thundering herd.
+ * - Returns the result with retry metadata.
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<RetryResult<T>>;
+/**
+ * Simpler version of withRetry that just returns T (no metadata).
+ * For use in places where you just want automatic retry without caring about details.
+ */
+export declare function withRetrySimple<T>(fn: () => Promise<T>, maxRetries?: number): Promise<T>;
+/**
+ * Wrap an ExchangeAdapter so every async method is automatically retried.
+ *
+ * Returns a Proxy that intercepts property access:
+ * - For non-function properties (like `name`), returns the value directly.
+ * - For function properties, returns a wrapper that calls `withRetry` around the original method.
+ */
+export declare function wrapAdapterWithRetry(adapter: ExchangeAdapter, opts?: RetryOptions): ExchangeAdapter;

package/dist/retry.js

@@ -0,0 +1,129 @@
+/**
+ * Auto-retry middleware for exchange operations.
+ * Retries operations that fail with retryable error codes.
+ */
+import { classifyError } from "./errors.js";
+/** Error thrown when all retries are exhausted */
+export class RetriesExhaustedError extends Error {
+    lastError;
+    attempts;
+    retries;
+    constructor(lastError, attempts, retries) {
+        super(`All ${attempts} attempts failed. Last error: [${lastError.code}] ${lastError.message}`);
+        this.name = "RetriesExhaustedError";
+        this.lastError = lastError;
+        this.attempts = attempts;
+        this.retries = retries;
+    }
+}
+const DEFAULT_OPTIONS = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    backoffMultiplier: 2,
+};
+/**
+ * Apply jitter of +/-20% to a delay value.
+ * Returns a value in [delay * 0.8, delay * 1.2].
+ */
+export function applyJitter(delayMs) {
+    const jitterFactor = 0.8 + Math.random() * 0.4; // [0.8, 1.2]
+    return Math.round(delayMs * jitterFactor);
+}
+/**
+ * Compute the delay for a given retry attempt.
+ * Uses exponential backoff, respects retryAfterMs from the error code,
+ * applies jitter, and caps at maxDelayMs.
+ */
+export function computeDelay(attempt, error, opts) {
+    // Start with exponential backoff: baseDelay * multiplier^(attempt-1)
+    let delay = opts.baseDelayMs * Math.pow(opts.backoffMultiplier, attempt - 1);
+    // If the error specifies a retryAfterMs, use the larger of the two
+    if (error.retryAfterMs !== undefined) {
+        delay = Math.max(delay, error.retryAfterMs);
+    }
+    // Cap at maxDelayMs
+    delay = Math.min(delay, opts.maxDelayMs);
+    // Apply jitter
+    return applyJitter(delay);
+}
+/** Internal sleep helper */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Execute `fn` with automatic retry on retryable errors.
+ *
+ * - On failure, classifies the error via `classifyError`.
+ * - If `retryable: true`, waits with exponential backoff and retries.
+ * - If `retryable: false`, throws immediately.
+ * - Uses `retryAfterMs` from the error code if available (e.g., rate limit = 1000ms).
+ * - Caps delay at `maxDelayMs`.
+ * - Adds jitter (+/-20%) to prevent thundering herd.
+ * - Returns the result with retry metadata.
+ */
+export async function withRetry(fn, opts) {
+    const { maxRetries, baseDelayMs, maxDelayMs, backoffMultiplier } = {
+        ...DEFAULT_OPTIONS,
+        ...opts,
+    };
+    const resolvedOpts = { maxRetries, baseDelayMs, maxDelayMs, backoffMultiplier };
+    const retries = [];
+    let totalDelayMs = 0;
+    for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
+        try {
+            const data = await fn();
+            return { data, attempts: attempt, totalDelayMs, retries };
+        }
+        catch (err) {
+            const classified = classifyError(err);
+            // Non-retryable error: throw immediately
+            if (!classified.retryable) {
+                throw err;
+            }
+            // Out of retries: throw with exhaustion info
+            if (attempt > maxRetries) {
+                throw new RetriesExhaustedError(classified, attempt, retries);
+            }
+            const delayMs = computeDelay(attempt, classified, resolvedOpts);
+            // Call onRetry callback if provided
+            opts?.onRetry?.(attempt, classified, delayMs);
+            retries.push({ attempt, error: classified, delayMs });
+            totalDelayMs += delayMs;
+            await sleep(delayMs);
+        }
+    }
+    // Unreachable, but TypeScript needs it
+    throw new Error("withRetry: unexpected exit from retry loop");
+}
+/**
+ * Simpler version of withRetry that just returns T (no metadata).
+ * For use in places where you just want automatic retry without caring about details.
+ */
+export async function withRetrySimple(fn, maxRetries) {
+    const result = await withRetry(fn, maxRetries !== undefined ? { maxRetries } : undefined);
+    return result.data;
+}
+/**
+ * Wrap an ExchangeAdapter so every async method is automatically retried.
+ *
+ * Returns a Proxy that intercepts property access:
+ * - For non-function properties (like `name`), returns the value directly.
+ * - For function properties, returns a wrapper that calls `withRetry` around the original method.
+ */
+export function wrapAdapterWithRetry(adapter, opts) {
+    return new Proxy(adapter, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, receiver);
+            // Pass through non-function properties (e.g., `name` getter)
+            if (typeof value !== "function") {
+                return value;
+            }
+            // Wrap function in retry logic
+            return async function (...args) {
+                const result = await withRetry(() => value.apply(target, args), opts);
+                return result.data;
+            };
+        },
+    });
+}

package/dist/risk.d.ts

@@ -0,0 +1,48 @@
+import type { ExchangeBalance, ExchangePosition } from "./exchanges/interface.js";
+export interface RiskLimits {
+    maxDrawdownUsd: number;
+    maxPositionUsd: number;
+    maxTotalExposureUsd: number;
+    dailyLossLimitUsd: number;
+    maxPositions: number;
+    maxLeverage: number;
+    maxMarginUtilization: number;
+}
+export declare function loadRiskLimits(): RiskLimits;
+export declare function saveRiskLimits(limits: RiskLimits): void;
+export type RiskLevel = "low" | "medium" | "high" | "critical";
+export interface RiskViolation {
+    rule: string;
+    severity: RiskLevel;
+    message: string;
+    current: number;
+    limit: number;
+}
+export interface RiskAssessment {
+    level: RiskLevel;
+    violations: RiskViolation[];
+    metrics: {
+        totalEquity: number;
+        totalUnrealizedPnl: number;
+        totalMarginUsed: number;
+        totalExposure: number;
+        positionCount: number;
+        marginUtilization: number;
+        largestPositionUsd: number;
+        maxLeverageUsed: number;
+    };
+    limits: RiskLimits;
+    canTrade: boolean;
+}
+export declare function assessRisk(balances: {
+    exchange: string;
+    balance: ExchangeBalance;
+}[], positions: {
+    exchange: string;
+    position: ExchangePosition;
+}[], limits?: RiskLimits): RiskAssessment;
+/** Pre-trade check: would this new order violate risk limits? */
+export declare function preTradeCheck(assessment: RiskAssessment, newOrderNotional: number, newOrderLeverage: number): {
+    allowed: boolean;
+    reason?: string;
+};

package/dist/risk.js

@@ -0,0 +1,156 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { resolve } from "path";
+const DEFAULT_LIMITS = {
+    maxDrawdownUsd: 500,
+    maxPositionUsd: 5000,
+    maxTotalExposureUsd: 20000,
+    dailyLossLimitUsd: 200,
+    maxPositions: 10,
+    maxLeverage: 20,
+    maxMarginUtilization: 80,
+};
+const PERP_DIR = resolve(process.env.HOME || "~", ".perp");
+const RISK_FILE = resolve(PERP_DIR, "risk.json");
+export function loadRiskLimits() {
+    if (!existsSync(RISK_FILE))
+        return { ...DEFAULT_LIMITS };
+    try {
+        const stored = JSON.parse(readFileSync(RISK_FILE, "utf-8"));
+        return { ...DEFAULT_LIMITS, ...stored };
+    }
+    catch {
+        return { ...DEFAULT_LIMITS };
+    }
+}
+export function saveRiskLimits(limits) {
+    if (!existsSync(PERP_DIR))
+        mkdirSync(PERP_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(RISK_FILE, JSON.stringify(limits, null, 2), { mode: 0o600 });
+}
+export function assessRisk(balances, positions, limits) {
+    const lim = limits ?? loadRiskLimits();
+    const violations = [];
+    // Compute metrics
+    let totalEquity = 0;
+    let totalUnrealizedPnl = 0;
+    let totalMarginUsed = 0;
+    for (const { balance } of balances) {
+        totalEquity += Number(balance.equity);
+        totalUnrealizedPnl += Number(balance.unrealizedPnl);
+        totalMarginUsed += Number(balance.marginUsed);
+    }
+    let totalExposure = 0;
+    let largestPositionUsd = 0;
+    let maxLeverageUsed = 0;
+    for (const { position: p } of positions) {
+        const notional = Math.abs(Number(p.size) * Number(p.markPrice));
+        totalExposure += notional;
+        if (notional > largestPositionUsd)
+            largestPositionUsd = notional;
+        const lev = Number(p.leverage) || 0;
+        if (lev > maxLeverageUsed)
+            maxLeverageUsed = lev;
+    }
+    const marginUtilization = totalEquity > 0 ? (totalMarginUsed / totalEquity) * 100 : 0;
+    // Check violations
+    if (totalUnrealizedPnl < -lim.maxDrawdownUsd) {
+        violations.push({
+            rule: "max_drawdown",
+            severity: "critical",
+            message: `Unrealized loss $${Math.abs(totalUnrealizedPnl).toFixed(2)} exceeds max drawdown $${lim.maxDrawdownUsd}`,
+            current: Math.abs(totalUnrealizedPnl),
+            limit: lim.maxDrawdownUsd,
+        });
+    }
+    if (largestPositionUsd > lim.maxPositionUsd) {
+        violations.push({
+            rule: "max_position_size",
+            severity: "high",
+            message: `Largest position $${largestPositionUsd.toFixed(2)} exceeds limit $${lim.maxPositionUsd}`,
+            current: largestPositionUsd,
+            limit: lim.maxPositionUsd,
+        });
+    }
+    if (totalExposure > lim.maxTotalExposureUsd) {
+        violations.push({
+            rule: "max_total_exposure",
+            severity: "high",
+            message: `Total exposure $${totalExposure.toFixed(2)} exceeds limit $${lim.maxTotalExposureUsd}`,
+            current: totalExposure,
+            limit: lim.maxTotalExposureUsd,
+        });
+    }
+    if (positions.length > lim.maxPositions) {
+        violations.push({
+            rule: "max_positions",
+            severity: "medium",
+            message: `${positions.length} positions exceeds limit of ${lim.maxPositions}`,
+            current: positions.length,
+            limit: lim.maxPositions,
+        });
+    }
+    if (maxLeverageUsed > lim.maxLeverage) {
+        violations.push({
+            rule: "max_leverage",
+            severity: "high",
+            message: `Leverage ${maxLeverageUsed}x exceeds limit ${lim.maxLeverage}x`,
+            current: maxLeverageUsed,
+            limit: lim.maxLeverage,
+        });
+    }
+    if (marginUtilization > lim.maxMarginUtilization) {
+        violations.push({
+            rule: "max_margin_utilization",
+            severity: marginUtilization > 90 ? "critical" : "high",
+            message: `Margin utilization ${marginUtilization.toFixed(1)}% exceeds limit ${lim.maxMarginUtilization}%`,
+            current: marginUtilization,
+            limit: lim.maxMarginUtilization,
+        });
+    }
+    // Determine overall risk level
+    let level = "low";
+    if (violations.some(v => v.severity === "critical"))
+        level = "critical";
+    else if (violations.some(v => v.severity === "high"))
+        level = "high";
+    else if (violations.some(v => v.severity === "medium"))
+        level = "medium";
+    // Can trade only if no critical violations
+    const canTrade = !violations.some(v => v.severity === "critical");
+    return {
+        level,
+        violations,
+        metrics: {
+            totalEquity,
+            totalUnrealizedPnl,
+            totalMarginUsed,
+            totalExposure,
+            positionCount: positions.length,
+            marginUtilization,
+            largestPositionUsd,
+            maxLeverageUsed,
+        },
+        limits: lim,
+        canTrade,
+    };
+}
+/** Pre-trade check: would this new order violate risk limits? */
+export function preTradeCheck(assessment, newOrderNotional, newOrderLeverage) {
+    if (!assessment.canTrade) {
+        return { allowed: false, reason: "Trading suspended: critical risk violation active" };
+    }
+    const lim = assessment.limits;
+    if (newOrderNotional > lim.maxPositionUsd) {
+        return { allowed: false, reason: `Order notional $${newOrderNotional.toFixed(0)} exceeds max position size $${lim.maxPositionUsd}` };
+    }
+    if (assessment.metrics.totalExposure + newOrderNotional > lim.maxTotalExposureUsd) {
+        return { allowed: false, reason: `Would exceed total exposure limit ($${(assessment.metrics.totalExposure + newOrderNotional).toFixed(0)} > $${lim.maxTotalExposureUsd})` };
+    }
+    if (assessment.metrics.positionCount + 1 > lim.maxPositions) {
+        return { allowed: false, reason: `Would exceed max positions (${assessment.metrics.positionCount + 1} > ${lim.maxPositions})` };
+    }
+    if (newOrderLeverage > lim.maxLeverage) {
+        return { allowed: false, reason: `Leverage ${newOrderLeverage}x exceeds max ${lim.maxLeverage}x` };
+    }
+    return { allowed: true };
+}

package/dist/settings.d.ts

@@ -0,0 +1,19 @@
+export interface Settings {
+    /** Default exchange when -e flag is omitted */
+    defaultExchange: string;
+    /** Enable referral/builder codes (default: false — opt-in only) */
+    referrals: boolean;
+    /** Per-exchange referral codes (used when referrals=true) */
+    referralCodes: {
+        pacifica: string;
+        hyperliquid: string;
+        lighter: string;
+    };
+    /** Track which exchanges have had referral codes applied (one-time) */
+    referralApplied: {
+        hyperliquid: boolean;
+        lighter: boolean;
+    };
+}
+export declare function loadSettings(): Settings;
+export declare function saveSettings(settings: Settings): void;

package/dist/settings.js

@@ -0,0 +1,45 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { resolve } from "path";
+const PERP_DIR = resolve(process.env.HOME || "~", ".perp");
+const SETTINGS_FILE = resolve(PERP_DIR, "settings.json");
+const DEFAULTS = {
+    defaultExchange: "",
+    referrals: false,
+    referralCodes: {
+        pacifica: "",
+        hyperliquid: "HYPERCASH",
+        lighter: "718585MY",
+    },
+    referralApplied: {
+        hyperliquid: false,
+        lighter: false,
+    },
+};
+export function loadSettings() {
+    if (!existsSync(SETTINGS_FILE))
+        return { ...DEFAULTS, referralCodes: { ...DEFAULTS.referralCodes } };
+    try {
+        const stored = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
+        return {
+            defaultExchange: stored.defaultExchange ?? DEFAULTS.defaultExchange,
+            referrals: stored.referrals ?? DEFAULTS.referrals,
+            referralCodes: {
+                pacifica: stored.referralCodes?.pacifica ?? DEFAULTS.referralCodes.pacifica,
+                hyperliquid: stored.referralCodes?.hyperliquid ?? DEFAULTS.referralCodes.hyperliquid,
+                lighter: stored.referralCodes?.lighter ?? DEFAULTS.referralCodes.lighter,
+            },
+            referralApplied: {
+                hyperliquid: stored.referralApplied?.hyperliquid ?? DEFAULTS.referralApplied.hyperliquid,
+                lighter: stored.referralApplied?.lighter ?? DEFAULTS.referralApplied.lighter,
+            },
+        };
+    }
+    catch {
+        return { ...DEFAULTS, referralCodes: { ...DEFAULTS.referralCodes } };
+    }
+}
+export function saveSettings(settings) {
+    if (!existsSync(PERP_DIR))
+        mkdirSync(PERP_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), { mode: 0o600 });
+}

package/dist/shared-api.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Barrel re-export wrapper for backward compatibility.
+ * Actual implementation moved to src/api/public/.
+ */
+export * from "./api/public/index.js";

package/dist/shared-api.js

@@ -0,0 +1,5 @@
+/**
+ * Barrel re-export wrapper for backward compatibility.
+ * Actual implementation moved to src/api/public/.
+ */
+export * from "./api/public/index.js";

package/dist/strategies/dca.d.ts

@@ -0,0 +1,25 @@
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export interface DCAParams {
+    symbol: string;
+    side: "buy" | "sell";
+    amountPerOrder: number;
+    intervalSec: number;
+    totalOrders: number;
+    priceLimit?: number;
+    maxRuntime?: number;
+}
+export interface DCAState {
+    ordersPlaced: number;
+    totalFilled: number;
+    totalCost: number;
+    avgPrice: number;
+    errors: number;
+    startedAt: number;
+    running: boolean;
+}
+export declare function runDCA(adapter: ExchangeAdapter, params: DCAParams, jobId?: string, log?: (msg: string) => void): Promise<{
+    ordersPlaced: number;
+    totalFilled: number;
+    avgPrice: number;
+    runtime: number;
+}>;