perp-cli 0.15.0 → 0.16.0

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

@@ -34,13 +34,14 @@
  * Limit prices and TP/SL triggers must be on tick (INVALID_TICK); sizes are
  * floored to the step (SIZE_TOO_SMALL when that reaches zero).
  */
-import type { ExchangeAdapter, ExchangeBalance, ExchangeFundingPayment, ExchangeKline, ExchangeMarketInfo, ExchangeOrder, ExchangePosition, ExchangeTrade, ExchangePublicTrade } from "../interface.js";
+import type { ExchangeAdapter, ExchangeBalance, ExchangeFundingPayment, ExchangeKline, ExchangeMarketInfo, ExchangeOrder, ExchangePosition, ExchangeTrade, ExchangePublicTrade, FundingHistoryRow } from "../interface.js";
 import type { ResolvedSlippage } from "../slippage.js";
 import type { TradingV2 } from "../trading-v2.js";
 import type { VenueCreateContext, VenueDefinition } from "../venue.js";
 import type { AmendRequest, CancelResult, LeverageResult, Network, OrderRef, OrderRequest, OrderResult, VenueMarket } from "../venue-types.js";
 import { type BuilderFeeGate } from "../builder-fee.js";
 import { OndoClient } from "./client.js";
+import { type OndoListedStatus } from "./public.js";
 export declare class OndoAdapter implements ExchangeAdapter, TradingV2 {
     readonly name: "ondo";
     readonly aliases: readonly ["ondo-perps"];
@@ -49,6 +50,7 @@ export declare class OndoAdapter implements ExchangeAdapter, TradingV2 {
     private readonly caps;
     private readonly client;
     private pairsCache;
+    private contractsCache;
     /**
      * Builder-fee gate (settings builder.ondo; Ondo has no approval step); null = not
      * configured. Set by the venue definition's create — the adapter never reads settings.
@@ -65,6 +67,8 @@ export declare class OndoAdapter implements ExchangeAdapter, TradingV2 {
     get restClient(): OndoClient;
     /** Account id from GET /v1/account — the `from.id`/`to.id` of withdrawals and spot↔perp transfers. */
     accountId(): Promise<string>;
+    private pairsByMarket;
+    private contractsByMarket;
     private pairOf;
     /**
      * An order the venue returned as "pending" (not yet open / filled) is read back by id
@@ -99,18 +103,40 @@ export declare class OndoAdapter implements ExchangeAdapter, TradingV2 {
     cancelAllV2(symbol: string | null): Promise<CancelResult>;
     applyLeverage(symbol: string, leverage: number, marginMode: "cross" | "isolated" | null): Promise<LeverageResult>;
     getOrderStatus(_symbol: string, ref: OrderRef): Promise<OrderResult>;
-    getMarkets(): Promise<ExchangeMarketInfo[]>;
+    /** Legacy rows of LISTED markets plus `tradable` (status "active") and `status` (active / closed / reduceOnly). */
+    getMarkets(): Promise<Array<ExchangeMarketInfo & {
+        tradable: boolean;
+        status: OndoListedStatus;
+    }>>;
+    /**
+     * `market info` for one market, resolved with the Ondo normalizer (ondoVenueSymbol: "AAPL",
+     * "AAPL-USD", "AAPL-USD.P", "AAPL-PERP"). A disabled market is refused like every per-symbol read.
+     */
+    getMarketInfo(symbol: string): Promise<ExchangeMarketInfo & {
+        tradable: boolean;
+        status: OndoListedStatus;
+    }>;
+    /**
+     * Venue symbol of a per-symbol read (book / trades / funding / kline), via the one normalizer
+     * (ondoVenueSymbol). A disabled (delisted / paused) listing → SYMBOL_NOT_FOUND with status
+     * "disabled": its prices are zeroed or frozen and its funding rate is stale, so nothing it returns
+     * is live market data. An unlisted symbol is left to each read's own SYMBOL_NOT_FOUND
+     * (nonEmptyOrListed / the venue's answer).
+     */
+    private readableMarket;
     getOrderbook(symbol: string): Promise<{
         bids: [string, string][];
         asks: [string, string][];
     }>;
     getRecentTrades(symbol: string, limit?: number): Promise<ExchangePublicTrade[]>;
-    getFundingHistory(symbol: string, limit?: number): Promise<{
-        time: number;
-        rate: string;
-        price: string | null;
-    }[]>;
-    /** GET /v1/perps/candles — authenticated (see klinesRequireAuth). */
+    getFundingHistory(symbol: string, limit?: number): Promise<FundingHistoryRow[]>;
+    /**
+     * GET /v1/perps/candles — authenticated (see klinesRequireAuth).
+     * Minute-based resolutions are bucketed from `from` (live 2026-10-19: from=10:01:07 → candles at
+     * :01), so `from` is floored to the interval boundary first; D / W / M are venue-aligned already.
+     * The venue also returns a zero-volume bucket that opens after `to`; candles opening after the
+     * requested end are not part of the range and are left out.
+     */
     getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
     getBalance(): Promise<ExchangeBalance>;
     /**

package/dist/exchanges/ondo/adapter.js

@@ -44,7 +44,7 @@ import { parseOrderRef, toLegacyMarketInfo } from "../venue-types.js";
 import { builderGateOf, builderRejectionOf, NO_BUILDER, requireFeeBps } from "../builder-fee.js";
 import { loadOndoCredentials, ONDO_APPROVE_REMEDIATION } from "./agent.js";
 import { OndoClient } from "./client.js";
-import { fetchOndoTradingPairs, ondoPlainSymbol, ondoPublicData, ondoVenueSymbol, parseOndoTime, strOrNull, } from "./public.js";
+import { fetchOndoMarketsWithStatus, fetchOndoTradingPairs, ondoDisabled, ondoPlainSymbol, ondoPublicData, ondoVenueSymbol, parseOndoTime, strOrNull, } from "./public.js";
 const ORDERS_PAGE_LIMIT = 100;
 const DEPTH_LEVELS = 50;
 const PAIRS_TTL_MS = 5 * 60_000;
@@ -164,6 +164,7 @@ export class OndoAdapter {
     caps;
     client;
     pairsCache = null;
+    contractsCache = null;
     /**
      * Builder-fee gate (settings builder.ondo; Ondo has no approval step); null = not
      * configured. Set by the venue definition's create — the adapter never reads settings.
@@ -217,13 +218,25 @@ export class OndoAdapter {
         return account.accountID;
     }
     // ── Helpers ──
-    async pairOf(symbol) {
-        const market = ondoVenueSymbol(symbol);
+    async pairsByMarket() {
         if (this.pairsCache === null || Date.now() - this.pairsCache.at > PAIRS_TTL_MS) {
             const pairs = await fetchOndoTradingPairs(this.client);
             this.pairsCache = { at: Date.now(), byMarket: new Map(pairs.map(p => [p.market, p])) };
         }
-        const pair = this.pairsCache.byMarket.get(market);
+        return this.pairsCache.byMarket;
+    }
+    async contractsByMarket() {
+        if (this.contractsCache === null || Date.now() - this.contractsCache.at > PAIRS_TTL_MS) {
+            const rows = await this.client.publicGet("/v1/perps/contracts", null);
+            if (!Array.isArray(rows))
+                throw new PerpError("EXCHANGE_ERROR", "Ondo Perps: /v1/perps/contracts is not a list");
+            this.contractsCache = { at: Date.now(), byMarket: new Map(rows.map(c => [c.market, c])) };
+        }
+        return this.contractsCache.byMarket;
+    }
+    async pairOf(symbol) {
+        const market = ondoVenueSymbol(symbol);
+        const pair = (await this.pairsByMarket()).get(market);
         if (pair === undefined) {
             throw new PerpError("SYMBOL_NOT_FOUND", `Ondo Perps has no market ${market}`, {
                 remediation: "List markets with: perp market list -e ondo",
@@ -657,17 +670,50 @@ export class OndoAdapter {
         return this.toOrderResult(order, order, readExecution(order));
     }
     // ── Legacy ExchangeAdapter: market data ──
+    /** Legacy rows of LISTED markets plus `tradable` (status "active") and `status` (active / closed / reduceOnly). */
     async getMarkets() {
-        return (await this.getVenueMarkets()).map(toLegacyMarketInfo);
+        return (await fetchOndoMarketsWithStatus(this.network)).map(r => ({ ...toLegacyMarketInfo(r.market), tradable: r.market.tradable, status: r.status }));
+    }
+    /**
+     * `market info` for one market, resolved with the Ondo normalizer (ondoVenueSymbol: "AAPL",
+     * "AAPL-USD", "AAPL-USD.P", "AAPL-PERP"). A disabled market is refused like every per-symbol read.
+     */
+    async getMarketInfo(symbol) {
+        const market = (await this.pairOf(symbol)).market; // unlisted → SYMBOL_NOT_FOUND
+        await this.readableMarket(market);
+        const row = (await this.getMarkets()).find(m => m.symbol === ondoPlainSymbol(market));
+        if (row === undefined) {
+            throw new PerpError("SYMBOL_NOT_FOUND", `Ondo Perps ${market} has no mark price (no price feed)`, { exchange: "ondo", remediation: "List markets with: perp market list -e ondo" });
+        }
+        return row;
+    }
+    /**
+     * Venue symbol of a per-symbol read (book / trades / funding / kline), via the one normalizer
+     * (ondoVenueSymbol). A disabled (delisted / paused) listing → SYMBOL_NOT_FOUND with status
+     * "disabled": its prices are zeroed or frozen and its funding rate is stale, so nothing it returns
+     * is live market data. An unlisted symbol is left to each read's own SYMBOL_NOT_FOUND
+     * (nonEmptyOrListed / the venue's answer).
+     */
+    async readableMarket(symbol) {
+        const market = ondoVenueSymbol(symbol);
+        const pair = (await this.pairsByMarket()).get(market);
+        // Same predicate as the listing (ondoDisabled): the /v1/markets pair OR the contracts row.
+        if (pair !== undefined && ondoDisabled(pair, (await this.contractsByMarket()).get(market) ?? null)) {
+            throw new PerpError("SYMBOL_NOT_FOUND", `Ondo Perps ${market} is disabled (delisted / paused) — no live market data`, {
+                exchange: "ondo", status: "disabled", remediation: "List tradable markets with: perp market list -e ondo",
+            });
+        }
+        return market;
     }
     async getOrderbook(symbol) {
-        const book = await this.client.publicGet("/v1/perps/depth", { market: ondoVenueSymbol(symbol), depth: DEPTH_LEVELS });
+        const book = await this.client.publicGet("/v1/perps/depth", { market: await this.readableMarket(symbol), depth: DEPTH_LEVELS });
         const lvl = (l) => [l[0], l[1]];
         return { bids: book.bids.map(lvl), asks: book.asks.map(lvl) };
     }
     async getRecentTrades(symbol, limit) {
+        const market = await this.readableMarket(symbol);
         const trades = await this.client.publicGet("/v1/perps/trades", {
-            market: ondoVenueSymbol(symbol), limit: limit === undefined ? null : limit,
+            market, limit: limit === undefined ? null : limit,
         });
         // `200 []` for an unlisted market (live 2026-10-14): checked against the market directory.
         return nonEmptyOrListed(this, symbol, listOf(trades).map(t => ({
@@ -677,23 +723,34 @@ export class OndoAdapter {
             price: t.price,
             size: t.size,
             fee: null, // public tape: no fee applies to the viewer
-        })), ondoPlainSymbol(ondoVenueSymbol(symbol)));
+        })), ondoPlainSymbol(market));
     }
     async getFundingHistory(symbol, limit) {
         const rows = await this.client.publicGet("/v1/perps/funding_rate_history", {
-            market: ondoVenueSymbol(symbol), limit: limit === undefined ? null : limit,
+            market: await this.readableMarket(symbol), limit: limit === undefined ? null : limit,
         });
-        return listOf(rows).map(r => ({ time: parseOndoTime(r.time, "funding"), rate: r.fundingRate, price: null }));
+        return listOf(rows).map(r => ({ time: parseOndoTime(r.time, "funding"), rate: r.fundingRate, price: null, intervalHours: 1, rateKind: "lastSettled" }));
     }
-    /** GET /v1/perps/candles — authenticated (see klinesRequireAuth). */
+    /**
+     * GET /v1/perps/candles — authenticated (see klinesRequireAuth).
+     * Minute-based resolutions are bucketed from `from` (live 2026-10-19: from=10:01:07 → candles at
+     * :01), so `from` is floored to the interval boundary first; D / W / M are venue-aligned already.
+     * The venue also returns a zero-volume bucket that opens after `to`; candles opening after the
+     * requested end are not part of the range and are left out.
+     */
     async getKlines(symbol, interval, startTime, endTime) {
+        const resolution = toResolution(interval);
+        const minuteMs = /^\d+$/.test(resolution) ? Number(resolution) * 60_000 : null;
+        const from = minuteMs === null ? startTime : Math.floor(startTime / minuteMs) * minuteMs;
+        const market = await this.readableMarket(symbol);
         const candles = await this.client.get("/v1/perps/candles", {
-            market: ondoVenueSymbol(symbol),
-            resolution: toResolution(interval),
-            from: Math.floor(startTime / 1000),
+            market,
+            resolution,
+            from: Math.floor(from / 1000),
             to: Math.floor(endTime / 1000),
         });
-        return nonEmptyOrListed(this, symbol, listOf(candles).map(c => ({
+        const inRange = listOf(candles).filter(c => parseOndoTime(c.startTime, "candle") <= endTime);
+        return nonEmptyOrListed(this, symbol, inRange.map(c => ({
             time: parseOndoTime(c.startTime, "candle"),
             open: c.open,
             high: c.high,
@@ -702,7 +759,7 @@ export class OndoAdapter {
             volume: c.volume,
             quoteVolume: null,
             trades: null, // Ondo publishes no per-candle trade count
-        })), ondoPlainSymbol(ondoVenueSymbol(symbol)));
+        })), ondoPlainSymbol(market));
     }
     // ── Legacy ExchangeAdapter: account ──
     async getBalance() {

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

@@ -18,7 +18,7 @@
  * fetchOndoSpotTradingPairs.
  */
 import type { VenuePublicData } from "../venue.js";
-import type { AssetClass, FundingRateBasis, Network } from "../venue-types.js";
+import type { AssetClass, FundingRateBasis, Network, VenueMarket } from "../venue-types.js";
 import { OndoClient } from "./client.js";
 export declare const ONDO_PERP_SUFFIX = "-USD.P";
 export declare const ONDO_FUNDING_BASIS: FundingRateBasis;
@@ -84,8 +84,24 @@ export interface OndoMarkPrice {
 export declare function ondoAssetClass(market: string, tags: readonly string[] | null | undefined): AssetClass;
 /** "TSLA-USD.P" → "TSLA". Throws for non-perp symbols. */
 export declare function ondoPlainSymbol(venueSymbol: string): string;
-/** CLI symbol ("tsla", "TSLA", "TSLA-USD.P") → venue symbol "TSLA-USD.P". */
+/**
+ * The one Ondo symbol normalizer, used by every command: "tsla", "TSLA", "TSLA-USD", "TSLA-USD.P",
+ * "TSLA-PERP" → venue symbol "TSLA-USD.P". 0.15.0 appended the suffix to whatever it was given
+ * ("AAPL-USD" → "AAPL-USD-USD.P", "AAPL-PERP" → "AAPL-PERP-USD.P").
+ */
 export declare function ondoVenueSymbol(symbol: string): string;
+/**
+ * Listing state of an Ondo perp. "disabled" = delisted / paused (`disabled: true` on the
+ * /v1/markets pair or the /v1/perps/contracts row; its price fields are zeroed or frozen and its
+ * fundingRate is stale); "closed" = `isClosed` (no new trading); "reduceOnly" = closes only.
+ * Only "active" is tradable.
+ */
+export type OndoMarketStatus = "active" | "disabled" | "closed" | "reduceOnly";
+/** State of a LISTED market: a disabled one is not listed (listing policy: delisted / disabled / inactive → not listed). */
+export type OndoListedStatus = Exclude<OndoMarketStatus, "disabled">;
+/** The one "disabled" predicate (listing and every per-symbol read): either source flags it. */
+export declare function ondoDisabled(pair: Pick<OndoTradingPair, "disabled">, contract: Pick<OndoContract, "disabled"> | null): boolean;
+export declare function ondoMarketStatus(pair: Pick<OndoTradingPair, "disabled">, contract: Pick<OndoContract, "disabled" | "isClosed" | "reduceOnly"> | null): OndoMarketStatus;
 /** Empty string / absent → null. Ondo omits or blanks fields it does not publish. */
 export declare function strOrNull(v: string | undefined | null): string | null;
 /**
@@ -99,4 +115,13 @@ export declare function parseOndoTime(iso: string, what: string): number;
 export declare function ondoPublicClient(net: Network): OndoClient;
 export declare function fetchOndoTradingPairs(client: OndoClient): Promise<OndoTradingPair[]>;
 export declare function fetchOndoSpotTradingPairs(client: OndoClient): Promise<OndoSpotTradingPair[]>;
+/**
+ * Every listed Ondo perp with its state (getMarkets rows carry `status`; VenueMarket has no field
+ * for it). Disabled (delisted / paused) listings are NOT listed — per-symbol reads refuse them —
+ * while closed / reduce-only markets stay listed with tradable false.
+ */
+export declare function fetchOndoMarketsWithStatus(net: Network): Promise<Array<{
+    market: VenueMarket;
+    status: OndoListedStatus;
+}>>;
 export declare const ondoPublicData: VenuePublicData;

package/dist/exchanges/ondo/public.js

@@ -54,12 +54,29 @@ export function ondoPlainSymbol(venueSymbol) {
     }
     return venueSymbol.slice(0, -ONDO_PERP_SUFFIX.length);
 }
-/** CLI symbol ("tsla", "TSLA", "TSLA-USD.P") → venue symbol "TSLA-USD.P". */
+/**
+ * The one Ondo symbol normalizer, used by every command: "tsla", "TSLA", "TSLA-USD", "TSLA-USD.P",
+ * "TSLA-PERP" → venue symbol "TSLA-USD.P". 0.15.0 appended the suffix to whatever it was given
+ * ("AAPL-USD" → "AAPL-USD-USD.P", "AAPL-PERP" → "AAPL-PERP-USD.P").
+ */
 export function ondoVenueSymbol(symbol) {
-    const up = symbol.trim().toUpperCase();
-    if (up.length === 0)
+    const base = symbol.trim().toUpperCase().replace(/(-USD\.P|-PERP|-USD)$/, "");
+    if (base.length === 0)
         throw new PerpError("INVALID_PARAMS", "symbol is empty");
-    return up.endsWith(ONDO_PERP_SUFFIX) ? up : `${up}${ONDO_PERP_SUFFIX}`;
+    return `${base}${ONDO_PERP_SUFFIX}`;
+}
+/** The one "disabled" predicate (listing and every per-symbol read): either source flags it. */
+export function ondoDisabled(pair, contract) {
+    return pair.disabled === true || contract?.disabled === true;
+}
+export function ondoMarketStatus(pair, contract) {
+    if (ondoDisabled(pair, contract))
+        return "disabled";
+    if (contract?.isClosed === true)
+        return "closed";
+    if (contract?.reduceOnly === true)
+        return "reduceOnly";
+    return "active";
 }
 /** Empty string / absent → null. Ondo omits or blanks fields it does not publish. */
 export function strOrNull(v) {
@@ -150,7 +167,12 @@ function requireRow(m, market, source) {
     }
     return row;
 }
-async function fetchMarkets(net) {
+/**
+ * Every listed Ondo perp with its state (getMarkets rows carry `status`; VenueMarket has no field
+ * for it). Disabled (delisted / paused) listings are NOT listed — per-symbol reads refuse them —
+ * while closed / reduce-only markets stay listed with tradable false.
+ */
+export async function fetchOndoMarketsWithStatus(net) {
     const client = ondoPublicClient(net);
     const pairs = await fetchOndoTradingPairs(client);
     const contracts = byMarket(await client.publicGet("/v1/perps/contracts", null));
@@ -162,37 +184,47 @@ async function fetchMarkets(net) {
     if (noMark.length > 0) {
         console.warn(`[ondo] excluded ${noMark.length} market(s) without a mark price: ${noMark.join(", ")}`);
     }
-    return pairs.filter(p => marks[p.market] !== undefined).map((pair) => {
+    const out = [];
+    for (const pair of pairs.filter(p => marks[p.market] !== undefined)) {
         const contract = requireRow(contracts, pair.market, "/v1/perps/contracts");
         const mark = marks[pair.market];
         const symbol = ondoPlainSymbol(pair.market);
         const assetClass = ondoAssetClass(pair.market, pair.tags);
         const { maxLeverage, tiers } = marginTiersOf(pair);
-        return {
-            venue: "ondo",
-            venueSymbol: pair.market,
-            symbol,
-            canonical: canonicalFor("ondo", symbol, assetClass),
-            assetClass,
-            settle: "USDC",
-            quoteAsset: pair.pair.quote,
-            markPrice: mark.markPrice,
-            indexPrice: priceOrNull(contract.indexPrice),
-            fundingRate: strOrNull(contract.fundingRate),
-            fundingRateBasis: ONDO_FUNDING_BASIS,
-            settlementIntervalHours: ONDO_SETTLEMENT_HOURS,
-            openInterest: strOrNull(contract.openInterest),
-            volume24h: strOrNull(contract.usdVolume),
-            tickSize: pair.quoteIncrement,
-            stepSize: pair.baseIncrement,
-            minSize: null,
-            minNotional: null,
-            maxLeverage,
-            marginTiers: tiers,
-            session: sessionOf(pair, mark),
-            tradable: pair.disabled !== true && !contract.disabled && contract.isClosed !== true && contract.reduceOnly !== true,
-        };
-    });
+        const status = ondoMarketStatus(pair, contract);
+        if (status === "disabled")
+            continue;
+        out.push({ status, market: {
+                venue: "ondo",
+                venueSymbol: pair.market,
+                symbol,
+                canonical: canonicalFor("ondo", symbol, assetClass),
+                assetClass,
+                settle: "USDC",
+                quoteAsset: pair.pair.quote,
+                markPrice: mark.markPrice,
+                // /v1/perps/contracts `indexPrice` is frozen (live 2026-10-19: BTC 82702.30 unchanged for 17 min
+                // while the mark_prices oracle moved 0.5%); the oracle of /v1/perps/mark_prices is the live index.
+                indexPrice: priceOrNull(mark.oraclePrice),
+                fundingRate: strOrNull(contract.fundingRate),
+                fundingRateBasis: ONDO_FUNDING_BASIS,
+                settlementIntervalHours: ONDO_SETTLEMENT_HOURS,
+                openInterest: strOrNull(contract.openInterest),
+                volume24h: strOrNull(contract.usdVolume),
+                tickSize: pair.quoteIncrement,
+                stepSize: pair.baseIncrement,
+                minSize: null,
+                minNotional: null,
+                maxLeverage,
+                marginTiers: tiers,
+                session: sessionOf(pair, mark),
+                tradable: status === "active",
+            } });
+    }
+    return out;
+}
+async function fetchMarkets(net) {
+    return (await fetchOndoMarketsWithStatus(net)).map(r => ({ ...r.market, status: r.status }));
 }
 async function fetchFundingRates(net) {
     const client = ondoPublicClient(net);

package/dist/exchanges/outcome-interface.d.ts

@@ -80,6 +80,10 @@ export interface OutcomeViewSide extends OutcomeSideInfo {
     bestAsk?: string;
     /** Implied probability of THIS side winning, derived from mid */
     impliedProb?: number;
+    /** Side name without a "template:" prefix ("template:Yes" → "Yes"). */
+    label?: string;
+    /** true = bid–ask wider than OUTCOME_WIDE_SPREAD: the mid is a weak probability estimate; null = one side empty. */
+    wideSpread?: boolean | null;
 }
 export interface OutcomeViewUnderlying {
     /** Underlying symbol from description (e.g. "BTC") */

package/dist/exchanges/pacifica-spot.d.ts

@@ -18,6 +18,12 @@ import type { SpotAdapter, SpotMarketInfo, SpotBalance, SpotOrderResult, SpotOpe
 import type { ResolvedSlippage } from "./slippage.js";
 import { type PacificaAdapter } from "./pacifica.js";
 import type { IocOutcome } from "./ioc-outcome.js";
+/**
+ * Spot balances from Pacifica GET /account (USDC = the shared perp collateral, then
+ * `spot_balances`) — the one mapper behind the keyed spot adapter and the keyless
+ * `account balance --address`.
+ */
+export declare function pacificaSpotBalanceRows(info: Record<string, unknown>): SpotBalance[];
 export declare class PacificaSpotAdapter implements SpotAdapter, SpotOpenOrdersCapable, SpotCancelAllCapable {
     readonly name = "pacifica";
     private _perp;

package/dist/exchanges/pacifica-spot.js

@@ -36,6 +36,28 @@ function decimalsOf(step) {
     const frac = step.split(".")[1];
     return frac ? frac.replace(/0+$/, "").length : 0;
 }
+/**
+ * Spot balances from Pacifica GET /account (USDC = the shared perp collateral, then
+ * `spot_balances`) — the one mapper behind the keyed spot adapter and the keyless
+ * `account balance --address`.
+ */
+export function pacificaSpotBalanceRows(info) {
+    const rows = info.spot_balances;
+    if (!Array.isArray(rows)) {
+        throw new PerpError("INVALID_PARAMS", "Pacifica /account response has no spot_balances array", { exchange: "pacifica" });
+    }
+    const out = [];
+    // USDC = the shared perp collateral (same money as perp equity).
+    const total = String(info.balance);
+    const available = String(info.available_to_spend);
+    out.push({ token: QUOTE, total, available, held: subDecimal(total, available), shared: true });
+    for (const r of rows) {
+        const t = String(r.amount);
+        const a = String(r.available_to_withdraw);
+        out.push({ token: String(r.symbol), total: t, available: a, held: subDecimal(t, a), shared: false });
+    }
+    return out;
+}
 export class PacificaSpotAdapter {
     name = "pacifica";
     _perp;
@@ -105,21 +127,7 @@ export class PacificaSpotAdapter {
     }
     async getSpotBalances() {
         const info = (await this._perp.sdk.getAccount(this._perp.publicKey));
-        const rows = info.spot_balances;
-        if (!Array.isArray(rows)) {
-            throw new PerpError("INVALID_PARAMS", "Pacifica /account response has no spot_balances array", { exchange: "pacifica" });
-        }
-        const out = [];
-        // USDC = the shared perp collateral (same money as perp equity).
-        const total = String(info.balance);
-        const available = String(info.available_to_spend);
-        out.push({ token: QUOTE, total, available, held: subDecimal(total, available), shared: true });
-        for (const r of rows) {
-            const t = String(r.amount);
-            const a = String(r.available_to_withdraw);
-            out.push({ token: String(r.symbol), total: t, available: a, held: subDecimal(t, a), shared: false });
-        }
-        return out;
+        return pacificaSpotBalanceRows(info);
     }
     /** Mark price for min-notional / slippage checks. */
     async _mark(wire) {

package/dist/exchanges/pacifica-vaults.d.ts

@@ -53,6 +53,15 @@ export declare function findVault(vaults: PacificaVault[], ref: string): Pacific
 /** UNOFFICIAL endpoint (not in the API docs; used by app.pacifica.fi). Advisory only — the venue's own refusal is final. */
 export declare const DEPOSIT_WHITELIST_API_STATUS: "unofficial";
 export declare function fetchDepositWhitelist(client: Reader, vault: string): Promise<string[]>;
+/**
+ * The advisory whitelist read for display: `addresses` null = unreadable, with the error CODE that
+ * made it so (never a bare null that looks like "no whitelist data"). The venue's refusal of a
+ * deposit stays final either way.
+ */
+export declare function readDepositWhitelist(client: Reader, vault: string): Promise<{
+    addresses: string[] | null;
+    error: string | null;
+}>;
 export interface WithdrawWindow {
     /** No window configured: always open (subject to the other rules). */
     restricted: boolean;

package/dist/exchanges/pacifica-vaults.js

@@ -23,7 +23,7 @@
  * Live 2026-10-19: absent config fields are omitted (→ null here), and `user_share` was null for a
  * vault's own manager (it counts LP shares; the manager's are `manager_shares`).
  */
-import { PerpError } from "../errors.js";
+import { PerpError, classifyError } from "../errors.js";
 import { mulDecimal, subDecimal } from "./precision.js";
 import { cmpDecimal, divDecimal, isPlainDecimal, trimDecimal } from "./pacifica-decimal.js";
 import { envelopeData, requireUsdcAmount, PLAIN_POSITIVE } from "./pacifica-print.js";
@@ -142,6 +142,19 @@ export async function fetchDepositWhitelist(client, vault) {
         throw bad("/lake/get_deposit_whitelist without an addresses list", data);
     return a;
 }
+/**
+ * The advisory whitelist read for display: `addresses` null = unreadable, with the error CODE that
+ * made it so (never a bare null that looks like "no whitelist data"). The venue's refusal of a
+ * deposit stays final either way.
+ */
+export async function readDepositWhitelist(client, vault) {
+    try {
+        return { addresses: await fetchDepositWhitelist(client, vault), error: null };
+    }
+    catch (e) {
+        return { addresses: null, error: classifyError(e, "pacifica").code };
+    }
+}
 /** docs: open while current_unix_time_s mod withdraw_window_s < withdraw_duration_s (epoch-anchored). */
 export function withdrawWindowAt(c, nowMs) {
     if (c.withdrawWindowS === null || c.withdrawDurationS === null || c.withdrawWindowS <= 0)