perp-cli 0.14.3 → 0.16.0

package/dist/exchanges/pacifica.js

@@ -1,8 +1,12 @@
+import { nonEmptyOrListed, symbolNotFound } from "./unknown-symbol.js";
+import { assertCandleInterval, withTapeSkipped } from "./interface.js";
 import { PacificaClient } from "../pacifica/index.js";
+import { isPacificaRateLimited } from "../pacifica/rate-limit.js";
 import { LocalSolanaSigner } from "../signer/index.js";
 import { isExpired } from "../agent-wallet/expiry.js";
+import { isPacificaPerpetual } from "../ws/pacifica-instrument.js";
 import { randomUUID } from "crypto";
-import { PerpError, extractErrorMessage, isDefiniteOrderFailure, orderNotSent, orderOutcomeUnknown } from "../errors.js";
+import { PerpError, extractErrorMessage, isDefiniteOrderFailure, orderNotSent, orderOutcomeUnknown, noAccountKeyError } from "../errors.js";
 import { parseFiniteVenueNumber, venueRateField } from "../utils/numeric.js";
 import { unsupported, validateLegacyTif } from "./trading-v2.js";
 import { floorSize, requireOnTick, subDecimal } from "./precision.js";
@@ -10,7 +14,7 @@ import { requireCapabilities } from "./venue.js";
 import { PACIFICA_UUID_RE, pacificaVenue } from "./venues/pacifica.js";
 import { approvalFromCeiling, builderGateOf, rateToBps, requireFeeBps, NO_BUILDER } from "./builder-fee.js";
 /**
- * CLI TIF → Pacifica TIF (design §13.3). GTC / IOC / ALO / TOB are native; venue
+ * CLI TIF → Pacifica TIF. GTC / IOC / ALO / TOB are native; venue
  * aliases GTT → GTC and GTX → ALO; no TIF → GTC (uniform default). FOK (never
  * emulated) and unknown values → uniform CAPABILITY_UNSUPPORTED.
  */
@@ -20,7 +24,7 @@ export function pacificaTif(tif) {
     return validateLegacyTif(pacificaVenue, requireCapabilities(pacificaVenue), tif);
 }
 /**
- * Generated client_order_id carrying the order's TIF (design §13.4, §13.10 #10, like Ondo's
+ * Generated client_order_id carrying the order's TIF (like Ondo's
  * `pcli-<p|n>-…`): Pacifica takes a full UUID and never returns the TIF (GET /orders has no
  * tif field), so amend recovers it from the id. Layout: a UUID v4 whose first 6 hex digits are
  * `5ac1f` + TIF code (1 GTC, 2 IOC, 3 ALO, 4 TOB). The native edit keeps the client_order_id.
@@ -274,7 +278,10 @@ export function pacificaWithdrawRejection(e, amount) {
     }
     return new PerpError("ACTION_REJECTED", `Pacifica withdraw ${amount} USDC refused (nothing was withdrawn): ${body.error}`, details);
 }
+/** A POST the venue refused with HTTP 4xx — incl. RATE_LIMITED (429 / pre-send throttle, nothing sent). */
 export function pacificaRefused(e) {
+    if (isPacificaRateLimited(e))
+        return true;
     return !(e instanceof PerpError) && /^POST \S+ failed \(4\d\d\)/.test(extractErrorMessage(e));
 }
 /**
@@ -311,6 +318,24 @@ function pacificaBodyError(r) {
         return String(o.error ?? "request rejected");
     return null;
 }
+/** GET /trades answers the last 20 fills (40 taker + maker rows); no limit or cursor. */
+export const PACIFICA_TRADES_CAP = 20;
+/** GET /funding_rate/history `limit` maximum per request (docs; live 4001 → 4000). */
+export const PACIFICA_FUNDING_PAGE = 4000;
+/** GET /kline: "Max range: 4000 candles" per request (HTTP 400 beyond, live 2026-10-19). */
+export const PACIFICA_KLINE_MAX_BARS = 4000;
+/** Requests one funding / kline read may send (the venue meters reads by credits). */
+export const PACIFICA_MAX_PAGES = 10;
+/**
+ * GET /kline intervals (venue error text, live 2026-10-19: "Must be one of 1m, 3m, 5m, 15m, 30m,
+ * 1h, 2h, 4h, 8h, 12h, 1d, 1w, 1M"; each answered 200 with rows labelled `i` = the interval).
+ * The ms length sizes the 4000-bar request windows (1M: 31 days, the longest month).
+ */
+export const PACIFICA_KLINE_INTERVALS = {
+    "1m": 60_000, "3m": 180_000, "5m": 300_000, "15m": 900_000, "30m": 1_800_000,
+    "1h": 3_600_000, "2h": 7_200_000, "4h": 14_400_000, "8h": 28_800_000, "12h": 43_200_000,
+    "1d": 86_400_000, "1w": 604_800_000, "1M": 2_678_400_000,
+};
 /** /info rows must carry instrument_type — a row without it cannot be classified perp vs spot. */
 function requireInstrumentType(rows) {
     for (const m of rows) {
@@ -320,13 +345,13 @@ function requireInstrumentType(rows) {
     }
     return rows;
 }
-/** Perp markets of /info (spot rows such as SOL-USDC excluded, design §12). */
+/** Perp markets of /info: instrument_type "perpetual" only (spot rows such as SOL-USDC, or any other type, excluded). */
 function perpInfoRows(rows) {
-    return requireInstrumentType(rows).filter((m) => m.instrument_type !== "spot");
+    return requireInstrumentType(rows).filter(isPacificaPerpetual);
 }
-/** Wire symbols of /info spot markets. */
-function spotInfoSymbols(rows) {
-    return new Set(requireInstrumentType(rows).filter((m) => m.instrument_type === "spot").map((m) => m.symbol));
+/** Wire symbols of /info markets that are not perps (spot, any other instrument_type). */
+function nonPerpInfoSymbols(rows) {
+    return new Set(requireInstrumentType(rows).filter((m) => !isPacificaPerpetual(m)).map((m) => m.symbol));
 }
 /** Pacifica order_type of a stop / TP / SL order (stop_market, stop_limit, take_profit_*, stop_loss_*). */
 export function isPacificaStopType(type) {
@@ -335,6 +360,18 @@ export function isPacificaStopType(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"]);
+/**
+ * Trade direction of a Pacifica fill `side` (position effect): open_long / close_short buy,
+ * open_short / close_long sell; bid / ask for rows that carry an order side. Anything else →
+ * EXCHANGE_ERROR (never a guessed direction). Used by the public tape and the account fills.
+ */
+export function pacificaFillSide(side, endpoint) {
+    if (PACIFICA_FILL_BUY_SIDES.has(side))
+        return "buy";
+    if (PACIFICA_FILL_SELL_SIDES.has(side))
+        return "sell";
+    throw new PerpError("EXCHANGE_ERROR", `Pacifica ${endpoint} row with unknown side "${side}"`, { exchange: "pacifica" });
+}
 /** `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));
@@ -349,6 +386,124 @@ function pacificaField(row, key, endpoint) {
         return String(v);
     throw new PerpError("EXCHANGE_ERROR", `Pacifica ${endpoint} row without a readable ${key}: ${JSON.stringify(row).slice(0, 160)}`, { exchange: "pacifica" });
 }
+/**
+ * Balance of a Pacifica account from GET /account, its positions and /info/prices — the one
+ * implementation behind PacificaAdapter.getBalance() and the keyless `account balance --address`.
+ */
+export function pacificaBalanceOf(info, positions, prices) {
+    const raw = info;
+    const priceMap = new Map(prices.map((p) => [p.symbol, p]));
+    // API often returns unrealized_pnl=0 — compute from price delta when needed
+    let totalPnl = 0;
+    for (const p of positions) {
+        let upnl = parseFiniteVenueNumber(p.unrealized_pnl, "position.unrealized_pnl", "pacifica");
+        const amount = parseFiniteVenueNumber(p.amount, "position.amount", "pacifica");
+        if (upnl === 0 && amount > 0) {
+            const mark = parseFiniteVenueNumber(priceMap.get(p.symbol)?.mark ?? p.mark_price, "position.mark", "pacifica");
+            const entry = parseFiniteVenueNumber(p.entry_price, "position.entry_price", "pacifica");
+            const dir = p.side === "bid" ? 1 : -1;
+            if (mark > 0 && entry > 0)
+                upnl = (mark - entry) * amount * dir;
+        }
+        totalPnl += upnl;
+    }
+    // Unified margin: a negative USDC `balance` is a loan; `pending_interest` is accrued,
+    // unpaid loan interest (docs get-account-info). Surfaced, not folded into equity.
+    const usdcBalance = info.balance;
+    if (typeof usdcBalance !== "string") {
+        throw new PerpError("EXCHANGE_ERROR", "Pacifica account info has no USDC `balance`", { exchange: "pacifica", venueRaw: raw });
+    }
+    const balance = {
+        equity: info.account_equity,
+        available: info.available_to_spend,
+        marginUsed: String(raw.total_margin_used ?? raw.margin_used ?? "0"),
+        unrealizedPnl: totalPnl.toFixed(4),
+        usdcBalance,
+        borrowedUsdc: usdcBalance.startsWith("-") ? usdcBalance.slice(1) : "0",
+        pendingInterest: typeof info.pending_interest === "string" ? info.pending_interest : null,
+        availableToWithdraw: info.available_to_withdraw,
+    };
+    return balance;
+}
+/**
+ * Open positions of one Pacifica account (`GET /positions?account=`), marked with `/info/prices`.
+ * The ONE mapper of the keyed `getPositions` and the public-address read: unresolved leverage is
+ * read from the account's `/account/settings` (public, by address), then the market max.
+ */
+export async function pacificaPositionRows(positions, prices, deps) {
+    const priceMap = new Map(prices.map((p) => [p.symbol, p]));
+    const mapped = positions.map((p) => {
+        const mark = priceMap.get(p.symbol)?.mark ?? p.mark_price ?? "0";
+        const side = p.side === "bid" ? "long" : "short";
+        const size = parseFiniteVenueNumber(p.amount, "position.amount", "pacifica");
+        const entry = parseFiniteVenueNumber(p.entry_price, "position.entry_price", "pacifica");
+        const markNum = parseFiniteVenueNumber(mark, "position.mark", "pacifica");
+        // API often returns unrealized_pnl=0 — compute from price delta when needed
+        let upnl = parseFiniteVenueNumber(p.unrealized_pnl, "position.unrealized_pnl", "pacifica");
+        if (upnl === 0 && size > 0 && entry > 0 && markNum > 0) {
+            const dir = side === "long" ? 1 : -1;
+            upnl = (markNum - entry) * size * dir;
+        }
+        // Leverage, in order: (1) the API's own `leverage` when present; (2) for an ISOLATED
+        // position, entry-notional / margin — the docs define `margin` as "Amount of margin
+        // allocated to an isolated position (only shown when isolated)", so a cross position
+        // reports "0" here; (3)/(4) resolved below from GET /account/settings, then the market max.
+        const marginNum = parseFiniteVenueNumber(p.margin ?? p.margin_used, "position.margin", "pacifica", { defaultValue: 0 });
+        const apiLev = typeof p.leverage === "number" && p.leverage > 0 ? p.leverage : 0;
+        const entryNotional = size * entry;
+        const derivedLev = marginNum > 0 && entryNotional > 0 ? Math.round(entryNotional / marginNum) : 0;
+        return {
+            symbol: p.symbol,
+            side: side,
+            size: String(p.amount),
+            entryPrice: String(p.entry_price),
+            markPrice: mark,
+            liquidationPrice: p.liquidation_price != null ? String(p.liquidation_price) : null,
+            unrealizedPnl: upnl.toFixed(4),
+            // 0 = unresolved; resolved from the account settings / market max below.
+            leverage: apiLev > 0 ? apiLev : derivedLev,
+        };
+    });
+    // Unresolved (cross) positions: (3) the symbol's entry in GET /account/settings
+    // `margin_settings` — "Current leverage set by the user"; (4) no entry = the symbol is at its
+    // default, and the docs (get-account-settings) say "all markets have margin settings default
+    // to cross margin and leverage default to max ... will return blank" → the market's max
+    // leverage. Neither known → EXCHANGE_ERROR (never a fabricated value). Both reads happen ONLY
+    // when something is unresolved; a failure of either propagates.
+    if (mapped.some((m) => m.leverage <= 0)) {
+        const settings = await deps.accountSettings();
+        if (settings === null || typeof settings !== "object" || !Array.isArray(settings.margin_settings)) {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica /account/settings returned no margin_settings list (got ${JSON.stringify(settings).slice(0, 160)})`, { exchange: "pacifica" });
+        }
+        const setLev = new Map();
+        for (const s of settings.margin_settings) {
+            if (typeof s?.symbol !== "string" || typeof s.leverage !== "number" || !(s.leverage > 0)) {
+                throw new PerpError("EXCHANGE_ERROR", `Pacifica /account/settings: malformed margin_settings entry ${JSON.stringify(s)}`, { exchange: "pacifica" });
+            }
+            setLev.set(s.symbol, s.leverage);
+        }
+        let maxLevMap = null;
+        for (const m of mapped) {
+            if (m.leverage > 0)
+                continue;
+            const configured = setLev.get(m.symbol);
+            if (configured !== undefined) {
+                m.leverage = configured;
+                continue;
+            }
+            if (maxLevMap === null)
+                maxLevMap = await deps.maxLeverage();
+            const max = maxLevMap.get(m.symbol);
+            if (typeof max !== "number" || !(max > 0)) {
+                throw new PerpError("EXCHANGE_ERROR", `Pacifica ${m.symbol}: the position's leverage cannot be determined (no leverage on the position, no /account/settings entry, and no max leverage for the market)`, {
+                    exchange: "pacifica", remediation: "Check the market: perp -e pacifica market info " + m.symbol,
+                });
+            }
+            m.leverage = max;
+        }
+    }
+    return mapped;
+}
 export class PacificaAdapter {
     name = "pacifica";
     chain = "solana";
@@ -372,6 +527,7 @@ export class PacificaAdapter {
     signMessage;
     _marketsCache = null;
     _marketsCacheTime = 0;
+    _infoCache = null;
     static CACHE_TTL = 30_000;
     /** Venue network — part of every account cache key (the same key exists on mainnet and testnet). */
     _network;
@@ -491,6 +647,15 @@ export class PacificaAdapter {
             remediation: "Select the master wallet (--ows <wallet> or perp wallet use <wallet>), or do it on the Pacifica website",
         });
     }
+    /**
+     * The active signer for an account request whose body the caller builds itself (Print / vault
+     * writes): `account` (master address) and `agentWallet` (agent pubkey, or null when the master
+     * signs). Resolving it signs nothing. NO_SIGNER_AVAILABLE / AGENT_EXPIRED as `_resolveSigner`.
+     */
+    signingIdentity() {
+        const r = this._resolveSigner();
+        return { tier: r.tier, account: this.account, agentWallet: r.tier === "agent" ? r.address : null, signMessage: (msg) => r.signer.signMessage(msg) };
+    }
     /** Access the underlying Keypair (only available with LocalSolanaSigner). */
     get keypair() {
         if (this._solanaSigner instanceof LocalSolanaSigner) {
@@ -541,18 +706,35 @@ export class PacificaAdapter {
     get sdk() {
         return this.client;
     }
+    /**
+     * The configured account for an account read (settings, TWAP orders, …): no Pacifica key
+     * configured → NO_SIGNER_AVAILABLE. A keyless adapter holds a generated throwaway keypair, whose
+     * empty account would otherwise read as "no settings / no orders".
+     */
+    accountForReads() {
+        if (!this._hasRealKey)
+            throw noAccountKeyError("pacifica");
+        return this.account;
+    }
     get signer() {
         return this.signMessage;
     }
+    /** GET /info rows (every instrument type), one CACHE_TTL cache for symbol resolution and getMarkets. */
+    async infoRows() {
+        if (!this._infoCache || Date.now() - this._infoCache.at >= PacificaAdapter.CACHE_TTL) {
+            this._infoCache = { rows: requireInstrumentType(await this.client.getInfo()), at: Date.now() };
+        }
+        return this._infoCache.rows;
+    }
     async getMarkets() {
         if (this._marketsCache && Date.now() - this._marketsCacheTime < PacificaAdapter.CACHE_TTL)
             return this._marketsCache;
         const [markets, prices] = await Promise.all([
-            this.client.getInfo(),
+            this.infoRows(),
             this._getPrices(),
         ]);
         const priceMap = new Map(prices.map((p) => [p.symbol, p]));
-        // /info also lists spot markets (e.g. SOL-USDC); those are not perps (§12).
+        // /info also lists spot markets (e.g. SOL-USDC); those are not perps.
         const result = perpInfoRows(markets).map((m) => {
             const p = priceMap.get(m.symbol);
             // Derive sizeDecimals from lot_size (e.g. "0.001" → 3, "1" → 0)
@@ -563,14 +745,19 @@ export class PacificaAdapter {
                 symbol: m.symbol,
                 markPrice: p?.mark ?? "-",
                 indexPrice: p?.oracle ?? null,
-                fundingRate: m.next_funding_rate ?? m.funding_rate,
+                // `fundingRate` = the LAST SETTLED hourly rate (/info funding_rate — the WS prices `funding`,
+                // = the newest /funding_rate/history print); the rate expected at the next settlement
+                // (next_funding_rate, WS `next_funding` / predictedRate) is `predictedFundingRate`.
+                fundingRate: m.funding_rate ?? null,
+                fundingRateKind: m.funding_rate != null ? "lastSettled" : null,
+                predictedFundingRate: m.next_funding_rate ?? null,
                 volume24h: p?.volume_24h ?? null,
                 openInterest: p?.open_interest ?? null,
                 maxLeverage: m.max_leverage,
                 sizeDecimals,
                 stepSize: validLot ? m.lot_size : null,
-                // Pacifica publishes neither a per-market funding interval nor margin tiers.
-                fundingHours: null,
+                // Uniform hourly funding (venue fundingRateBasis perHours 1); no margin tiers published.
+                fundingHours: 1,
                 marginTiers: null,
             };
         });
@@ -578,8 +765,69 @@ export class PacificaAdapter {
         this._marketsCacheTime = Date.now();
         return result;
     }
+    /**
+     * The venue's own spelling of a perp market typed by the user. Pacifica's API is
+     * case-sensitive (kBONK / kPEPE / kSHIB: `KPEPE` answers `200 []` on /trades, /kline and
+     * /funding_rate/history and 400 "Book not found" on /book — live 2026-10-19), and the CLI
+     * upper-cases the argument. Matched against /info exactly first, then case-insensitively
+     * (a "-PERP" display suffix ignored), as `market info` does. A listed non-perp (spot SOL-USDC)
+     * is refused before any request: this adapter serves perps only (isPacificaPerpetual).
+     */
+    async wireSymbol(symbol) {
+        const rows = await this.infoRows();
+        const want = symbol.replace(/-PERP$/i, "");
+        const exact = rows.filter((m) => m.symbol === want);
+        const matches = exact.length > 0 ? exact : rows.filter((m) => m.symbol.toUpperCase() === want.toUpperCase());
+        if (matches.length === 0)
+            throw symbolNotFound("pacifica", symbol);
+        if (matches.length > 1) {
+            throw new PerpError("INVALID_PARAMS", `Pacifica lists several markets matching ${symbol} (${matches.map((m) => m.symbol).join(", ")}); type the exact symbol`, { exchange: "pacifica" });
+        }
+        const m = matches[0];
+        if (!isPacificaPerpetual(m)) {
+            throw symbolNotFound("pacifica", symbol, `Pacifica ${m.symbol} is a ${m.instrument_type} market, not a perp — the perp market data reads serve perpetuals only`);
+        }
+        return m.symbol;
+    }
+    /**
+     * wireSymbol for an order entry point (market / limit / stop / edit): a resolution failure is
+     * a definite "not sent" (orderNotSent re-types a read error), never a retryable code.
+     */
+    async orderSymbol(symbol, what) {
+        try {
+            return await this.wireSymbol(symbol);
+        }
+        catch (e) {
+            throw orderNotSent("pacifica", `${what} ${symbol}`, e);
+        }
+    }
+    /**
+     * The venue's spelling for a cancel / TP-SL on an existing order or position: resolved as in
+     * wireSymbol when /info lists it (any instrument type, case-insensitive); otherwise — not listed
+     * (a delisted market) or /info unreadable — sent as typed: a cancel must still reach the venue,
+     * whose own answer is final.
+     */
+    async listedSymbol(symbol) {
+        let rows;
+        try {
+            rows = await this.infoRows();
+        }
+        catch {
+            return symbol;
+        }
+        const want = symbol.replace(/-PERP$/i, "");
+        const exact = rows.filter((m) => m.symbol === want);
+        const hits = exact.length > 0 ? exact : rows.filter((m) => m.symbol.toUpperCase() === want.toUpperCase());
+        return hits.length === 1 ? hits[0].symbol : symbol;
+    }
     async getOrderbook(symbol) {
-        const book = await this.client.getBook(symbol);
+        symbol = await this.wireSymbol(symbol);
+        const book = await this.client.getBook(symbol).catch((e) => {
+            // GET /book for an unlisted symbol: HTTP 400 {"error":"Book not found: NOPE"} (live 2026-10-14).
+            if (e instanceof Error && /^GET \/book failed \(400\):.*Book not found/.test(e.message))
+                throw symbolNotFound("pacifica", symbol);
+            throw e;
+        });
         return {
             bids: book.l[0].map((e) => [e.p, e.a]),
             asks: book.l[1].map((e) => [e.p, e.a]),
@@ -587,125 +835,25 @@ export class PacificaAdapter {
     }
     async getBalance() {
         if (!this._hasRealKey)
-            throw new Error("No private key configured — account data unavailable. Run: perp setup");
+            throw noAccountKeyError("pacifica");
         const [info, positions, prices] = await Promise.all([
             this.client.getAccount(this.account),
             this._getPositions(),
             this._getPrices(),
         ]);
-        const raw = info;
-        const priceMap = new Map(prices.map((p) => [p.symbol, p]));
-        // API often returns unrealized_pnl=0 — compute from price delta when needed
-        let totalPnl = 0;
-        for (const p of positions) {
-            let upnl = parseFiniteVenueNumber(p.unrealized_pnl, "position.unrealized_pnl", "pacifica");
-            const amount = parseFiniteVenueNumber(p.amount, "position.amount", "pacifica");
-            if (upnl === 0 && amount > 0) {
-                const mark = parseFiniteVenueNumber(priceMap.get(p.symbol)?.mark ?? p.mark_price, "position.mark", "pacifica");
-                const entry = parseFiniteVenueNumber(p.entry_price, "position.entry_price", "pacifica");
-                const dir = p.side === "bid" ? 1 : -1;
-                if (mark > 0 && entry > 0)
-                    upnl = (mark - entry) * amount * dir;
-            }
-            totalPnl += upnl;
-        }
-        // Unified margin: a negative USDC `balance` is a loan; `pending_interest` is accrued,
-        // unpaid loan interest (docs get-account-info). Surfaced, not folded into equity.
-        const usdcBalance = info.balance;
-        if (typeof usdcBalance !== "string") {
-            throw new PerpError("EXCHANGE_ERROR", "Pacifica account info has no USDC `balance`", { exchange: "pacifica", venueRaw: raw });
-        }
-        const balance = {
-            equity: info.account_equity,
-            available: info.available_to_spend,
-            marginUsed: String(raw.total_margin_used ?? raw.margin_used ?? "0"),
-            unrealizedPnl: totalPnl.toFixed(4),
-            usdcBalance,
-            borrowedUsdc: usdcBalance.startsWith("-") ? usdcBalance.slice(1) : "0",
-            pendingInterest: typeof info.pending_interest === "string" ? info.pending_interest : null,
-            availableToWithdraw: info.available_to_withdraw,
-        };
-        return balance;
+        return pacificaBalanceOf(info, positions, prices);
     }
     async getPositions() {
         if (!this._hasRealKey)
-            throw new Error("No private key configured — account data unavailable. Run: perp setup");
+            throw noAccountKeyError("pacifica");
         const [positions, prices] = await Promise.all([
             this._getPositions(),
             this._getPrices(),
         ]);
-        const priceMap = new Map(prices.map((p) => [p.symbol, p]));
-        const mapped = positions.map((p) => {
-            const mark = priceMap.get(p.symbol)?.mark ?? p.mark_price ?? "0";
-            const side = p.side === "bid" ? "long" : "short";
-            const size = parseFiniteVenueNumber(p.amount, "position.amount", "pacifica");
-            const entry = parseFiniteVenueNumber(p.entry_price, "position.entry_price", "pacifica");
-            const markNum = parseFiniteVenueNumber(mark, "position.mark", "pacifica");
-            // API often returns unrealized_pnl=0 — compute from price delta when needed
-            let upnl = parseFiniteVenueNumber(p.unrealized_pnl, "position.unrealized_pnl", "pacifica");
-            if (upnl === 0 && size > 0 && entry > 0 && markNum > 0) {
-                const dir = side === "long" ? 1 : -1;
-                upnl = (markNum - entry) * size * dir;
-            }
-            // Leverage, in order: (1) the API's own `leverage` when present; (2) for an ISOLATED
-            // position, entry-notional / margin — the docs define `margin` as "Amount of margin
-            // allocated to an isolated position (only shown when isolated)", so a cross position
-            // reports "0" here; (3)/(4) resolved below from GET /account/settings, then the market max.
-            const marginNum = parseFiniteVenueNumber(p.margin ?? p.margin_used, "position.margin", "pacifica", { defaultValue: 0 });
-            const apiLev = typeof p.leverage === "number" && p.leverage > 0 ? p.leverage : 0;
-            const entryNotional = size * entry;
-            const derivedLev = marginNum > 0 && entryNotional > 0 ? Math.round(entryNotional / marginNum) : 0;
-            return {
-                symbol: p.symbol,
-                side: side,
-                size: String(p.amount),
-                entryPrice: String(p.entry_price),
-                markPrice: mark,
-                liquidationPrice: p.liquidation_price != null ? String(p.liquidation_price) : null,
-                unrealizedPnl: upnl.toFixed(4),
-                // 0 = unresolved; resolved from the account settings / market max below.
-                leverage: apiLev > 0 ? apiLev : derivedLev,
-            };
+        return pacificaPositionRows(positions, prices, {
+            accountSettings: () => this.client.getAccountSettings(this.account),
+            maxLeverage: async () => new Map((await this.getMarkets()).map((mk) => [mk.symbol, mk.maxLeverage])),
         });
-        // Unresolved (cross) positions: (3) the symbol's entry in GET /account/settings
-        // `margin_settings` — "Current leverage set by the user"; (4) no entry = the symbol is at its
-        // default, and the docs (get-account-settings) say "all markets have margin settings default
-        // to cross margin and leverage default to max ... will return blank" → the market's max
-        // leverage. Neither known → EXCHANGE_ERROR (never a fabricated value). Both reads happen ONLY
-        // when something is unresolved; a failure of either propagates.
-        if (mapped.some((m) => m.leverage <= 0)) {
-            const settings = await this.client.getAccountSettings(this.account);
-            if (settings === null || typeof settings !== "object" || !Array.isArray(settings.margin_settings)) {
-                throw new PerpError("EXCHANGE_ERROR", `Pacifica /account/settings returned no margin_settings list (got ${JSON.stringify(settings).slice(0, 160)})`, { exchange: "pacifica" });
-            }
-            const setLev = new Map();
-            for (const s of settings.margin_settings) {
-                if (typeof s?.symbol !== "string" || typeof s.leverage !== "number" || !(s.leverage > 0)) {
-                    throw new PerpError("EXCHANGE_ERROR", `Pacifica /account/settings: malformed margin_settings entry ${JSON.stringify(s)}`, { exchange: "pacifica" });
-                }
-                setLev.set(s.symbol, s.leverage);
-            }
-            let maxLevMap = null;
-            for (const m of mapped) {
-                if (m.leverage > 0)
-                    continue;
-                const configured = setLev.get(m.symbol);
-                if (configured !== undefined) {
-                    m.leverage = configured;
-                    continue;
-                }
-                if (maxLevMap === null)
-                    maxLevMap = new Map((await this.getMarkets()).map((mk) => [mk.symbol, mk.maxLeverage]));
-                const max = maxLevMap.get(m.symbol);
-                if (typeof max !== "number" || !(max > 0)) {
-                    throw new PerpError("EXCHANGE_ERROR", `Pacifica ${m.symbol}: the position's leverage cannot be determined (no leverage on the position, no /account/settings entry, and no max leverage for the market)`, {
-                        exchange: "pacifica", remediation: "Check the market: perp -e pacifica market info " + m.symbol,
-                    });
-                }
-                m.leverage = max;
-            }
-        }
-        return mapped;
     }
     /**
      * The leverage this account applies to `symbol`: its GET /account/settings `margin_settings`
@@ -733,11 +881,11 @@ export class PacificaAdapter {
     }
     async getOpenOrders() {
         if (!this._hasRealKey)
-            throw new Error("No private key configured — account data unavailable. Run: perp setup");
+            throw noAccountKeyError("pacifica");
         // GET /orders covers every market; spot orders (SOL-USDC) belong to the spot adapter.
         const [orders, info] = await Promise.all([this.client.getOrders(this.account), this.client.getInfo()]);
-        const spotSymbols = spotInfoSymbols(info);
-        return orders.filter((o) => !spotSymbols.has(String(o.symbol))).map((o) => {
+        const nonPerp = nonPerpInfoSymbols(info);
+        return orders.filter((o) => !nonPerp.has(String(o.symbol))).map((o) => {
             const raw = o;
             return {
                 orderId: String(raw.order_id),
@@ -755,6 +903,7 @@ export class PacificaAdapter {
     }
     async marketOrder(symbol, side, size, opts) {
         this.ensureSigner();
+        symbol = await this.orderSymbol(symbol, `market ${side} ${size}`);
         // A caller's client order id is sent as client_order_id (validated UUID); none → none sent.
         const cloid = opts.clientOrderId === undefined ? null : requirePacificaClientOrderId(opts.clientOrderId, null);
         const created = await this.client.createMarketOrder({
@@ -786,7 +935,7 @@ export class PacificaAdapter {
                         const filled = parseFloat(String(latest.filled_amount ?? "0"));
                         if (status === "filled" || filled > 0) {
                             // Terminal row (filled / cancelled remainder) with a reported filled_amount = the
-                            // order's final fill (design §13.10 #4). A non-terminal partial row is not final.
+                            // order's final fill. A non-terminal partial row is not final.
                             const reported = latest.filled_amount;
                             const terminal = status === "filled" || status === "cancelled" || status === "rejected";
                             if (terminal && reported !== undefined && reported !== null && String(reported).trim() !== ""
@@ -830,7 +979,7 @@ export class PacificaAdapter {
         return result;
     }
     /**
-     * Venue-final outcome of a raw marketOrder() result (IocOutcomeCapable, design §13.10 #4),
+     * Venue-final outcome of a raw marketOrder() result (IocOutcomeCapable),
      * parsed from the result's content (so copies of it work): its `fillReport` — the terminal
      * history_by_id row (filled / cancelled / rejected) with a reported filled_amount — for the
      * same order id as the create response. null otherwise — reduce-only orders (not polled),
@@ -891,16 +1040,18 @@ export class PacificaAdapter {
      */
     async limitOrder(symbol, side, price, size, opts) {
         this.ensureSigner();
-        const tif = pacificaTif(opts?.tif); // §13.3 common mapping; FOK → CAPABILITY_UNSUPPORTED
+        const tif = pacificaTif(opts?.tif); // common mapping; FOK → CAPABILITY_UNSUPPORTED
         // The caller's client order id (validated UUID) is sent as given; without one a generated
         // client_order_id records the TIF for a later TIF-preserving amend. Either way the id sent
         // rides on the result (`clientOrderId`).
         const cloid = opts?.clientOrderId !== undefined ? requirePacificaClientOrderId(opts.clientOrderId, tif) : pacificaClientOrderId(tif);
+        symbol = await this.orderSymbol(symbol, `limit ${tif} ${side} ${size}`);
         const raw = await this.client.createLimitOrder({ symbol, price, amount: size, side: side === "buy" ? "bid" : "ask", reduce_only: opts?.reduceOnly ?? false, tif, client_order_id: cloid }, this.account, this.signMessage, await this.builderCode()).catch((e) => { throw pacificaCreateRejection(e, `limit ${tif} ${side} ${size} ${symbol} @ ${price}`); });
         return withSentClientOrderId(await this.withOrderOutcome(raw, `limit ${tif} ${side} ${size} ${symbol} @ ${price}`, { terminalOnly: tif === "IOC", expect: { price, size } }), cloid);
     }
     async cancelOrder(symbol, orderId) {
         this.ensureSigner();
+        symbol = await this.listedSymbol(symbol);
         return this.client.cancelOrder({ symbol, order_id: Number(orderId) }, this.account, this.signMessage);
     }
     /**
@@ -912,7 +1063,7 @@ export class PacificaAdapter {
      */
     async orderByClientId(clientOrderId) {
         if (!this._hasRealKey)
-            throw new Error("No private key configured — account data unavailable. Run: perp setup");
+            throw noAccountKeyError("pacifica");
         const wanted = requirePacificaClientOrderId(clientOrderId, pacificaTifOf(clientOrderId.toLowerCase())).toLowerCase();
         const pick = (rows, open) => {
             if (!Array.isArray(rows)) {
@@ -1031,10 +1182,11 @@ export class PacificaAdapter {
      */
     async editOrder(symbol, orderId, price, size) {
         this.ensureSigner();
+        symbol = await this.orderSymbol(symbol, `edit ${orderId}`);
         return this.client.editOrder({ symbol, order_id: Number(orderId), price, amount: size }, this.account, this.signMessage);
     }
     /**
-     * Amend that keeps the order's TIF (design §13.4, §13.10 #10). `size` = new open size.
+     * Amend that keeps the order's TIF. `size` = new open size.
      * TIF = `tif` when the caller gives one, else the TIF encoded in the order's generated
      * client_order_id; unknown → uniform CAPABILITY_UNSUPPORTED (never guessed).
      *  - ALO: native edit (the venue re-creates the order as ALO, keeping its client_order_id).
@@ -1059,6 +1211,8 @@ export class PacificaAdapter {
         if (String(original.symbol).toUpperCase() !== sym) {
             throw new PerpError("INVALID_PARAMS", `Order ${orderId} is on ${original.symbol}, not ${sym}`);
         }
+        // The venue's own spelling (kPEPE), for the cancel and the replacement.
+        const venueSym = String(original.symbol);
         if (original.order_type !== "limit") {
             throw unsupported("Pacifica", "amend", `only open limit orders can be amended (order is ${original.order_type})`, `Cancel it (perp trade cancel ${sym} ${orderId} -e pacifica) and place a new order`);
         }
@@ -1074,7 +1228,7 @@ export class PacificaAdapter {
         }
         const tifNote = tif !== null ? `TIF ${keep} (from --tif)` : `TIF ${keep} kept (from the order's client id)`;
         if (keep === "ALO") {
-            const raw = await this.editOrder(sym, orderId, price, size);
+            const raw = await this.editOrder(venueSym, orderId, price, size);
             const err = pacificaBodyError(raw);
             if (err !== null)
                 throw new PerpError("ORDER_REJECTED", `Pacifica edit of ${orderId} refused: ${err}`, { exchange: "pacifica" });
@@ -1119,7 +1273,7 @@ export class PacificaAdapter {
         const cancelWhat = `amend: cancel of ${orderId}`;
         let cancelRaw;
         try {
-            cancelRaw = await this.client.cancelOrder({ symbol: sym, order_id: Number(orderId) }, this.account, this.signMessage);
+            cancelRaw = await this.client.cancelOrder({ symbol: venueSym, order_id: Number(orderId) }, this.account, this.signMessage);
         }
         catch (e) {
             if (pacificaRefused(e)) {
@@ -1180,7 +1334,7 @@ export class PacificaAdapter {
         const cloid = pacificaClientOrderId(keep);
         let placed;
         try {
-            placed = await this.client.createLimitOrder({ symbol: sym, price, amount: replaceSize, side: original.side, reduce_only: original.reduce_only === true, tif: keep, client_order_id: cloid }, this.account, this.signMessage, await this.builderCode());
+            placed = await this.client.createLimitOrder({ symbol: venueSym, price, amount: replaceSize, side: original.side, reduce_only: original.reduce_only === true, tif: keep, client_order_id: cloid }, this.account, this.signMessage, await this.builderCode());
         }
         catch (e) {
             if (pacificaRefused(e)) {
@@ -1215,7 +1369,8 @@ export class PacificaAdapter {
         this.ensureSigner();
         if (!/^\d+$/.test(orderId))
             throw new PerpError("INVALID_PARAMS", `Pacifica stop order id must be numeric (got "${orderId}")`);
-        const raw = await this.client.cancelStopOrder({ symbol: symbol.toUpperCase(), order_id: Number(orderId) }, this.account, this.signMessage);
+        const venueSym = await this.listedSymbol(symbol);
+        const raw = await this.client.cancelStopOrder({ symbol: venueSym, order_id: Number(orderId) }, this.account, this.signMessage);
         const err = pacificaBodyError(raw);
         if (err !== null)
             throw new PerpError("ORDER_REJECTED", `Pacifica cancel of stop order ${orderId} refused: ${err}`, { exchange: "pacifica" });
@@ -1239,7 +1394,7 @@ export class PacificaAdapter {
     async setPositionTpSl(symbol, positionSide, tpsl) {
         this.ensureSigner();
         const params = {
-            symbol: symbol.toUpperCase(),
+            symbol: await this.listedSymbol(symbol),
             side: positionSide === "long" ? "ask" : "bid",
         };
         if (tpsl.tp !== null)
@@ -1254,6 +1409,7 @@ export class PacificaAdapter {
     }
     async setLeverage(symbol, leverage, marginMode = "cross") {
         this.ensureSigner();
+        symbol = await this.orderSymbol(symbol, `leverage ${leverage}x`);
         await this.client.updateLeverage({ symbol, leverage }, this.account, this.signMessage);
         if (marginMode === "isolated") {
             await this.client.updateMarginMode({ symbol, is_isolated: true }, this.account, this.signMessage);
@@ -1269,6 +1425,7 @@ export class PacificaAdapter {
     async stopOrder(symbol, side, size, triggerPrice, opts) {
         this.ensureSigner();
         const triggerPriceType = opts?.triggerType ? PacificaAdapter.TRIGGER_TYPE[opts.triggerType] : undefined;
+        symbol = await this.orderSymbol(symbol, `stop ${side} ${size}`);
         const raw = await this.client.createStopOrder({
             symbol,
             side: side === "buy" ? "bid" : "ask",
@@ -1314,48 +1471,152 @@ export class PacificaAdapter {
         return this.client.withdraw({ amount }, this.account, (msg) => master.signMessage(msg))
             .catch((e) => { throw pacificaWithdrawRejection(e, amount); });
     }
-    async getRecentTrades(symbol, _limit = 20) {
+    /**
+     * Public tape (GET /trades). Every fill is listed TWICE — a `fulfill_taker` row and a
+     * `fulfill_maker` row, each with that party's position effect as `side` (live 2026-10-14:
+     * taker `open_short` paired with maker `close_short` at the same time / price / amount). The
+     * tape is the taker rows, with the taker's direction: open_long / close_short buy, open_short /
+     * close_long sell (the same mapping as the account fills, PACIFICA_FILL_*_SIDES). Was every row
+     * of both parties mapped through `side === "bid"` → all "sell". No de-duplication: two taker
+     * rows with equal time / price / amount are two fills (one order filling two makers).
+     */
+    async getRecentTrades(symbol, limit = 20) {
+        // GET /trades has no limit / cursor: it answers the last 40 tape rows = 20 fills (taker +
+        // maker row each; live 2026-10-19 on BTC, ETH, SOL, kPEPE, XRP). A larger limit is refused,
+        // never silently answered with 20.
+        if (!Number.isInteger(limit) || limit < 1 || limit > PACIFICA_TRADES_CAP) {
+            throw new PerpError("INVALID_PARAMS", `Pacifica trades limit must be 1..${PACIFICA_TRADES_CAP} (got ${limit})`, {
+                exchange: "pacifica", remediation: `Pacifica publishes only the last ${PACIFICA_TRADES_CAP} trades (GET /trades has no limit or cursor)`,
+            });
+        }
+        symbol = await this.wireSymbol(symbol);
         const trades = await this.client.getTrades(symbol);
-        // Deduplicate by time+price+size+side (API sometimes returns duplicate entries)
-        const seen = new Set();
-        const unique = trades.filter((t) => {
-            const key = `${t.created_at}:${t.price}:${t.amount}:${t.side}`;
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
-        return unique.slice(0, _limit).map((t) => ({
-            time: Number(t.created_at ?? 0),
-            symbol,
-            side: t.side === "bid" ? "buy" : "sell",
-            price: t.price,
-            size: t.amount,
-            fee: String(t.fee ?? "0"),
-        }));
+        if (!Array.isArray(trades)) {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica /trades returned no trade list (${JSON.stringify(trades).slice(0, 120)})`, { exchange: "pacifica" });
+        }
+        // The docs list event_type fulfill_taker / fulfill_maker and side open_long / open_short /
+        // close_long / close_short without declaring the sets closed: a row with any other value is
+        // skipped (stderr warning + meta.skippedRows), never given a guessed direction, and does not
+        // fail the rest of the tape.
+        const skippedWhy = [];
+        const rows = [];
+        for (const t of trades) {
+            const ev = pacificaField(t, "event_type", "/trades");
+            if (ev === "fulfill_maker")
+                continue;
+            if (ev !== "fulfill_taker") {
+                skippedWhy.push(`undocumented event_type "${ev}"`);
+                continue;
+            }
+            const side = pacificaField(t, "side", "/trades");
+            if (!PACIFICA_FILL_BUY_SIDES.has(side) && !PACIFICA_FILL_SELL_SIDES.has(side)) {
+                skippedWhy.push(`undocumented side "${side}"`);
+                continue;
+            }
+            if (rows.length >= limit)
+                continue;
+            rows.push({
+                time: pacificaTime(t, "/trades"),
+                symbol,
+                side: pacificaFillSide(side, "/trades"),
+                price: pacificaField(t, "price", "/trades"),
+                size: pacificaField(t, "amount", "/trades"),
+                fee: null, // the public tape carries no fee
+            });
+        }
+        const skipped = skippedWhy.length === 0 ? null : { count: skippedWhy.length, reason: [...new Set(skippedWhy)].join(", ") };
+        if (skipped !== null)
+            process.stderr.write(`[pacifica] /trades: skipped ${skipped.count} row(s) — ${skipped.reason}\n`);
+        return withTapeSkipped(await nonEmptyOrListed(this, symbol, rows), skipped);
     }
     async getFundingHistory(symbol, limit = 10) {
-        const result = await this.client.getFundingHistory(symbol, { limit });
-        const data = (result.data ?? result);
-        if (!Array.isArray(data))
-            return [];
-        return data.map((h) => ({
-            time: Number(h.created_at ?? 0),
-            rate: venueRateField(h.funding_rate, "funding history funding_rate", "pacifica"),
-            price: String(h.oracle_price ?? "0"),
+        // `limit` is at most 4000 per request (docs; live: limit 4001 / 5000 → 4000 rows, has_more
+        // true): deeper history is paged with `cursor` / `next_cursor`, newest first.
+        if (!Number.isInteger(limit) || limit < 1 || limit > PACIFICA_FUNDING_PAGE * PACIFICA_MAX_PAGES) {
+            throw new PerpError("INVALID_PARAMS", `Pacifica funding history limit must be 1..${PACIFICA_FUNDING_PAGE * PACIFICA_MAX_PAGES} (got ${limit})`, { exchange: "pacifica" });
+        }
+        symbol = await this.wireSymbol(symbol);
+        const data = [];
+        let cursor = null;
+        let hasMore = false;
+        for (let page = 0; data.length < limit && page < PACIFICA_MAX_PAGES; page++) {
+            const params = { symbol, limit: String(Math.min(PACIFICA_FUNDING_PAGE, limit - data.length)) };
+            if (cursor !== null)
+                params.cursor = cursor;
+            const env = await this.client.getEnvelope("/funding_rate/history", params);
+            if (env.success !== true || !Array.isArray(env.data)) {
+                throw new PerpError("EXCHANGE_ERROR", `Pacifica /funding_rate/history returned no row list (${JSON.stringify(env).slice(0, 120)})`, { exchange: "pacifica" });
+            }
+            data.push(...env.data);
+            hasMore = env.has_more === true;
+            if (!hasMore || typeof env.next_cursor !== "string" || env.next_cursor === "" || env.data.length === 0)
+                break;
+            cursor = env.next_cursor;
+        }
+        // Short of `limit` while the venue says there is more (no cursor / empty page / page budget): never a silent short history.
+        if (data.length < limit && hasMore) {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica /funding_rate/history: ${data.length} of ${limit} rows read and the venue reports more (has_more) without a usable next page`, { exchange: "pacifica" });
+        }
+        // `200 []` for an unlisted symbol (live): checked against the market directory.
+        return nonEmptyOrListed(this, symbol, data.slice(0, limit).map((h) => {
+            const oracle = h.oracle_price;
+            return {
+                time: pacificaTime(h, "/funding_rate/history"),
+                rate: venueRateField(h.funding_rate, "funding history funding_rate", "pacifica"),
+                // absent → null (unknown), never "0"
+                price: (typeof oracle === "string" && oracle !== "") || (typeof oracle === "number" && Number.isFinite(oracle)) ? String(oracle) : null,
+                intervalHours: 1, // hourly settlement (venue fundingRateBasis perHours 1)
+                rateKind: "lastSettled",
+            };
         }));
     }
+    /**
+     * GET /kline over [startTime, endTime]. The venue refuses a range over 4000 candles (HTTP 400
+     * "Time range too large … Max range: 4000 candles"), so a longer window is read in consecutive
+     * 4000-bar windows (at most PACIFICA_MAX_PAGES), merged by open time. Intervals outside
+     * PACIFICA_KLINE_INTERVALS are refused locally with INVALID_PARAMS (the venue: HTTP 400).
+     */
     async getKlines(symbol, interval, startTime, endTime) {
-        const klines = await this.client.getKline(symbol, interval, startTime, endTime);
-        return klines.map((k) => ({
+        const ivMs = PACIFICA_KLINE_INTERVALS[interval];
+        if (ivMs === undefined) {
+            throw new PerpError("INVALID_PARAMS", `Pacifica kline interval ${JSON.stringify(interval)} is not served (supported: ${Object.keys(PACIFICA_KLINE_INTERVALS).join(", ")})`, {
+                exchange: "pacifica", remediation: `Use one of: ${Object.keys(PACIFICA_KLINE_INTERVALS).join(", ")}`,
+            });
+        }
+        if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || startTime > endTime) {
+            throw new PerpError("INVALID_PARAMS", `Pacifica kline window must be start ≤ end (unix ms; got ${startTime}..${endTime})`, { exchange: "pacifica" });
+        }
+        const span = PACIFICA_KLINE_MAX_BARS * ivMs;
+        const pages = Math.ceil((endTime - startTime + 1) / span);
+        if (pages > PACIFICA_MAX_PAGES) {
+            throw new PerpError("INVALID_PARAMS", `Pacifica kline window spans more than ${PACIFICA_KLINE_MAX_BARS * PACIFICA_MAX_PAGES} ${interval} bars (${PACIFICA_MAX_PAGES} requests of ${PACIFICA_KLINE_MAX_BARS})`, {
+                exchange: "pacifica", remediation: "Narrow --start / --end or use a longer interval",
+            });
+        }
+        symbol = await this.wireSymbol(symbol);
+        const byTime = new Map();
+        for (let from = startTime; from <= endTime; from += span) {
+            const to = Math.min(endTime, from + span - 1);
+            const raw = await this.client.getKline(symbol, interval, from, to);
+            if (!Array.isArray(raw)) {
+                throw new PerpError("EXCHANGE_ERROR", `Pacifica /kline returned no candle list (${JSON.stringify(raw).slice(0, 120)})`, { exchange: "pacifica" });
+            }
+            // A row of another interval → EXCHANGE_ERROR (assertCandleInterval), never returned.
+            for (const k of raw)
+                byTime.set(k.t, (assertCandleInterval("pacifica", interval, k.i), k));
+        }
+        const klines = [...byTime.values()].sort((a, b) => a.t - b.t);
+        // `200 []` for an unlisted symbol (live): checked against the market directory.
+        return nonEmptyOrListed(this, symbol, klines.map((k) => ({
             time: k.t,
             open: k.o,
             high: k.h,
             low: k.l,
             close: k.c,
             volume: k.v,
+            quoteVolume: null, // /kline carries base volume only
             trades: k.n,
-        }));
+        })));
     }
     /**
      * Recent orders, newest first (GET /orders/history; PacificaClient.get already unwraps the
@@ -1364,7 +1625,7 @@ export class PacificaAdapter {
      */
     async getOrderHistory(limit = 30) {
         if (!this._hasRealKey)
-            throw new Error("No private key configured — account data unavailable. Run: perp setup");
+            throw noAccountKeyError("pacifica");
         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" });
@@ -1396,21 +1657,17 @@ export class PacificaAdapter {
      */
     async getTradeHistory(limit = 30) {
         if (!this._hasRealKey)
-            throw new Error("No private key configured — account data unavailable. Run: perp setup");
+            throw noAccountKeyError("pacifica");
         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" });
-            }
+            const side = pacificaFillSide(pacificaField(t, "side", "/trades/history"), "/trades/history");
             return {
                 time: pacificaTime(t, "/trades/history"),
                 symbol: pacificaField(t, "symbol", "/trades/history"),
-                side: buy ? "buy" : "sell",
+                side,
                 price: pacificaField(t, "price", "/trades/history"),
                 size: pacificaField(t, "amount", "/trades/history"),
                 fee: pacificaField(t, "fee", "/trades/history"),
@@ -1420,7 +1677,7 @@ export class PacificaAdapter {
     /** 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");
+            throw noAccountKeyError("pacifica");
         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" });