perp-cli 0.14.1 → 0.14.3

package/dist/exchanges/hyperliquid.js

@@ -1,7 +1,7 @@
 import { LocalEvmSigner } from "../signer/index.js";
 import { DEFINITE_ORDER_FAILURE_CODES, PerpError, classifyError, extractErrorMessage, orderNotSent, orderOutcomeUnknown, sendFailure } from "../errors.js";
 import { parseFiniteVenueNumber, venueRateField } from "../utils/numeric.js";
-import { alignProtectionPrice, floorSize, formatComputedPrice, slippagePrice } from "./precision.js";
+import { alignProtectionPrice, floorSize, formatComputedPrice, slippagePrice, subDecimal } from "./precision.js";
 import { unsupported } from "./trading-v2.js";
 import { buildHlUserSignedAction, hlUserSignedNonceField, signHlL1Action, signHlUserSignedAction } from "./hl-signing.js";
 import { HL_CLOID_RE } from "./venues/hyperliquid.js";
@@ -339,6 +339,29 @@ export function hlL1ActionRejection(type, e) {
         remediation: "The venue refused the whole request and executed nothing; fix the cause named in the venue message above before sending it again",
     });
 }
+/** POST /info userFunding page size (docs: at most 500 rows per response). */
+const HL_FUNDING_PAGE = 500;
+/** 7 days of hourly funding = 168 rows per coin; 20 pages = 10 000 rows (~60 coins). */
+const HL_FUNDING_MAX_PAGES = 20;
+/** A required field of an HL info row as a string; missing / empty → EXCHANGE_ERROR. */
+function hlField(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", `Hyperliquid ${endpoint} row without a readable ${key}: ${JSON.stringify(row).slice(0, 160)}`, { exchange: "hyperliquid" });
+}
+/** historicalOrders status precedence on equal statusTimestamp: open < triggered < any terminal status. */
+function hlStatusRank(status) {
+    return status === "open" ? 0 : status === "triggered" ? 1 : 2;
+}
+/** HL side "B" (bid) → buy, "A" (ask) → sell; anything else → EXCHANGE_ERROR. */
+function hlSide(v, endpoint) {
+    if (v === "B")
+        return "buy";
+    if (v === "A")
+        return "sell";
+    throw new PerpError("EXCHANGE_ERROR", `Hyperliquid ${endpoint} row with unknown side ${JSON.stringify(v)}`, { exchange: "hyperliquid" });
+}
 export class HyperliquidAdapter {
     name = "hyperliquid";
     chain = "evm";
@@ -1774,48 +1797,150 @@ export class HyperliquidAdapter {
             trades: Number(c.n ?? 0),
         }));
     }
+    /**
+     * Order history: POST /info {type:"historicalOrders"} ("Retrieve a user's historical orders",
+     * at most 2000 most recent; live 2026-10-13: newest first, each order listed once per status —
+     * e.g. "open" then "filled" — with equal statusTimestamp possible). One row per oid with its
+     * final status (latest statusTimestamp; on a tie a non-"open" status wins). Includes canceled /
+     * rejected orders (the previous userFills read showed fills only). Unreadable rows → EXCHANGE_ERROR.
+     * The info endpoint is account-wide; rows are scoped to this adapter (see _inHistoryScope).
+     */
     async getOrderHistory(limit = 30) {
         this.ensureAddress();
-        const fills = await this._infoPost({ type: "userFills", user: this._address });
-        return (fills ?? []).slice(0, limit).map((f) => ({
-            orderId: String(f.oid ?? ""),
-            symbol: this._displaySymbol(String(f.coin ?? "")),
-            side: String(f.side) === "B" ? "buy" : String(f.side) === "A" ? "sell" : String(f.side).toLowerCase(),
-            price: String(f.px ?? "0"),
-            size: String(f.sz ?? ""),
-            filled: String(f.sz ?? ""),
-            status: "filled",
-            type: String(f.dir ?? ""),
-            triggerPrice: null, // fills carry no trigger price
-        }));
+        const rows = await this._infoPost({ type: "historicalOrders", user: this._address });
+        if (!Array.isArray(rows)) {
+            throw new PerpError("EXCHANGE_ERROR", `Hyperliquid historicalOrders returned no list (${JSON.stringify(rows).slice(0, 120)})`, { exchange: "hyperliquid" });
+        }
+        await this._historyScopeReady();
+        const latest = new Map();
+        for (const row of rows) {
+            const o = row.order;
+            const at = Number(row.statusTimestamp);
+            if (o === undefined || o === null || typeof row.status !== "string" || !Number.isFinite(at) || (typeof o.oid !== "number" && typeof o.oid !== "string")) {
+                throw new PerpError("EXCHANGE_ERROR", `Hyperliquid historicalOrders row without order / oid / status / statusTimestamp: ${JSON.stringify(row).slice(0, 160)}`, { exchange: "hyperliquid" });
+            }
+            if (!this._inHistoryScope(hlField(o, "coin", "historicalOrders")))
+                continue;
+            const key = String(o.oid);
+            const prev = latest.get(key);
+            if (prev === undefined || at > prev.at || (at === prev.at && hlStatusRank(row.status) > hlStatusRank(prev.status))) {
+                latest.set(key, { at, status: row.status, o });
+            }
+        }
+        return [...latest.values()].sort((x, y) => y.at - x.at).slice(0, limit).map(({ status, o }) => {
+            const origSz = hlField(o, "origSz", "historicalOrders");
+            const remaining = hlField(o, "sz", "historicalOrders");
+            const triggerPx = Number(o.triggerPx);
+            return {
+                orderId: String(o.oid),
+                symbol: this._displaySymbol(hlField(o, "coin", "historicalOrders")),
+                side: hlSide(o.side, "historicalOrders"),
+                price: hlField(o, "limitPx", "historicalOrders"),
+                size: origSz,
+                filled: subDecimal(origSz, remaining),
+                status,
+                type: hlField(o, "orderType", "historicalOrders"),
+                triggerPrice: o.isTrigger === true && Number.isFinite(triggerPx) && triggerPx > 0 ? String(o.triggerPx) : null,
+            };
+        });
     }
+    /** Fills: POST /info {type:"userFills"} (at most 2000 most recent, newest first — live 2026-10-13). */
     async getTradeHistory(limit = 30) {
         this.ensureAddress();
         const fills = await this._infoPost({ type: "userFills", user: this._address });
-        return (fills ?? []).slice(0, limit).map((f) => ({
-            time: Number(f.time ?? 0),
-            symbol: this._displaySymbol(String(f.coin ?? "")),
-            side: String(f.side) === "B" ? "buy" : String(f.side) === "A" ? "sell" : String(f.side).toLowerCase(),
-            price: String(f.px ?? "0"),
-            size: String(f.sz ?? ""),
-            fee: String(f.fee ?? "0"),
-        }));
+        if (!Array.isArray(fills)) {
+            throw new PerpError("EXCHANGE_ERROR", `Hyperliquid userFills returned no list (${JSON.stringify(fills).slice(0, 120)})`, { exchange: "hyperliquid" });
+        }
+        await this._historyScopeReady();
+        return fills.filter((f) => this._inHistoryScope(hlField(f, "coin", "userFills"))).slice(0, limit).map((f) => {
+            const time = Number(hlField(f, "time", "userFills"));
+            if (!Number.isFinite(time))
+                throw new PerpError("EXCHANGE_ERROR", "Hyperliquid userFills row with a non-numeric time", { exchange: "hyperliquid" });
+            return {
+                time,
+                symbol: this._displaySymbol(hlField(f, "coin", "userFills")),
+                side: hlSide(f.side, "userFills"),
+                price: hlField(f, "px", "userFills"),
+                size: hlField(f, "sz", "userFills"),
+                fee: hlField(f, "fee", "userFills"),
+            };
+        });
     }
+    /**
+     * Funding payments in this adapter's scope (see _inHistoryScope), newest first, at most `limit`.
+     * Reads the last 24 h first and widens to 7 days only when that holds fewer than `limit` rows
+     * (POST /info userFunding weighs per row returned; bots poll it).
+     */
     async getFundingPayments(limit = 200) {
         this.ensureAddress();
-        // Direct API call — SDK's getUserFunding silently truncates results
-        const apiUrl = this._testnet ? "https://api.hyperliquid-testnet.xyz/info" : "https://api.hyperliquid.xyz/info";
-        const res = await fetch(apiUrl, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ type: "userFunding", user: this._address, startTime: Date.now() - 7 * 24 * 60 * 60 * 1000 }),
-        });
-        const data = await res.json();
-        return (data ?? []).slice(0, limit).map((h) => ({
-            time: h.time,
-            symbol: h.delta.coin + "-PERP",
-            payment: h.delta.usdc,
-        }));
+        await this._historyScopeReady();
+        const now = Date.now();
+        let rows = await this._fundingSince(now - 24 * 60 * 60 * 1000);
+        if (rows.length < limit)
+            rows = await this._fundingSince(now - 7 * 24 * 60 * 60 * 1000);
+        return rows.sort((a, b) => b.time - a.time).slice(0, limit);
+    }
+    /**
+     * Every userFunding row since `startTime`. The endpoint returns rows OLDEST first, at most 500
+     * per response (live 2026-10-13), and every coin of a funding hour shares one millisecond — so
+     * pages continue from the last row's time INCLUSIVE and rows are deduped by time + coin (funding
+     * rows carry a zero hash). A full page that adds nothing new, or more than HL_FUNDING_MAX_PAGES
+     * pages → EXCHANGE_ERROR (never a list with payments silently missing).
+     */
+    async _fundingSince(startTime) {
+        const out = [];
+        const seen = new Set();
+        let from = startTime;
+        for (let page = 0;; page++) {
+            if (page >= HL_FUNDING_MAX_PAGES) {
+                throw new PerpError("EXCHANGE_ERROR", `Hyperliquid funding history needs more than ${HL_FUNDING_MAX_PAGES} pages — the result would be incomplete`, { exchange: "hyperliquid" });
+            }
+            const rows = await this._infoPost({ type: "userFunding", user: this._address, startTime: from });
+            if (!Array.isArray(rows)) {
+                throw new PerpError("EXCHANGE_ERROR", `Hyperliquid userFunding returned no list (${JSON.stringify(rows).slice(0, 120)})`, { exchange: "hyperliquid" });
+            }
+            let last = -Infinity;
+            let fresh = 0;
+            for (const h of rows) {
+                const time = Number(h.time);
+                const delta = h.delta;
+                if (!Number.isFinite(time) || delta === undefined || delta === null || typeof delta.coin !== "string" || delta.coin === "" || typeof delta.usdc !== "string" || delta.usdc === "") {
+                    throw new PerpError("EXCHANGE_ERROR", `Hyperliquid userFunding row without time / delta.coin / delta.usdc: ${JSON.stringify(h).slice(0, 160)}`, { exchange: "hyperliquid" });
+                }
+                last = Math.max(last, time);
+                const key = `${time}|${delta.coin}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                fresh++;
+                if (this._inHistoryScope(delta.coin))
+                    out.push({ time, symbol: this._displaySymbol(delta.coin), payment: delta.usdc });
+            }
+            if (rows.length < HL_FUNDING_PAGE)
+                break;
+            if (fresh === 0) {
+                throw new PerpError("EXCHANGE_ERROR", `Hyperliquid returned ${HL_FUNDING_PAGE}+ funding rows at one millisecond (${last}) — paging cannot advance`, { exchange: "hyperliquid" });
+            }
+            from = last;
+        }
+        return out;
+    }
+    /** The asset map backs _displaySymbol / _inHistoryScope; load it before mapping history rows. */
+    async _historyScopeReady() {
+        if (this._assetMap.size === 0)
+            await this._loadAssetMap();
+        if (this._assetMapError)
+            throw this._assetMapError;
+    }
+    /**
+     * Whether an account-wide history row (historicalOrders / userFills / userFunding carry every
+     * dex, spot "@n" / "PAIR/USDC" and outcome "#n" coins) belongs to this adapter: a HIP-3 dex
+     * adapter keeps "<dex>:…" coins, the native adapter keeps native perp coins only.
+     */
+    _inHistoryScope(coin) {
+        if (this._dex)
+            return coin.startsWith(`${this._dex}:`);
+        return !/[:@#/]/.test(coin);
     }
     async getFundingHistory(symbol, limit = 10) {
         const now = Date.now();
@@ -2260,27 +2385,6 @@ export class HyperliquidAdapter {
         }
         return res;
     }
-    /**
-     * Get funding history for a symbol.
-     */
-    async getFundingHistoryRaw(symbol, startTime, endTime) {
-        const baseUrl = this._testnet
-            ? "https://api.hyperliquid-testnet.xyz"
-            : "https://api.hyperliquid.xyz";
-        const body = {
-            type: "fundingHistory",
-            coin: symbol.toUpperCase(),
-            startTime,
-        };
-        if (endTime)
-            body.endTime = endTime;
-        const res = await fetch(`${baseUrl}/info`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(body),
-        });
-        return res.json();
-    }
     /**
      * Get user trade fills.
      */

package/dist/exchanges/interface.d.ts

@@ -13,7 +13,8 @@ export interface ExchangeMarketInfo {
     volume24h: string | null;
     /** null = venue does not publish open interest (never "0" as a stand-in) */
     openInterest: string | null;
-    maxLeverage: number;
+    /** null = the venue does not publish it (Aster: the public exchangeInfo carries no leverage) */
+    maxLeverage: number | null;
     /** quantity precision (e.g. 0 = integers only, 2 = 0.01); null = unknown */
     sizeDecimals: number | null;
     /** lot step size (e.g. "1", "0.1", "0.001"); null = unknown */
@@ -38,7 +39,7 @@ export interface ExchangeMarketInfo {
  * A venue that publishes no tiers (`marginTiers === null`) has one flat cap,
  * `maxLeverage`, at every size — that is the venue's definition, not a fallback.
  */
-export declare function maxLeverageForNotional(market: ExchangeMarketInfo, notional: number): number;
+export declare function maxLeverageForNotional(market: ExchangeMarketInfo, notional: number): number | null;
 export interface ExchangePosition {
     symbol: string;
     side: "long" | "short";

package/dist/exchanges/interface.js

@@ -10,8 +10,9 @@ export function maxLeverageForNotional(market, notional) {
     }
     const tiers = market.marginTiers;
     if (tiers === null || tiers.length === 0)
-        return market.maxLeverage;
-    let effective = market.maxLeverage;
+        return market.maxLeverage; // null = not published
+    // No headline but published tiers: the first (lowest-notional) tier is the cap below every threshold.
+    let effective = market.maxLeverage ?? tiers[0].maxLeverage;
     for (const t of tiers) {
         if (notional >= t.lowerBound)
             effective = t.maxLeverage;

package/dist/exchanges/lighter.d.ts

@@ -154,7 +154,7 @@ export declare function lighterTakerFilledBase(eventInfo: unknown, sentBaseAmoun
  * A required open-order row field as a string (Rule #2): missing / empty / non-finite numeric →
  * EXCHANGE_ERROR, never listed as price / size "0" or status "open".
  */
-export declare function lighterRowField(o: Record<string, unknown>, key: string, venue: string): string;
+export declare function lighterRowField(o: Record<string, unknown>, key: string, venue: string, what?: "open order" | "order history"): string;
 /** What identifies OUR accountOrders row besides the client order index: the market sent to and the send time. */
 export interface LighterRowMatch {
     marketIndex: number;

package/dist/exchanges/lighter.js

@@ -250,12 +250,12 @@ export function lighterTakerFilledBase(eventInfo, sentBaseAmount) {
  * A required open-order row field as a string (Rule #2): missing / empty / non-finite numeric →
  * EXCHANGE_ERROR, never listed as price / size "0" or status "open".
  */
-export function lighterRowField(o, key, venue) {
+export function lighterRowField(o, key, venue, what = "open order") {
     const v = o[key];
     if ((typeof v === "string" && v.trim() !== "") || (typeof v === "number" && Number.isFinite(v)))
         return String(v);
-    throw new PerpError("EXCHANGE_ERROR", `${venue} open order ${lighterOrderIdOf(o) || "(no id)"}: row has no ${key} (got ${JSON.stringify(v ?? null)})`, {
-        exchange: venue, remediation: `Retry: perp -e ${venue} account orders`,
+    throw new PerpError("EXCHANGE_ERROR", `${venue} ${what} ${lighterOrderIdOf(o) || "(no id)"}: row has no ${key} (got ${JSON.stringify(v ?? null)})`, {
+        exchange: venue, remediation: `Retry: perp -e ${venue} ${what === "open order" ? "account orders" : "account history"}`,
     });
 }
 /** `iocOutcomeOf` parser shared by LighterAdapter and LighterSpotAdapter. */
@@ -1438,7 +1438,7 @@ export class LighterAdapter {
                 size: lighterRowField(o, "initial_base_amount", this.name),
                 filled: lighterRowField(o, "filled_base_amount", this.name),
                 status: lighterRowField(o, "status", this.name),
-                type: String(o.type ?? "limit"),
+                type: lighterRowField(o, "type", this.name),
                 triggerPrice: Number(o.trigger_price) > 0 ? String(o.trigger_price) : null,
             };
         });
@@ -2097,15 +2097,17 @@ export class LighterAdapter {
         if (!this._address)
             throw new Error("No private key configured — account data unavailable. Run: perp setup");
         const orders = await this.historyRows("/accountInactiveOrders", "orders", { market_type: "perp" }, limit, true);
+        // Every field is required: a missing price / size / status / type is an unreadable row, never "0" / "done" / "limit".
+        const req = (o, k) => lighterRowField(o, k, this.name, "order history");
         return orders.map((o) => ({
             orderId: lighterOrderIdOf(o),
             symbol: this.historySymbol(o.market_index, "order history", o),
             side: this.sideOfIsAsk(o.is_ask, "order history", o),
-            price: String(o.price ?? "0"),
-            size: String(o.initial_base_amount ?? o.base_amount ?? ""),
-            filled: String(o.filled_base_amount ?? "0"),
-            status: String(o.status ?? "done"),
-            type: String(o.type ?? "limit"),
+            price: req(o, "price"),
+            size: req(o, "initial_base_amount"),
+            filled: req(o, "filled_base_amount"),
+            status: req(o, "status"),
+            type: req(o, "type"),
             triggerPrice: Number(o.trigger_price) > 0 ? String(o.trigger_price) : null,
         }));
     }

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

@@ -21,7 +21,6 @@ import { type OndoDepositChain } from "../venues/ondo.js";
 export interface OndoFundsClient {
     get<T>(path: string, query: null): Promise<T>;
     post<T>(path: string, body: unknown): Promise<T>;
-    postNoResult(path: string, body: unknown): Promise<void>;
 }
 export declare const ONDO_DEPOSIT_CREDIT_TIMEOUT_MS = 600000;
 export declare const ONDO_DEPOSIT_CREDIT_POLL_MS = 10000;

package/dist/exchanges/pacifica.d.ts

@@ -381,6 +381,13 @@ export declare class PacificaAdapter implements ExchangeAdapter {
      * readable field → EXCHANGE_ERROR, never an empty list or a placeholder value.
      */
     getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    /**
+     * 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.
+     */
     getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
+    /** Funding paid / received per position (GET /funding/history, `payout` signed). Strict like getTradeHistory. */
     getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
 }

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";
@@ -1352,12 +1369,7 @@ export class PacificaAdapter {
         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) => {
-            const v = o[k];
-            if ((typeof v === "string" && v !== "") || typeof v === "number")
-                return String(v);
-            throw new PerpError("EXCHANGE_ERROR", `Pacifica order-history row without a readable ${k}: ${JSON.stringify(o).slice(0, 160)}`, { 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") {
@@ -1376,33 +1388,47 @@ export class PacificaAdapter {
             };
         });
     }
+    /**
+     * 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/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.