perp-cli 0.14.3 → 0.16.0

package/dist/exchanges/pacifica-print.js

@@ -0,0 +1,417 @@
+/**
+ * Pacifica Print — yield-earning strike orders (docs.pacifica.fi/print.md and pages under it).
+ *
+ * Product (docs + live API, 2026-10-19):
+ *  - A Print order locks a USDC deposit (min 10) as margin and names a target ("strike") price:
+ *    long = target BELOW mark, short = target ABOVE mark, 0.5% … 10% / 20% / 40% from mark for a
+ *    24-hour / 7-day / 30-day cycle. Leverage 1× … the product's max (live /game/config).
+ *  - Each cycle the Print pool pays a premium ("yield") at the START of the cycle; it is added to
+ *    the order's locked margin. WHILE RESTING (before a fill) the order is evaluated only at the
+ *    END of each cycle: mark at/through the target → it fills AT the target; otherwise it rolls to
+ *    a new target at the same % distance from the new mark; mark beyond the liquidation level at
+ *    that checkpoint → liquidated, the margin (deposit + premiums) is lost.
+ *  - AFTER a fill it is an ordinary perp position in the main account (size = deposit × leverage
+ *    / target): continuous mark-price liquidation, it nets with an existing position in the same
+ *    market and may be cross-margined — read it with `perp -e pacifica account positions`.
+ *  - Max loss of the resting order = deposit + premiums.
+ *  - `total_segments` 1 … 1000 caps the number of cycles; omitted = rolls until ended.
+ *  - Ending ("cancel", signing type `end_game`, POST /game/end) takes effect only at the end of
+ *    the current cycle; funds return to the trading balance then. No in-place edit.
+ *
+ * Endpoints (unauthenticated GET; writes are signed):
+ *   GET  /game/config                          products (game ids, cycle, caps, max leverage)
+ *   GET  /game/accounts?account=               the account's current Print orders
+ *   GET  /game/history_summary?account=        every Print order of the account (paginated)
+ *   GET  /game/history?game_account=           event log of one Print order (paginated)
+ *   POST /game/deposit   type deposit_to_game  create (documented)
+ *   POST /game/end       type end_game         end at the cycle's close — UNOFFICIAL: not in the API docs,
+ *                                              shape captured from app.pacifica.fi (fixture app-unofficial-requests.json)
+ * `preview_game_account` (POST /game/preview, the app's premium quote) is a SIGNED request; read
+ * paths never sign, so the premium of a new order is not quoted here (estimatedPremium: null).
+ */
+import { PerpError } from "../errors.js";
+import { USDC_DECIMALS } from "../pacifica/constants.js";
+import { exactUnits, mulDecimal, subDecimal, formatComputedPrice } from "./precision.js";
+import { cmpDecimal, divDecimal, fractionDigits, isPlainDecimal, trimDecimal } from "./pacifica-decimal.js";
+import { buildPresigned } from "./pacifica-presigned.js";
+// ── Documented limits ───────────────────────────────────────────────────
+/** docs print/placing-and-managing-orders: "Deposit — your locked margin, minimum $10". */
+export const PRINT_MIN_DEPOSIT_USDC = "10";
+/** docs: target "at least 0.5% away from the current mark price". */
+export const PRINT_MIN_TARGET_DISTANCE_PCT = "0.5";
+/** docs: "at most 10% on a 24-hour cycle, 20% on 7 days, or 40% on 30 days" (keyed by cycle days). */
+export const PRINT_MAX_TARGET_DISTANCE_PCT = { 1: "10", 7: "20", 30: "40" };
+/** API create-print-order: "total_segments … 1 to 1000". */
+export const PRINT_MAX_CYCLES = 1000;
+const DAY_MS = 86_400_000;
+/**
+ * The docs formula (target ∓ (deposit + yield) × target / (leverage × deposit)) is where the margin
+ * is fully lost. A liquidation was observed earlier than that in one live case (mainnet 2026-10-16:
+ * a ZEC_24H short, strike 1150.95, 10×, deposit 922.93, premium 23.80, liquidated at the checkpoint
+ * with mark 1216.836 while the formula gives ≈ 1269.0). The venue's trigger is unpublished; its own
+ * figure comes only from the signed preview (preview_game_account), not called here.
+ */
+export const PRINT_LIQUIDATION_NOTE = "docsLiquidationPrice is the docs formula (margin fully lost) — an outer bound, not the trigger: a liquidation was observed earlier in one live case (2026-10-16); the venue's trigger is unpublished. After a fill the position follows ordinary perp liquidation (continuous mark price, main account).";
+// ── Parsing (strict: a missing required field is EXCHANGE_ERROR, an optional one is null) ──
+function bad(what, row) {
+    return new PerpError("EXCHANGE_ERROR", `Pacifica ${what}: ${JSON.stringify(row).slice(0, 200)}`, { exchange: "pacifica" });
+}
+function reqStr(row, key, ctx) {
+    const v = row[key];
+    if (typeof v === "string" && v !== "")
+        return v;
+    throw bad(`${ctx} without a readable ${key}`, row);
+}
+function optStr(row, key) {
+    const v = row[key];
+    return typeof v === "string" && v !== "" ? v : null;
+}
+function reqDec(row, key, ctx) {
+    const v = reqStr(row, key, ctx);
+    if (!isPlainDecimal(v))
+        throw bad(`${ctx} with a non-decimal ${key}`, row);
+    return trimDecimal(v);
+}
+function optDec(row, key) {
+    const v = row[key];
+    return isPlainDecimal(v) ? trimDecimal(v) : null;
+}
+/** Positive ms timestamp, else null (the venue sends null / 0 for "not yet"). */
+function optMs(row, key) {
+    const v = row[key];
+    return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : null;
+}
+function optInt(row, key) {
+    const v = row[key];
+    return typeof v === "number" && Number.isInteger(v) ? v : null;
+}
+function asRow(x, ctx) {
+    if (x === null || typeof x !== "object" || Array.isArray(x))
+        throw bad(`${ctx} is not an object`, x);
+    return x;
+}
+/** `data` of a `{success: true, data}` envelope; a refusal / other shape is EXCHANGE_ERROR. */
+export function envelopeData(env, path) {
+    if (env.success !== true)
+        throw new PerpError("EXCHANGE_ERROR", `Pacifica GET ${path} failed: ${String(env.error ?? JSON.stringify(env).slice(0, 160))}`, { exchange: "pacifica" });
+    return env.data;
+}
+function pageMeta(env) {
+    return {
+        hasMore: typeof env.has_more === "boolean" ? env.has_more : null,
+        nextCursor: typeof env.next_cursor === "string" && env.next_cursor !== "" ? env.next_cursor : null,
+    };
+}
+/** GET /game/config `data` → products (`{configs: [...]}`; the app also accepts a bare array). */
+export function parsePrintGames(data) {
+    const rows = Array.isArray(data) ? data : asRow(data, "/game/config data").configs;
+    if (!Array.isArray(rows))
+        throw bad("/game/config without a configs list", data);
+    return rows.map((x) => {
+        const r = asRow(x, "/game/config row");
+        const kind = optStr(r, "segment_kind");
+        const days = kind === "fixed_days" ? optInt(r, "segment_value") : null;
+        return {
+            schema: 1,
+            game: reqStr(r, "game", "/game/config row"),
+            asset: reqStr(r, "target_asset", "/game/config row"),
+            cycleDays: days !== null && days > 0 ? days : null,
+            maxLeverage: optDec(r, "max_leverage"),
+            productDepositCap: optDec(r, "deposit_cap"),
+            poolDepositCap: optDec(r, "lake_deposit_cap"),
+            capScope: optStr(r, "cap_scope"),
+            poolAddress: optStr(r, "lake_address"),
+            minDeposit: PRINT_MIN_DEPOSIT_USDC,
+            targetDistancePct: { min: PRINT_MIN_TARGET_DISTANCE_PCT, max: days !== null ? PRINT_MAX_TARGET_DISTANCE_PCT[days] ?? null : null },
+        };
+    });
+}
+function directionOf(v, row) {
+    if (v === 0)
+        return "long";
+    if (v === 1)
+        return "short";
+    throw bad(`Print order with unknown direction ${JSON.stringify(v)}`, row);
+}
+/** docs margin-and-liquidation: target ∓ (deposit + yield) × target / (leverage × deposit). */
+export function printLiquidationPrice(direction, strike, deposit, leverage, premium, tickSize = null) {
+    const k = divDecimal(sum(deposit, premium), mulDecimal(leverage, deposit));
+    if (k === null)
+        return null;
+    const off = mulDecimal(strike, k);
+    const px = direction === "long" ? subDecimal(strike, off) : sum(strike, off);
+    if (cmpDecimal(px, "0") <= 0)
+        return null;
+    return formatComputedPrice(Number(px), tickSize);
+}
+function sum(a, b) {
+    return subDecimal(a, `-${b}`.replace(/^--/, ""));
+}
+/** One /game/accounts or /game/history_summary row. */
+export function parsePrintPosition(x) {
+    const r = asRow(x, "Print order row");
+    const ctx = "Print order row";
+    const direction = directionOf(r.direction, r);
+    const deposit = reqDec(r, "initial_deposit", ctx);
+    const strike = reqDec(r, "strike_price", ctx);
+    const leverage = reqDec(r, "leverage", ctx);
+    const premium = optDec(r, "premium_paid");
+    const endedAt = optMs(r, "game_ended_at_ms");
+    const endReason = optStr(r, "end_reason");
+    const cancelRequested = r.user_initiated_game_end === true;
+    const notional = mulDecimal(deposit, leverage);
+    let status;
+    if (endedAt !== null) {
+        status = endReason === "filled" ? "filled"
+            : endReason === "liquidated" ? "liquidated"
+                : endReason === "user_requested" ? "cancelled"
+                    : endReason === "schedule_completed" ? "completed"
+                        : "ended"; // ended, reason not reported — never guessed
+    }
+    else {
+        status = cancelRequested ? "cancelling" : "printing";
+    }
+    return {
+        schema: 1,
+        address: reqStr(r, "address", ctx),
+        game: reqStr(r, "game", ctx),
+        asset: optStr(r, "target_asset"),
+        direction,
+        deposit,
+        strikePrice: strike,
+        leverage,
+        entryMarkPrice: optDec(r, "entry_mark_price"),
+        premiumPaid: premium,
+        notional,
+        size: divDecimal(notional, strike, 8),
+        docsLiquidationPrice: premium === null ? null : printLiquidationPrice(direction, strike, deposit, leverage, premium),
+        maxLoss: premium === null ? null : sum(deposit, premium),
+        cycles: { total: optInt(r, "total_segments"), started: optInt(r, "segments_started") },
+        createdAt: optMs(r, "game_created_at_ms"),
+        startedAt: optMs(r, "game_started_at_ms"),
+        currentCycleEndAt: optMs(r, "current_segment_end_at_ms"),
+        scheduledEndAt: optMs(r, "scheduled_end_at_ms"),
+        endedAt,
+        endReason,
+        cancelRequested,
+        status,
+    };
+}
+/** GET /game/accounts `data` (`{game_accounts: [...]}`). */
+export function parsePrintAccounts(data) {
+    const rows = Array.isArray(data) ? data : asRow(data, "/game/accounts data").game_accounts;
+    if (!Array.isArray(rows))
+        throw bad("/game/accounts without a game_accounts list", data);
+    return rows.map(parsePrintPosition);
+}
+/** One /game/history event (created / premium / end_requested / filled / liquidated / …). */
+export function parsePrintEvent(x) {
+    const r = asRow(x, "/game/history row");
+    const id = r.history_id;
+    const time = r.created_at;
+    if (typeof id !== "number" || typeof time !== "number")
+        throw bad("/game/history row without history_id / created_at", r);
+    return {
+        schema: 1,
+        id,
+        printAddress: reqStr(r, "address", "/game/history row"),
+        depositor: optStr(r, "depositor_address"),
+        event: reqStr(r, "event_type", "/game/history row"),
+        amount: optDec(r, "amount"),
+        strikePrice: optDec(r, "strike_price"),
+        markPrice: optDec(r, "mark_price"),
+        size: optDec(r, "size"),
+        cycleStartedAt: optMs(r, "segment_started_at_ms"),
+        cycleEndedAt: optMs(r, "segment_ended_at_ms"),
+        cycleNumber: optInt(r, "segment_number"),
+        time,
+    };
+}
+export async function fetchPrintGames(client) {
+    return parsePrintGames(envelopeData(await client.getEnvelope("/game/config"), "/game/config"));
+}
+export async function fetchPrintPositions(client, account) {
+    return parsePrintAccounts(envelopeData(await client.getEnvelope("/game/accounts", { account }), "/game/accounts"));
+}
+function pageParams(p) {
+    return { ...(p.limit !== null ? { limit: String(p.limit) } : {}), ...(p.cursor !== null ? { cursor: p.cursor } : {}) };
+}
+export async function fetchPrintHistory(client, account, page) {
+    const env = await client.getEnvelope("/game/history_summary", { account, ...pageParams(page) });
+    const data = envelopeData(env, "/game/history_summary");
+    if (!Array.isArray(data))
+        throw bad("/game/history_summary without a list", data);
+    return { items: data.map(parsePrintPosition), ...pageMeta(env) };
+}
+export async function fetchPrintEvents(client, printAddress, page) {
+    const env = await client.getEnvelope("/game/history", { game_account: printAddress, ...pageParams(page) });
+    const data = envelopeData(env, "/game/history");
+    if (!Array.isArray(data))
+        throw bad("/game/history without a list", data);
+    return { items: data.map(parsePrintEvent), ...pageMeta(env) };
+}
+/** Mark price + tick size of the product's perp market (GET /prices, GET /info). */
+export async function fetchPrintMarket(client, asset) {
+    const [prices, info] = await Promise.all([client.getPrices(), client.getInfo()]);
+    const p = prices.find((x) => x.symbol === asset);
+    const m = info.find((x) => x.symbol === asset);
+    if (p === undefined || !isPlainDecimal(p.mark) || !(Number(p.mark) > 0)) {
+        throw new PerpError("PRICE_STALE", `Pacifica has no mark price for ${asset}`, { exchange: "pacifica", remediation: "Retry; check perp -e pacifica market list" });
+    }
+    if (m === undefined || !isPlainDecimal(m.tick_size)) {
+        throw new PerpError("EXCHANGE_ERROR", `Pacifica /info has no tick_size for ${asset}`, { exchange: "pacifica" });
+    }
+    return { mark: p.mark, tickSize: m.tick_size };
+}
+/** The product `game` (case-insensitive) from the live list; unknown → SYMBOL_NOT_FOUND naming what exists. */
+export function findPrintGame(games, game) {
+    const g = games.find((x) => x.game.toUpperCase() === game.toUpperCase());
+    if (g === undefined) {
+        throw new PerpError("SYMBOL_NOT_FOUND", `No Print product "${game}"`, {
+            exchange: "pacifica", remediation: `Available: ${games.map((x) => x.game).join(", ")} — see: perp -e pacifica print games`,
+        });
+    }
+    return g;
+}
+function invalid(msg, remediation) {
+    return new PerpError("INVALID_PARAMS", msg, { exchange: "pacifica", remediation });
+}
+/** Plain non-negative decimal without leading zeros ("0.5", "10", "10.25"; not "010", "1e3", ".5"). */
+export const PLAIN_POSITIVE = /^(0|[1-9]\d*)(\.\d+)?$/;
+/** Strict USDC amount: plain positive decimal, no leading zeros, at most 6 fractional digits (USDC precision). */
+export function requireUsdcAmount(raw, what) {
+    const s = String(raw).trim();
+    if (!PLAIN_POSITIVE.test(s) || !(Number(s) > 0))
+        throw invalid(`${what} must be a positive decimal number without leading zeros (got "${raw}")`, "Pass a plain decimal amount, e.g. 100 or 100.5");
+    if (fractionDigits(s) > USDC_DECIMALS)
+        throw invalid(`${what} ${s} has more than ${USDC_DECIMALS} decimals (USDC precision)`, `Round to ${USDC_DECIMALS} decimals`);
+    return trimDecimal(s);
+}
+/**
+ * Validate a Print order against the product and the live mark (docs limits) and compute the
+ * preview. Throws INVALID_PARAMS / INVALID_TICK / CAPABILITY_UNSUPPORTED; signs and sends nothing.
+ */
+export function quotePrintOrder(game, input, market) {
+    const where = `Print ${game.game}`;
+    if (game.cycleDays === null || game.targetDistancePct.max === null) {
+        throw new PerpError("CAPABILITY_UNSUPPORTED", `${where}: cycle length not in the documented set (24 hours / 7 days / 30 days) — no documented target range`, {
+            exchange: "pacifica", remediation: "Use a product listed with a 1d / 7d / 30d cycle in: perp -e pacifica print games",
+        });
+    }
+    if (game.maxLeverage === null) {
+        throw new PerpError("EXCHANGE_ERROR", `${where}: /game/config reports no max_leverage`, { exchange: "pacifica" });
+    }
+    const deposit = requireUsdcAmount(input.deposit, "deposit");
+    if (cmpDecimal(deposit, PRINT_MIN_DEPOSIT_USDC) < 0) {
+        throw invalid(`${where}: deposit ${deposit} USDC is below the ${PRINT_MIN_DEPOSIT_USDC} USDC minimum`, `Deposit at least ${PRINT_MIN_DEPOSIT_USDC} USDC`);
+    }
+    // No local deposit_cap check: it caps the product's total open deposits (all users), so only the
+    // venue knows the remaining room — its refusal decides.
+    if (!/^[1-9]\d*$/.test(input.leverage) || cmpDecimal(input.leverage, game.maxLeverage) > 0) {
+        throw invalid(`${where}: leverage must be a whole number from 1 to ${game.maxLeverage} (got "${input.leverage}")`, `Pass --leverage 1 … ${game.maxLeverage}`);
+    }
+    const leverage = input.leverage;
+    const strike = String(input.strikePrice).trim();
+    if (!PLAIN_POSITIVE.test(strike) || !(Number(strike) > 0))
+        throw invalid(`${where}: strike must be a positive price (got "${input.strikePrice}")`, "Pass --strike <price>");
+    if (exactUnits(strike, market.tickSize) === null) {
+        throw new PerpError("INVALID_TICK", `${where}: strike ${strike} is not a multiple of the ${game.asset} tick ${market.tickSize}`, {
+            exchange: "pacifica", remediation: `Use a strike that is a multiple of ${market.tickSize}`,
+        });
+    }
+    const mark = market.mark;
+    const side = cmpDecimal(strike, mark);
+    if (input.direction === "long" && side >= 0)
+        throw invalid(`${where}: a Print long's target must be BELOW the mark ${mark} (got ${strike})`, "Lower the strike, or use short");
+    if (input.direction === "short" && side <= 0)
+        throw invalid(`${where}: a Print short's target must be ABOVE the mark ${mark} (got ${strike})`, "Raise the strike, or use long");
+    const gap = input.direction === "long" ? subDecimal(mark, strike) : subDecimal(strike, mark);
+    const gapX100 = mulDecimal(gap, "100");
+    const { min, max } = { min: game.targetDistancePct.min, max: game.targetDistancePct.max };
+    if (cmpDecimal(gapX100, mulDecimal(min, mark)) < 0 || cmpDecimal(gapX100, mulDecimal(max, mark)) > 0) {
+        throw invalid(`${where}: target ${strike} is ${divDecimal(gapX100, mark, 4)}% from the mark ${mark}; allowed ${min}% … ${max}% for a ${game.cycleDays}-day cycle`, `Pick a strike ${min}% … ${max}% ${input.direction === "long" ? "below" : "above"} the mark`);
+    }
+    if (input.cycles !== null && !(Number.isInteger(input.cycles) && input.cycles >= 1 && input.cycles <= PRINT_MAX_CYCLES)) {
+        throw invalid(`${where}: cycles must be a whole number from 1 to ${PRINT_MAX_CYCLES} (got ${input.cycles})`, `Pass --cycles 1 … ${PRINT_MAX_CYCLES}, or omit it to roll until ended`);
+    }
+    const notional = mulDecimal(deposit, leverage);
+    const size = divDecimal(notional, strike, 8);
+    return {
+        schema: 1,
+        game: game.game,
+        asset: game.asset,
+        cycleDays: game.cycleDays,
+        direction: input.direction,
+        deposit,
+        leverage,
+        strikePrice: strike,
+        markPrice: mark,
+        targetDistancePct: divDecimal(gapX100, mark, 4),
+        allowedTargetDistancePct: { min, max },
+        notional,
+        size,
+        docsLiquidationPrice: printLiquidationPrice(input.direction, strike, deposit, leverage, "0", market.tickSize),
+        maxLoss: deposit,
+        cycles: input.cycles,
+        maxDurationDays: input.cycles === null ? null : input.cycles * game.cycleDays,
+        cancelSettlesWithinDays: game.cycleDays,
+        liquidationNote: PRINT_LIQUIDATION_NOTE,
+        estimatedPremium: null,
+        notes: [
+            `While resting, fill and liquidation are checked only at each ${game.cycleDays}-day checkpoint; a fill opens ${size} ${game.asset} at exactly ${strike}.`,
+            `After a fill it is an ordinary position in your main account: continuous mark-price liquidation, it nets with any ${game.asset} position you hold and may be cross-margined — see perp -e pacifica account positions.`,
+            `Max loss: the ${deposit} USDC deposit plus every premium credited to it — never more.`,
+            `Cancelling resolves at the end of the running cycle (up to ${game.cycleDays} day${game.cycleDays === 1 ? "" : "s"}); funds stay locked until then.`,
+            "The premium is set by the venue at the start of each cycle; its quote (preview_game_account) is a signed request and is not called here.",
+            "Product and pool deposit caps are totals shared by all users: the venue refuses when they are full (not checkable here).",
+        ],
+    };
+}
+// ── Write requests (pure) ───────────────────────────────────────────────
+/** POST /game/deposit body + canonical message (deposit_to_game). Field set per the API docs. */
+export function buildPrintDepositRequest(q, identity, opts) {
+    return buildPresigned({
+        type: "deposit_to_game",
+        path: "/game/deposit",
+        identity,
+        timestamp: opts.timestamp,
+        expiryWindow: opts.expiryWindow,
+        payload: {
+            game: q.game,
+            deposit_amount: q.deposit,
+            direction: q.direction === "long" ? 0 : 1,
+            strike_price: q.strikePrice,
+            leverage: q.leverage,
+            ...(q.cycles !== null ? { total_segments: q.cycles } : {}),
+            idempotency_key: opts.idempotencyKey,
+        },
+    });
+}
+/** POST /game/end body + canonical message (end_game, payload `{game_account}` as app.pacifica.fi sends it). */
+export function buildPrintEndRequest(printAddress, identity, opts) {
+    return buildPresigned({
+        type: "end_game",
+        path: "/game/end",
+        identity,
+        timestamp: opts.timestamp,
+        expiryWindow: opts.expiryWindow,
+        payload: { game_account: printAddress },
+    });
+}
+/** An end request is accepted only for a running order of the account (not ended, not already ending). */
+export function requireEndable(positions, printAddress) {
+    const p = positions.find((x) => x.address === printAddress);
+    if (p === undefined) {
+        throw new PerpError("POSITION_NOT_FOUND", `No current Print order ${printAddress} on this account`, {
+            exchange: "pacifica", remediation: "List them: perp -e pacifica print positions",
+        });
+    }
+    if (p.status !== "printing") {
+        throw invalid(`Print order ${printAddress} is ${p.status}; only a running (printing) order can be ended`, "Nothing to do — see: perp -e pacifica print positions");
+    }
+    return p;
+}
+/** When a cycle that ends at `cycleEndAt` frees the funds, in days from `now` (null = unknown). */
+export function daysUntil(cycleEndAt, now) {
+    return cycleEndAt === null ? null : (Math.max(0, cycleEndAt - now) / DAY_MS).toFixed(2);
+}

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

@@ -1,5 +1,5 @@
 /**
- * Pacifica Spot Adapter (design §12).
+ * Pacifica Spot Adapter.
  *
  * Spot is a different `symbol` ("SOL-USDC") on the same Pacifica order
  * endpoints as perps, signed by the same Solana signer (incl. agent_wallet).
@@ -18,6 +18,12 @@ import type { SpotAdapter, SpotMarketInfo, SpotBalance, SpotOrderResult, SpotOpe
 import type { ResolvedSlippage } from "./slippage.js";
 import { type PacificaAdapter } from "./pacifica.js";
 import type { IocOutcome } from "./ioc-outcome.js";
+/**
+ * Spot balances from Pacifica GET /account (USDC = the shared perp collateral, then
+ * `spot_balances`) — the one mapper behind the keyed spot adapter and the keyless
+ * `account balance --address`.
+ */
+export declare function pacificaSpotBalanceRows(info: Record<string, unknown>): SpotBalance[];
 export declare class PacificaSpotAdapter implements SpotAdapter, SpotOpenOrdersCapable, SpotCancelAllCapable {
     readonly name = "pacifica";
     private _perp;
@@ -56,7 +62,7 @@ export declare class PacificaSpotAdapter implements SpotAdapter, SpotOpenOrdersC
     private _withOutcome;
     /**
      * Venue-final outcome of a SpotOrderResult returned by spotMarketOrder / IOC
-     * spotLimitOrder (IocOutcomeCapable, design §13.10 #4): set only when the polled
+     * spotLimitOrder (IocOutcomeCapable): set only when the polled
      * history row was terminal and reported filled_amount. null for anything else.
      */
     iocOutcomeOf(raw: unknown): IocOutcome | null;

package/dist/exchanges/pacifica-spot.js

@@ -1,5 +1,5 @@
 /**
- * Pacifica Spot Adapter (design §12).
+ * Pacifica Spot Adapter.
  *
  * Spot is a different `symbol` ("SOL-USDC") on the same Pacifica order
  * endpoints as perps, signed by the same Solana signer (incl. agent_wallet).
@@ -36,6 +36,28 @@ function decimalsOf(step) {
     const frac = step.split(".")[1];
     return frac ? frac.replace(/0+$/, "").length : 0;
 }
+/**
+ * Spot balances from Pacifica GET /account (USDC = the shared perp collateral, then
+ * `spot_balances`) — the one mapper behind the keyed spot adapter and the keyless
+ * `account balance --address`.
+ */
+export function pacificaSpotBalanceRows(info) {
+    const rows = info.spot_balances;
+    if (!Array.isArray(rows)) {
+        throw new PerpError("INVALID_PARAMS", "Pacifica /account response has no spot_balances array", { exchange: "pacifica" });
+    }
+    const out = [];
+    // USDC = the shared perp collateral (same money as perp equity).
+    const total = String(info.balance);
+    const available = String(info.available_to_spend);
+    out.push({ token: QUOTE, total, available, held: subDecimal(total, available), shared: true });
+    for (const r of rows) {
+        const t = String(r.amount);
+        const a = String(r.available_to_withdraw);
+        out.push({ token: String(r.symbol), total: t, available: a, held: subDecimal(t, a), shared: false });
+    }
+    return out;
+}
 export class PacificaSpotAdapter {
     name = "pacifica";
     _perp;
@@ -105,21 +127,7 @@ export class PacificaSpotAdapter {
     }
     async getSpotBalances() {
         const info = (await this._perp.sdk.getAccount(this._perp.publicKey));
-        const rows = info.spot_balances;
-        if (!Array.isArray(rows)) {
-            throw new PerpError("INVALID_PARAMS", "Pacifica /account response has no spot_balances array", { exchange: "pacifica" });
-        }
-        const out = [];
-        // USDC = the shared perp collateral (same money as perp equity).
-        const total = String(info.balance);
-        const available = String(info.available_to_spend);
-        out.push({ token: QUOTE, total, available, held: subDecimal(total, available), shared: true });
-        for (const r of rows) {
-            const t = String(r.amount);
-            const a = String(r.available_to_withdraw);
-            out.push({ token: String(r.symbol), total: t, available: a, held: subDecimal(t, a), shared: false });
-        }
-        return out;
+        return pacificaSpotBalanceRows(info);
     }
     /** Mark price for min-notional / slippage checks. */
     async _mark(wire) {
@@ -211,7 +219,7 @@ export class PacificaSpotAdapter {
     }
     /**
      * Venue-final outcome of a SpotOrderResult returned by spotMarketOrder / IOC
-     * spotLimitOrder (IocOutcomeCapable, design §13.10 #4): set only when the polled
+     * spotLimitOrder (IocOutcomeCapable): set only when the polled
      * history row was terminal and reported filled_amount. null for anything else.
      */
     iocOutcomeOf(raw) {
@@ -254,7 +262,7 @@ export class PacificaSpotAdapter {
         try { // pre-send (see spotMarketOrder)
             await this.init();
             m = this._resolve(symbol);
-            tif = pacificaTif(opts?.tif); // §13.3 common mapping; FOK → CAPABILITY_UNSUPPORTED
+            tif = pacificaTif(opts?.tif); // common mapping; FOK → CAPABILITY_UNSUPPORTED
             px = requireOnTick(price, m.tick_size);
             requirePositive(size, "size");
             amount = floorSize(size, m.lot_size);

package/dist/exchanges/pacifica-typed-data.d.ts

@@ -2,7 +2,7 @@
  * Pacifica agent-wallet signing builders (Phase 2c).
  *
  * Pacifica auth model — off-chain signed messages over Solana Ed25519.
- * Reference: https://pacifica.gitbook.io/docs/api-documentation/api/signing.md
+ * Reference: https://docs.pacifica.fi/api-documentation/api/signing.md
  *
  * Canonical JSON rules (from Pacifica signing spec + production reference
  * `src/pacifica/signing.ts:prepareMessage()`):

package/dist/exchanges/pacifica-typed-data.js

@@ -2,7 +2,7 @@
  * Pacifica agent-wallet signing builders (Phase 2c).
  *
  * Pacifica auth model — off-chain signed messages over Solana Ed25519.
- * Reference: https://pacifica.gitbook.io/docs/api-documentation/api/signing.md
+ * Reference: https://docs.pacifica.fi/api-documentation/api/signing.md
  *
  * Canonical JSON rules (from Pacifica signing spec + production reference
  * `src/pacifica/signing.ts:prepareMessage()`):