perp-cli 0.12.17 → 0.14.1

package/dist/exchanges/pacifica.js

@@ -1,7 +1,337 @@
 import { PacificaClient } from "../pacifica/index.js";
 import { LocalSolanaSigner } from "../signer/index.js";
 import { isExpired } from "../agent-wallet/expiry.js";
-import { PerpError } from "../errors.js";
+import { randomUUID } from "crypto";
+import { PerpError, extractErrorMessage, isDefiniteOrderFailure, orderNotSent, orderOutcomeUnknown } from "../errors.js";
+import { parseFiniteVenueNumber, venueRateField } from "../utils/numeric.js";
+import { unsupported, validateLegacyTif } from "./trading-v2.js";
+import { floorSize, requireOnTick, subDecimal } from "./precision.js";
+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
+ * aliases GTT → GTC and GTX → ALO; no TIF → GTC (uniform default). FOK (never
+ * emulated) and unknown values → uniform CAPABILITY_UNSUPPORTED.
+ */
+export function pacificaTif(tif) {
+    if (tif === undefined || tif.trim() === "")
+        return "GTC";
+    return validateLegacyTif(pacificaVenue, requireCapabilities(pacificaVenue), tif);
+}
+/**
+ * Generated client_order_id carrying the order's TIF (design §13.4, §13.10 #10, 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.
+ */
+const PACIFICA_TIF_CODE = { GTC: "1", IOC: "2", ALO: "3", TOB: "4" };
+const PACIFICA_CLOID_RE = /^5ac1f([1-4])[0-9a-f]{2}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+export function pacificaClientOrderId(tif) {
+    return `5ac1f${PACIFICA_TIF_CODE[tif]}${randomUUID().slice(6)}`;
+}
+/**
+ * A caller's client order id: Pacifica takes a "Full UUID string" (docs.pacifica.fi rest-api
+ * orders/create-limit-order + create-market-order: `client_order_id` | Full UUID string | optional
+ * | "Client-defined order ID" | f47ac10b-58cc-4372-a567-0e02b2c3d479). Anything else →
+ * INVALID_PARAMS before sending. An id in the reserved generated layout (`5ac1f` + TIF code) must
+ * state the order's own TIF `tif` (amend trusts it); null `tif` = the order has none (market).
+ */
+export function requirePacificaClientOrderId(id, tif) {
+    if (!PACIFICA_UUID_RE.test(id)) {
+        throw new PerpError("INVALID_PARAMS", `Client order id "${id}" is not valid on Pacifica (a full UUID, e.g. f47ac10b-58cc-4372-a567-0e02b2c3d479)`, {
+            exchange: "pacifica", remediation: "Pass a UUID as --client-id, or use --auto-id (a UUID is generated and reported)",
+        });
+    }
+    const encoded = pacificaTifOf(id.toLowerCase());
+    if (encoded !== null && encoded !== tif) {
+        throw new PerpError("INVALID_PARAMS", `Client order id "${id}" uses the reserved 5ac1f prefix that encodes TIF ${encoded}, but the order is ${tif === null ? "a market order" : tif}`, {
+            exchange: "pacifica", remediation: "Use a UUID that does not start with 5ac1f, or --auto-id",
+        });
+    }
+    return id;
+}
+/** The raw create result with the client_order_id that was SENT attached (read back by LegacyTradingV2.result). */
+function withSentClientOrderId(raw, clientOrderId) {
+    if (clientOrderId === null || raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return raw;
+    return { ...raw, clientOrderId };
+}
+/** TIF encoded in a generated client_order_id; null = not generated here (attributes unknown). */
+export function pacificaTifOf(clientOrderId) {
+    if (typeof clientOrderId !== "string")
+        return null;
+    const m = PACIFICA_CLOID_RE.exec(clientOrderId);
+    if (m === null)
+        return null;
+    const hit = Object.entries(PACIFICA_TIF_CODE).find(([, c]) => c === m[1]);
+    return hit === undefined ? null : hit[0];
+}
+/** Pacifica POST error that is a venue answer (HTTP 4xx): the request was refused, nothing changed. */
+const PACIFICA_TERMINAL_STATUSES = new Set(["filled", "cancelled", "canceled", "rejected"]);
+/**
+ * The order's current `/orders/history_by_id` row. The array position is not a documented
+ * ordering and is never used: the row with the largest `created_at` wins (a timestamp tie →
+ * the single terminal row among them; several terminal rows tied → null). When rows lack a
+ * numeric `created_at`, only an explicit terminal row (filled / cancelled / rejected) for
+ * that order id is taken, and only when it is the only one. null = not proven (the caller
+ * polls again or reports pending). Rows of another order id are ignored.
+ */
+export function pacificaLatestHistoryRow(rows, orderId) {
+    if (!Array.isArray(rows))
+        return null;
+    const mine = rows.filter((r) => r !== null && typeof r === "object" && (r.order_id === undefined || r.order_id === null || String(r.order_id) === orderId));
+    if (mine.length === 0)
+        return null;
+    const ts = (r) => {
+        const v = r.created_at;
+        if (typeof v === "number" && Number.isFinite(v))
+            return v;
+        if (typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v)))
+            return Number(v);
+        return null;
+    };
+    const terminal = (rs) => rs.filter(r => PACIFICA_TERMINAL_STATUSES.has(String(r.order_status ?? "")));
+    if (mine.every(r => ts(r) !== null)) {
+        const max = Math.max(...mine.map(r => ts(r)));
+        const top = mine.filter(r => ts(r) === max);
+        if (top.length === 1)
+            return top[0];
+        const t = terminal(top);
+        if (t.length === 1)
+            return t[0];
+        return t.length === 0 ? top[0] : null;
+    }
+    const t = terminal(mine);
+    return t.length === 1 ? t[0] : null;
+}
+const DECIMAL_RE = /^\d+(\.\d+)?$/;
+/**
+ * The order's outcome from its history_by_id rows (pacificaLatestHistoryRow), or null when not
+ * proven: no row for `orderId`, an unknown order_status, or no decimal filled_amount.
+ * `terminalOnly` (IOC): an open / partially_filled row is not an outcome (the order never rests).
+ * `expect` (price / size sent): a row whose price or initial_amount differ is not this
+ * placement / edit yet → null.
+ */
+export function pacificaOrderOutcomeOf(rows, orderId, opts = {}) {
+    const row = pacificaLatestHistoryRow(rows, orderId);
+    if (row === null || row.order_id === undefined || row.order_id === null)
+        return null;
+    const st = String(row.order_status ?? "");
+    const filled = String(row.filled_amount ?? "").trim();
+    if (!DECIMAL_RE.test(filled))
+        return null;
+    const price = typeof row.price === "string" || typeof row.price === "number" ? String(row.price) : null;
+    const size = typeof row.initial_amount === "string" || typeof row.initial_amount === "number" ? String(row.initial_amount) : null;
+    const ex = opts.expect;
+    if (ex !== undefined) {
+        if (ex.price !== null && (price === null || Number(price) !== Number(ex.price)))
+            return null;
+        if (ex.size !== null && (size === null || Number(size) !== Number(ex.size)))
+            return null;
+    }
+    const hasFill = Number(filled) > 0;
+    let status;
+    if (st === "open")
+        status = hasFill ? "partiallyFilled" : "open";
+    else if (st === "partially_filled")
+        status = "partiallyFilled";
+    else if (st === "filled")
+        status = "filled";
+    else if (st === "cancelled" || st === "canceled")
+        status = hasFill ? "partiallyFilled" : "cancelled";
+    else if (st === "rejected")
+        status = "rejected";
+    else
+        return null;
+    if (opts.terminalOnly === true && (st === "open" || st === "partially_filled"))
+        return null;
+    return {
+        status, final: true, venueStatus: st, eventType: typeof row.event_type === "string" ? row.event_type : null,
+        orderId, filledSize: filled, price, size, source: "history_by_id",
+    };
+}
+/** order_id of a create / edit response ({ success, data: { order_id } }), or null. */
+function pacificaCreatedId(raw) {
+    if (raw === null || typeof raw !== "object")
+        return null;
+    const r = raw;
+    const data = (r.data !== null && typeof r.data === "object" ? r.data : r);
+    return typeof data.order_id === "number" || typeof data.order_id === "string" ? String(data.order_id) : null;
+}
+/**
+ * A create-order POST the venue refused with HTTP 422 (Pacifica "Business Logic Error", error-codes
+ * doc) is a definite pre-trade rejection — no order was created. Live testnet 2026-10-02:
+ * POST /orders/create_market 422 {"success":false,"error":"No reasonable price found for SOL-USDC",
+ * "code":0,"error_id":"no_reasonable_price"} (an empty book). → ORDER_REJECTED carrying the venue's
+ * error / code / error_id — but ONLY for the documented validation codes
+ * (PACIFICA_DEFINITE_CREATE_CODES / _ERROR_IDS). Internal or unknown codes → ORDER_PENDING (the
+ * order may exist). Anything else (other status, unparseable body, not a create path, already a
+ * PerpError) → `e` unchanged.
+ */
+export function pacificaCreateRejection(e, what) {
+    if (e instanceof PerpError)
+        return e;
+    const m = /^POST (\/orders\/(?:stop\/)?create\S*) failed \(422\): ([\s\S]*)$/.exec(extractErrorMessage(e));
+    if (m === null)
+        return e;
+    let body;
+    try {
+        const parsed = JSON.parse(m[2]);
+        if (parsed === null || typeof parsed !== "object")
+            return e;
+        body = parsed;
+    }
+    catch {
+        return e;
+    }
+    if (body.success !== false || typeof body.error !== "string" || body.error === "")
+        return e;
+    const details = { exchange: "pacifica", venueCode: body.code ?? null, errorId: typeof body.error_id === "string" ? body.error_id : null, path: m[1] };
+    // Business-logic codes per docs.pacifica.fi api error-codes (422): 4 INVALID_TICK_LEVEL,
+    // 5 INSUFFICIENT_BALANCE, 7 ORDER_AMOUNT_TOO_LOW, 8 ORDER_AMOUNT_TOO_HIGH. All are definite: no order was created.
+    const byCode = {
+        4: "INVALID_TICK", 5: "INSUFFICIENT_BALANCE", 7: "SIZE_TOO_SMALL", 8: "SIZE_TOO_LARGE",
+    };
+    const mapped = typeof body.code === "number" ? byCode[body.code] : undefined;
+    if (mapped !== undefined)
+        return new PerpError(mapped, `Pacifica ${what} refused (no order was created): ${body.error}`, details);
+    const errorId = typeof body.error_id === "string" ? body.error_id.toLowerCase() : null;
+    const definite = (typeof body.code === "number" && PACIFICA_DEFINITE_CREATE_CODES.has(body.code))
+        || (errorId !== null && PACIFICA_DEFINITE_CREATE_ERROR_IDS.has(errorId));
+    if (definite)
+        return new PerpError("ORDER_REJECTED", `Pacifica ${what} refused (no order was created): ${body.error}`, details);
+    // 0 INTERNAL, 14 DATABASE_ERROR, 26 CHANNEL_CLOSED, 27 RESPONSE_DROPPED, or a code this CLI does
+    // not know: the venue did not say the order was refused — it may exist.
+    return orderOutcomeUnknown("pacifica", what, new Error(`HTTP 422 code ${String(body.code)}${errorId !== null ? ` (${errorId})` : ""}: ${body.error}`), "Do NOT resubmit — the order may have been created. Check: perp account orders -e pacifica / perp account positions -e pacifica");
+}
+/**
+ * 422 business codes that say a create was validated and REFUSED (docs.pacifica.fi api
+ * error-codes, read 2026-10-05): 1 ACCOUNT_NOT_FOUND, 3 BOOK_NOT_FOUND, 4 INVALID_TICK_LEVEL,
+ * 5 INSUFFICIENT_BALANCE, 7/8 ORDER_AMOUNT_TOO_LOW/HIGH, 10 OPEN_ORDER_LIMIT_REACHED,
+ * 13 POSITION_NOT_FOUND, 16–23 stop / order-type / reduce-only validation, 25 NO_REASONABLE_PRICE,
+ * 28 IMMEDIATE_LIQUIDATION, 30 PRICE_TOO_FAR_FROM_MARK, 36 DUPLICATE_CLIENT_ORDER_ID,
+ * 38 TRADING_DISABLED, 41 OPEN_INTEREST_LIMIT_EXCEEDED, 49 POSITION_TPSL_LIMIT_EXCEEDED,
+ * 50 INVALID_BUILDER_CODE, 51 UNSUPPORTED_OPERATION, 52 INVALID_TICK_SIZE,
+ * 53 ORDER_BLOCKED_BY_LOAN_POOL_STRESS, 55/56 ASSET_NOT_FOUND/NOT_ACTIVE, 59 INVALID_AMOUNT,
+ * 62 INSUFFICIENT_SPOT_BALANCE, 63 MISSING_MARK_PRICE, 106–108 spot restrictions,
+ * 119 ORACLE_NOT_AVAILABLE. NOT listed (outcome unknown): 0 INTERNAL, 14 DATABASE_ERROR,
+ * 26 CHANNEL_CLOSED, 27 RESPONSE_DROPPED and every undocumented code.
+ */
+export const PACIFICA_DEFINITE_CREATE_CODES = new Set([
+    1, 3, 4, 5, 7, 8, 10, 13, 16, 17, 18, 19, 20, 21, 22, 23, 25, 28, 30, 36, 38, 41, 49, 50, 51, 52, 53, 55, 56, 59, 62, 63, 106, 107, 108, 119,
+]);
+/**
+ * `error_id` values that are definite on their own: the venue sends some validation refusals
+ * under code 0 with a specific error_id (live testnet 2026-10-02: an empty book →
+ * {"code":0,"error_id":"no_reasonable_price"}).
+ * Live mainnet 2026-10-05: a reduce-only limit with no position →
+ * {"code":0,"error_id":"no_position_for_reduce_only_order"} ("No position found for reduce-only order").
+ */
+export const PACIFICA_DEFINITE_CREATE_ERROR_IDS = new Set(["no_reasonable_price", "no_position_for_reduce_only_order"]);
+/**
+ * Pacifica's documented USDC withdrawal minimum (docs.pacifica.fi "Deposits & Withdrawals":
+ * "Minimum withdrawal: $1. Fees: $1 per withdrawal (gas)"). Not the whole rule: testnet refused
+ * exactly 1 USDC on 2026-10-02 with 422 code 29 WITHDRAW_AMOUNT_TOO_LOW, so amounts at or just
+ * above it are left to the venue (pacificaWithdrawRejection maps the refusal).
+ */
+export const PACIFICA_WITHDRAW_MIN_USDC = "1";
+/**
+ * A withdraw POST the venue refused with HTTP 422 (Business Logic Error — nothing was withdrawn):
+ * code 29 WITHDRAW_AMOUNT_TOO_LOW → INVALID_PARAMS, code 9 OVER_WITHDRAWAL → INSUFFICIENT_BALANCE,
+ * any other explicit refusal → ACTION_REJECTED (codes: docs.pacifica.fi api error-codes). Anything
+ * else (other status, unparseable body, already a PerpError) → `e` unchanged (outcome unknown).
+ */
+export function pacificaWithdrawRejection(e, amount) {
+    if (e instanceof PerpError)
+        return e;
+    const m = /^POST \/account\/withdraw failed \(422\): ([\s\S]*)$/.exec(extractErrorMessage(e));
+    if (m === null)
+        return e;
+    let body;
+    try {
+        const parsed = JSON.parse(m[1]);
+        if (parsed === null || typeof parsed !== "object")
+            return e;
+        body = parsed;
+    }
+    catch {
+        return e;
+    }
+    if (body.success !== false || typeof body.error !== "string" || body.error === "")
+        return e;
+    const details = { exchange: "pacifica", venueCode: body.code ?? null, errorId: typeof body.error_id === "string" ? body.error_id : null };
+    if (body.code === 29) {
+        return new PerpError("INVALID_PARAMS", `Pacifica withdraw ${amount} USDC refused (nothing was withdrawn): ${body.error}`, {
+            ...details,
+            remediation: `Withdraw a larger amount — Pacifica documents a ${PACIFICA_WITHDRAW_MIN_USDC} USDC minimum plus a $1 fee per withdrawal, and refused ${amount} USDC`,
+        });
+    }
+    if (body.code === 9) {
+        return new PerpError("INSUFFICIENT_BALANCE", `Pacifica withdraw ${amount} USDC refused (nothing was withdrawn): ${body.error}`, {
+            ...details, remediation: "Check available_to_withdraw: perp -e pacifica portfolio",
+        });
+    }
+    return new PerpError("ACTION_REJECTED", `Pacifica withdraw ${amount} USDC refused (nothing was withdrawn): ${body.error}`, details);
+}
+export function pacificaRefused(e) {
+    return !(e instanceof PerpError) && /^POST \S+ failed \(4\d\d\)/.test(extractErrorMessage(e));
+}
+/**
+ * What a refused cancel (POST /orders/cancel 4xx, e.g. 422 {"error":"Failed to cancel order","code":5}
+ * for an already-filled market order — live testnet 2026-10-02) means for the order, from its
+ * history_by_id read (`history` = the read's data, or the read's error):
+ * - terminal row (filled / cancelled / rejected) → failed: nothing was cancelled by this request;
+ * - GET 404 "Order history not found" → failed: the venue has no such order;
+ * - a still-open row, no row, or any other read failure → pending (not proven either way).
+ * Never "cancelled".
+ */
+export function pacificaCancelRefusalOf(orderId, refusal, history) {
+    if ("error" in history) {
+        const msg = extractErrorMessage(history.error);
+        if (/^GET \S*history_by_id failed \(404\)/.test(msg)) {
+            return { kind: "failed", error: `order ${orderId} does not exist on Pacifica (history_by_id 404); nothing was cancelled — venue refusal: ${refusal}` };
+        }
+        return { kind: "pending", reason: `the venue refused the cancel (${refusal}) and the order's state could not be read (${msg})` };
+    }
+    const out = pacificaOrderOutcomeOf(history.data, orderId);
+    if (out === null)
+        return { kind: "pending", reason: `the venue refused the cancel (${refusal}) and history_by_id shows no settled row for order ${orderId}` };
+    if (out.venueStatus === "open" || out.venueStatus === "partially_filled") {
+        return { kind: "pending", reason: `the venue refused the cancel (${refusal}) but order ${orderId} is still ${out.venueStatus} (filled ${out.filledSize})` };
+    }
+    return { kind: "failed", error: `order ${orderId} is already ${out.venueStatus} (filled ${out.filledSize}, history_by_id); nothing was cancelled — venue refusal: ${refusal}` };
+}
+/** `{ success: false }` / `{ error }` body = explicit venue refusal. */
+function pacificaBodyError(r) {
+    if (r === null || typeof r !== "object")
+        return null;
+    const o = r;
+    if (o.success === false || (typeof o.error === "string" && o.error !== ""))
+        return String(o.error ?? "request rejected");
+    return null;
+}
+/** /info rows must carry instrument_type — a row without it cannot be classified perp vs spot. */
+function requireInstrumentType(rows) {
+    for (const m of rows) {
+        if (typeof m.instrument_type !== "string") {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica /info row ${String(m.symbol)} has no instrument_type`, { exchange: "pacifica" });
+        }
+    }
+    return rows;
+}
+/** Perp markets of /info (spot rows such as SOL-USDC excluded, design §12). */
+function perpInfoRows(rows) {
+    return requireInstrumentType(rows).filter((m) => m.instrument_type !== "spot");
+}
+/** Wire symbols of /info spot markets. */
+function spotInfoSymbols(rows) {
+    return new Set(requireInstrumentType(rows).filter((m) => m.instrument_type === "spot").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) {
+    return /^(stop|take_profit|stop_loss)_/.test(type);
+}
 export class PacificaAdapter {
     name = "pacifica";
     chain = "solana";
@@ -26,18 +356,35 @@ export class PacificaAdapter {
     _marketsCache = null;
     _marketsCacheTime = 0;
     static CACHE_TTL = 30_000;
-    constructor(keypair, network = "mainnet", builderCode, hasRealKey = true) {
+    /** Venue network — part of every account cache key (the same key exists on mainnet and testnet). */
+    _network;
+    /**
+     * Builder-fee gate (settings builder.pacifica + confirmed approval); null = not configured.
+     * Set by createPacifica (venues/create-helpers.ts) — the adapter never reads settings.
+     */
+    builderFee = null;
+    constructor(keypair, network = "mainnet", hasRealKey = true) {
+        this._network = network;
         this._solanaSigner = new LocalSolanaSigner(keypair);
         this._hasRealKey = hasRealKey;
         this.account = this._solanaSigner.getPublicKeyBase58();
-        this.client = new PacificaClient({ network, builderCode });
+        this.client = new PacificaClient({ network });
         // Hot-path methods always go through `_resolveSigner()` so the bound
         // `signMessage` reflects the highest-priority active tier.
         this.signMessage = (msg) => this._resolveSigner().signer.signMessage(msg);
     }
     ensureSigner() {
         // Resolves across all tiers; throws PerpError if none available.
-        this._resolveSigner();
+        const r = this._resolveSigner();
+        // Sync the client's agent_wallet for the active tier. Agent-signed requests
+        // (account = master, signature = agent key) MUST carry agent_wallet, or
+        // Pacifica verifies the signature against the master key and rejects every
+        // order. Master/PK signers clear it so they self-sign as before.
+        this.client.setRequestAgentWallet(r.tier === "agent" ? r.address : undefined);
+    }
+    /** Resolve the active signer tier and sync agent_wallet on the client (used by PacificaSpotAdapter). */
+    prepareSigning() {
+        this.ensureSigner();
     }
     /**
      * Inject an external Solana signer (Tier 2 — OWS master).
@@ -83,20 +430,16 @@ export class PacificaAdapter {
     }
     /** Resolve the active signer across three tiers. Mirrors AsterAdapter._resolveSigner. */
     _resolveSigner() {
-        // Tier 1: agent (when registered, not expired, --no-agent NOT set)
+        // Tier 1: agent (when registered, --no-agent NOT set). An expired agent record is an
+        // explicit error — never a silent switch to the master signer; --no-agent is the opt-in.
         if (!this._useNoAgent && this._agentSigner && this._agentMeta) {
             if (isExpired(this._agentMeta)) {
-                // Skip Tier 1 only if Tier 2/3 available; otherwise throw AGENT_EXPIRED
-                if (!this._masterSigner && !this._hasRealKey) {
-                    throw new PerpError("AGENT_EXPIRED", "Agent wallet has expired", {
-                        remediation: "perp wallet agent approve pacifica --rotate",
-                    });
-                }
-                // fall through to Tier 2/3
-            }
-            else {
-                return { tier: "agent", signer: this._agentSigner, address: this._agentSigner.getPublicKeyBase58() };
+                throw new PerpError("AGENT_EXPIRED", `Pacifica agent wallet ${this._agentMeta.agentName} expired at ${this._agentMeta.expiresAt}`, {
+                    exchange: "pacifica",
+                    remediation: "Re-approve the agent: perp wallet agent approve pacifica — or sign with the master wallet for this command: --no-agent",
+                });
             }
+            return { tier: "agent", signer: this._agentSigner, address: this._agentSigner.getPublicKeyBase58() };
         }
         // Tier 2: OWS master
         if (this._masterSigner) {
@@ -118,6 +461,19 @@ export class PacificaAdapter {
             remediation: "Run one of: (a) perp wallet agent approve pacifica --master <wallet>; (b) perp wallet generate && perp -e pacifica --ows <wallet>; (c) export PACIFICA_PRIVATE_KEY=...",
         });
     }
+    /**
+     * The owner (master) Solana signer for on-chain transactions (deposit, test-token
+     * mint) — never the agent, which cannot move funds.
+     */
+    masterSolanaSigner() {
+        if (this._masterSigner)
+            return this._masterSigner;
+        if (this._hasRealKey && this._solanaSigner)
+            return this._solanaSigner;
+        throw new PerpError("NO_SIGNER_AVAILABLE", "No Pacifica master wallet on this computer for an on-chain transaction", {
+            remediation: "Select the master wallet (--ows <wallet> or perp wallet use <wallet>), or do it on the Pacifica website",
+        });
+    }
     /** Access the underlying Keypair (only available with LocalSolanaSigner). */
     get keypair() {
         if (this._solanaSigner instanceof LocalSolanaSigner) {
@@ -127,15 +483,44 @@ export class PacificaAdapter {
     }
     async _getPrices() {
         const { withCache, TTL_ACCOUNT } = await import("../cache.js");
-        return withCache(`acct:pac:prices:${this.account.slice(0, 8)}`, TTL_ACCOUNT, () => this.client.getPrices());
+        return withCache(`acct:pac:${this._network}:prices:${this.account}`, TTL_ACCOUNT, () => this.client.getPrices());
     }
     async _getPositions() {
         const { withCache, TTL_ACCOUNT } = await import("../cache.js");
-        return withCache(`acct:pac:positions:${this.account.slice(0, 8)}`, TTL_ACCOUNT, () => this.client.getPositions(this.account));
+        return withCache(`acct:pac:${this._network}:positions:${this.account}`, TTL_ACCOUNT, () => this.client.getPositions(this.account));
     }
     get publicKey() {
         return this.account;
     }
+    /** Builder decision for the next perp order (cached approval read; never throws). */
+    async builderDecision() {
+        const gate = builderGateOf(this);
+        return gate === null ? NO_BUILDER : gate.decide({ hip3: false });
+    }
+    /** builder_code to send with the next perp order, or null (not configured / not approved). */
+    async builderCode() {
+        const d = await this.builderDecision();
+        return d.applied === null ? null : d.applied.identity;
+    }
+    /**
+     * Approval of `target.identity` on this account (GET /account/builder_codes/approvals).
+     * Pacifica's builder sets its own rate up to the approved max_fee_rate, so the code is
+     * attached only while that max ≤ target.feeBps (the user's consent); a higher approved max
+     * is "aboveConsent" (not attached, real max reported).
+     */
+    async builderApprovalOf(target) {
+        const rows = await this.client.getBuilderApprovals(this.account);
+        if (!Array.isArray(rows)) {
+            return { status: "unknown", reason: `unexpected approvals response ${JSON.stringify(rows).slice(0, 120)}` };
+        }
+        const row = rows.find(r => r !== null && typeof r === "object" && r.builder_code === target.identity);
+        if (row === undefined)
+            return approvalFromCeiling(null, requireFeeBps(target));
+        const max = rateToBps(row.max_fee_rate);
+        if (max === null)
+            return { status: "unknown", reason: `unreadable max_fee_rate ${JSON.stringify(row.max_fee_rate)}` };
+        return approvalFromCeiling(max, requireFeeBps(target));
+    }
     get sdk() {
         return this.client;
     }
@@ -150,21 +535,26 @@ export class PacificaAdapter {
             this._getPrices(),
         ]);
         const priceMap = new Map(prices.map((p) => [p.symbol, p]));
-        const result = markets.map((m) => {
+        // /info also lists spot markets (e.g. SOL-USDC); those are not perps (§12).
+        const result = perpInfoRows(markets).map((m) => {
             const p = priceMap.get(m.symbol);
             // Derive sizeDecimals from lot_size (e.g. "0.001" → 3, "1" → 0)
-            const lotSize = parseFloat(m.lot_size ?? "0");
-            const sizeDecimals = lotSize > 0 ? Math.max(0, -Math.floor(Math.log10(lotSize))) : undefined;
+            const lotSize = m.lot_size != null ? parseFloat(m.lot_size) : null;
+            const validLot = lotSize !== null && Number.isFinite(lotSize) && lotSize > 0;
+            const sizeDecimals = validLot ? Math.max(0, -Math.floor(Math.log10(lotSize))) : null;
             return {
                 symbol: m.symbol,
                 markPrice: p?.mark ?? "-",
-                indexPrice: p?.oracle ?? "-",
+                indexPrice: p?.oracle ?? null,
                 fundingRate: m.next_funding_rate ?? m.funding_rate,
-                volume24h: p?.volume_24h ?? "-",
-                openInterest: p?.open_interest ?? "-",
+                volume24h: p?.volume_24h ?? null,
+                openInterest: p?.open_interest ?? null,
                 maxLeverage: m.max_leverage,
                 sizeDecimals,
-                stepSize: lotSize > 0 ? m.lot_size : undefined,
+                stepSize: validLot ? m.lot_size : null,
+                // Pacifica publishes neither a per-market funding interval nor margin tiers.
+                fundingHours: null,
+                marginTiers: null,
             };
         });
         this._marketsCache = result;
@@ -191,22 +581,34 @@ export class PacificaAdapter {
         // API often returns unrealized_pnl=0 — compute from price delta when needed
         let totalPnl = 0;
         for (const p of positions) {
-            let upnl = Number(p.unrealized_pnl ?? 0);
-            if (upnl === 0 && Number(p.amount) > 0) {
-                const mark = Number(priceMap.get(p.symbol)?.mark ?? p.mark_price ?? 0);
-                const entry = Number(p.entry_price);
+            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) * Number(p.amount) * dir;
+                    upnl = (mark - entry) * amount * dir;
             }
             totalPnl += upnl;
         }
-        return {
+        // 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;
     }
     async getPositions() {
         if (!this._hasRealKey)
@@ -216,45 +618,109 @@ export class PacificaAdapter {
             this._getPrices(),
         ]);
         const priceMap = new Map(prices.map((p) => [p.symbol, p]));
-        let levMap = new Map();
-        try {
-            const settings = await this.client.getAccountSettings(this.account);
-            if (Array.isArray(settings)) {
-                levMap = new Map(settings.map((s) => [s.symbol, s.leverage]));
-            }
-        }
-        catch {
-            // Settings API may not be available
-        }
-        return positions.map((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 = Number(p.amount);
-            const entry = Number(p.entry_price);
-            const markNum = Number(mark);
+            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 = Number(p.unrealized_pnl ?? 0);
+            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: String(p.liquidation_price ?? "N/A"),
+                liquidationPrice: p.liquidation_price != null ? String(p.liquidation_price) : null,
                 unrealizedPnl: upnl.toFixed(4),
-                leverage: p.leverage ?? levMap.get(String(p.symbol)) ?? 1,
+                // 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 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`
+     * entry ("Current leverage set by the user"); no entry → the market's max leverage (docs
+     * get-account-settings: "leverage default to max ... will return blank"). Unreadable → EXCHANGE_ERROR.
+     */
+    async marketLeverage(symbol) {
+        const sym = symbol.toUpperCase();
+        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 entry = settings.margin_settings.find(e => typeof e?.symbol === "string" && e.symbol.toUpperCase() === sym);
+        if (entry !== undefined) {
+            if (typeof entry.leverage !== "number" || !(entry.leverage >= 1)) {
+                throw new PerpError("EXCHANGE_ERROR", `Pacifica /account/settings: malformed margin_settings entry ${JSON.stringify(entry)}`, { exchange: "pacifica" });
+            }
+            return entry.leverage;
+        }
+        const max = (await this.getMarkets()).find(m => m.symbol.toUpperCase() === sym)?.maxLeverage;
+        if (typeof max !== "number" || !(max >= 1)) {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica ${sym}: no /account/settings entry and no max leverage for the market`, { exchange: "pacifica" });
+        }
+        return max;
     }
     async getOpenOrders() {
         if (!this._hasRealKey)
             throw new Error("No private key configured — account data unavailable. Run: perp setup");
-        const orders = await this.client.getOrders(this.account);
-        return orders.map((o) => {
+        // 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 raw = o;
             return {
                 orderId: String(raw.order_id),
@@ -265,36 +731,65 @@ export class PacificaAdapter {
                 filled: String(raw.filled_amount ?? raw.filled ?? "0"),
                 status: String(raw.order_status ?? "open"),
                 type: String(raw.order_type ?? ""),
+                // Stop / TP / SL orders: stop_price is the trigger (a position-level TP/SL lists price 0, amount 0).
+                triggerPrice: raw.stop_price !== null && raw.stop_price !== undefined && Number(raw.stop_price) > 0 ? String(raw.stop_price) : null,
             };
         });
     }
     async marketOrder(symbol, side, size, opts) {
         this.ensureSigner();
-        const result = await this.client.createMarketOrder({ symbol, amount: size, side: side === "buy" ? "bid" : "ask", reduce_only: opts?.reduceOnly ?? false, slippage_percent: "1" }, this.account, this.signMessage);
+        // 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({
+            symbol, amount: size, side: side === "buy" ? "bid" : "ask", reduce_only: opts.reduceOnly, slippage_percent: String(opts.slippage.bps / 100),
+            ...(cloid !== null ? { client_order_id: cloid } : {}),
+        }, this.account, this.signMessage, await this.builderCode()).catch((e) => { throw pacificaCreateRejection(e, `market ${side} ${size} ${symbol}`); });
+        const result = withSentClientOrderId(created, cloid);
         // Validate response
         const r = result;
         const data = (r.data ?? r);
         if (r.success === false || r.error) {
-            throw new Error(`Market ${side} ${symbol}: ${r.error ?? 'order rejected'}`);
+            // Explicit venue rejection in the response body: definitely not placed.
+            throw new PerpError("ORDER_REJECTED", `Market ${side} ${symbol}: ${r.error ?? 'order rejected'}`, { exchange: "pacifica" });
         }
         // Get order_id from response
         const orderId = data.order_id ? String(data.order_id) : null;
         if (orderId && !(opts?.reduceOnly ?? false)) {
             // Poll order status via history_by_id
             let lastPollError = null;
+            let verdict = null;
             for (let attempt = 0; attempt < 10; attempt++) {
                 await new Promise(r => setTimeout(r, 500));
                 try {
                     const history = await this.client.getOrderHistoryById(Number(orderId));
-                    const histData = (history.data ?? history);
-                    if (Array.isArray(histData) && histData.length > 0) {
-                        const latest = histData[histData.length - 1];
+                    const histData = history.data ?? history;
+                    const latest = pacificaLatestHistoryRow(histData, orderId);
+                    if (latest !== null) {
                         const status = String(latest.order_status ?? "");
                         const filled = parseFloat(String(latest.filled_amount ?? "0"));
-                        if (status === "filled" || filled > 0)
-                            return result; // confirmed fill
+                        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.
+                            const reported = latest.filled_amount;
+                            const terminal = status === "filled" || status === "cancelled" || status === "rejected";
+                            if (terminal && reported !== undefined && reported !== null && String(reported).trim() !== ""
+                                && Number.isFinite(Number(reported)) && result !== null && typeof result === "object") {
+                                // The terminal row rides along with the raw result (read back by iocOutcomeOf).
+                                const fillReport = { orderId, orderStatus: status, filledAmount: String(reported).trim() };
+                                return { ...result, fillReport };
+                            }
+                            return result; // confirmed fill (no final report)
+                        }
                         if (status === "cancelled" || status === "rejected") {
-                            throw new Error(`Market ${side} ${symbol}: order ${orderId} ${status}`);
+                            // Definite no-fill ONLY when the venue reports filled_amount and it is 0. A
+                            // terminal row without filled_amount may be a partially-filled IOC whose
+                            // remainder was cancelled — leave it untyped so the caller measures the fill.
+                            if (latest.filled_amount !== undefined && latest.filled_amount !== null && String(latest.filled_amount).trim() !== "" && Number(latest.filled_amount) === 0) {
+                                throw new PerpError("ORDER_REJECTED", `Market ${side} ${symbol}: order ${orderId} ${status}`, { exchange: "pacifica", orderId });
+                            }
+                            // Sent and terminal, but the fill amount is not reported: a partially filled IOC
+                            // whose remainder was cancelled looks the same — outcome unknown, never resubmit.
+                            verdict = orderOutcomeUnknown("pacifica", `market ${side} ${size} ${symbol}`, new Error(`order ${orderId} ${status} without a reported filled_amount`), `Do NOT resubmit — order ${orderId} may have partially filled. Check positions and fills first: perp -e pacifica account positions / trades`);
                         }
                         // Still processing, retry
                     }
@@ -304,42 +799,442 @@ export class PacificaAdapter {
                         throw e;
                     lastPollError = e;
                 }
+                if (verdict !== null)
+                    throw verdict;
             }
-            // Order was accepted but verification timed out — warn, don't throw
+            // Accepted but not confirmed within the poll window: returned without a fill report, so the
+            // caller (iocOutcomeOf → null) reports it unconfirmed — never assumed executed.
             const errDetail = lastPollError instanceof Error ? ` (poll error: ${lastPollError.message})` : "";
-            console.error(`[pacifica] Warning: market ${side} ${symbol} order ${orderId} not confirmed after 5s${errDetail} — assuming executed`);
+            console.error(`[pacifica] Warning: market ${side} ${symbol} order ${orderId} not confirmed after 5s${errDetail} — outcome unconfirmed; check positions before retrying: perp -e pacifica account positions`);
         }
-        if (!(opts?.reduceOnly ?? false)) {
+        if (!orderId && !(opts?.reduceOnly ?? false)) {
             console.error(`[pacifica] Warning: market ${side} ${symbol} accepted but no order_id in response — skipping fill verification`);
         }
         return result;
     }
+    /**
+     * Venue-final outcome of a raw marketOrder() result (IocOutcomeCapable, design §13.10 #4),
+     * 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),
+     * a poll that timed out or saw only non-terminal rows, any other raw value. Never guesses.
+     */
+    iocOutcomeOf(raw) {
+        if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+            return null;
+        const r = raw;
+        const fr = r.fillReport;
+        if (fr === null || typeof fr !== "object")
+            return null;
+        const data = (r.data !== null && typeof r.data === "object" ? r.data : r);
+        const createdId = typeof data.order_id === "number" || typeof data.order_id === "string" ? String(data.order_id) : null;
+        if (createdId === null || fr.orderId !== createdId)
+            return null;
+        if (fr.orderStatus !== "filled" && fr.orderStatus !== "cancelled" && fr.orderStatus !== "rejected")
+            return null;
+        const filled = fr.filledAmount;
+        if (typeof filled !== "string" || !/^\d+(\.\d+)?$/.test(filled))
+            return null;
+        return { filledSize: filled, final: true };
+    }
+    /**
+     * Venue-final outcome of a placed / edited order: polls `/orders/history_by_id` (bounded,
+     * 6 × 500 ms) until pacificaOrderOutcomeOf proves one. null = still unknown (the caller
+     * reports pending). Read failures poll again; the last one is logged when nothing resolved.
+     */
+    async resolveOrderOutcome(orderId, what, opts = {}) {
+        let lastErr = null;
+        for (let attempt = 0; attempt < 6; attempt++) {
+            await new Promise((r) => setTimeout(r, 500));
+            try {
+                const history = await this.client.getOrderHistoryById(Number(orderId));
+                const out = pacificaOrderOutcomeOf(history.data ?? history, orderId, opts);
+                if (out !== null)
+                    return out;
+            }
+            catch (e) {
+                lastErr = extractErrorMessage(e);
+            }
+        }
+        console.error(`[pacifica] Warning: ${what}: order ${orderId} outcome not confirmed${lastErr !== null ? ` (last read error: ${lastErr})` : ""} — verify with: perp account orders -e pacifica`);
+        return null;
+    }
+    /** The raw create result with its resolved `orderOutcome` attached (unchanged when there is no order id / a body error / no outcome). */
+    async withOrderOutcome(raw, what, opts) {
+        const id = pacificaCreatedId(raw);
+        if (id === null || pacificaBodyError(raw) !== null || raw === null || typeof raw !== "object")
+            return raw;
+        const orderOutcome = await this.resolveOrderOutcome(id, what, opts);
+        return orderOutcome === null ? raw : { ...raw, orderOutcome };
+    }
+    /**
+     * Limit order. The create response is only an ack ({ order_id }); the placement outcome
+     * (resting / filled / cancelled / rejected) is read back from history_by_id and attached as
+     * `orderOutcome` (IOC: terminal rows only). Unresolved → no `orderOutcome` (pending).
+     */
     async limitOrder(symbol, side, price, size, opts) {
         this.ensureSigner();
-        return this.client.createLimitOrder({ symbol, price, amount: size, side: side === "buy" ? "bid" : "ask", reduce_only: opts?.reduceOnly ?? false, tif: (opts?.tif ?? "GTC") }, this.account, this.signMessage);
+        const tif = pacificaTif(opts?.tif); // §13.3 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);
+        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();
         return this.client.cancelOrder({ symbol, order_id: Number(orderId) }, this.account, this.signMessage);
     }
+    /**
+     * The account's order carrying `clientOrderId`, from the venue's own listings — both document
+     * the field: GET /orders and GET /orders/history rows carry `client_order_id` ("CLOID of order
+     * if assigned by user", docs.pacifica.fi rest-api orders/get-open-orders, get-order-history).
+     * Open orders first, then the latest order-history page (the venue's default page, 100 rows).
+     * null = not among them. history_by_id itself takes only `order_id`, so this resolves the id.
+     */
+    async orderByClientId(clientOrderId) {
+        if (!this._hasRealKey)
+            throw new Error("No private key configured — account data unavailable. Run: perp setup");
+        const wanted = requirePacificaClientOrderId(clientOrderId, pacificaTifOf(clientOrderId.toLowerCase())).toLowerCase();
+        const pick = (rows, open) => {
+            if (!Array.isArray(rows)) {
+                throw new PerpError("EXCHANGE_ERROR", `Pacifica ${open ? "/orders" : "/orders/history"} returned no order list`, { exchange: "pacifica" });
+            }
+            const row = rows.find((o) => typeof o?.client_order_id === "string" && o.client_order_id.toLowerCase() === wanted);
+            if (row === undefined)
+                return null;
+            if (typeof row.order_id !== "number" && typeof row.order_id !== "string") {
+                throw new PerpError("EXCHANGE_ERROR", `Pacifica order with client id ${clientOrderId} has no order_id`, { exchange: "pacifica" });
+            }
+            return { orderId: String(row.order_id), symbol: String(row.symbol), type: String(row.order_type), open };
+        };
+        const open = pick(await this.client.getOrders(this.account), true);
+        if (open !== null)
+            return open;
+        return pick(await this.client.getOrderHistory(this.account), false);
+    }
+    /**
+     * Venue-final state of one order from a single `/orders/history_by_id` read (`trade status`).
+     * null outcome = the rows prove no state yet (reported pending). A 404 → ORDER_NOT_FOUND.
+     */
+    async orderStatusById(orderId) {
+        if (!/^\d+$/.test(orderId))
+            throw new PerpError("INVALID_PARAMS", `Pacifica order id must be numeric (got "${orderId}")`);
+        let history;
+        try {
+            history = await this.client.getOrderHistoryById(Number(orderId));
+        }
+        catch (e) {
+            if (/^GET \S*history_by_id failed \(404\)/.test(extractErrorMessage(e))) {
+                throw new PerpError("ORDER_NOT_FOUND", `Pacifica order ${orderId} not found`, { exchange: "pacifica" });
+            }
+            throw e;
+        }
+        const rows = (history !== null && typeof history === "object" && !Array.isArray(history) && "data" in history) ? history.data : history;
+        const row = pacificaLatestHistoryRow(rows, orderId);
+        if (row === null && (!Array.isArray(rows) || rows.length === 0)) {
+            throw new PerpError("ORDER_NOT_FOUND", `Pacifica order ${orderId} not found`, { exchange: "pacifica" });
+        }
+        return {
+            outcome: pacificaOrderOutcomeOf(rows, orderId),
+            clientOrderId: row !== null && typeof row.client_order_id === "string" && row.client_order_id !== "" ? row.client_order_id : null,
+            venueRaw: rows,
+        };
+    }
+    /** A refused cancel of `orderId` (pacificaRefused error) settled from one history_by_id read (pacificaCancelRefusalOf). */
+    async cancelRefusalOutcome(orderId, refusal) {
+        const msg = extractErrorMessage(refusal);
+        let history;
+        try {
+            const h = await this.client.getOrderHistoryById(Number(orderId));
+            history = { data: h?.data ?? h };
+        }
+        catch (e) {
+            history = { error: e };
+        }
+        return pacificaCancelRefusalOf(orderId, msg, history);
+    }
     async cancelAllOrders(symbol) {
         this.ensureSigner();
-        if (symbol) {
-            // Cancel only orders for this symbol: fetch open orders, filter, cancel individually
-            const orders = await this.getOpenOrders();
-            const filtered = orders.filter(o => o.symbol.toUpperCase() === symbol.toUpperCase());
-            const results = [];
-            for (const o of filtered) {
-                results.push(await this.cancelOrder(o.symbol, o.orderId));
+        // Never `cancel_all` with all_symbols:true — it would also cancel spot orders.
+        // getOpenOrders() already excludes spot symbols; cancel the perp orders one by one.
+        let orders;
+        try { // pre-send: the open-orders listing — nothing is cancelled when it fails
+            orders = await this.getOpenOrders();
+        }
+        catch (e) {
+            throw orderNotSent("pacifica", `cancel-all${symbol ? ` ${symbol.toUpperCase()}` : ""}`, e);
+        }
+        const targets = symbol ? orders.filter(o => o.symbol.toUpperCase() === symbol.toUpperCase()) : orders;
+        // Every target is attempted (like lighter.ts cancelAllOrders): one refused / unknown cancel
+        // must not leave the orders after it untouched and unreported. All cancelled → the raw
+        // results; any failure → one error carrying the per-order outcome.
+        const results = [];
+        const perOrder = [];
+        for (const o of targets) {
+            try {
+                const r = await this._cancelListed(o);
+                const bodyErr = pacificaBodyError(r);
+                if (bodyErr !== null)
+                    throw new PerpError("ORDER_REJECTED", `Pacifica cancel of ${o.orderId} refused: ${bodyErr}`, { exchange: "pacifica" });
+                results.push(r);
+                perOrder.push({ orderId: o.orderId, symbol: o.symbol, cancelled: true, definite: true, error: null });
+            }
+            catch (e) {
+                // A 4xx refusal / explicit body refusal / pre-send refusal is definite (that order was not
+                // cancelled by this request); a transport failure, 5xx or anything else leaves it unknown.
+                const definite = pacificaRefused(e) || isDefiniteOrderFailure(e);
+                perOrder.push({ orderId: o.orderId, symbol: o.symbol, cancelled: false, definite, error: extractErrorMessage(e) });
             }
-            return results;
         }
-        return this.client.cancelAllOrders({ all_symbols: true, exclude_reduce_only: false }, this.account, this.signMessage);
+        const failed = perOrder.filter(r => !r.cancelled);
+        if (failed.length === 0)
+            return results;
+        const cancelled = perOrder.length - failed.length;
+        const code = cancelled > 0 ? "ORDER_PARTIAL" : failed.every(r => r.definite) ? "ORDER_REJECTED" : "ORDER_PENDING";
+        throw new PerpError(code, `pacifica cancel-all: ${cancelled} of ${perOrder.length} order(s) cancelled; failed: ${failed.map(r => `${r.orderId} ${r.symbol} (${r.error})`).join("; ")}`, {
+            exchange: "pacifica",
+            results: perOrder,
+            remediation: "Check which orders are still open (perp account orders -e pacifica) and cancel the remaining ones individually",
+        });
     }
+    /** Stop / TP / SL rows (incl. position-level TP/SL) go to /orders/stop/cancel; /orders/cancel refuses them (422). */
+    _cancelListed(o) {
+        return isPacificaStopType(o.type) ? this.cancelStopOrder(o.symbol, o.orderId) : this.cancelOrder(o.symbol, o.orderId);
+    }
+    /**
+     * Native edit (POST /orders/edit). Venue semantics (docs rest-api/orders/edit-order,
+     * read 2026-10-02): the edit cancels the original and creates a new order with the same
+     * side, reduce-only and client_order_id, a new order_id, and TIF = ALO (post-only) —
+     * whatever the original TIF was. Post-only is therefore always kept (an ALO original
+     * stays ALO); a GTC / TOB original becomes ALO and is rejected instead of crossing.
+     * The original TIF is not readable (GET /orders has no tif field), so the conversion
+     * cannot be detected per order; callers report it (execution tifSent "ALO").
+     */
     async editOrder(symbol, orderId, price, size) {
         this.ensureSigner();
         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.
+     * 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).
+     *  - GTC / TOB: cancel → read the fill at cancel → replace with
+     *    size − (filledAtCancel − filledAtRead) at the same TIF / side / reduce-only (≤ 0 or below
+     *    the lot → no replacement, reported). Cancel outcome unknown → ORDER_PENDING (no replace);
+     *    cancel ok but the fill at cancel unreadable or the replacement refused → ORDER_PARTIAL
+     *    { cancelled, placed: null }; replacement outcome unknown → ORDER_PENDING.
+     */
+    async amendKeepingTif(symbol, orderId, price, size, tif, forceTif = false) {
+        this.ensureSigner();
+        if (!/^\d+$/.test(orderId))
+            throw new PerpError("INVALID_PARAMS", `Pacifica order id must be numeric (got "${orderId}")`);
+        if (!(Number(price) > 0) || !(Number(size) > 0))
+            throw new PerpError("INVALID_PARAMS", `Pacifica amend needs a positive price and size (got ${price} x ${size})`);
+        const sym = symbol.toUpperCase();
+        const open = await this.client.getOrders(this.account);
+        const original = open.find((o) => String(o.order_id) === orderId);
+        if (original === undefined) {
+            throw new PerpError("ORDER_NOT_FOUND", `Pacifica order ${orderId} is not among the open orders`, { exchange: "pacifica" });
+        }
+        if (String(original.symbol).toUpperCase() !== sym) {
+            throw new PerpError("INVALID_PARAMS", `Order ${orderId} is on ${original.symbol}, not ${sym}`);
+        }
+        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`);
+        }
+        const encoded = pacificaTifOf(original.client_order_id);
+        if (tif !== null && encoded !== null && (tif === "ALO") !== (encoded === "ALO") && !forceTif) {
+            throw new PerpError("INVALID_PARAMS", `--tif ${tif} would make order ${orderId} ${encoded === "ALO" ? "no longer post-only" : "post-only"} (its client id encodes TIF ${encoded})`, {
+                remediation: "Omit --tif to keep the order's own TIF, or pass --force-tif to change it",
+            });
+        }
+        const keep = tif ?? encoded;
+        if (keep === null) {
+            throw unsupported("Pacifica", "amend", "original order attributes unknown", `pass --tif: perp trade edit ${sym} ${orderId} <price> <size> --tif <GTC|ALO|TOB> -e pacifica`);
+        }
+        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 err = pacificaBodyError(raw);
+            if (err !== null)
+                throw new PerpError("ORDER_REJECTED", `Pacifica edit of ${orderId} refused: ${err}`, { exchange: "pacifica" });
+            const data = (raw !== null && typeof raw === "object" ? (raw.data ?? raw) : null);
+            const newId = data !== null && (typeof data.order_id === "number" || typeof data.order_id === "string") ? String(data.order_id) : null;
+            // The edited order (new id) read back with the new price / size verified.
+            const outcome = newId === null ? null : await this.resolveOrderOutcome(newId, `edit of ${orderId}`, { expect: { price, size } });
+            return {
+                method: "nativeAmend", tif: "ALO", orderId: newId, clientOrderId: original.client_order_id ?? null,
+                filledBeforeCancel: null, replacedSize: null, filledCompletely: false, outcome,
+                notes: [tifNote, "native edit (the venue re-creates the order as ALO with a new order id)"], venueRaw: raw,
+            };
+        }
+        if (keep === "IOC") {
+            throw unsupported("Pacifica", "amend", "an IOC order never rests, so there is nothing to amend", "Place a new order");
+        }
+        // cancel → replace. Validate the replacement before cancelling (bad size/price never loses the original).
+        const market = (await this.getMarkets()).find((m) => m.symbol.toUpperCase() === sym);
+        if (market === undefined || market.stepSize === null) {
+            throw new PerpError("SYMBOL_NOT_FOUND", `Pacifica ${sym}: no lot size published; cannot size a replacement`, { exchange: "pacifica" });
+        }
+        const lot = market.stepSize;
+        floorSize(size, lot);
+        // The replacement price must sit on the venue tick BEFORE the original is cancelled — an
+        // off-tick price would be refused only after the original is already gone.
+        const info = perpInfoRows(await this.client.getInfo()).find((m) => m.symbol.toUpperCase() === sym);
+        if (info === undefined || typeof info.tick_size !== "string" || !(Number(info.tick_size) > 0)) {
+            throw new PerpError("SYMBOL_NOT_FOUND", `Pacifica ${sym}: no tick size published; cannot validate the replacement price`, { exchange: "pacifica" });
+        }
+        requireOnTick(price, info.tick_size);
+        // The replacement size is derived from filled_amount (size − fills raced in during the cancel):
+        // an unreadable one is refused HERE, before the cancel — after it, the original would be gone
+        // with no computable replacement.
+        const filledAtReadRaw = original.filled_amount;
+        if ((typeof filledAtReadRaw !== "string" && typeof filledAtReadRaw !== "number") || !/^\d+(\.\d+)?$/.test(String(filledAtReadRaw).trim())) {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica order ${orderId} has no readable filled_amount (got ${JSON.stringify(filledAtReadRaw ?? null)}); nothing was cancelled`, {
+                exchange: "pacifica", sent: false,
+                remediation: `Retry the amend, or cancel (perp trade cancel ${sym} ${orderId} -e pacifica) and place a new order`,
+            });
+        }
+        const filledAtRead = String(filledAtReadRaw).trim();
+        const cancelWhat = `amend: cancel of ${orderId}`;
+        let cancelRaw;
+        try {
+            cancelRaw = await this.client.cancelOrder({ symbol: sym, order_id: Number(orderId) }, this.account, this.signMessage);
+        }
+        catch (e) {
+            if (pacificaRefused(e)) {
+                throw new PerpError("ORDER_REJECTED", `Pacifica ${cancelWhat} refused (${extractErrorMessage(e)}); the original order is untouched, nothing replaced`, { exchange: "pacifica" });
+            }
+            throw orderOutcomeUnknown("pacifica", cancelWhat, e, `No replacement was placed. Check the original: perp account orders -e pacifica`);
+        }
+        const cancelErr = pacificaBodyError(cancelRaw);
+        if (cancelErr !== null) {
+            throw new PerpError("ORDER_REJECTED", `Pacifica ${cancelWhat} refused: ${cancelErr}; the original order is untouched, nothing replaced`, { exchange: "pacifica" });
+        }
+        // Fill at cancel: the order's terminal history_by_id row with a reported filled_amount.
+        let filledAtCancel = null;
+        let terminalStatus = null;
+        let lastReadError = null;
+        for (let attempt = 0; attempt < 6 && filledAtCancel === null; attempt++) {
+            await new Promise((r) => setTimeout(r, 500));
+            try {
+                const history = await this.client.getOrderHistoryById(Number(orderId));
+                const latest = pacificaLatestHistoryRow(history.data ?? history, orderId);
+                const st = latest === null ? "" : String(latest.order_status ?? "");
+                const fa = latest?.filled_amount;
+                if ((st === "cancelled" || st === "filled") && fa !== undefined && fa !== null && /^\d+(\.\d+)?$/.test(String(fa).trim())) {
+                    filledAtCancel = String(fa).trim();
+                    terminalStatus = st;
+                }
+            }
+            catch (e) {
+                lastReadError = extractErrorMessage(e); // retried; still unknown after the loop → ORDER_PARTIAL below
+            }
+        }
+        const notes = [tifNote, `cancel→replace: filledAtRead ${filledAtRead}, filledAtCancel ${filledAtCancel ?? "unknown"}`];
+        if (filledAtCancel === null) {
+            throw new PerpError("ORDER_PARTIAL", `Pacifica amend: order ${orderId} was CANCELLED but its fill at cancel could not be read${lastReadError !== null ? ` (${lastReadError})` : ""}; no replacement was placed`, {
+                exchange: "pacifica", cancelled: { orderId, venueRaw: cancelRaw }, placed: null,
+                remediation: "The original order is gone; check the position (perp account positions -e pacifica) and place a new order manually",
+            });
+        }
+        const base = { tif: keep, orderId: null, clientOrderId: null, filledBeforeCancel: filledAtCancel, filledCompletely: false, outcome: null };
+        if (terminalStatus === "filled") {
+            return { ...base, filledCompletely: true, method: "cancelReplace", replacedSize: null, notes: [...notes, `order ${orderId} filled completely before the cancel — no replacement placed`], venueRaw: { cancelled: cancelRaw, placed: null } };
+        }
+        const raced = subDecimal(filledAtCancel, filledAtRead);
+        const replace = subDecimal(size, raced.startsWith("-") ? "0" : raced);
+        let replaceSize = null;
+        if (!replace.startsWith("-") && Number(replace) > 0) {
+            try {
+                replaceSize = floorSize(replace, lot);
+            }
+            catch (e) {
+                if (!(e instanceof PerpError) || e.structured.code !== "SIZE_TOO_SMALL")
+                    throw e;
+            }
+        }
+        if (replaceSize === null) {
+            return { ...base, method: "cancelReplace", replacedSize: null, notes: [...notes, `${raced} filled between read and cancel; replacement ${replace} is not above the lot ${lot} — no replacement placed`], venueRaw: { cancelled: cancelRaw, placed: null } };
+        }
+        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());
+        }
+        catch (e) {
+            if (pacificaRefused(e)) {
+                throw new PerpError("ORDER_PARTIAL", `Pacifica amend: original order ${orderId} was CANCELLED but the replacement was refused: ${extractErrorMessage(e)}`, {
+                    exchange: "pacifica", cancelled: { orderId, venueRaw: cancelRaw }, placed: null,
+                    remediation: "The original order is gone; place a new order manually",
+                });
+            }
+            throw new PerpError("ORDER_PENDING", `Pacifica amend: original order ${orderId} was CANCELLED; the replacement outcome is unknown: ${extractErrorMessage(e)}`, {
+                exchange: "pacifica", cancelled: { orderId, venueRaw: cancelRaw }, replacementClientOrderId: cloid,
+                remediation: "Do NOT resubmit. Check open orders: perp account orders -e pacifica",
+            });
+        }
+        const placeErr = pacificaBodyError(placed);
+        if (placeErr !== null) {
+            throw new PerpError("ORDER_PARTIAL", `Pacifica amend: original order ${orderId} was CANCELLED but the replacement was refused: ${placeErr}`, {
+                exchange: "pacifica", cancelled: { orderId, venueRaw: cancelRaw }, placed: null,
+                remediation: "The original order is gone; place a new order manually",
+            });
+        }
+        const pd = (placed !== null && typeof placed === "object" ? (placed.data ?? placed) : null);
+        const newId = pd !== null && (typeof pd.order_id === "number" || typeof pd.order_id === "string") ? String(pd.order_id) : null;
+        const extra = subDecimal(size, replaceSize) === "0" ? [] : [`replacement size ${replaceSize} (requested open size ${size})`];
+        const outcome = newId === null ? null : await this.resolveOrderOutcome(newId, `amend: replacement of ${orderId}`, { expect: { price, size: replaceSize } });
+        return {
+            ...base, method: "cancelReplace", orderId: newId, clientOrderId: cloid, replacedSize: replaceSize, outcome,
+            notes: [...notes, ...extra], venueRaw: { cancelled: cancelRaw, placed },
+        };
+    }
+    /** Cancel a stop / TP / SL order (POST /orders/stop/cancel). An explicit venue refusal → ORDER_REJECTED. */
+    async cancelStopOrder(symbol, orderId) {
+        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 err = pacificaBodyError(raw);
+        if (err !== null)
+            throw new PerpError("ORDER_REJECTED", `Pacifica cancel of stop order ${orderId} refused: ${err}`, { exchange: "pacifica" });
+        return raw;
+    }
+    /** Open position-level TP/SL orders (order_type take_profit_* / stop_loss_*) on `symbol`. */
+    async positionTpSlOrders(symbol) {
+        const sym = symbol.toUpperCase();
+        const open = await this.client.getOrders(this.account);
+        return open
+            .filter((o) => String(o.symbol).toUpperCase() === sym && /^(take_profit|stop_loss)_/.test(String(o.order_type)))
+            .map((o) => ({ orderId: String(o.order_id), type: String(o.order_type), stopPrice: o.stop_price === null ? null : String(o.stop_price) }));
+    }
+    /**
+     * Position-level TP/SL (POST /positions/tpsl). `positionSide` = the position's side; the
+     * venue's `side` field is the TP/SL orders' (CLOSING) side: long → "ask", short → "bid"
+     * (pacifica-fi/python-sdk rest/create_position_tpsl.py: a BTC long sends side "ask"; the
+     * position side was refused live on testnet 2026-10-02 with 422 "Invalid stop order side").
+     * Covers the whole position. An explicit venue refusal → ORDER_REJECTED.
+     */
+    async setPositionTpSl(symbol, positionSide, tpsl) {
+        this.ensureSigner();
+        const params = {
+            symbol: symbol.toUpperCase(),
+            side: positionSide === "long" ? "ask" : "bid",
+        };
+        if (tpsl.tp !== null)
+            params.take_profit = tpsl.tpLimit !== null ? { stop_price: tpsl.tp, limit_price: tpsl.tpLimit } : { stop_price: tpsl.tp };
+        if (tpsl.sl !== null)
+            params.stop_loss = { stop_price: tpsl.sl };
+        const raw = await this.client.setTPSL(params, this.account, this.signMessage, await this.builderCode());
+        const err = pacificaBodyError(raw);
+        if (err !== null)
+            throw new PerpError("ORDER_REJECTED", `Pacifica position TP/SL on ${params.symbol} refused: ${err}`, { exchange: "pacifica" });
+        return raw;
+    }
     async setLeverage(symbol, leverage, marginMode = "cross") {
         this.ensureSigner();
         await this.client.updateLeverage({ symbol, leverage }, this.account, this.signMessage);
@@ -348,18 +1243,59 @@ export class PacificaAdapter {
         }
         return { symbol, leverage, marginMode };
     }
+    /** CLI trigger-type → Pacifica `trigger_price_type` value. Omitted ⇒ venue default (mark_price). */
+    static TRIGGER_TYPE = {
+        mark: "mark_price",
+        last: "last_trade_price",
+        mid: "mid_price",
+    };
     async stopOrder(symbol, side, size, triggerPrice, opts) {
         this.ensureSigner();
-        return this.client.createStopOrder({
+        const triggerPriceType = opts?.triggerType ? PacificaAdapter.TRIGGER_TYPE[opts.triggerType] : undefined;
+        const raw = await this.client.createStopOrder({
             symbol,
             side: side === "buy" ? "bid" : "ask",
             reduce_only: opts?.reduceOnly ?? false,
-            stop_order: { stop_price: triggerPrice, amount: size, limit_price: opts?.limitPrice },
-        }, this.account, this.signMessage);
+            stop_order: { stop_price: triggerPrice, amount: size, limit_price: opts?.limitPrice, trigger_price_type: triggerPriceType },
+        }, this.account, this.signMessage, await this.builderCode()).catch((e) => { throw pacificaCreateRejection(e, `stop ${side} ${size} ${symbol} @ ${triggerPrice}`); });
+        // The ack carries only the order id: read the untriggered stop's state back (history_by_id).
+        return this.withOrderOutcome(raw, `stop ${side} ${size} ${symbol} @ ${triggerPrice}`, { expect: { price: null, size } });
     }
     async withdraw(amount, destination, _opts) {
-        this.ensureSigner();
-        return this.client.withdraw({ amount, dest_address: destination }, this.account, this.signMessage);
+        // A withdrawal moves funds: it is signed by the MASTER wallet only — never by the agent
+        // key, even when one is registered (an agent key must not be able to withdraw).
+        const master = this._masterSigner ?? (this._hasRealKey && this._solanaSigner ? this._solanaSigner : null);
+        if (master === null || master.getPublicKeyBase58() !== this.account) {
+            throw new PerpError("NO_SIGNER_AVAILABLE", "Pacifica withdraw must be signed by the account's master wallet (an agent wallet cannot withdraw), and it is not loaded", {
+                exchange: "pacifica",
+                remediation: "Run with the master wallet: perp -e pacifica --ows <wallet> funds withdraw ... (or withdraw on the Pacifica website)",
+            });
+        }
+        // Pacifica withdrawals ALWAYS go to the account owner's own connected wallet —
+        // the REST API has no destination field. Refuse a mismatched destination rather
+        // than silently sending to the own wallet (Rule #2: no misdirection / false
+        // affordance). An empty destination or the own address is accepted.
+        if (destination && destination !== this.account) {
+            throw new PerpError("INVALID_PARAMS", `Pacifica withdrawals only go to the account owner's own wallet (${this.account}); the API has no destination field, so withdrawing to ${destination} is not possible.`, { exchange: "pacifica" });
+        }
+        if (subDecimal(amount, PACIFICA_WITHDRAW_MIN_USDC).startsWith("-")) {
+            throw new PerpError("INVALID_PARAMS", `Pacifica withdraw ${amount} USDC is below the documented minimum of ${PACIFICA_WITHDRAW_MIN_USDC} USDC`, {
+                exchange: "pacifica",
+                remediation: `Withdraw more than ${PACIFICA_WITHDRAW_MIN_USDC} USDC (a $1 fee is charged per withdrawal)`,
+            });
+        }
+        // Cap by the venue's available_to_withdraw (equity minus margin in use / loans) before signing.
+        const info = await this.client.getAccount(this.account);
+        const headroom = subDecimal(info.available_to_withdraw, amount);
+        if (headroom.startsWith("-")) {
+            throw new PerpError("INSUFFICIENT_BALANCE", `Pacifica withdraw ${amount} USDC exceeds available_to_withdraw ${info.available_to_withdraw}`, {
+                exchange: "pacifica",
+                remediation: `Withdraw at most ${info.available_to_withdraw} USDC, or free margin first (close positions / cancel orders / repay a negative USDC balance)`,
+            });
+        }
+        this.client.setRequestAgentWallet(undefined); // master-signed: no agent_wallet field
+        return this.client.withdraw({ amount }, this.account, (msg) => master.signMessage(msg))
+            .catch((e) => { throw pacificaWithdrawRejection(e, amount); });
     }
     async getRecentTrades(symbol, _limit = 20) {
         const trades = await this.client.getTrades(symbol);
@@ -388,7 +1324,7 @@ export class PacificaAdapter {
             return [];
         return data.map((h) => ({
             time: Number(h.created_at ?? 0),
-            rate: String(h.funding_rate ?? "0"),
+            rate: venueRateField(h.funding_rate, "funding history funding_rate", "pacifica"),
             price: String(h.oracle_price ?? "0"),
         }));
     }
@@ -404,23 +1340,41 @@ export class PacificaAdapter {
             trades: k.n,
         }));
     }
+    /**
+     * Recent orders, newest first (GET /orders/history; PacificaClient.get already unwraps the
+     * `{success, data}` envelope, so the list is the result itself). A non-list or a row without a
+     * readable field → EXCHANGE_ERROR, never an empty list or a placeholder value.
+     */
     async getOrderHistory(limit = 30) {
         if (!this._hasRealKey)
             throw new Error("No private key configured — account data unavailable. Run: perp setup");
-        const result = await this.client.getOrderHistory(this.account);
-        const data = (result.data ?? result.orders ?? []);
-        if (!Array.isArray(data))
-            return [];
-        return data.slice(0, limit).map((o) => ({
-            orderId: String(o.order_id ?? ""),
-            symbol: String(o.symbol ?? ""),
-            side: String(o.side) === "bid" ? "buy" : "sell",
-            price: String(o.initial_price ?? o.price ?? "0"),
-            size: String(o.amount ?? o.initial_amount ?? ""),
-            filled: String(o.filled_amount ?? "0"),
-            status: String(o.order_status ?? "done"),
-            type: String(o.order_type ?? ""),
-        }));
+        const rows = await this.client.getOrderHistory(this.account, { limit });
+        if (!Array.isArray(rows)) {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica /orders/history returned no order list (${JSON.stringify(rows).slice(0, 120)})`, { exchange: "pacifica" });
+        }
+        const field = (o, k) => {
+            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" });
+        };
+        return rows.slice(0, limit).map((o) => {
+            const side = field(o, "side");
+            if (side !== "bid" && side !== "ask") {
+                throw new PerpError("EXCHANGE_ERROR", `Pacifica order-history row with unknown side "${side}"`, { exchange: "pacifica" });
+            }
+            return {
+                orderId: field(o, "order_id"),
+                symbol: field(o, "symbol"),
+                side: side === "bid" ? "buy" : "sell",
+                price: field(o, "initial_price"),
+                size: field(o, "amount"),
+                filled: field(o, "filled_amount"),
+                status: field(o, "order_status"),
+                type: field(o, "order_type"),
+                triggerPrice: Number(o.stop_price) > 0 ? String(o.stop_price) : null,
+            };
+        });
     }
     async getTradeHistory(limit = 30) {
         if (!this._hasRealKey)