perp-cli 0.3.3

package/dist/plan-executor.d.ts

@@ -0,0 +1,48 @@
+import type { ExchangeAdapter } from "./exchanges/interface.js";
+export type PlanAction = "market_order" | "limit_order" | "stop_order" | "cancel_order" | "cancel_all" | "set_leverage" | "close_position" | "wait" | "check_balance" | "check_position";
+export interface PlanStep {
+    id: string;
+    action: PlanAction;
+    params: Record<string, unknown>;
+    onFailure?: "abort" | "skip" | "rollback";
+    dependsOn?: string;
+    clientId?: string;
+}
+export interface ExecutionPlan {
+    version: "1.0";
+    exchange?: string;
+    description?: string;
+    steps: PlanStep[];
+}
+export interface StepResult {
+    stepId: string;
+    action: PlanAction;
+    status: "success" | "failed" | "skipped" | "rolled_back" | "dry_run";
+    result?: unknown;
+    error?: {
+        code: string;
+        message: string;
+    };
+    durationMs: number;
+}
+export interface PlanResult {
+    planId: string;
+    status: "completed" | "partial" | "failed" | "dry_run";
+    steps: StepResult[];
+    totalDurationMs: number;
+    timestamp: string;
+}
+/**
+ * Validate a plan structure without executing it.
+ */
+export declare function validatePlan(plan: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Execute a plan step by step.
+ */
+export declare function executePlan(adapter: ExchangeAdapter, plan: ExecutionPlan, opts?: {
+    dryRun?: boolean;
+    log?: (msg: string) => void;
+}): Promise<PlanResult>;

package/dist/plan-executor.js

@@ -0,0 +1,280 @@
+import { symbolMatch } from "./utils.js";
+import { logExecution } from "./execution-log.js";
+import { randomUUID } from "crypto";
+/**
+ * Validate a plan structure without executing it.
+ */
+export function validatePlan(plan) {
+    const errors = [];
+    if (!plan || typeof plan !== "object") {
+        errors.push("Plan must be an object");
+        return { valid: false, errors };
+    }
+    const p = plan;
+    if (p.version !== "1.0")
+        errors.push(`Unsupported version: ${p.version} (expected "1.0")`);
+    if (!Array.isArray(p.steps)) {
+        errors.push("steps must be an array");
+        return { valid: false, errors };
+    }
+    if (p.steps.length === 0)
+        errors.push("Plan has no steps");
+    const validActions = new Set(["market_order", "limit_order", "stop_order", "cancel_order", "cancel_all", "set_leverage", "close_position", "wait", "check_balance", "check_position"]);
+    const ids = new Set();
+    for (let i = 0; i < p.steps.length; i++) {
+        const step = p.steps[i];
+        if (!step.id)
+            errors.push(`Step ${i}: missing id`);
+        if (ids.has(String(step.id)))
+            errors.push(`Step ${i}: duplicate id "${step.id}"`);
+        ids.add(String(step.id));
+        if (!step.action || !validActions.has(String(step.action)))
+            errors.push(`Step ${i}: invalid action "${step.action}"`);
+        if (step.onFailure && !["abort", "skip", "rollback"].includes(String(step.onFailure))) {
+            errors.push(`Step ${i}: invalid onFailure "${step.onFailure}"`);
+        }
+        if (step.dependsOn && !ids.has(String(step.dependsOn))) {
+            // dependsOn might reference a later step or non-existent
+            // Check if any step has that id
+            const found = p.steps.some(s => s.id === step.dependsOn);
+            if (!found)
+                errors.push(`Step ${i}: dependsOn "${step.dependsOn}" not found`);
+        }
+        // Validate params per action
+        const params = (step.params || {});
+        const action = String(step.action);
+        if (["market_order", "limit_order", "stop_order"].includes(action)) {
+            if (!params.symbol)
+                errors.push(`Step ${i} (${action}): missing params.symbol`);
+            if (!params.side)
+                errors.push(`Step ${i} (${action}): missing params.side`);
+            if (!params.size)
+                errors.push(`Step ${i} (${action}): missing params.size`);
+        }
+        if (action === "limit_order" && !params.price)
+            errors.push(`Step ${i} (limit_order): missing params.price`);
+        if (action === "stop_order" && !params.triggerPrice)
+            errors.push(`Step ${i} (stop_order): missing params.triggerPrice`);
+        if (action === "cancel_order" && (!params.symbol || !params.orderId))
+            errors.push(`Step ${i} (cancel_order): missing params.symbol or params.orderId`);
+        if (action === "set_leverage" && (!params.symbol || !params.leverage))
+            errors.push(`Step ${i} (set_leverage): missing params.symbol or params.leverage`);
+        if (action === "wait" && !params.ms)
+            errors.push(`Step ${i} (wait): missing params.ms`);
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Execute a plan step by step.
+ */
+export async function executePlan(adapter, plan, opts) {
+    const planId = randomUUID().slice(0, 8);
+    const startTime = Date.now();
+    const results = [];
+    const completedSteps = new Map();
+    const dryRun = opts?.dryRun ?? false;
+    const log = opts?.log ?? (() => { });
+    log(`[plan:${planId}] Starting ${plan.steps.length} steps (${dryRun ? "DRY RUN" : "LIVE"})`);
+    for (const step of plan.steps) {
+        const stepStart = Date.now();
+        // Check dependency
+        if (step.dependsOn) {
+            const dep = completedSteps.get(step.dependsOn);
+            if (!dep || dep.status === "failed") {
+                const result = {
+                    stepId: step.id,
+                    action: step.action,
+                    status: "skipped",
+                    error: { code: "DEPENDENCY_FAILED", message: `Depends on ${step.dependsOn} which failed/missing` },
+                    durationMs: 0,
+                };
+                results.push(result);
+                completedSteps.set(step.id, result);
+                continue;
+            }
+        }
+        if (dryRun) {
+            const result = {
+                stepId: step.id,
+                action: step.action,
+                status: "dry_run",
+                result: { params: step.params, wouldExecute: true },
+                durationMs: Date.now() - stepStart,
+            };
+            results.push(result);
+            completedSteps.set(step.id, result);
+            log(`[plan:${planId}] Step ${step.id} (${step.action}): dry run OK`);
+            continue;
+        }
+        try {
+            const result = await executeStep(adapter, step, log);
+            const stepResult = {
+                stepId: step.id,
+                action: step.action,
+                status: "success",
+                result,
+                durationMs: Date.now() - stepStart,
+            };
+            results.push(stepResult);
+            completedSteps.set(step.id, stepResult);
+            log(`[plan:${planId}] Step ${step.id} (${step.action}): success (${stepResult.durationMs}ms)`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const onFailure = step.onFailure ?? "abort";
+            log(`[plan:${planId}] Step ${step.id} (${step.action}): FAILED — ${message}`);
+            if (onFailure === "skip") {
+                results.push({
+                    stepId: step.id,
+                    action: step.action,
+                    status: "skipped",
+                    error: { code: "STEP_FAILED", message },
+                    durationMs: Date.now() - stepStart,
+                });
+                completedSteps.set(step.id, results[results.length - 1]);
+                continue;
+            }
+            if (onFailure === "rollback") {
+                log(`[plan:${planId}] Rolling back completed steps...`);
+                await rollbackSteps(adapter, results.filter(r => r.status === "success"), log);
+                results.push({
+                    stepId: step.id,
+                    action: step.action,
+                    status: "rolled_back",
+                    error: { code: "STEP_FAILED", message },
+                    durationMs: Date.now() - stepStart,
+                });
+                return {
+                    planId,
+                    status: "failed",
+                    steps: results,
+                    totalDurationMs: Date.now() - startTime,
+                    timestamp: new Date().toISOString(),
+                };
+            }
+            // abort
+            results.push({
+                stepId: step.id,
+                action: step.action,
+                status: "failed",
+                error: { code: "STEP_FAILED", message },
+                durationMs: Date.now() - stepStart,
+            });
+            return {
+                planId,
+                status: results.some(r => r.status === "success") ? "partial" : "failed",
+                steps: results,
+                totalDurationMs: Date.now() - startTime,
+                timestamp: new Date().toISOString(),
+            };
+        }
+    }
+    return {
+        planId,
+        status: dryRun ? "dry_run" : "completed",
+        steps: results,
+        totalDurationMs: Date.now() - startTime,
+        timestamp: new Date().toISOString(),
+    };
+}
+async function executeStep(adapter, step, log) {
+    const p = step.params;
+    const symbol = String(p.symbol ?? "").toUpperCase();
+    const side = String(p.side ?? "");
+    const size = String(p.size ?? "");
+    switch (step.action) {
+        case "market_order": {
+            const result = await adapter.marketOrder(symbol, side, size);
+            logExecution({ type: "market_order", exchange: adapter.name, symbol, side, size, status: "success", dryRun: false, meta: { planStep: step.id, clientId: step.clientId } });
+            return result;
+        }
+        case "limit_order": {
+            const price = String(p.price ?? "");
+            const result = await adapter.limitOrder(symbol, side, price, size);
+            logExecution({ type: "limit_order", exchange: adapter.name, symbol, side, size, price, status: "success", dryRun: false, meta: { planStep: step.id, clientId: step.clientId } });
+            return result;
+        }
+        case "stop_order": {
+            const triggerPrice = String(p.triggerPrice ?? "");
+            const limitPrice = p.limitPrice ? String(p.limitPrice) : undefined;
+            return adapter.stopOrder(symbol, side, size, triggerPrice, { limitPrice, reduceOnly: !!p.reduceOnly });
+        }
+        case "cancel_order": {
+            return adapter.cancelOrder(symbol, String(p.orderId ?? ""));
+        }
+        case "cancel_all": {
+            return adapter.cancelAllOrders(symbol || undefined);
+        }
+        case "set_leverage": {
+            const lev = Number(p.leverage);
+            const mode = p.marginMode ?? "cross";
+            return adapter.setLeverage(symbol, lev, mode);
+        }
+        case "close_position": {
+            const positions = await adapter.getPositions();
+            const pos = positions.find(pp => symbolMatch(pp.symbol, symbol));
+            if (!pos)
+                throw new Error(`No position found for ${symbol}`);
+            const closeSide = pos.side === "long" ? "sell" : "buy";
+            const result = await adapter.marketOrder(pos.symbol, closeSide, pos.size);
+            logExecution({ type: "market_order", exchange: adapter.name, symbol, side: closeSide, size: pos.size, status: "success", dryRun: false, meta: { planStep: step.id, action: "close_position" } });
+            return result;
+        }
+        case "wait": {
+            const ms = Number(p.ms ?? 1000);
+            log(`[wait] ${ms}ms`);
+            await new Promise(r => setTimeout(r, ms));
+            return { waited: ms };
+        }
+        case "check_balance": {
+            const balance = await adapter.getBalance();
+            const minAvailable = Number(p.minAvailable ?? 0);
+            if (minAvailable > 0 && Number(balance.available) < minAvailable) {
+                throw new Error(`Balance check failed: $${balance.available} available < $${minAvailable} required`);
+            }
+            return balance;
+        }
+        case "check_position": {
+            const positions = await adapter.getPositions();
+            const pos = positions.find(pp => symbolMatch(pp.symbol, symbol));
+            if (p.mustExist && !pos)
+                throw new Error(`Position ${symbol} not found`);
+            if (p.mustNotExist && pos)
+                throw new Error(`Position ${symbol} exists but should not`);
+            return pos ?? { symbol, exists: false };
+        }
+        default:
+            throw new Error(`Unknown action: ${step.action}`);
+    }
+}
+/**
+ * Attempt to rollback completed steps by performing inverse operations.
+ */
+async function rollbackSteps(adapter, completedSteps, log) {
+    // Rollback in reverse order
+    for (let i = completedSteps.length - 1; i >= 0; i--) {
+        const step = completedSteps[i];
+        try {
+            switch (step.action) {
+                case "market_order":
+                case "limit_order": {
+                    // Close the position that was opened
+                    // This is best-effort — market conditions may have changed
+                    log(`[rollback] Attempting to reverse ${step.action} ${step.stepId}`);
+                    // We'd need position info; just cancel any pending orders as safety measure
+                    await adapter.cancelAllOrders().catch(() => { });
+                    break;
+                }
+                case "cancel_order":
+                case "cancel_all":
+                    // Can't un-cancel, skip
+                    break;
+                default:
+                    break;
+            }
+        }
+        catch (err) {
+            log(`[rollback] Failed to rollback step ${step.stepId}: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+}

package/dist/position-history.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Position history — persists position lifecycle events to ~/.perp/positions.jsonl
+ * Enables agents to review past trades, analyze P&L, and learn from history.
+ */
+import type { StreamEvent } from "./event-stream.js";
+export interface PositionRecord {
+    id: string;
+    exchange: string;
+    symbol: string;
+    side: "long" | "short";
+    entryPrice: string;
+    exitPrice?: string;
+    size: string;
+    realizedPnl?: string;
+    unrealizedPnl?: string;
+    openedAt: string;
+    closedAt?: string;
+    updatedAt: string;
+    status: "open" | "closed" | "updated";
+    duration?: number;
+    meta?: Record<string, unknown>;
+}
+export interface PositionStats {
+    totalTrades: number;
+    wins: number;
+    losses: number;
+    winRate: number;
+    totalPnl: number;
+    avgPnl: number;
+    bestTrade: number;
+    worstTrade: number;
+    avgDuration: number;
+    longestTrade: number;
+    shortestTrade: number;
+    bySymbol: Record<string, {
+        trades: number;
+        pnl: number;
+        winRate: number;
+    }>;
+    byExchange: Record<string, {
+        trades: number;
+        pnl: number;
+    }>;
+}
+/** Append a position record to the log */
+export declare function logPosition(record: PositionRecord): void;
+/** Read position history with optional filters */
+export declare function readPositionHistory(opts?: {
+    symbol?: string;
+    exchange?: string;
+    status?: string;
+    limit?: number;
+    since?: string;
+}): PositionRecord[];
+/** Compute aggregate stats from closed position records */
+export declare function getPositionStats(opts?: {
+    exchange?: string;
+    since?: string;
+}): PositionStats;
+/**
+ * Returns a wrapper around the event callback that intercepts position events
+ * and logs them to the position history file.
+ *
+ * Usage:
+ *   const loggedOnEvent = attachPositionLogger(originalOnEvent);
+ *   startEventStream(adapter, { onEvent: loggedOnEvent, ... });
+ */
+export declare function attachPositionLogger(onEvent: (event: StreamEvent) => void): (event: StreamEvent) => void;

package/dist/position-history.js

@@ -0,0 +1,222 @@
+/**
+ * Position history — persists position lifecycle events to ~/.perp/positions.jsonl
+ * Enables agents to review past trades, analyze P&L, and learn from history.
+ */
+import { existsSync, appendFileSync, readFileSync, mkdirSync } from "fs";
+import { resolve } from "path";
+const PERP_DIR = resolve(process.env.HOME || "~", ".perp");
+const POSITIONS_FILE = resolve(PERP_DIR, "positions.jsonl");
+function ensureDir() {
+    if (!existsSync(PERP_DIR))
+        mkdirSync(PERP_DIR, { recursive: true, mode: 0o700 });
+}
+function genId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/** Append a position record to the log */
+export function logPosition(record) {
+    ensureDir();
+    appendFileSync(POSITIONS_FILE, JSON.stringify(record) + "\n", { mode: 0o600 });
+}
+/** Read position history with optional filters */
+export function readPositionHistory(opts) {
+    if (!existsSync(POSITIONS_FILE))
+        return [];
+    const lines = readFileSync(POSITIONS_FILE, "utf-8").trim().split("\n").filter(Boolean);
+    let records = lines.map(line => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    }).filter(Boolean);
+    // Apply filters
+    if (opts?.exchange) {
+        records = records.filter(r => r.exchange === opts.exchange);
+    }
+    if (opts?.symbol) {
+        records = records.filter(r => r.symbol.toUpperCase().includes(opts.symbol.toUpperCase()));
+    }
+    if (opts?.status) {
+        records = records.filter(r => r.status === opts.status);
+    }
+    if (opts?.since) {
+        const sinceDate = new Date(opts.since).getTime();
+        records = records.filter(r => new Date(r.updatedAt).getTime() >= sinceDate);
+    }
+    // Sort newest first
+    records.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    // Limit
+    if (opts?.limit) {
+        records = records.slice(0, opts.limit);
+    }
+    return records;
+}
+/** Compute aggregate stats from closed position records */
+export function getPositionStats(opts) {
+    const records = readPositionHistory({
+        exchange: opts?.exchange,
+        status: "closed",
+        since: opts?.since,
+    });
+    const stats = {
+        totalTrades: 0,
+        wins: 0,
+        losses: 0,
+        winRate: 0,
+        totalPnl: 0,
+        avgPnl: 0,
+        bestTrade: 0,
+        worstTrade: 0,
+        avgDuration: 0,
+        longestTrade: 0,
+        shortestTrade: Infinity,
+        bySymbol: {},
+        byExchange: {},
+    };
+    if (records.length === 0) {
+        stats.shortestTrade = 0;
+        return stats;
+    }
+    let totalDuration = 0;
+    let durationCount = 0;
+    for (const r of records) {
+        stats.totalTrades++;
+        const pnl = Number(r.realizedPnl ?? 0);
+        if (pnl > 0)
+            stats.wins++;
+        else if (pnl < 0)
+            stats.losses++;
+        stats.totalPnl += pnl;
+        if (pnl > stats.bestTrade)
+            stats.bestTrade = pnl;
+        if (pnl < stats.worstTrade)
+            stats.worstTrade = pnl;
+        if (r.duration !== undefined && r.duration > 0) {
+            totalDuration += r.duration;
+            durationCount++;
+            if (r.duration > stats.longestTrade)
+                stats.longestTrade = r.duration;
+            if (r.duration < stats.shortestTrade)
+                stats.shortestTrade = r.duration;
+        }
+        // By symbol
+        if (!stats.bySymbol[r.symbol]) {
+            stats.bySymbol[r.symbol] = { trades: 0, pnl: 0, winRate: 0 };
+        }
+        stats.bySymbol[r.symbol].trades++;
+        stats.bySymbol[r.symbol].pnl += pnl;
+        // By exchange
+        if (!stats.byExchange[r.exchange]) {
+            stats.byExchange[r.exchange] = { trades: 0, pnl: 0 };
+        }
+        stats.byExchange[r.exchange].trades++;
+        stats.byExchange[r.exchange].pnl += pnl;
+    }
+    stats.winRate = stats.totalTrades > 0 ? (stats.wins / stats.totalTrades) * 100 : 0;
+    stats.avgPnl = stats.totalTrades > 0 ? stats.totalPnl / stats.totalTrades : 0;
+    stats.avgDuration = durationCount > 0 ? totalDuration / durationCount : 0;
+    if (stats.shortestTrade === Infinity)
+        stats.shortestTrade = 0;
+    // Compute per-symbol win rates
+    // We need to recount wins per symbol from the records
+    const symbolWins = {};
+    for (const r of records) {
+        const pnl = Number(r.realizedPnl ?? 0);
+        if (pnl > 0) {
+            symbolWins[r.symbol] = (symbolWins[r.symbol] ?? 0) + 1;
+        }
+    }
+    for (const sym of Object.keys(stats.bySymbol)) {
+        const wins = symbolWins[sym] ?? 0;
+        stats.bySymbol[sym].winRate = stats.bySymbol[sym].trades > 0
+            ? (wins / stats.bySymbol[sym].trades) * 100
+            : 0;
+    }
+    return stats;
+}
+/**
+ * Returns a wrapper around the event callback that intercepts position events
+ * and logs them to the position history file.
+ *
+ * Usage:
+ *   const loggedOnEvent = attachPositionLogger(originalOnEvent);
+ *   startEventStream(adapter, { onEvent: loggedOnEvent, ... });
+ */
+export function attachPositionLogger(onEvent) {
+    // Track open positions to compute duration on close
+    const openPositions = new Map();
+    return (event) => {
+        const ts = event.timestamp;
+        const exchange = event.exchange;
+        const data = event.data;
+        if (event.type === "position_opened") {
+            const id = genId();
+            const symbol = String(data.symbol ?? "");
+            const side = String(data.side ?? "long");
+            const key = `${exchange}:${symbol}`;
+            openPositions.set(key, { id, openedAt: ts, entryPrice: String(data.entryPrice ?? "") });
+            logPosition({
+                id,
+                exchange,
+                symbol,
+                side,
+                entryPrice: String(data.entryPrice ?? ""),
+                size: String(data.size ?? ""),
+                unrealizedPnl: String(data.unrealizedPnl ?? ""),
+                openedAt: ts,
+                updatedAt: ts,
+                status: "open",
+            });
+        }
+        else if (event.type === "position_updated") {
+            const symbol = String(data.symbol ?? "");
+            const side = String(data.side ?? "long");
+            const key = `${exchange}:${symbol}`;
+            const tracked = openPositions.get(key);
+            logPosition({
+                id: tracked?.id ?? genId(),
+                exchange,
+                symbol,
+                side,
+                entryPrice: String(data.entryPrice ?? tracked?.entryPrice ?? ""),
+                size: String(data.size ?? ""),
+                unrealizedPnl: String(data.unrealizedPnl ?? ""),
+                openedAt: tracked?.openedAt ?? ts,
+                updatedAt: ts,
+                status: "updated",
+                meta: {
+                    prevSize: data.prevSize,
+                    prevSide: data.prevSide,
+                },
+            });
+        }
+        else if (event.type === "position_closed") {
+            const symbol = String(data.symbol ?? "");
+            const side = String(data.side ?? "long");
+            const key = `${exchange}:${symbol}`;
+            const tracked = openPositions.get(key);
+            const openedAt = tracked?.openedAt ?? ts;
+            const duration = new Date(ts).getTime() - new Date(openedAt).getTime();
+            const realizedPnl = String(data.unrealizedPnl ?? "0");
+            logPosition({
+                id: tracked?.id ?? genId(),
+                exchange,
+                symbol,
+                side,
+                entryPrice: String(data.entryPrice ?? tracked?.entryPrice ?? ""),
+                size: String(data.size ?? ""),
+                realizedPnl,
+                openedAt,
+                closedAt: ts,
+                updatedAt: ts,
+                status: "closed",
+                duration: duration > 0 ? duration : undefined,
+            });
+            openPositions.delete(key);
+        }
+        // Always forward the event to the original callback
+        onEvent(event);
+    };
+}

package/dist/rebalance.d.ts

@@ -0,0 +1,64 @@
+import type { ExchangeAdapter } from "./exchanges/interface.js";
+/**
+ * Cross-exchange rebalancing engine.
+ *
+ * Checks balances across exchanges, computes a rebalancing plan,
+ * and optionally executes withdraw → bridge → deposit pipeline.
+ */
+export interface ExchangeBalanceSnapshot {
+    exchange: string;
+    equity: number;
+    available: number;
+    marginUsed: number;
+    unrealizedPnl: number;
+}
+export interface RebalancePlan {
+    snapshots: ExchangeBalanceSnapshot[];
+    totalEquity: number;
+    targetPerExchange: number;
+    moves: RebalanceMove[];
+    summary: string;
+}
+export interface RebalanceMove {
+    from: string;
+    to: string;
+    amount: number;
+    reason: string;
+}
+/**
+ * Fetch balances from all exchanges in parallel.
+ */
+export declare function fetchAllBalances(adapters: Map<string, ExchangeAdapter>): Promise<ExchangeBalanceSnapshot[]>;
+/**
+ * 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 declare function computeRebalancePlan(snapshots: ExchangeBalanceSnapshot[], opts?: {
+    /** Minimum move amount to bother with ($) */
+    minMove?: number;
+    /** Target allocation weights (default: equal). Keys = exchange names, values = 0-1 weights summing to 1 */
+    weights?: Record<string, number>;
+    /** Reserve: keep at least this much available on each exchange */
+    reserve?: number;
+}): RebalancePlan;
+/**
+ * Check if an exchange has enough available balance for a given trade size.
+ */
+export declare function hasEnoughBalance(snapshots: ExchangeBalanceSnapshot[], exchange: string, requiredUsd: number, marginBuffer?: number): boolean;
+/**
+ * Get the chain/bridge info for an exchange.
+ */
+export declare function getExchangeChain(exchange: string): {
+    chain: string;
+};
+/**
+ * Describe the bridge route for a rebalance move.
+ */
+export declare function describeBridgeRoute(move: RebalanceMove): string;
+/**
+ * Estimate total time for a rebalance move.
+ */
+export declare function estimateMoveTime(move: RebalanceMove): string;