perp-cli 0.14.0 → 0.14.2

package/dist/exchanges/pacifica.js

@@ -332,6 +332,23 @@ function spotInfoSymbols(rows) {
 export function isPacificaStopType(type) {
     return /^(stop|take_profit|stop_loss)_/.test(type);
 }
+/** Fill sides of GET /trades/history (position effect) plus the order sides bid / ask. */
+const PACIFICA_FILL_BUY_SIDES = new Set(["open_long", "close_short", "bid"]);
+const PACIFICA_FILL_SELL_SIDES = new Set(["open_short", "close_long", "ask"]);
+/** `created_at` (ms) of a Pacifica history row; non-numeric → EXCHANGE_ERROR (never NaN). */
+function pacificaTime(row, endpoint) {
+    const t = Number(pacificaField(row, "created_at", endpoint));
+    if (!Number.isFinite(t))
+        throw new PerpError("EXCHANGE_ERROR", `Pacifica ${endpoint} row with a non-numeric created_at`, { exchange: "pacifica" });
+    return t;
+}
+/** A required field of a Pacifica history row as a string; missing / empty → EXCHANGE_ERROR. */
+function pacificaField(row, key, endpoint) {
+    const v = row[key];
+    if ((typeof v === "string" && v !== "") || (typeof v === "number" && Number.isFinite(v)))
+        return String(v);
+    throw new PerpError("EXCHANGE_ERROR", `Pacifica ${endpoint} row without a readable ${key}: ${JSON.stringify(row).slice(0, 160)}`, { exchange: "pacifica" });
+}
 export class PacificaAdapter {
     name = "pacifica";
     chain = "solana";
@@ -1340,52 +1357,78 @@ export class PacificaAdapter {
             trades: k.n,
         }));
     }
+    /**
+     * Recent orders, newest first (GET /orders/history; PacificaClient.get already unwraps the
+     * `{success, data}` envelope, so the list is the result itself). A non-list or a row without a
+     * readable field → EXCHANGE_ERROR, never an empty list or a placeholder value.
+     */
     async getOrderHistory(limit = 30) {
         if (!this._hasRealKey)
             throw new Error("No private key configured — account data unavailable. Run: perp setup");
-        const result = await this.client.getOrderHistory(this.account);
-        const data = (result.data ?? result.orders ?? []);
-        if (!Array.isArray(data))
-            return [];
-        return data.slice(0, limit).map((o) => ({
-            orderId: String(o.order_id ?? ""),
-            symbol: String(o.symbol ?? ""),
-            side: String(o.side) === "bid" ? "buy" : "sell",
-            price: String(o.initial_price ?? o.price ?? "0"),
-            size: String(o.amount ?? o.initial_amount ?? ""),
-            filled: String(o.filled_amount ?? "0"),
-            status: String(o.order_status ?? "done"),
-            type: String(o.order_type ?? ""),
-            triggerPrice: Number(o.stop_price) > 0 ? String(o.stop_price) : null,
-        }));
+        const rows = await this.client.getOrderHistory(this.account, { limit });
+        if (!Array.isArray(rows)) {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica /orders/history returned no order list (${JSON.stringify(rows).slice(0, 120)})`, { exchange: "pacifica" });
+        }
+        const field = (o, k) => pacificaField(o, k, "/orders/history");
+        return rows.slice(0, limit).map((o) => {
+            const side = field(o, "side");
+            if (side !== "bid" && side !== "ask") {
+                throw new PerpError("EXCHANGE_ERROR", `Pacifica order-history row with unknown side "${side}"`, { exchange: "pacifica" });
+            }
+            return {
+                orderId: field(o, "order_id"),
+                symbol: field(o, "symbol"),
+                side: side === "bid" ? "buy" : "sell",
+                price: field(o, "initial_price"),
+                size: field(o, "amount"),
+                filled: field(o, "filled_amount"),
+                status: field(o, "order_status"),
+                type: field(o, "order_type"),
+                triggerPrice: Number(o.stop_price) > 0 ? String(o.stop_price) : null,
+            };
+        });
     }
+    /**
+     * Recent fills, newest first (GET /trades/history; the client unwraps `{success, data}`).
+     * `side` is the position effect — open_long / close_short buy, open_short / close_long sell
+     * (live 2026-10-13: `"side":"close_short"` on a buy-to-close fill); bid / ask are accepted for
+     * rows that carry an order side. Anything else, a non-list or an unreadable field → EXCHANGE_ERROR.
+     */
     async getTradeHistory(limit = 30) {
         if (!this._hasRealKey)
             throw new Error("No private key configured — account data unavailable. Run: perp setup");
-        const raw = await this.client.getTradeHistory(this.account);
-        const trades = (raw.data ?? raw);
-        if (!Array.isArray(trades))
-            return [];
-        return trades.slice(0, limit).map((t) => ({
-            time: Number(t.created_at ?? 0),
-            symbol: String(t.symbol ?? ""),
-            side: String(t.side) === "bid" ? "buy" : "sell",
-            price: String(t.price ?? "0"),
-            size: String(t.amount ?? ""),
-            fee: String(t.fee ?? "0"),
-        }));
+        const rows = await this.client.getTradeHistory(this.account, { limit });
+        if (!Array.isArray(rows)) {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica /trades/history returned no list (${JSON.stringify(rows).slice(0, 120)})`, { exchange: "pacifica" });
+        }
+        return rows.slice(0, limit).map((t) => {
+            const side = pacificaField(t, "side", "/trades/history");
+            const buy = PACIFICA_FILL_BUY_SIDES.has(side);
+            if (!buy && !PACIFICA_FILL_SELL_SIDES.has(side)) {
+                throw new PerpError("EXCHANGE_ERROR", `Pacifica /trades/history row with unknown side "${side}"`, { exchange: "pacifica" });
+            }
+            return {
+                time: pacificaTime(t, "/trades/history"),
+                symbol: pacificaField(t, "symbol", "/trades/history"),
+                side: buy ? "buy" : "sell",
+                price: pacificaField(t, "price", "/trades/history"),
+                size: pacificaField(t, "amount", "/trades/history"),
+                fee: pacificaField(t, "fee", "/trades/history"),
+            };
+        });
     }
+    /** Funding paid / received per position (GET /funding/history, `payout` signed). Strict like getTradeHistory. */
     async getFundingPayments(limit = 200) {
         if (!this._hasRealKey)
             throw new Error("No private key configured — account data unavailable. Run: perp setup");
-        const raw = await this.client.getFundingAccountHistory(this.account);
-        const history = (raw.data ?? raw);
-        if (!Array.isArray(history))
-            return [];
-        return history.slice(0, limit).map((h) => ({
-            time: Number(h.created_at ?? 0),
-            symbol: String(h.symbol ?? ""),
-            payment: String(h.payout ?? "0"),
+        const rows = await this.client.getFundingAccountHistory(this.account, { limit });
+        if (!Array.isArray(rows)) {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica /funding/history returned no list (${JSON.stringify(rows).slice(0, 120)})`, { exchange: "pacifica" });
+        }
+        return rows.slice(0, limit).map((h) => ({
+            time: pacificaTime(h, "/funding/history"),
+            symbol: pacificaField(h, "symbol", "/funding/history"),
+            payment: pacificaField(h, "payout", "/funding/history"),
         }));
     }
 }

package/dist/exchanges/qfex/adapter.js

@@ -47,7 +47,7 @@ import { alignProtectionPrice, floorSize, requireOnTick, slippagePrice, subDecim
 import { unsupported, validateLegacyTif, validateOrderRequest } from "../trading-v2.js";
 import { requireCapabilities } from "../venue.js";
 import { parseOrderRef, toLegacyMarketInfo } from "../venue-types.js";
-import { QFEX_BANKER_NETWORK, QFEX_ENDPOINTS } from "../venues/qfex.js";
+import { QFEX_BANKER_NETWORK, QFEX_ENDPOINTS, QFEX_WITHDRAW_DISABLED, QFEX_WITHDRAW_ENABLED } from "../venues/qfex.js";
 import { loadQfexCredentials, QFEX_IMPORT_REMEDIATION } from "./agent.js";
 import { QfexClient } from "./client.js";
 import { qfexStatusClass } from "./errors.js";
@@ -1319,6 +1319,9 @@ export class QfexAdapter {
      * `available_balance` is a different quantity — the venue's own 400 is the answer.
      */
     async withdraw(amount, destination, opts) {
+        if (!QFEX_WITHDRAW_ENABLED) {
+            throw unsupported("QFEX", "withdraw", QFEX_WITHDRAW_DISABLED.reason, QFEX_WITHDRAW_DISABLED.remediation);
+        }
         const meta = this.requireMeta();
         if (opts?.assetId !== undefined || opts?.routeType !== undefined) {
             throw new PerpError("INVALID_PARAMS", "QFEX withdraw takes no assetId/routeType (USDC on Arbitrum One only)");

package/dist/exchanges/venues/ondo.d.ts

@@ -7,11 +7,6 @@
  * Not registered here; the registry module owns registerVenue().
  */
 import type { VenueDefinition } from "../venue.js";
-/**
- * Chain Ondo Perps withdrawals are paid out on (POST /v1/withdraw `network`).
- * The venue settles off-chain (settlementChain "offchain"); USDC leaves on Ethereum.
- */
-export declare const ONDO_WITHDRAW_NETWORK = "ethereum";
 /** Chains the CLI funds an Ondo Perps account from (`funds deposit ondo --chain`). */
 export type OndoDepositChain = "arbitrum" | "ethereum";
 export interface OndoDepositChainPins {

package/dist/exchanges/venues/ondo.js

@@ -16,11 +16,6 @@ const publicData = {
         return (await import("../ondo/public.js")).ondoPublicData.fetchMarkets(net);
     },
 };
-/**
- * Chain Ondo Perps withdrawals are paid out on (POST /v1/withdraw `network`).
- * The venue settles off-chain (settlementChain "offchain"); USDC leaves on Ethereum.
- */
-export const ONDO_WITHDRAW_NETWORK = "ethereum";
 /**
  * PINNED USDC token addresses for Ondo Perps funding (mainnet). Funding is a plain ERC-20
  * transfer of USDC to the account's own funding address (docs.ondoperps.xyz/funding-ondo-perps:
@@ -103,7 +98,8 @@ export const ondoVenue = {
         amend: "cancelReplace",
         batchPlaceMax: 20,
         marginModes: ["cross"],
-        withdrawAssets: ["USDC"],
+        // The API does not allow withdrawals (web app only) — OndoAdapter.withdraw refuses.
+        withdrawAssets: null,
     },
     rateLimit: { capacity: 1, refillPerSec: 1, weights: null },
     // Docs (account-set-up, about): "outside the U.S., Panama and other prohibited

package/dist/exchanges/venues/qfex.d.ts

@@ -23,6 +23,17 @@ export declare const QFEX_ENDPOINTS: Readonly<Record<Network, {
 }>>;
 /** Chain QFEX USDC deposits / withdrawals use in perp-cli (banker network ARBITRUM_ONE). */
 export declare const QFEX_WITHDRAW_NETWORK = "arbitrum";
+/**
+ * API withdrawals are switched off (owner decision 2026-10-13): `funds withdraw qfex` and
+ * QfexAdapter.withdraw refuse with CAPABILITY_UNSUPPORTED. The implementation (banker POST
+ * /withdraw behind settings.withdraw.qfex) is kept; flip this to re-enable it.
+ */
+export declare const QFEX_WITHDRAW_ENABLED: boolean;
+/** The uniform refusal while QFEX_WITHDRAW_ENABLED is false. */
+export declare const QFEX_WITHDRAW_DISABLED: {
+    readonly reason: "QFEX withdrawals are disabled in perp-cli for now";
+    readonly remediation: "Withdraw from the QFEX web app";
+};
 /** Banker `network` value for QFEX_WITHDRAW_NETWORK. */
 export declare const QFEX_BANKER_NETWORK = "ARBITRUM_ONE";
 export declare const qfexVenue: VenueDefinition;

package/dist/exchanges/venues/qfex.js

@@ -21,6 +21,14 @@ export const QFEX_ENDPOINTS = {
 };
 /** Chain QFEX USDC deposits / withdrawals use in perp-cli (banker network ARBITRUM_ONE). */
 export const QFEX_WITHDRAW_NETWORK = "arbitrum";
+/**
+ * API withdrawals are switched off (owner decision 2026-10-13): `funds withdraw qfex` and
+ * QfexAdapter.withdraw refuse with CAPABILITY_UNSUPPORTED. The implementation (banker POST
+ * /withdraw behind settings.withdraw.qfex) is kept; flip this to re-enable it.
+ */
+export const QFEX_WITHDRAW_ENABLED = false;
+/** The uniform refusal while QFEX_WITHDRAW_ENABLED is false. */
+export const QFEX_WITHDRAW_DISABLED = { reason: "QFEX withdrawals are disabled in perp-cli for now", remediation: "Withdraw from the QFEX web app" };
 /** Banker `network` value for QFEX_WITHDRAW_NETWORK. */
 export const QFEX_BANKER_NETWORK = "ARBITRUM_ONE";
 /** Lazy: public.ts (and `ws`) is only loaded when market data is actually requested. */
@@ -92,8 +100,8 @@ export const qfexVenue = {
         amend: QFEX_MODIFY_KEEPS_CLIENT_ID === true ? "native" : null,
         batchPlaceMax: null,
         marginModes: ["cross"],
-        // TRON USDT and USD bank rails are out of scope.
-        withdrawAssets: ["USDC"],
+        // TRON USDT and USD bank rails are out of scope. API withdrawals are off (QFEX_WITHDRAW_ENABLED).
+        withdrawAssets: QFEX_WITHDRAW_ENABLED ? ["USDC"] : null,
     },
     // Venue budget: 12,000 weight / 60 s per USER across all connections and keys (general and
     // cancel buckets separate). This process takes 25% (50/s, burst 100); the rest is left to the

package/dist/mcp-server.js

@@ -214,7 +214,7 @@ const HL_SCOPE_NOTE = "Hyperliquid: native perps only (HIP-3 dexes via the CLI -
  */
 export const MCP_DEPOSIT_VENUES = ["pacifica", "hyperliquid", "lighter", "lighter-rh", "aster", "ondo", "qfex"];
 /** Venues with a `perp funds withdraw <venue>` command. Tested against the real command tree. */
-export const MCP_WITHDRAW_VENUES = ["pacifica", "hyperliquid", "lighter", "aster", "ondo", "arcus", "qfex"];
+export const MCP_WITHDRAW_VENUES = ["pacifica", "hyperliquid", "lighter", "aster", "arcus"];
 // ── MCP Server ──
 const _require = createRequire(import.meta.url);
 const _pkg = _require("../package.json");
@@ -1314,7 +1314,7 @@ server.resource("cli_schema", "perp://schema", { mimeType: "application/json", d
                 subcommands: {
                     show: { usage: "perp wallet show", description: "Show configured wallets with public addresses" },
                     list: { usage: "perp wallet list", description: "List all wallets (OWS vault + legacy)" },
-                    balance: { usage: "perp wallet balance [name]", description: "On-chain balances" },
+                    balance: { usage: "perp wallet balance [name]", description: "On-chain gas token + USDC/USDT on Arbitrum, Ethereum, Base, BNB Chain, Robinhood Chain (USDG) and Solana" },
                     generate: { usage: "perp wallet generate [name]", description: "Generate new OWS wallet (encrypted, multi-chain)" },
                     import: { usage: "printf '%s' \"$KEY\" | OWS_PASSPHRASE=<pp> perp wallet import --name <name> [--chain evm|solana|dual]", description: "Import key into OWS vault (stdin / hidden prompt — never argv)" },
                     migrate: { usage: "perp wallet migrate", description: "Migrate legacy wallets to OWS vault" },

package/dist/onchain-balances.d.ts

@@ -0,0 +1,40 @@
+export interface OnchainBalance {
+    /** Chain id in perp-cli terms (arbitrum, ethereum, base, bsc, robinhood, solana, …). */
+    chain: string;
+    token: string;
+    kind: "stable" | "native";
+    /** Decimal string; null = the read failed (see `error`). */
+    balance: string | null;
+    /** Stablecoins at $1; native tokens at the Hyperliquid mid; null when unknown. */
+    usdValue: number | null;
+    /** Why the balance read failed (balance null). */
+    error: string | null;
+    /** Why a native token's usdValue is null although its balance was read. */
+    priceError: string | null;
+}
+interface TokenPin {
+    symbol: string;
+    address: string;
+    decimals: number;
+}
+interface EvmChainPin {
+    label: string;
+    chainId: number;
+    rpcUrl: string;
+    native: string;
+    tokens: TokenPin[];
+}
+/** Mainnet EVM chains, in display order. */
+export declare function mainnetEvmChains(): Record<string, EvmChainPin>;
+/** Per-request timeout of every read here: a stuck public RPC becomes a per-row error, not a hang. */
+export declare const ONCHAIN_READ_TIMEOUT_MS = 10000;
+/** Gas token + stablecoins on every EVM chain (mainnet), or Arbitrum Sepolia (testnet). `only` limits the chains. */
+export declare function evmOnchainBalances(address: string, testnet: boolean, only?: readonly string[]): Promise<OnchainBalance[]>;
+/** SOL + USDC / USDT (mainnet) or USDP (devnet) of a Solana address. */
+export declare function solanaOnchainBalances(address: string, testnet: boolean): Promise<OnchainBalance[]>;
+/** Sum of the stablecoin balances that were read (failed reads are excluded and listed in `errors`). */
+export declare function stableTotal(rows: readonly OnchainBalance[]): {
+    usd: number;
+    errors: string[];
+};
+export {};

package/dist/onchain-balances.js

@@ -0,0 +1,173 @@
+/**
+ * On-chain wallet balances (`perp wallet balance`): the gas token plus the USD stablecoins
+ * (USDC / USDT; USDG on Robinhood Chain) on every chain perp-cli moves funds on.
+ *
+ * Token pins come from the registries the fund-movement code already uses (RELAY_CHAINS,
+ * ONDO_DEPOSIT_CHAINS); the two not in them are Tether's Ethereum USDT and Solana USDT
+ * (tether.to/en/supported-protocols). A read that fails is reported per token
+ * (balance null + error) — never shown as 0.
+ */
+import { HYPERLIQUID_API_URL } from "./api/public/urls.js";
+import { ONDO_DEPOSIT_CHAINS } from "./exchanges/venues/ondo.js";
+import { RELAY_CHAINS } from "./relay-swap.js";
+const relayToken = (chain, symbol) => {
+    const a = RELAY_CHAINS[chain]?.assets[symbol];
+    if (a === undefined)
+        throw new Error(`RELAY_CHAINS has no ${symbol} on ${chain}`);
+    return { symbol, address: a.address, decimals: a.decimals };
+};
+const relayRpc = (chain) => {
+    const url = RELAY_CHAINS[chain]?.rpcUrl;
+    if (url === null || url === undefined)
+        throw new Error(`RELAY_CHAINS has no RPC for ${chain}`);
+    return url;
+};
+/** Mainnet EVM chains, in display order. */
+export function mainnetEvmChains() {
+    return {
+        arbitrum: {
+            label: "Arbitrum", chainId: 42161, rpcUrl: relayRpc("arbitrum"), native: "ETH",
+            tokens: [relayToken("arbitrum", "USDC"), relayToken("arbitrum", "USDT")],
+        },
+        ethereum: {
+            label: "Ethereum", chainId: 1, rpcUrl: ONDO_DEPOSIT_CHAINS.ethereum.rpcUrl, native: "ETH",
+            tokens: [
+                { symbol: "USDC", address: ONDO_DEPOSIT_CHAINS.ethereum.usdc, decimals: 6 },
+                { symbol: "USDT", address: "0xdAC17F958D2ee523a2206206994597C13D831ec7", decimals: 6 },
+            ],
+        },
+        base: {
+            label: "Base", chainId: 8453, rpcUrl: relayRpc("base"), native: "ETH",
+            tokens: [relayToken("base", "USDC")],
+        },
+        bsc: {
+            label: "BNB Chain", chainId: 56, rpcUrl: relayRpc("bsc"), native: "BNB",
+            tokens: [relayToken("bsc", "USDT"), relayToken("bsc", "USDC")],
+        },
+        robinhood: {
+            label: "Robinhood Chain", chainId: 4663, rpcUrl: relayRpc("robinhood"), native: "ETH",
+            tokens: [relayToken("robinhood", "USDG")],
+        },
+    };
+}
+const TESTNET_EVM_CHAINS = {
+    "arbitrum-sepolia": {
+        label: "Arbitrum Sepolia", chainId: 421614, rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc", native: "ETH",
+        tokens: [{ symbol: "USDC", address: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d", decimals: 6 }],
+    },
+};
+/** Built on use (not at import) so a registry change can only break `wallet balance`, never startup. */
+function solanaPins(testnet) {
+    return testnet
+        ? { rpcUrl: "https://api.devnet.solana.com", tokens: [{ symbol: "USDP", address: "USDPqRbLidFGufty2s3oizmDEKdqx7ePTqzDMbf5ZKM", decimals: 6 }] }
+        : {
+            rpcUrl: "https://api.mainnet-beta.solana.com",
+            tokens: [
+                { symbol: "USDC", address: relayToken("solana", "USDC").address, decimals: 6 },
+                { symbol: "USDT", address: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB", decimals: 6 },
+            ],
+        };
+}
+/** Per-request timeout of every read here: a stuck public RPC becomes a per-row error, not a hang. */
+export const ONCHAIN_READ_TIMEOUT_MS = 10_000;
+const timedFetch = (input, init) => fetch(input, { ...init, signal: AbortSignal.timeout(ONCHAIN_READ_TIMEOUT_MS) });
+const errText = (e) => (e instanceof Error ? e.message : String(e)).slice(0, 160);
+/**
+ * USD mids of the native gas tokens from Hyperliquid allMids. A failed / missing price leaves the
+ * native row's usdValue null and names the reason in `priceError`; balances are unaffected.
+ */
+async function nativePrices() {
+    const px = new Map();
+    try {
+        const res = await timedFetch(HYPERLIQUID_API_URL, {
+            method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ type: "allMids" }),
+        });
+        if (!res.ok)
+            return { px, error: `Hyperliquid allMids HTTP ${res.status}` };
+        const mids = await res.json();
+        for (const sym of ["ETH", "BNB", "SOL"]) {
+            const v = Number(mids[sym]);
+            if (typeof mids[sym] === "string" && Number.isFinite(v) && v > 0)
+                px.set(sym, v);
+        }
+        return { px, error: null };
+    }
+    catch (e) {
+        return { px, error: `Hyperliquid allMids: ${errText(e)}` };
+    }
+}
+function row(chain, token, kind, balance, prices, error) {
+    let usdValue = null;
+    let priceError = null;
+    if (balance !== null) {
+        if (kind === "stable")
+            usdValue = Number(balance);
+        else if (prices.px.has(token))
+            usdValue = Number(balance) * prices.px.get(token);
+        else
+            priceError = prices.error ?? `no Hyperliquid mid for ${token}`;
+    }
+    return { chain, token, kind, balance, usdValue, error, priceError };
+}
+async function evmChainBalances(ethers, chain, pin, address, prices) {
+    const req = new ethers.FetchRequest(pin.rpcUrl);
+    req.timeout = ONCHAIN_READ_TIMEOUT_MS;
+    // batchMaxCount 1: one plain JSON-RPC call per read (not every public RPC accepts batches).
+    const provider = new ethers.JsonRpcProvider(req, pin.chainId, { staticNetwork: true, batchMaxCount: 1 });
+    const native = provider.getBalance(address)
+        .then(b => row(chain, pin.native, "native", ethers.formatEther(b), prices, null))
+        .catch(e => row(chain, pin.native, "native", null, prices, errText(e)));
+    const tokens = pin.tokens.map(t => {
+        const c = new ethers.Contract(t.address, ["function balanceOf(address) view returns (uint256)"], provider);
+        return c.balanceOf(address)
+            .then(b => row(chain, t.symbol, "stable", ethers.formatUnits(b, t.decimals), prices, null))
+            .catch(e => row(chain, t.symbol, "stable", null, prices, errText(e)));
+    });
+    return Promise.all([native, ...tokens]);
+}
+/** Gas token + stablecoins on every EVM chain (mainnet), or Arbitrum Sepolia (testnet). `only` limits the chains. */
+export async function evmOnchainBalances(address, testnet, only) {
+    const chains = testnet ? TESTNET_EVM_CHAINS : mainnetEvmChains();
+    const selected = Object.entries(chains).filter(([id]) => only === undefined || only.includes(id));
+    const [{ ethers }, prices] = await Promise.all([import("ethers"), nativePrices()]);
+    return (await Promise.all(selected.map(([id, pin]) => evmChainBalances(ethers, id, pin, address, prices)))).flat();
+}
+/** SOL + USDC / USDT (mainnet) or USDP (devnet) of a Solana address. */
+export async function solanaOnchainBalances(address, testnet) {
+    const { Connection, PublicKey } = await import("@solana/web3.js");
+    const cfg = solanaPins(testnet);
+    const chain = testnet ? "solana-devnet" : "solana";
+    const connection = new Connection(cfg.rpcUrl, { fetch: timedFetch });
+    const owner = new PublicKey(address);
+    const prices = await nativePrices();
+    const sol = connection.getBalance(owner)
+        .then(l => row(chain, "SOL", "native", (l / 1e9).toFixed(9).replace(/\.?0+$/, ""), prices, null))
+        .catch(e => row(chain, "SOL", "native", null, prices, errText(e)));
+    const tokens = cfg.tokens.map(t => connection.getParsedTokenAccountsByOwner(owner, { mint: new PublicKey(t.address) })
+        .then(res => {
+        let raw = 0n;
+        for (const { account } of res.value) {
+            const amount = account.data.parsed?.info?.tokenAmount?.amount;
+            if (typeof amount !== "string")
+                throw new Error(`token account without a raw amount for ${t.symbol}`);
+            raw += BigInt(amount);
+        }
+        const s = raw.toString().padStart(t.decimals + 1, "0");
+        const dec = `${s.slice(0, -t.decimals)}.${s.slice(-t.decimals)}`.replace(/\.?0+$/, "");
+        return row(chain, t.symbol, "stable", dec, prices, null);
+    })
+        .catch(e => row(chain, t.symbol, "stable", null, prices, errText(e))));
+    return Promise.all([sol, ...tokens]);
+}
+/** Sum of the stablecoin balances that were read (failed reads are excluded and listed in `errors`). */
+export function stableTotal(rows) {
+    let usd = 0;
+    const errors = [];
+    for (const r of rows) {
+        if (r.error !== null)
+            errors.push(`${r.chain} ${r.token}: ${r.error}`);
+        else if (r.kind === "stable")
+            usd += Number(r.balance);
+    }
+    return { usd, errors };
+}

package/dist/rebalance.d.ts

@@ -28,10 +28,29 @@ export interface RebalanceMove {
     amount: number;
     reason: string;
 }
+/** A venue whose balance could not be read (left out of the snapshots). */
+export interface BalanceReadFailure {
+    exchange: string;
+    error: string;
+}
 /**
- * Fetch balances from all exchanges in parallel.
+ * Fetch balances from all exchanges in parallel. Venues whose read failed are warned on
+ * stderr and left out; callers that must know which (plan / execute) use fetchBalancesWithFailures.
  */
 export declare function fetchAllBalances(adapters: Map<string, ExchangeAdapter>): Promise<ExchangeBalanceSnapshot[]>;
+/**
+ * Fetch balances from all exchanges in parallel; a venue whose read failed (error, empty or
+ * non-finite field) is returned in `failed` — never dropped silently, never counted as $0.
+ * A read-only adapter (no credentials: `isReadOnly`) cannot hold funds the CLI trades, so it
+ * is not read and is returned in `notConfigured` — not a failure.
+ */
+export declare function fetchBalancesWithFailures(adapters: Map<string, ExchangeAdapter>): Promise<{
+    snapshots: ExchangeBalanceSnapshot[];
+    failed: BalanceReadFailure[];
+    notConfigured: string[];
+}>;
+/** An adapter built without credentials (read-only market data) — `isReadOnly` on the venue adapters. */
+export declare function isReadOnlyAdapter(a: ExchangeAdapter): boolean;
 /**
  * Compute a rebalancing plan to equalize available balance across exchanges.
  *

package/dist/rebalance.js

@@ -20,10 +20,26 @@ 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.
+ * Fetch balances from all exchanges in parallel. Venues whose read failed are warned on
+ * stderr and left out; callers that must know which (plan / execute) use fetchBalancesWithFailures.
  */
 export async function fetchAllBalances(adapters) {
-    const entries = [...adapters.entries()];
+    const { snapshots, failed, notConfigured } = await fetchBalancesWithFailures(adapters);
+    for (const f of failed)
+        process.stderr.write(`[warn] ${f.exchange} balance unavailable (left out): ${f.error}\n`);
+    for (const n of notConfigured)
+        process.stderr.write(`[info] ${n} not configured (no credentials) — left out\n`);
+    return snapshots;
+}
+/**
+ * Fetch balances from all exchanges in parallel; a venue whose read failed (error, empty or
+ * non-finite field) is returned in `failed` — never dropped silently, never counted as $0.
+ * A read-only adapter (no credentials: `isReadOnly`) cannot hold funds the CLI trades, so it
+ * is not read and is returned in `notConfigured` — not a failure.
+ */
+export async function fetchBalancesWithFailures(adapters) {
+    const notConfigured = [...adapters.entries()].filter(([, a]) => isReadOnlyAdapter(a)).map(([n]) => n);
+    const entries = [...adapters.entries()].filter(([, a]) => !isReadOnlyAdapter(a));
     const results = await Promise.allSettled(entries.map(async ([name, adapter]) => {
         const bal = await adapter.getBalance();
         // Strict policy (qa/2026-05-16): empty string is corruption, not
@@ -57,9 +73,19 @@ export async function fetchAllBalances(adapters) {
             unrealizedPnl,
         };
     }));
-    return results
-        .filter((r) => r.status === "fulfilled")
-        .map((r) => r.value);
+    const snapshots = [];
+    const failed = [];
+    results.forEach((r, i) => {
+        if (r.status === "fulfilled")
+            snapshots.push(r.value);
+        else
+            failed.push({ exchange: entries[i][0], error: r.reason instanceof Error ? r.reason.message : String(r.reason) });
+    });
+    return { snapshots, failed, notConfigured };
+}
+/** An adapter built without credentials (read-only market data) — `isReadOnly` on the venue adapters. */
+export function isReadOnlyAdapter(a) {
+    return a.isReadOnly === true;
 }
 /**
  * Compute a rebalancing plan to equalize available balance across exchanges.