@parchment-trade/sdk 0.0.0-stage → 1.0.0

package/dist/packages/parchment/parchmentTypes.d.ts

@@ -0,0 +1,2031 @@
+import type { Transaction } from "@mysten/sui/transactions";
+/** Bytes of a signed Pyth Lazer update. The caller supplies them. */
+export type SignedLazerUpdate = string | Uint8Array;
+export type TxAction = "open-account" | "deposit" | "withdraw" | "request-open" | "request-open-as-delegate" | "request-close" | "request-close-as-delegate" | "cancel-order" | "cancel-order-as-delegate" | "expire-order" | "emergency-close" | "emergency-close-as-delegate" | "close-retired" | "close-retired-as-delegate" | "liquidate" | "liquidate-retired" | "sweep" | "sweep-surplus" | "claim-pending-mint" | "harvest" | "bind-referrer" | "bind-trading-referrer" | "transfer-account" | "stake" | "unstake" | "claim" | "grant-delegate" | "revoke-delegate" | "register-builder" | "set-builder-payout" | "create-builder" | "set-builder-fee" | "pause-builder" | "resume-builder" | "transfer-builder" | "approve-builder" | "revoke-builder-approval" | "set-builder-create-fee" | "install-treasury" | "auth-register" | "game-attach" | "claim-daily" | "open-crate" | "open-crates" | "claim-quest" | "collect-mint" | "release-unlocked" | "exit-early" | "exit-early-bounded" | "grant-close-delegate" | "grant-session-and-trigger" | "revoke-session-and-trigger";
+export declare const TX_ACTIONS: readonly TxAction[];
+export interface ApiParchmentCoinRef {
+    objectId: string;
+    version: string;
+    digest: string;
+}
+export interface ApiParchmentSharedVersions {
+    [objectId: string]: string | bigint;
+}
+export interface ParchmentMoveCommand {
+    package: string;
+    module: string;
+    function: string;
+    typeArguments: string[];
+}
+export interface ApiParchmentTxData {
+    txBytesBase64: string;
+    commands: ParchmentMoveCommand[];
+    note: string | null;
+}
+/** Transaction kind with its sender set. Gas is not included. */
+export interface ParchmentBuiltTx {
+    /**
+     * The builder route (`request-close`, ...) and request body the kind was built and checked for.
+     * Pass it on with the kind as a Close All leg (`BatchCloseLeg.request`), so the batch re-checks it.
+     */
+    request: ParchmentTxRequest;
+    tx: Transaction;
+    commands: ParchmentMoveCommand[];
+    note: string | null;
+    txBytesBase64: string;
+}
+/** A builder request: `transactions/<route>` and the JSON body posted to it. */
+export interface ParchmentTxRequest {
+    route: string;
+    body: Record<string, unknown>;
+}
+/** The service has not read the market's pinned PriceFeedStorage, or cannot decode its feed. */
+export interface ParchmentPriceUnavailable {
+    status: "price_unavailable";
+    storageId: string | null;
+    reason: string | null;
+    priceWad: null;
+    twapWad: null;
+    timestampMs: null;
+    spreadWad: null;
+    spreadSource: null;
+    ageMs?: null;
+    maxAgeMs?: null;
+    stale?: false;
+    confWad?: null;
+    indicative?: true;
+}
+/**
+ * Where a quoted spread came from: `floor` (the market's spread floor only) or `market-latest`
+ * (rebuilt from the market's latest indexed signed confidence, not the caller's own update).
+ */
+export type ParchmentSpreadSource = "floor" | "market-latest";
+/** Served price fields shared by `live` and `stale` (`PriceView`). */
+interface ParchmentPriceQuoted {
+    storageId: string | null;
+    reason: null;
+    priceWad: bigint;
+    twapWad: bigint | null;
+    timestampMs: bigint | null;
+    /**
+     * The one-step spread (emergency / retired / admin closes): `max(confidence or 0, price *
+     * one_step_spread_bps)`. Two-step fills settle at the plain mid with no spread (no bid/ask).
+     */
+    spreadWad: bigint;
+    spreadSource: ParchmentSpreadSource;
+    /** `now - timestampMs` (negative when ahead). Absent on older services. */
+    ageMs?: bigint | null;
+    /** The market's `max_age_ms` the age is judged against. Absent on older services. */
+    maxAgeMs?: bigint | null;
+    /** True when `oracle::begin_price` would reject the observation; then `status` is `stale`. */
+    stale?: boolean;
+    /** The signed confidence the spread was built from (`market-latest` only). */
+    confWad?: bigint | null;
+    /** True when no fresh signed confidence is indexed: fills and payouts are an estimate. */
+    indicative?: boolean;
+}
+/** Older than the market's `max_age_ms` or too far ahead: `oracle::begin_price` would abort, so a keeper fill or emergency close waits for a fresh price. */
+export interface ParchmentPriceStale extends ParchmentPriceQuoted {
+    status: "stale";
+}
+export interface ParchmentPriceLive extends ParchmentPriceQuoted {
+    status: "live";
+}
+export type ParchmentPrice = ParchmentPriceLive | ParchmentPriceStale | ParchmentPriceUnavailable;
+/** @deprecated Renamed to `ParchmentPriceUnavailable` (status `price_unavailable`). */
+export type ParchmentPriceUnbound = ParchmentPriceUnavailable;
+/**
+ * `TimingParamsV1` as the API serves it (camelCase). `minHoldMs` is a u64 (Move `min_hold_ms`);
+ * read it with `marketMinHoldMs`. Close fills use the hold snapshotted at request.
+ */
+export interface ParchmentMarketTiming {
+    minHoldMs?: bigint;
+}
+/** `OracleParamsV1` as the API serves it (camelCase). `minSpreadBps` is the floor of the one-step spread. */
+export interface ParchmentMarketOracle {
+    storageId: string;
+    sourceId: bigint;
+    feedInfoId: string;
+    lazerFeedId: bigint;
+    maxAgeMs: bigint;
+    maxConfAgeMs: bigint;
+    maxFutureMs: bigint;
+    maxTwapDevBps: bigint;
+    minSpreadBps: bigint;
+}
+/** `RiskParamsV1` as the API serves it (camelCase; USDC base units, `bustBufferWad` a WAD fraction of entry). */
+export interface ParchmentMarketRisk {
+    minLeverage: bigint;
+    maxLeverage: bigint;
+    bustBufferWad: bigint;
+    minMargin: bigint;
+    minNotional: bigint;
+    maxPositionNotional: bigint;
+    maxTxNotional: bigint;
+    maxBlockNotional: bigint;
+    maxAccountNotional: bigint;
+    liqBountyBps: bigint;
+}
+/** `ImpactParamsV1` as the API serves it (camelCase). */
+export interface ParchmentMarketImpact {
+    cNum: bigint;
+    cDen: bigint;
+    deadbandDiv: bigint;
+    referenceNotional: bigint;
+    pNum: bigint;
+    pDen: bigint;
+    effectiveDepth: bigint;
+    deadbandPpm: bigint;
+    closeFeePpm: bigint;
+}
+export interface ParchmentMarketView {
+    marketId: string;
+    symbol: string | null;
+    kind: bigint | null;
+    /** `market::status`: 1 active, 2 reduce-only, 3 retired (`MARKET_STATUS_*`); null when unindexed. */
+    status: bigint | null;
+    enabled: boolean | null;
+    opensPaused: boolean | null;
+    /**
+     * While true new open requests abort `order::ERequestsPaused` (15) and a pending open's fill refunds with
+     * outcome 5 (`paused`, full escrow including the exec fee). Close requests, close fills (including
+     * liquidate-on-close), emergency close, close-retired, add-margin, liquidate and sweep all still run; a
+     * pending close that expires under it refunds with outcome 5.
+     */
+    closesPaused: boolean | null;
+    /**
+     * While true, liquidation, sweep, emergency close and close-retired abort `trade::EOracleKilled` (20); requests
+     * abort `order::ERequestsPaused` (15); a pending order's fill refunds with outcome 6 (`killed`, full escrow
+     * including the exec fee). The only flag that stops liquidation and exits.
+     */
+    oracleKilled: boolean | null;
+    /**
+     * True while liquidation on this market is stopped, which is only its oracle kill switch
+     * (`trade::EOracleKilled` 20), served on `/v1/markets` and `/v1/markets/{id}`.
+     * `null` when unindexed; older services omit it. `liquidationPaused(market)` honours it.
+     */
+    liquidationPaused?: boolean | null;
+    takerFeeBps: bigint | null;
+    winFeeBps: bigint | null;
+    /** Null when the market has no indexed oracle / risk / impact params. */
+    oracle: ParchmentMarketOracle | null;
+    risk: ParchmentMarketRisk | null;
+    impact: ParchmentMarketImpact | null;
+    /** Null when the market has no indexed timing params. */
+    timing: ParchmentMarketTiming | null;
+    longOi: bigint;
+    shortOi: bigint;
+    longLockedExposure: bigint;
+    shortLockedExposure: bigint;
+    lastOracleTsMs: bigint | null;
+    lastOracleSequence: bigint | null;
+    lastOracleSlot: bigint | null;
+    paramsStale: boolean;
+    /** The exchange this market is bound to (`market::exchange_id`, fixed at `register_market`). */
+    exchangeId: string | null;
+    /**
+     * Per-side open-interest notional caps in micro-USDC (`market::max_long_oi` / `max_short_oi`).
+     * Opens past a cap abort `trade::EOiNotionalCap` (29).
+     */
+    maxLongOi: bigint | null;
+    maxShortOi: bigint | null;
+    /** Per-side caps on locked winning exposure (`market::max_long_exposure` / `max_short_exposure`). Absent on older services. */
+    maxLongExposure?: bigint | null;
+    maxShortExposure?: bigint | null;
+    /**
+     * `OrderParamsV1.one_step_spread_bps` in bps: the spread floor that one-step exits
+     * (emergency close, `close_retired`) pay. Absent on services that predate it.
+     */
+    oneStepSpreadBps?: bigint;
+    /**
+     * `OrderParamsV1.cancel_delay_ms`: how long after a request it can be cancelled when the order has
+     * no stored `cancelAfterMs`. Null while the market has no order params; absent on older services.
+     */
+    cancelDelayMs?: bigint | null;
+    /**
+     * True when the service indexed the market but it is missing from the configured Registry's
+     * `market_ids` (the contract has no removal today; the chain still accepts requests on a market
+     * with status 1). The service keeps its row and history and still lists it, but stops polling its
+     * storage, so its price can go stale; the keeper still serves its open positions. Absent on
+     * services that predate it (read it with `marketIsDelisted`).
+     */
+    delisted?: boolean;
+    /** `"equity"` for markets with trading sessions (force-closed at each session end). Absent on older services. */
+    hoursMode?: string | null;
+    /** `"draining"` while the on-chain session close is armed and positions are still being closed. */
+    sessionState?: ParchmentSessionState | null;
+    /** End of the current session (ms); every open position on the market is force-closed then. Null when not equity or closed. */
+    sessionEndsAtMs?: bigint | null;
+    /** Start of the next session (ms) while closed or draining. */
+    nextSessionOpenMs?: bigint | null;
+    price: ParchmentPrice;
+}
+/** Equity session state served on market reads. */
+export type ParchmentSessionState = "open" | "closed" | "draining";
+export interface ApiParchmentMarketsResponse {
+    markets: ParchmentMarketView[];
+}
+export interface ApiParchmentMarketResponse {
+    market: ParchmentMarketView;
+}
+export interface ParchmentPricePoint {
+    timestampMs: bigint;
+    priceWad: bigint;
+    twapWad: bigint | null;
+    source: string;
+}
+export interface ApiParchmentPriceHistoryBody {
+    marketId: string;
+    fromMs?: string | bigint;
+    toMs?: string | bigint;
+    /** 1..=u64::MAX (`bad_request` otherwise, no request); the service clamps to its max page. */
+    limit?: string | number | bigint;
+}
+export interface ApiParchmentPriceHistoryResponse {
+    points: ParchmentPricePoint[];
+}
+/**
+ * A candle's interval, aligned on the Unix epoch (UTC: `4h` buckets start at 00:00, 04:00, …, `1d` at midnight).
+ * `1s`, `5s` and `15s` are bucketed from the service's 1 s Lazer price bars (`price_bars_1s`); a service without
+ * them answers 400 for them. `1s` and `5s` fill a quiet slot of a live 15 s bucket with a flat candle at the
+ * previous close; a missing 15 s bucket (an outage) stays a gap. The day is lowercase on the wire (`1d`).
+ */
+export type ParchmentCandleResolution = "1s" | "5s" | "15s" | "1m" | "5m" | "15m" | "1h" | "4h" | "1d";
+/** One candle: `timeMs` is its interval's start; the first, highest, lowest and last price point (WAD). */
+export interface ParchmentCandle {
+    timeMs: bigint;
+    openWad: bigint;
+    highWad: bigint;
+    lowWad: bigint;
+    closeWad: bigint;
+}
+export interface ApiParchmentCandlesBody {
+    marketId: string;
+    resolution: ParchmentCandleResolution;
+    /** Inclusive; raised to the start of the `limit`th newest interval up to `toMs`. */
+    fromMs?: string | bigint;
+    /** Inclusive; default now. */
+    toMs?: string | bigint;
+    /** Newest intervals read, 1..=u64::MAX; the service serves at most 500 (its default). */
+    limit?: string | number | bigint;
+}
+/** `GET /markets/{id}/candles`: oldest first; an interval without a price point has no candle. */
+export interface ApiParchmentCandlesResponse {
+    candles: ParchmentCandle[];
+}
+/** The most markets one `GET /markets/candles` reads (the service answers 400 `too_many_markets` past it). */
+export declare const PARCHMENT_CANDLES_BATCH_MAX_MARKETS = 12;
+/**
+ * `GET /markets/candles`: {@link ApiParchmentCandlesBody} for several markets at once. `resolution`, `fromMs`,
+ * `toMs` and `limit` apply to every market (one window for the batch).
+ */
+export interface ApiParchmentCandlesBatchBody {
+    /** 1..=12 market ids, counted after normalizing and dropping repeats (the first occurrence keeps its place). */
+    marketIds: readonly string[];
+    resolution: ParchmentCandleResolution;
+    /** Inclusive; raised, per market, to the start of the `limit`th newest interval up to `toMs`. */
+    fromMs?: string | bigint;
+    /** Inclusive; default now. */
+    toMs?: string | bigint;
+    /** Newest intervals read per market, 1..=u64::MAX; the service serves at most 500 (its default). */
+    limit?: string | number | bigint;
+}
+/** One market's candles in a batch: what `GET /markets/{id}/candles` answers for it. */
+export interface ParchmentCandlesBatchCandles {
+    marketId: string;
+    candles: ParchmentCandle[];
+    error?: undefined;
+}
+/** One market's failure in a batch (e.g. an unknown market); the other markets are still served. */
+export interface ParchmentCandlesBatchError {
+    marketId: string;
+    candles?: undefined;
+    error: {
+        code: string;
+        message: string;
+    };
+}
+export type ParchmentCandlesBatchSeries = ParchmentCandlesBatchCandles | ParchmentCandlesBatchError;
+/**
+ * `GET /markets/candles`: one entry per requested market, in request order; a market's failure is its own
+ * `error`, never the batch's. Each market's candles are oldest first, as from `GET /markets/{id}/candles`.
+ */
+export interface ApiParchmentCandlesBatchResponse {
+    resolution: ParchmentCandleResolution;
+    /** The service's clock when it answered (ms). */
+    serverTimeMs: bigint;
+    series: ParchmentCandlesBatchSeries[];
+}
+export interface ParchmentPinPrice {
+    symbol: string;
+    storageId: string;
+    sourceId: bigint;
+    lazerFeedId: bigint;
+    status: string;
+    reason: string | null;
+    priceWad: bigint | null;
+    twapWad: bigint | null;
+    timestampMs: bigint | null;
+    ageMs?: bigint | null;
+    stale?: boolean;
+}
+export interface ApiParchmentPricesResponse {
+    markets: Array<ParchmentPrice & {
+        marketId: string;
+        symbol: string | null;
+    }>;
+    pins: ParchmentPinPrice[];
+}
+/**
+ * One `price` event of `GET prices/stream` (Server-Sent Events): a market's live Pyth Lazer index
+ * price. Display only (charts): marks, fills, PnL and liquidation use the on-chain storage price
+ * of {@link ApiParchmentPricesResponse}, which can lag or differ.
+ */
+export interface ParchmentLivePrice {
+    marketId: string;
+    symbol: string | null;
+    /** 1e18-scaled. */
+    priceWad: bigint;
+    /** The Lazer `feed_update_timestamp` (ms). */
+    timestampMs: bigint;
+}
+/**
+ * One `trade` event of `GET trades/stream` (Server-Sent Events): an open, close or liquidation by
+ * any trader, sent once the service has indexed it. Amounts are USDC base units.
+ */
+export interface ParchmentTrade {
+    /** Increases with every trade; resume a stream after it (`tradesStreamUrl({ after })`). */
+    id: bigint;
+    action: "open" | "close" | "liquidate";
+    marketId: string;
+    symbol: string | null;
+    side: "long" | "short" | null;
+    /** The position owner's address. */
+    owner: string;
+    positionId: bigint;
+    notional: bigint;
+    margin: bigint;
+    /** Realized PnL of a close or liquidation; null on opens. */
+    pnl: bigint | null;
+    timestampMs: bigint;
+}
+export interface ParchmentPosition {
+    positionId: bigint;
+    accountId: string | null;
+    owner: string;
+    marketId: string;
+    trader: string;
+    attribution: string;
+    isLong: boolean;
+    midWad: bigint | null;
+    confWad: bigint | null;
+    entryWad: bigint | null;
+    bustWad: bigint | null;
+    margin: bigint | null;
+    notional: bigint | null;
+    leverage: bigint | null;
+    factorBps: bigint | null;
+    winningExposure: bigint | null;
+    winFeeBps: bigint | null;
+    deadbandPpm: bigint | null;
+    closeFeePpm: bigint | null;
+    openedAtMs: bigint | null;
+    openTx: string | null;
+    status: string;
+    /** Equity markets: when this position is force-closed at session end (ms). Null otherwise; absent on older services. */
+    autoCloseAtMs?: bigint | null;
+    /** Take-profit price (1e18), set or closing the position. Null when unset. */
+    takeProfitWad: bigint | null;
+    /** Stop-loss price (1e18), set or closing the position. Null when unset. */
+    stopLossWad: bigint | null;
+    /** Why the stop signed with the open was not armed: past the filled position's liquidation. Null otherwise. */
+    slDroppedReason: "past_liquidation_at_fill" | null;
+    /** The filled position's liquidation (1e18) when its stop was dropped. Null otherwise. */
+    fillBustWad: bigint | null;
+    /** How a closed position exited (`PositionExitEventV1.kind`). Null while open; absent on older services. */
+    exitKind?: ParchmentExitKind | null;
+}
+/** `PositionView.exitKind`: plain close, liquidation, or equity session force close. */
+export type ParchmentExitKind = "close" | "liquidation" | "session";
+export interface ApiParchmentPositionsResponse {
+    positions: ParchmentPosition[];
+    /** Next page's `cursor` (position id); null on the last page. Older services omit it. */
+    nextCursor?: string | null;
+}
+/** Optional keyset page for paged reads (service default 50). Follow `nextCursor` until it is null; an exactly-full last page already returns null (the service limit+1 paging). */
+export interface ParchmentPageQuery {
+    limit?: number | bigint;
+    cursor?: string | number | bigint | null;
+}
+/** History `deposit` / `withdraw` payload. */
+export interface ParchmentAmountPayload {
+    amount: bigint;
+}
+/** History `open` payload (`OpenPositionEventV1`, camelCase). Opens pay a builder nothing. */
+export interface ParchmentOpenPayload {
+    builderId: bigint | null;
+    positionId: bigint;
+    accountId: string;
+    marketId: string;
+    isLong: boolean;
+    midWad: bigint;
+    confWad: bigint;
+    entryWad: bigint;
+    bustWad: bigint;
+    margin: bigint;
+    notional: bigint;
+    factorBps: bigint;
+    winningExposure: bigint;
+    winFeeBps: bigint;
+    deadbandPpm: bigint;
+    closeFeePpm: bigint;
+}
+/** History `close` payload (`ClosePositionEventV1`, camelCase). Carries no close charge. */
+export interface ParchmentClosePayload {
+    positionId: bigint;
+    accountId: string;
+    gross: bigint;
+    haircut: bigint;
+    fee: bigint;
+    net: bigint;
+    queued: boolean;
+    builderId: bigint | null;
+    /** The approved builder's on-top fee taken from this close's profit (paid now or queued). */
+    builderAmount: bigint;
+    exitWad: bigint | null;
+    exitKind: string | null;
+}
+/** History `liquidate` payload (`LiquidatePositionEventV1`, camelCase). */
+export interface ParchmentLiquidatePayload {
+    positionId: bigint;
+    accountId: string;
+    bounty: bigint;
+    toLp: bigint;
+    exitWad: bigint | null;
+    exitKind: string | null;
+    liquidator: string;
+    swept?: boolean | null;
+}
+export interface ParchmentActivity {
+    id: bigint;
+    kind: string;
+    marketId: string | null;
+    positionId: bigint | null;
+    accountId: string | null;
+    txDigest: string;
+    timestampMs: bigint;
+    /** By `kind`: `ParchmentAmountPayload`, `ParchmentOpenPayload`, `ParchmentClosePayload` or `ParchmentLiquidatePayload`. */
+    payload: ParchmentAmountPayload | ParchmentOpenPayload | ParchmentClosePayload | ParchmentLiquidatePayload | null;
+    /** `tp` or `sl` when this close is the one a take-profit or stop-loss requested. Null otherwise. */
+    triggerKind: "tp" | "sl" | null;
+    /** That trigger's price (1e18). Null when `triggerKind` is null. */
+    triggerPriceWad: bigint | null;
+}
+export interface ApiParchmentHistoryBody {
+    walletAddress: string;
+    /** A page's `nextCursor`; null or blank is omitted. */
+    cursor?: string | number | bigint | null;
+    limit?: string | number | bigint;
+}
+export interface ApiParchmentHistoryResponse {
+    items: ParchmentActivity[];
+    nextCursor: string | null;
+}
+/** The windows `GET accounts/{owner}/equity` serves. */
+export type ParchmentEquityRange = "24h" | "7d" | "30d" | "all";
+export interface ApiParchmentEquityHistoryBody {
+    walletAddress: string;
+    range: ParchmentEquityRange;
+}
+/**
+ * One hourly equity snapshot (USDC base units). `equity` = `free` + `margin` + `unrealizedPnl`
+ * summed over the owner's trading accounts, the open positions valued at what closing them at the
+ * indexed oracle mid would pay after fees; `unpricedPositions` were counted at their margin.
+ */
+export interface ParchmentEquityPoint {
+    tsMs: bigint;
+    equity: bigint;
+    free: bigint;
+    margin: bigint;
+    /** Negative while the open positions are under water. */
+    unrealizedPnl: bigint;
+    openPositions: bigint;
+    unpricedPositions: bigint;
+}
+/**
+ * `GET accounts/{owner}/equity?range=`: oldest first, at most 500 points; the first point is the
+ * last snapshot at or before `fromMs` (null for `all`). Hourly rows, the hour's latest observation;
+ * an account with no open position has a row only when its equity changed.
+ */
+export interface ApiParchmentEquityHistoryResponse {
+    range: ParchmentEquityRange;
+    bucketMs: bigint;
+    fromMs: bigint | null;
+    toMs: bigint;
+    points: ParchmentEquityPoint[];
+    /** The equity now, from one read of balances, positions and prices; null without an account or while the indexer lags. */
+    current: ParchmentEquityPoint | null;
+}
+export interface ParchmentDelegate {
+    delegate: string;
+    expiryMs: bigint;
+}
+export interface ParchmentAccountRecord {
+    accountId: string;
+    owner: string;
+    exchangeId: string | null;
+    free: bigint;
+    openNotional: bigint;
+    delegates: ParchmentDelegate[];
+    /**
+     * Live order requests on this account (`Account.pending_orders`; open and close, still pending).
+     * Display only: closes are never capped. Absent on older services.
+     */
+    pendingOrders?: bigint;
+    /**
+     * Live OPEN requests on this account (`order::pending_open_orders`: pending requests minus pending closes). Only opens count toward
+     * `getConfig().maxPendingOrders`: compare via `hasPendingOrderSlot`. Absent on older services.
+     */
+    pendingOpenOrders?: bigint;
+    /**
+     * Parked mint basis (USDC base units) claimable with `claimPendingMintTxBody`: eligible trader losses from
+     * liquidations this account was not part of (a keeper's parks the forfeited margin including the bounty, an
+     * outsider's only the real price loss; the owner's or a delegate's parks nothing).
+     * Absent on older services.
+     */
+    pendingMintBasis?: bigint;
+    /**
+     * UPPER-BOUND estimate of the PARCHMENT raw units (9 decimals) the parked basis mints, at the current
+     * mint rate (current H). The claim mints at the H and remaining reward supply at claim time, so it
+     * may mint less, including zero (the service does not index the remaining supply). No per-account
+     * time-window cap. Absent on older services.
+     */
+    pendingMint?: bigint;
+    /** Total delegate count; `delegates` is capped at the page limit. Absent on older services. */
+    delegatesCount?: bigint;
+    /**
+     * The wallet that opened the account (the derivation key's `opener`); differs from `owner` after a
+     * `transfer-account`. Absent on older services.
+     */
+    opener?: string | null;
+    /** The opener's derivation nonce for this account (`AccountKey { opener, nonce }`). Absent on older services. */
+    nonce?: bigint | null;
+    /**
+     * Close-only delegates (take-profit and stop-loss): they can only close this account's positions
+     * and never expire; `getRevokeDelegateTx` removes one.
+     */
+    closeDelegates: string[];
+}
+export interface ParchmentClaim {
+    claimId: bigint;
+    positionId: bigint | null;
+    owner: string | null;
+    accountId: string | null;
+    net: bigint;
+    status: string;
+    enqueuedTx: string | null;
+    harvestedTx: string | null;
+    timestampMs: bigint | null;
+    /** Net still owed after partial harvests (service `remaining`); use it, not `net`, for what is owed. Absent on older services. */
+    remaining?: bigint;
+    /** Protocol fee still queued with the claim; null until its queue node is indexed. Absent on older services. */
+    feeRemaining?: bigint | null;
+    /** Builder on-top fee still queued with the claim (paid after the net); null until its queue node is indexed. */
+    onTopRemaining?: bigint | null;
+}
+export interface ApiParchmentAccountResponse {
+    owner: string;
+    /**
+     * The derivation nonce of the next account this wallet opens (`deriveAccountId({ ..., nonce })`): the number of
+     * accounts it opened before. 0 unless it transferred accounts away. Absent on older services.
+     */
+    nextAccountNonce?: bigint;
+    accounts: ParchmentAccountRecord[];
+    /** Pass as `accountsCursor` for the next page; null on the last page. Older services omit it. */
+    accountsNextCursor?: string | null;
+    positions: ParchmentPosition[];
+    /** Pass as `positionsCursor` for the next page; null on the last page. */
+    positionsNextCursor?: string | null;
+    queue: {
+        claims: ParchmentClaim[];
+        /** Pass as `claimsCursor` for the next page; null on the last page. */
+        claimsNextCursor?: string | null;
+        aheadCount: bigint;
+        aheadNet: bigint;
+    };
+}
+/** Protocol FIFO queue. Amounts are base units. Cash fields are null until known. */
+export interface ParchmentQueue {
+    length: bigint;
+    totalOwed: bigint;
+    lpCash: bigint | null;
+    instantlyPayable: bigint | null;
+}
+/** One wallet's place in the FIFO queue. `rank` is null when `hasClaim` is false. */
+export interface ParchmentAccountQueue {
+    hasClaim: boolean;
+    net: bigint;
+    owner: string;
+    rank: bigint | null;
+}
+/** Live sweep settings from indexed Config and setter history. Cash is USDC base units (6 dp). */
+export interface ParchmentSweepParams {
+    floorBps: bigint;
+    maxBps: bigint;
+    intervalMs: bigint;
+    capBps: bigint;
+    cashFloor: bigint;
+    stakerBps: bigint;
+    treasuryBps: bigint;
+    growthBps: bigint;
+}
+export interface ApiParchmentLpResponse {
+    /** Null before Config indexing; absent on older services. Display estimates, never tx gates. */
+    sweep?: ParchmentSweepParams | null;
+    lpCash: bigint | null;
+    trackedLp: bigint | null;
+    equity: bigint | null;
+    totalOwed: bigint;
+    totalOwedSource: string;
+    queueLength: bigint;
+    feeLp: bigint | null;
+    feeStaker: bigint | null;
+    feeDev: bigint | null;
+    userFree: bigint | null;
+    lockedMargin: bigint | null;
+    tailProgress: bigint | null;
+    /** Growth share of surplus sweeps. There is no insurance fund. */
+    feeGrowth: bigint | null;
+    /**
+     * Stakers' share (bps) of the next retained fee at the current coverage, and the curve it comes
+     * from (`config::set_retained_fee_curve`): `stakerShareMinBps` at coverage <= `stakerCovLowBps`,
+     * linear to `stakerShareMaxBps` at >= `stakerCovHighBps` (launch 30% -> 70% between 100% and 200%).
+     * Read the curve with `lpRetainedFeeCurve`. Null until indexed; absent on older services.
+     */
+    stakerShareBps?: bigint | null;
+    stakerShareMinBps?: bigint | null;
+    stakerShareMaxBps?: bigint | null;
+    stakerCovLowBps?: bigint | null;
+    stakerCovHighBps?: bigint | null;
+    /** Positive open PnL across markets (last per-market snapshots). */
+    reserveUpnl: bigint | null;
+    /** Stress cushion across markets (larger side x stress bps x trim share). */
+    reserveStress: bigint | null;
+    /** totalOwed + reserveUpnl + reserveStress (the contract's `exchange::reserve`). */
+    reserve: bigint | null;
+    lastSurplusMs: bigint | null;
+    /**
+     * A `ReserveCheck` begun at an older epoch aborts `exchange::ECheckStale` (11). Nothing bumps it since the signed band was removed; the field stays in the Exchange layout.
+     */
+    reserveEpoch: bigint | null;
+    /**
+     * Markets in the exchange's `oi_set` (snapshot covers open interest). A sweep-surplus
+     * transaction must re-price every one of them.
+     */
+    oiMarkets: bigint | null;
+    paused: boolean | null;
+    /**
+     * Global close pause, on every market: open requests abort `order::ERequestsPaused` and pending open fills
+     * refund with outcome 5. Closes, emergency close, close-retired, liquidate and sweep still run.
+     */
+    closesPaused: boolean | null;
+    head: ParchmentClaim | null;
+    claims: ParchmentClaim[];
+    note: string;
+}
+export interface ApiParchmentReferralBind {
+    address: string;
+    boundAtMs: bigint;
+}
+export interface ApiParchmentReferralsResponse {
+    address: string;
+    asReferee: {
+        referrer: string;
+        boundAtMs: bigint;
+    } | null;
+    asReferrer: {
+        direct: ApiParchmentReferralBind[];
+        /** Pass as `directCursor` for the next page; null on the last page. Older services omit it. */
+        directNextCursor?: string | null;
+        secondLevel: Array<ApiParchmentReferralBind & {
+            via: string;
+        }>;
+        /** Pass as `secondLevelCursor` for the next page; null on the last page. */
+        secondLevelNextCursor?: string | null;
+        /** Total direct / second-level referees (the lists are paged). Absent on older services. */
+        directCount?: bigint;
+        secondLevelCount?: bigint;
+        refereeClaimVolume: bigint;
+        /** Estimate of the bonus accrued to date, paid or still owed (a short treasury leaves the rest owed). Not `staking::referral_owed`. */
+        estimatedDirectBonus: bigint;
+        /** Estimate of the bonus accrued to date, paid or still owed (a short treasury leaves the rest owed). Not `staking::referral_owed`. */
+        estimatedSecondBonus: bigint;
+    };
+    /** Wording returned with the figures. These bonuses are not settled amounts. */
+    estimate: string;
+}
+export interface ApiParchmentProtocolResponse {
+    openPositions: bigint;
+    openNotional: bigint;
+    volumeNotional: bigint;
+    equity: bigint | null;
+    lpCash: bigint | null;
+    queueLength: bigint;
+    paused: boolean | null;
+    /**
+     * Exchange-wide close pause, same flag as `getLp().closesPaused`. The service serves it as
+     * a boolean (`false` until indexed); optional only for older services, which omit it. It does not stop
+     * liquidation or exits.
+     */
+    closesPaused?: boolean | null;
+}
+export interface ParchmentPricePin {
+    symbol: string;
+    storageId: string;
+    sourceId: bigint;
+    lazerFeedId: bigint;
+}
+/**
+ * `/v1/config` `gameRewards`: the minted game-reward knobs (indexed values, else the contract
+ * defaults). Amounts are PARCHMENT base units (`decimals`).
+ */
+export interface ParchmentGameRewardsConfig {
+    model: "minted";
+    decimals: bigint;
+    walletMintCapPerDay: bigint;
+    globalMintCapPerDay: bigint;
+    winMint: bigint;
+    achievementMintFractionBps: bigint;
+    dailyDrop: {
+        base: bigint;
+        step: bigint;
+        max: bigint;
+        streakCap: bigint;
+    };
+    dailyDropUnit: "XP";
+    treasuryInstalled: boolean;
+    note: string;
+}
+export interface ApiParchmentConfigResponse {
+    /** Latest core `parchment` package (account, config, exchange, market, lp, events, ...). */
+    packageId: string | null;
+    /** Every core `parchment` package version, original first. Absent on older services. */
+    packageIds?: string[];
+    /**
+     * Latest `parchment_trade` package (package split): `trade`, the `oracle` receipt entries,
+     * `game`, `referral`, `builder`, `fees`, `fee_mint`, `launch`, `keeper`, `auth`. Null on a
+     * service without `parchment.trade-packages`.
+     */
+    tradePackageId: string | null;
+    /**
+     * Every `parchment_trade` version, original first. Its types (`oracle::PriceReceipt`,
+     * `fees::LossTicket`, ...) carry the original (first) id. Absent on older services.
+     */
+    tradePackageIds?: string[];
+    /** Latest `parchment_base` package (`liq_book`, `builder_book`, `lp`, `position`, `safety`, `constants`). */
+    basePackageId?: string | null;
+    /** Every `parchment_base` version, original first. Absent on older services. */
+    basePackageIds?: string[];
+    /** Latest `parchment_game` package. `game_book` / `game_events` types use the original id. */
+    gamePackageId?: string | null;
+    /** Every `parchment_game` version, original first. Absent on older services. */
+    gamePackageIds?: string[];
+    /** Latest `parchment_mint` package. `locked_mint` / `mint_cap` types use the original id. */
+    mintPackageId?: string | null;
+    /** Every `parchment_mint` version, original first. Absent on older services. */
+    mintPackageIds?: string[];
+    oraclePackageId: string | null;
+    tokenPackageId: string | null;
+    /**
+     * the Pyth Lazer integration package. Not a Parchment package: clients may call only
+     * `price_feed_storage::update_price_feed` on it, ahead of a one-step `adapter::quote`.
+     * Absent on older services.
+     */
+    lazerIntegrationPackageId?: string;
+    configId: string | null;
+    exchangeId: string | null;
+    registryId: string | null;
+    stakingPoolId: string | null;
+    /** The Sui `Random` object id the service passes to game txs. Null when unset; absent on older services. */
+    randomId?: string | null;
+    /**
+     * `<original token package>::parchment::PARCHMENT`, stable across token upgrades. Null without a
+     * token package; absent on older services.
+     */
+    rewardCoinType?: string | null;
+    /** Removed from `/v1/config` by the service; older services sent it. */
+    treasuryId?: string | null;
+    usdcType: string;
+    storageType: string;
+    pins: ParchmentPricePin[];
+    graphqlUrl: string;
+    /**
+     * Admin-set per-account pending order cap (`ConfigStateV1.max_pending_orders`, 1..64; a
+     * js_bigint on the wire such as `"64n"`; contract default `64n` until indexed). A `request-open*` while the account already
+     * has this many pending opens aborts `order::ETooManyOrders` (11). Close requests are not counted. Absent on older services.
+     */
+    maxPendingOrders?: bigint;
+    /** Minted game-reward knobs. Absent on older services. */
+    gameRewards?: ParchmentGameRewardsConfig;
+    /** Close-only delegate address for take-profit and stop-loss. Null when unset. */
+    triggerDelegate: string | null;
+    /** Builder-code limits. */
+    builders: ParchmentBuilderConfig;
+}
+/**
+ * Builder codes charge only an on-top fee, in bps of the trader's profit, that the trader approves.
+ * `ownerFeeLimitBps` is the most an owner may set (above it is admin-only), `maxFeeBps` the live max
+ * and `hardCapBps` the 1% ceiling. `createFee` is the live, admin-set price of a code in USDC base
+ * units (default 1 USDC, 0 to 100 USDC); `create_builder` takes exactly this amount.
+ */
+export interface ParchmentBuilderConfig {
+    /** Whether new opens snapshot a builder at all. */
+    enabled: boolean;
+    ownerFeeLimitBps: bigint;
+    maxFeeBps: bigint;
+    hardCapBps: bigint;
+    createFee: bigint;
+}
+export interface ApiParchmentLimitsResponse {
+    priceFeedStorageGetter: string;
+    priceUnavailable: string;
+    tradeTransactions: string;
+    tradeTxNote: string;
+    /** Note on request-open / request-close bytes (service `tx::ORDER_NOTE`). */
+    orderTxNote: string;
+    referralBonuses: string;
+    referralEstimate: string;
+    orderBook: string;
+    sponsor: string;
+    incomingTxKind: string;
+    signedAuth: string;
+    moveAbortCatalog: string;
+    unseen: string[];
+}
+/**
+ * Close-preview PnL as served by the service (`preview_close`). Amounts are unsigned
+ * USDC base units. The service always sends every field; the breakdown
+ * fields after `net` are optional so code typed against the original five fields (and older
+ * services) still compiles.
+ */
+export interface ParchmentPnl {
+    /** Loss charged to margin (capped at margin). 0 on a winning close. */
+    loss: bigint;
+    /** Exposure-adjusted profit past the deadband, before the trim. */
+    raw?: bigint;
+    /** `raw - adjusted`: profit removed by the trim. */
+    trimmed?: bigint;
+    /** `raw` after the trim (the base of the win fee). */
+    adjusted: bigint;
+    winFee: bigint;
+    closeToll: bigint;
+    /** Profit after win fee and close toll. */
+    net: bigint;
+    /** Close toll taken from profit / from margin (trade::apply_pnl order). */
+    closeTollFromProfit?: bigint;
+    closeTollFromMargin?: bigint;
+    userProfit?: bigint;
+    marginReturned?: bigint;
+    /** `payoutBeforeRefund + refereeRefund`. */
+    payout?: bigint;
+    payoutBeforeRefund?: bigint;
+    /** Referee discount on the fees collected now, credited back to free balance. */
+    refereeRefund?: bigint;
+    /** Fees collected at close (toll from margin, plus toll from profit and win fee when paid now). */
+    feesCollectedNow?: bigint;
+    /**
+     * The approved builder's on-top fee, taken from `userProfit` (already out of `payout`): the
+     * position's snapshotted bps clamped to the live max, 0 without a builder or after a revoke.
+     */
+    builderFee?: bigint;
+    builderFeeBps?: bigint;
+    /** Profit paid at close: queue empty and LP cash covers it. */
+    paidNow?: boolean;
+    /** Profit waits in the claims queue; its fees are collected at harvest. */
+    queued?: boolean;
+    trimMaxShareBps?: bigint;
+    trimCPpm?: bigint;
+}
+export interface ApiParchmentOpenPreviewBody {
+    marketId: string;
+    margin: string | bigint;
+    leverage: string | bigint;
+    isLong: boolean;
+    /** 0..10000. When set, the preview returns `suggestedBoundWad` for this slippage. */
+    slippageBps?: string | bigint;
+    /** Check this entry bound (WAD) against the current fill; a miss adds an error. Preview only: the chain takes no price bound on fills. */
+    acceptableEntryWad?: string | bigint;
+    /**
+     * Alias of `acceptableEntryWad` (the request tx bodies' name). `acceptableEntryWad` wins when
+     * both are set; the SDK sends the value as `acceptableEntryWad`, so older services read it too.
+     */
+    acceptablePriceWad?: string | bigint;
+    /**
+     * The account that will request the open. Without it the service skips every account check:
+     * the referral-discounted open fee, the exec-fee / free-balance check (`topUp` only counts
+     * here), the account notional cap and `account_not_found`. `ParchmentAccount.getPreviewOpen`
+     * fills it in when the owner has exactly one account.
+     */
+    accountId?: string;
+    /** The request's `minFactorBps`; a payout factor below it adds `factor_worse`. */
+    minFactorBps?: string | bigint;
+    /**
+     * Wallet top-up for the exec-fee check, in base units (an integer, not a coin ref; the tx routes
+     * take a coin ref instead). Only read together with `accountId`. The service answers 400 to
+     * anything that is not a base-unit integer.
+     */
+    topUp?: string | bigint;
+}
+/** Price-bound fields on open/close previews. */
+export interface ApiParchmentBoundPreviewFields {
+    /**
+     * Current fill price (WAD): the oracle mid, which is what a two-step keeper fill pays (older
+     * services returned mid ± the spread). Treat it as an estimate;
+     * the bound check uses whatever the service sends.
+     */
+    fillWad?: bigint | null;
+    /**
+     * The one-step price (WAD): mid + spread for long opens/short closes, else mid − spread, i.e. the
+     * price that emergency close and `close_retired` pay. Null when the price is not live; absent on
+     * services that predate it. Not the two-step fill price (that is `fillWad`).
+     */
+    oneStepWad?: bigint | null;
+    /** Bound for the requested `slippageBps`; null when it was not given. */
+    suggestedBoundWad?: bigint | null;
+}
+export interface ApiParchmentOpenPreviewResponse extends ApiParchmentOrderPreviewFields, ApiParchmentBoundPreviewFields {
+    marketId: string;
+    isLong: boolean;
+    margin: bigint | null;
+    fee: bigint | null;
+    locked: bigint | null;
+    notional: bigint | null;
+    winningExposure: bigint | null;
+    factorBps: bigint | null;
+    entryWad: bigint | null;
+    bustWad: bigint | null;
+    spreadSource: ParchmentSpreadSource | null;
+    /** False when a fresh signed confidence priced the spread (`spreadSource: "market-latest"`). */
+    indicative?: boolean;
+    confWad?: bigint | null;
+    takerFeeBps?: bigint;
+    minPayoutFactorBps?: bigint;
+    errors: string[];
+}
+export interface ApiParchmentClosePreviewBody {
+    positionId: string | bigint;
+    nowMs?: string | bigint;
+    /** 0..10000. When set, the preview returns `suggestedBoundWad` for this slippage. */
+    slippageBps?: string | bigint;
+    /** Check this exit bound (WAD) against the current fill; a miss adds an error. Preview only: the chain takes no price bound on fills. */
+    acceptableExitWad?: string | bigint;
+    /**
+     * Alias of `acceptableExitWad` (the request tx bodies' name). `acceptableExitWad` wins when both
+     * are set; the SDK sends the value as `acceptableExitWad`, so older services read it too.
+     */
+    acceptablePriceWad?: string | bigint;
+    /**
+     * Wallet top-up for the exec-fee check, in base units (an integer, not a coin ref; the tx routes
+     * take a coin ref instead). The service answers 400 to anything that is not a base-unit integer.
+     */
+    topUp?: string | bigint;
+}
+export interface ApiParchmentClosePreviewResponse extends ApiParchmentOrderPreviewFields, ApiParchmentBoundPreviewFields {
+    /**
+     * Delay (ms) after a close request before emergency close is allowed (`OrderParamsV1`), not an
+     * absolute time. Exact up to u64::MAX (disabled). Test it with `isEmergencyAfterDisabled`, never
+     * `=== EMERGENCY_CLOSE_DISABLED_MS`.
+     */
+    emergencyAfterMs?: bigint | null;
+    /**
+     * The part of `execFee` a close request would owe rather than escrow: 0 when free balance covers
+     * the fee, else the shortfall, taken from the close payout on a fill (capped at it). A close never
+     * reports `insufficient_free_balance` for the exec fee. Absent on services that predate it.
+     */
+    feeOwed?: bigint | null;
+    positionId: bigint;
+    errors: string[];
+    /** As on the open preview: false when a fresh signed confidence priced the spread. */
+    indicative?: boolean;
+    confWad?: bigint | null;
+    pnl: ParchmentPnl | null;
+    exitWad: bigint | null;
+    /** Mid crossed bust; false while liquidation is paused (see `liquidationPaused`); null without a live price. */
+    liquidatable: boolean | null;
+    /**
+     * True while liquidation of this position's market is stopped: only the market's oracle kill switch
+     * (`trade::EOracleKilled`, 20; no pause stops liquidation); then
+     * `liquidatable` is false. `null` when the market is not indexed; older services omit it.
+     */
+    liquidationPaused?: boolean | null;
+    spreadSource?: ParchmentSpreadSource | null;
+}
+export interface ApiParchmentOpenAccountTxBody {
+    walletAddress: string;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Owned AccountCap. Version and digest are sent only when the caller provides them. */
+export interface ApiParchmentAccountCap {
+    /** Object id of the owned AccountCap for this account. */
+    accountCapId: string;
+    accountCapVersion?: string;
+    accountCapDigest?: string;
+}
+export interface ApiParchmentDepositTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    coin: ApiParchmentCoinRef;
+    shared?: ApiParchmentSharedVersions;
+}
+export interface ApiParchmentWithdrawTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    amount: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+/**
+ * Permissionless, account-free liquidation (v3): the record lives in the market's liquidation
+ * book, the bounty coin goes to `walletAddress`, and the owner's account reconciles on its next
+ * touch. `retired` targets `liquidate_retired` on a retired market. Priced with
+ * `oracle::begin_price` like every other fill (there is no TWAP band check). Liquidation runs under every
+ * pause, including `pause_all`; only the market's oracle kill switch stops it (`trade::EOracleKilled` 20; see
+ * `liquidationPaused`).
+ */
+export interface ApiParchmentLiquidateTxBody {
+    walletAddress: string;
+    marketId: string;
+    positionId: string | bigint;
+    update: SignedLazerUpdate;
+    retired?: boolean;
+    shared?: ApiParchmentSharedVersions;
+}
+/**
+ * Two-step open request (`order::request_open`). The keeper fills it at the plain oracle mid
+ * (no spread) inside the fill window. No oracle update is needed at request time.
+ */
+export interface ApiParchmentRequestOpenTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    marketId: string;
+    margin: string | bigint;
+    leverage: string | bigint;
+    isLong: boolean;
+    /** Minimum winning-exposure factor in bps. Defaults to `0`. */
+    minFactorBps?: string | bigint;
+    /**
+     * Requested worst fill (WAD u128); `0` is no bound.
+     * On chain: stored and emitted only; two-step fills and emergency close take no price bound.
+     */
+    acceptablePriceWad: string | bigint;
+    /** Registered builder id (u32). Sent only when provided. */
+    builderId?: string | bigint;
+    /** Registered builder code (1 to 32 bytes of printable UTF-8, ASCII recommended; no NUL), resolved to its id by the service. Not with `builderId`. */
+    builderCode?: string;
+    /** USDC coin from the wallet deposited into free balance in the same PTB. Sent only when provided. */
+    topUp?: ApiParchmentCoinRef;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Delegate open request. No AccountCap and no wallet top-up. */
+/**
+ * Pre-flight for a delegate order request: the sender's delegation expiry and the
+ * market's `fill_deadline_ms` (`OrderParams.fillDeadlineMs`). On chain a delegate request aborts
+ * `EDelegateExpiresBeforeDeadline` (order 28) unless the delegation outlives `now + fill_deadline_ms`;
+ * the SDK refuses before building unless it outlives that by `DELEGATE_FILL_MARGIN_MS` (60 s) more.
+ * Omit it for a close-only delegate (no expiry).
+ */
+export interface ParchmentDelegateLiveness {
+    /** The delegation's expiry (`grant_delegate` `expiry_ms`). */
+    expiryMs: string | bigint | number;
+    /** The market's `fill_deadline_ms` (relative ms). */
+    fillDeadlineMs: string | bigint | number;
+    /** Clock ms to check against; defaults to `Date.now()`. */
+    nowMs?: string | bigint | number;
+}
+export interface ApiParchmentRequestOpenAsDelegateTxBody {
+    /** Delegate-liveness pre-flight (not sent). See {@link ParchmentDelegateLiveness}. */
+    delegation?: ParchmentDelegateLiveness;
+    walletAddress: string;
+    accountId: string;
+    marketId: string;
+    margin: string | bigint;
+    leverage: string | bigint;
+    isLong: boolean;
+    minFactorBps?: string | bigint;
+    acceptablePriceWad: string | bigint;
+    builderId?: string | bigint;
+    builderCode?: string;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Two-step close request (`order::request_close`). */
+export interface ApiParchmentRequestCloseTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    marketId: string;
+    positionId: string | bigint;
+    /**
+     * Requested worst exit (WAD u128). Omit it, or pass `0`, for no bound. Only opens require a value.
+     * On chain: stored and emitted only; two-step fills and emergency close take no price bound.
+     */
+    acceptablePriceWad?: string | bigint;
+    /** USDC coin from the wallet for the exec fee. Sent only when provided. */
+    topUp?: ApiParchmentCoinRef;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Delegate close request. No AccountCap and no wallet top-up. */
+export interface ApiParchmentRequestCloseAsDelegateTxBody {
+    /** Delegate-liveness pre-flight (not sent) for a trade delegate's close. Omit for a close-only delegate. */
+    delegation?: ParchmentDelegateLiveness;
+    walletAddress: string;
+    accountId: string;
+    marketId: string;
+    positionId: string | bigint;
+    /** Omit it, or pass `0`, for no bound. Only opens require a value. Not enforced at fill. */
+    acceptablePriceWad?: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Order reference without a cap: `cancel-order-as-delegate` (and the base of `expire-order`). */
+export interface ApiParchmentOrderRefTxBody {
+    walletAddress: string;
+    accountId: string;
+    orderId: string;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Owner cancel (`order::cancel`). Allowed at or after `effectiveCancelAfterMs(order)` = `max(cancelAfterMs, requestedMs + 5 s)`. */
+export interface ApiParchmentCancelOrderTxBody extends ApiParchmentAccountCap, ApiParchmentOrderRefTxBody {
+}
+/** Delegate cancel. No AccountCap. */
+export type ApiParchmentCancelOrderAsDelegateTxBody = ApiParchmentOrderRefTxBody;
+/**
+ * Permissionless expiry. Allowed strictly after `orderExpiresAfterMs(order)`: `fillDeadlineMs`
+ * for opens (and closes with emergency close disabled); for closes, `emergencyAfterMs` plus the
+ * fill-deadline span (`fillDeadlineMs - requestedMs`), so the emergency-close path gets its turn first.
+ */
+export interface ApiParchmentExpireOrderTxBody extends ApiParchmentOrderRefTxBody {
+    /**
+     * The order's market. The service resolves it from the order and uses this only as the fallback
+     * for an order its index has not seen; the chain asserts it is the order's market.
+     */
+    marketId?: string;
+    /**
+     * Signed Lazer update for the expiry price (`oracle::begin_expiry_price`, which `order::expire` takes
+     * on every market). When omitted, the service attaches a cached update that normalizes to the
+     * storage print, not the latest message. The expiry refunds the exec fee unless the storage's
+     * latest write is inside the order's fill window.
+     */
+    update?: SignedLazerUpdate;
+}
+/**
+ * Delegate emergency close. No AccountCap. Prices with a signed oracle update. There is no exit
+ * bound field, and the close request's stored `acceptablePriceWad` is not checked (the contract
+ * passes `trade::no_price_bound()`): the close fills at the one-step price whatever it is.
+ */
+export interface ApiParchmentEmergencyCloseAsDelegateTxBody {
+    walletAddress: string;
+    accountId: string;
+    marketId: string;
+    orderId: string;
+    /** Signed Lazer update. When omitted, the service fetches the latest one for the market. */
+    update?: SignedLazerUpdate;
+    shared?: ApiParchmentSharedVersions;
+}
+/**
+ * Emergency close of a pending close order after `emergencyAfterMs` (15 s by default), when the
+ * keeper has not filled it. Priced with the caller's signed update, or the latest one the
+ * service fetches when `update` is omitted.
+ */
+export interface ApiParchmentEmergencyCloseTxBody extends ApiParchmentAccountCap, ApiParchmentEmergencyCloseAsDelegateTxBody {
+}
+/**
+ * One-step `trade::close_retired_as_delegate`: closes a position on a retired market (orders
+ * are refused there), with no price bound. No AccountCap.
+ */
+export interface ApiParchmentCloseRetiredAsDelegateTxBody {
+    walletAddress: string;
+    accountId: string;
+    marketId: string;
+    positionId: string | bigint;
+    /** Signed Lazer update. When omitted, the service fetches the latest one for the market. */
+    update?: SignedLazerUpdate;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Owner `trade::close_retired`. */
+export interface ApiParchmentCloseRetiredTxBody extends ApiParchmentAccountCap, ApiParchmentCloseRetiredAsDelegateTxBody {
+}
+export type OrderKind = "open" | "close";
+export type OrderStatus = "pending" | "filled" | "liquidated" | "cancelled" | "expired" | "refunded" | "void" | "emergency_closed"
+/** The service could not map the on-chain outcome (the retired outcome 4, or a newer contract outcome code). */
+ | "unknown";
+/**
+ * Why a `refunded` order was refunded. `band` (outcome 12, `OUTCOME_REFUND_BAND`) is reserved and never
+ * emitted (the signed band is gone). `session` (outcome 13, `OUTCOME_SESSION_CLOSED`): filled while the equity market's session close was
+ * pending, or a close whose position the session force close already settled. The retired outcome 4
+ * (the old price refund) has no reason: it decodes as `unknown`. `retry` (outcome 14, `OUTCOME_REFUND_LIQ_PAUSED`;
+ * no pause emits it): the liquidation backlog could not be drained in that fill; fully refunded, try again.
+ * `revoked` (outcome 15, `OUTCOME_REFUND_REVOKED`): the delegate that submitted the request was no longer live
+ * at the order's cancel point; the escrow is returned and the execution fee is kept like a cancel (* earlier contracts also returned the fee).
+ */
+export type OrderRefundReason = "paused" | "killed" | "closed" | "fee" | "risk" | "band" | "session" | "retry" | "revoked";
+export type OrderStatusFilter = "pending" | "final" | "all";
+/**
+ * `GET /orders/{orderId}`. Integers are bigints.
+ * Request-side fields are null when the indexer has seen the final event but not
+ * yet the request event; `status` and the fill fields are then still accurate.
+ */
+export interface Order {
+    orderId: string;
+    accountId: string;
+    owner: string;
+    requester: string | null;
+    marketId: string;
+    kind: OrderKind;
+    isLong: boolean | null;
+    margin: bigint | null;
+    leverage: bigint | null;
+    positionId: bigint | null;
+    acceptablePriceWad: bigint | null;
+    minFactorBps: bigint | null;
+    maxFeeBps: bigint | null;
+    execFee: bigint | null;
+    requestedMs: bigint | null;
+    fillDeadlineMs: bigint | null;
+    cancelAfterMs: bigint | null;
+    /**
+     * Chain u64::MAX (emergency close disabled; every open order) is served as `18446744073709551615n`.
+     * Test it with `isEmergencyAfterDisabled` / `orderExpiresAfterMs`.
+     */
+    emergencyAfterMs: bigint | null;
+    /**
+     * Close requests: the exec fee part not escrowed (free balance was short), taken from the close
+     * payout on a fill; 0 for opens and fully funded closes. Null when the request event is not
+     * indexed; absent on services that predate it.
+     */
+    feeOwed?: bigint | null;
+    status: OrderStatus;
+    /** Set when `status` is `refunded`. */
+    reason: OrderRefundReason | null;
+    fillPriceWad: bigint | null;
+    fillPriceTsMs: bigint | null;
+    /** Milliseconds from request to fill; only for filled/liquidated orders. */
+    fillLatencyMs: bigint | null;
+    refund: bigint | null;
+    /**
+     * The escrowed exec fee returned to free balance (0 when paid). An `expired` order gets it back
+     * unless a keeper missed a storage write inside the fill window. Null while pending; absent on
+     * services that predate it.
+     */
+    execFeeRefunded?: bigint | null;
+    requestDigest: string | null;
+    finalDigest: string | null;
+    finalizedMs: bigint | null;
+}
+export interface ApiParchmentOrdersResponse {
+    orders: Order[];
+    nextCursor?: string | null;
+}
+export interface ApiParchmentOrdersQuery {
+    status?: OrderStatusFilter;
+    limit?: number | bigint;
+    /** `nextCursor` from the previous page (`<sortMs>:<orderId>`); null or blank is omitted. */
+    cursor?: string | null;
+}
+/** Two-step order fields on open/close previews. */
+export interface ApiParchmentOrderPreviewFields {
+    suggestedAcceptablePriceWad?: bigint | null;
+    maxFeeBps?: bigint | null;
+    execFee?: bigint | null;
+    /** The market's fill window and cancel delay (ms). */
+    fillWindowMs?: bigint | null;
+    /**
+     * The market's signed fill window (ms, verify-in-fill): the fill price is the first signed Lazer
+     * tick after the request, at most this much later.
+     */
+    signedWindowMs?: bigint | null;
+    cancelDelayMs?: bigint | null;
+    /**
+     * `OrderParamsV1.one_step_spread_bps`.
+     * Absent on services that predate it.
+     */
+    oneStepSpreadBps?: bigint | null;
+}
+/**
+ * Keeper crank: liquidate up to `maxEntries` (1..=8, default 8; clamped on chain) crossed positions.
+ * Priced with `oracle::begin_price` (there is no TWAP band check). Like `liquidate`, it runs under every
+ * pause; only the market's oracle kill switch stops it.
+ */
+export interface ApiParchmentSweepTxBody {
+    walletAddress: string;
+    marketId: string;
+    update: SignedLazerUpdate;
+    maxEntries?: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+/**
+ * Permissionless surplus sweep (at most once per interval, only above the reserve floor). The
+ * service re-prices every market with open interest in the same PTB (`ReserveCheck`), so the
+ * floor uses a fresh reserve.
+ */
+export interface ApiParchmentSweepSurplusTxBody {
+    walletAddress: string;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Owner mints PARCHMENT against fee-mint basis parked by account-free liquidations. */
+export interface ApiParchmentClaimPendingMintTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    shared?: ApiParchmentSharedVersions;
+}
+export interface ApiParchmentLpHarvestTxBody {
+    walletAddress: string;
+    maxEntries?: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+export interface ApiParchmentBindReferrerTxBody {
+    walletAddress: string;
+    referrer: string;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Trading referral for one wallet. `referrer` is null when the wallet is unbound. */
+export interface ParchmentTradingReferral {
+    referrer: string | null;
+    refereeCount: bigint;
+    totalEarned: bigint;
+    pending: bigint;
+}
+/** Trading-referral bind. Version and digest are sent only when the caller provides them. */
+export interface ApiParchmentBindTradingReferrerTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    referrer: string;
+    shared?: ApiParchmentSharedVersions;
+}
+/**
+ * `transfer-account`: `account_transfer::transfer_account` hands the whole account to `recipient` in one
+ * step (no accept): the cap, the owner, the balance, open positions, queued claims and the referee
+ * binding move. The game profile stays with the wallet that earned it (XP, crates, quests, cosmetics,
+ * unminted game PARCH, the daily mint count). Every delegate (session keys, the TP/SL close delegate)
+ * is cleared. The recipient must hold no account (`holder_book::ERecipientHasAccount`) and the account
+ * no live two-step order (`account::EPendingOrders`).
+ */
+export interface ApiParchmentTransferAccountTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    recipient: string;
+    shared?: ApiParchmentSharedVersions;
+}
+export interface ApiParchmentStakeTxBody {
+    walletAddress: string;
+    coin: ApiParchmentCoinRef;
+    shared?: ApiParchmentSharedVersions;
+}
+export interface ApiParchmentUnstakeTxBody {
+    walletAddress: string;
+    amount: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+export interface ApiParchmentClaimTxBody {
+    walletAddress: string;
+    shared?: ApiParchmentSharedVersions;
+}
+/**
+ * `release-unlocked`: `locked_mint::release_unlocked` pays the vested part of `who`'s locked
+ * PARCHMENT to `who` (default: the sender). Permissionless; it always pays the ledger owner.
+ */
+export interface ApiParchmentReleaseUnlockedTxBody {
+    walletAddress: string;
+    who?: string;
+    /**
+     * Append `staking::sync_locked` for the ledger's owner. The SDK adds it to `tx` itself (ids from
+     * `/config`); it is not sent to the API, and `txBytesBase64` is the API's kind without it.
+     */
+    syncLocked?: boolean;
+    shared?: ApiParchmentSharedVersions;
+}
+/** `exit-early`: the sender leaves the vest now, forfeiting `earlyExitPenaltyNow`. Lock-window entries stay. */
+export interface ApiParchmentExitEarlyTxBody {
+    walletAddress: string;
+    /**
+     * Append `staking::sync_locked` for the ledger's owner. The SDK adds it to `tx` itself (ids from
+     * `/config`); it is not sent to the API, and `txBytesBase64` is the API's kind without it.
+     */
+    syncLocked?: boolean;
+    shared?: ApiParchmentSharedVersions;
+}
+/**
+ * `exit-early-bounded`: exit only the approved entries, at most `maxPenalty` forfeited.
+ * Pass the profile's `earlyExitUnlocks` and `earlyExitPenaltyNow` the owner was shown. Entries that
+ * unlock later stay, and the penalty only falls with time, so the quote stays valid until signed.
+ */
+export interface ApiParchmentExitEarlyBoundedTxBody {
+    walletAddress: string;
+    /** `unlock_ms` of each approved entry (`earlyExitUnlocks`). At least one, at most 244 (`max_buckets`). */
+    unlocks: readonly bigint[];
+    /** Most PARCHMENT base units the exit may forfeit (`earlyExitPenaltyNow`). */
+    maxPenalty: bigint;
+    /**
+     * Append `staking::sync_locked` for the ledger's owner. The SDK adds it to `tx` itself (ids from
+     * `/config`); it is not sent to the API, and `txBytesBase64` is the API's kind without it.
+     */
+    syncLocked?: boolean;
+    shared?: ApiParchmentSharedVersions;
+}
+export interface ApiParchmentGrantDelegateTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    delegate: string;
+    expiryMs: string | bigint;
+    /** @deprecated Ignored. Delegate expiry is checked against the shared on-chain Clock (0x6). */
+    nowMs?: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+export interface ApiParchmentRevokeDelegateTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    delegate: string;
+    shared?: ApiParchmentSharedVersions;
+}
+/**
+ * `grant-close-delegate`: grants the service's configured close-only delegate (`config.triggerDelegate`).
+ * The body names no delegate; the service picks it.
+ */
+export interface ApiParchmentGrantCloseDelegateTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    shared?: ApiParchmentSharedVersions;
+}
+/**
+ * One transaction that grants the browser session key (`sessionDelegate`, until `expiryMs`) and the service's
+ * configured close-only delegate (`config.triggerDelegate`, no expiry; the body names no trigger delegate). The
+ * owner can revoke both with {@link ApiParchmentRevokeSessionAndTriggerTxBody}.
+ */
+export interface ApiParchmentGrantSessionAndTriggerTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    sessionDelegate: string;
+    expiryMs: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+/** One transaction that revokes the browser session key and the close-only trigger delegate (only the grants held). */
+export interface ApiParchmentRevokeSessionAndTriggerTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    sessionDelegate: string;
+    triggerDelegate: string;
+    shared?: ApiParchmentSharedVersions;
+}
+export type ParchmentTriggerStatus = "pending" | "armed" | "idle" | "firing" | "submitted" | "fired" | "closed" | "attached" | "void";
+/**
+ * The take-profit and stop-loss of one position (`positionId`), or of the position the open request in
+ * transaction `openTxDigest` creates (status `pending` until it finalizes). `firing` and `submitted`: a
+ * trigger's close is out (`firingKind`). `idle` rows are listed only with `stopLossDropped`.
+ */
+export interface ParchmentTrigger {
+    accountId: string;
+    owner: string;
+    positionId: bigint | null;
+    openTxDigest: string | null;
+    marketId: string;
+    isLong: boolean;
+    takeProfitWad: bigint | null;
+    stopLossWad: bigint | null;
+    /** Present when the stop signed with the open was not armed (it was past the filled position's liquidation). */
+    stopLossDropped?: ParchmentStopLossDropped;
+    status: ParchmentTriggerStatus;
+    firingKind: "tp" | "sl" | null;
+    /**
+     * Why a voided intent ended (`not_filled`, `not_in_transaction`, `ambiguous_open`, `aborted`, `over_cap`,
+     * `expired`, `attach_impossible`); voids from the last seven days are listed. Null otherwise.
+     */
+    voidReason?: string | null;
+    /** A pending intent whose open was not seen in time: kept, and it still attaches if the open lands. */
+    lapsed?: boolean;
+    /** The account has no close-only grant: nothing fires until it is granted again (the legs stay). */
+    paused?: boolean;
+}
+/** A stop signed with an open that the service dropped at the fill. */
+export interface ParchmentStopLossDropped {
+    /** Stable code: `past_liquidation` (the stop was at or past the filled position's liquidation). */
+    reason: string;
+    /** When the service dropped it, unix ms. */
+    ms: bigint;
+    /** The requested stop, 1e18. */
+    wad: bigint;
+}
+export interface ParchmentTriggers {
+    triggers: ParchmentTrigger[];
+    /** Next page's `cursor`; null on the last page. */
+    nextCursor: string | null;
+}
+/**
+ * One builder code. Amounts are base units. Chain accepts any 1-32 bytes, but the
+ * service indexes the exact bytes, yet takes codes as UTF-8 strings: use printable UTF-8 (ASCII recommended); a non-UTF-8 or
+ * NUL-containing code cannot be resolved by the service.
+ */
+/**
+ * A registered builder. It charges only an on-top fee (`feeBps` of the trader's profit) and only to
+ * accounts that approved it. `code`, `payout` and `owner` are null when the API serves none.
+ */
+export interface ParchmentBuilder {
+    id: bigint;
+    code: string | null;
+    payout: string | null;
+    owner: string | null;
+    active: boolean;
+    /** `paused` by the owner, `suspended` by the admin, `tombstoned` when the code is retired. */
+    status: "active" | "paused" | "suspended" | "tombstoned";
+    /** Created by its owner rather than registered by the admin. */
+    selfServe: boolean;
+    feeBps: bigint;
+    /** An admin suspend that also voided the fee on positions already open. */
+    revokeOpen: boolean;
+    pending: bigint;
+    totalEarned: bigint;
+}
+/** An account's approval of one builder, up to `maxFeeBps` of its profit. */
+/**
+ * A wallet's self-serve builder allowance, counted like `create_builder` on chain (* owner decision): `created` live (not tombstoned) self-serve codes it registered, whoever owns
+ * them now. Codes transferred to the wallet do not count; codes it handed on still do.
+ */
+export interface ParchmentBuilderAllowance {
+    created: bigint;
+    limit: bigint;
+    remaining: bigint;
+}
+export interface ParchmentBuilderApproval {
+    accountId: string;
+    builderId: bigint;
+    maxFeeBps: bigint;
+}
+/** Admin register. Version and digest are sent only when the caller provides them. */
+export interface ApiParchmentRegisterBuilderTxBody {
+    walletAddress: string;
+    authorityCapId: string;
+    authorityCapVersion?: string;
+    authorityCapDigest?: string;
+    code: string;
+    payout: string;
+    owner: string;
+    /** On-top fee in bps of profit, 0 to 100. */
+    feeBps: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Admin: set the self-serve creation price. Version and digest are sent only when the caller provides them. */
+export interface ApiParchmentSetBuilderCreateFeeTxBody {
+    walletAddress: string;
+    authorityCapId: string;
+    authorityCapVersion?: string;
+    authorityCapDigest?: string;
+    /** USDC base units, 0 (free) to 100_000_000 ($100). */
+    amount: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Create a code; the sender owns it. The service splits exactly `builders.createFee` from `coin`. */
+export interface ApiParchmentCreateBuilderTxBody {
+    walletAddress: string;
+    /** 3 to 32 bytes of `[a-z0-9_-]`. */
+    code: string;
+    payout: string;
+    /** On-top fee in bps of profit, 0 up to the owner limit. */
+    feeBps: string | bigint;
+    coin: ApiParchmentCoinRef;
+    shared?: ApiParchmentSharedVersions;
+}
+/** The owner's own code actions: `set-builder-fee` (with `feeBps`), `pause-builder`, `resume-builder`. */
+export interface ApiParchmentBuilderOwnerTxBody {
+    walletAddress: string;
+    builderId: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+export interface ApiParchmentSetBuilderFeeTxBody extends ApiParchmentBuilderOwnerTxBody {
+    feeBps: string | bigint;
+}
+/** One transaction: the new owner runs the code at once. The payout is unchanged. */
+export interface ApiParchmentTransferBuilderTxBody extends ApiParchmentBuilderOwnerTxBody {
+    newOwner: string;
+}
+/** The account owner's approval (AccountCap, not a delegate) of a builder's fee, 1 to 100 bps. */
+export interface ApiParchmentApproveBuilderTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    builderId: string | bigint;
+    maxFeeBps: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+/** Stops a builder's fee on later opens. Works under every pause. */
+export interface ApiParchmentRevokeBuilderApprovalTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    builderId: string | bigint;
+    shared?: ApiParchmentSharedVersions;
+}
+export interface ApiParchmentSetBuilderPayoutTxBody {
+    walletAddress: string;
+    builderId: string | bigint;
+    newPayout: string;
+    shared?: ApiParchmentSharedVersions;
+}
+/**
+ * Install the single PARCHMENT treasury cap once.
+ * Version and digest are sent only when the caller provides them.
+ */
+export interface ApiParchmentInstallTreasuryTxBody {
+    walletAddress: string;
+    authorityCapId: string;
+    authorityCapVersion?: string;
+    authorityCapDigest?: string;
+    treasuryCap: ApiParchmentCoinRef;
+    shared?: ApiParchmentSharedVersions;
+}
+/**
+ * Admin package-split setup: `parchment_trade::auth::register<C>(config, exchange, admin_cap)`.
+ * Run once per exchange after publishing `parchment_trade`; idempotent.
+ * Version and digest are sent only when the caller provides them.
+ */
+export interface ApiParchmentAuthRegisterTxBody {
+    walletAddress: string;
+    authorityCapId: string;
+    authorityCapVersion?: string;
+    authorityCapDigest?: string;
+    shared?: ApiParchmentSharedVersions;
+}
+export declare const LEADERBOARD_PERIODS: readonly ["daily", "weekly", "all", "season"];
+export declare const LEADERBOARD_METRICS: readonly ["pnl", "pnlPct", "volume", "winStreak", "xp"];
+export type ParchmentLeaderboardPeriod = (typeof LEADERBOARD_PERIODS)[number];
+export type ParchmentLeaderboardBy = (typeof LEADERBOARD_METRICS)[number];
+/** One wallet's game state. Amounts are base units. XP is notional. */
+export interface ParchmentGame {
+    walletAddress: string;
+    xp: bigint;
+    seasonXp: bigint;
+    seasonId: bigint;
+    tier: bigint;
+    streak: bigint;
+    winStreak: bigint;
+    crates: bigint;
+    trades: bigint;
+    /** Unlocked achievement ids, completed quest ids and owned cosmetic ids. */
+    achievements?: bigint[];
+    questsDone?: bigint[];
+    cosmetics?: bigint[];
+    /** Issued PARCHMENT (base units): all-time, today (UTC), and accrued-but-uncollected. */
+    minted?: bigint;
+    mintedToday?: bigint;
+    pendingMint?: bigint;
+    /** UTC day number of the last daily claim, or null. Daily claims grant XP only. */
+    lastDailyDay?: bigint | null;
+    dailyClaimedToday?: boolean;
+    /** Retained-fee credit in USDC base units (wash/self trades excluded on-chain). */
+    feeCredit?: bigint;
+    feeCreditUsed?: bigint;
+    achievementMintFractionBps?: bigint;
+    feeAchievements?: ParchmentFeeAchievement[];
+    /**
+     * Locked mint + 30-day vest (`locked_mint`). `current` when the seven figures below come from
+     * the wallet's current ledger; `rebuilding` / `failed` while the service reconstructs it, and then
+     * every figure is null (unknown, not zero). Absent on older services.
+     */
+    lockedLedgerStatus?: ParchmentLockedLedgerStatus;
+    /** Everything held in the wallet's locked-mint ledger (`locked_mint::locked_balance`). */
+    lockedBalance?: bigint | null;
+    /** The part still inside the 7-day lock (cannot be released or exited). */
+    lockWindowBalance?: bigint | null;
+    /** `locked_mint::next_unlock_ms`; 0 when nothing is still inside the lock. */
+    nextUnlockMs?: bigint | null;
+    /** Unlocked and vesting. */
+    vestingBalance?: bigint | null;
+    /** Vested now: what `release-unlocked` pays the owner. */
+    releasableNow?: bigint | null;
+    /** What `exit-early` would pay now (vested in full plus unvested less the penalty). */
+    earlyExitPaidNow?: bigint | null;
+    /** What `exit-early` would forfeit now (dripped to stakers over 7 days). */
+    earlyExitPenaltyNow?: bigint | null;
+    /** `unlock_ms` of the entries that penalty covers: the `unlocks` for `exit-early-bounded`. */
+    earlyExitUnlocks?: bigint[] | null;
+}
+export declare const LOCKED_LEDGER_STATUSES: readonly ["current", "rebuilding", "failed"];
+export type ParchmentLockedLedgerStatus = (typeof LOCKED_LEDGER_STATUSES)[number];
+/**
+ * A FEES_PAID (kind-8) achievement: the only game path that can mint PARCHMENT. Full or wait
+ *: active rungs are settled in `(feesRequired, id)` order, and a met rung pays its
+ * full `mintAmount` only when the fee credit not yet consumed by earlier rungs covers
+ * `ceil(mintAmount x 10000 / (100000 x fraction))` (USDC base units). Otherwise it stays locked
+ * and pays nothing; it never pays part of its mint.
+ */
+export interface ParchmentFeeAchievement {
+    id: bigint;
+    name: string | null;
+    /** Lifetime retained fees (USDC base units, `feeCredit`) the rung's criterion needs. */
+    feesRequired: bigint;
+    /**
+     * More fee credit (USDC base units) after which a settle is guaranteed to pay this rung: 0 when
+     * `eligibleMint` is set or once unlocked; otherwise max(feesRequired - feeCredit, the ceil cost
+     * of this rung and every earlier locked active rung - (feeCredit - feeCreditUsed)). Can exceed
+     * `feesRequired - feeCredit`. A zero-mint rung, or any rung at fraction 0 (no mint can pay),
+     * reports only the threshold gap. Meaningless while `unlockable` is false.
+     */
+    feesNeeded: bigint;
+    xp: bigint;
+    mintAmount: bigint;
+    /** `mintAmount` when the next settle would pay this rung with no new fees, else 0; 0 once unlocked. */
+    eligibleMint: bigint;
+    /** What the rung pays when it unlocks: always the full `mintAmount`; 0 once unlocked. */
+    mintAtUnlock: bigint;
+    active: boolean;
+    unlocked: boolean;
+    /**
+     * False when no fee top-up can unlock this locked rung under the current config (inactive, a
+     * mint at fraction 0, or a threshold or own cost past the u64 fee-credit ceiling); true once unlocked. Optional:
+     * older services don't serve it.
+     */
+    unlockable?: boolean;
+}
+export interface ParchmentQuestDefinition {
+    id: bigint;
+    name: string | null;
+    kind: bigint;
+    param: bigint;
+    xp: bigint;
+    cosmetic: bigint | null;
+    active: boolean;
+    startMs: bigint;
+    endMs: bigint;
+    seasonId: bigint;
+}
+export interface ParchmentAchievementDefinition {
+    id: bigint;
+    name: string | null;
+    kind: bigint;
+    param: bigint;
+    xp: bigint;
+    mintAmount: bigint;
+    cosmetic: bigint | null;
+    active: boolean;
+}
+export interface ParchmentGameDefinitions {
+    quests: ParchmentQuestDefinition[];
+    achievements: ParchmentAchievementDefinition[];
+    cosmetics: {
+        id: bigint;
+        name: string;
+    }[];
+    achievementMintFractionBps: bigint;
+}
+/** Per-row activity for the requested leaderboard period. */
+export interface ParchmentLeaderboardStats {
+    trades: bigint;
+    closes: bigint;
+    wins: bigint;
+    volume: bigint;
+    pnl: bigint;
+    winRateBps: bigint | null;
+    xp: bigint;
+    tier: bigint;
+    winStreak: bigint;
+}
+export interface ParchmentLeaderboardRow {
+    rank: bigint;
+    walletAddress: string;
+    value: bigint;
+    stats?: ParchmentLeaderboardStats;
+}
+export interface ParchmentLeaderboard {
+    period: ParchmentLeaderboardPeriod;
+    by: ParchmentLeaderboardBy;
+    rows: ParchmentLeaderboardRow[];
+    viewer: ParchmentLeaderboardRow | null;
+    /** Offset of the next page (pass it back as `cursor`); null on the last page. */
+    nextCursor: bigint | null;
+}
+/** Arguments of `Parchment.getLeaderboard`. */
+export interface ParchmentLeaderboardQuery {
+    period: ParchmentLeaderboardPeriod;
+    by: ParchmentLeaderboardBy;
+    /** Adds the wallet's own row as `viewer`. */
+    walletAddress?: string;
+    /** Row offset from a previous page's `nextCursor` (decimal). Omitted = first page. */
+    cursor?: string | number | bigint | null;
+    /** Page size, 1..=u64::MAX; the service defaults to 50 and caps at 200. */
+    limit?: number | bigint;
+    /** Window reference time in ms, 0..=i64::MAX (daily/weekly/season bounds). Omitted = now. */
+    nowMs?: string | number | bigint;
+}
+export interface ParchmentFeedEntry {
+    walletAddress: string;
+    marketId: string;
+    positionId: bigint;
+    pnl: bigint;
+    notional: bigint;
+    atMs: bigint;
+    side?: "long" | "short" | null;
+    isLong?: boolean | null;
+    leverage?: bigint | null;
+    /** service `game_scores.kind`: "open" (whale opens), "close" or "liquidate" (rekt feed). */
+    kind?: "open" | "close" | "liquidate" | (string & {});
+    /** Exit price from PositionExitEventV1 (fill for a close, storage mid for a liquidation). */
+    exitWad?: bigint | null;
+}
+/** One ticker row from `/positions/recent`. */
+export interface ParchmentRecentPosition {
+    kind: "open" | "close" | "liquidate";
+    walletAddress: string;
+    marketId: string | null;
+    symbol: string | null;
+    positionId: bigint | null;
+    atMs: bigint;
+    txDigest: string;
+    isLong: boolean | null;
+    side: "long" | "short" | null;
+    notional: bigint | null;
+    margin: bigint | null;
+    leverage: bigint | null;
+    entryWad: bigint | null;
+    exitWad: bigint | null;
+    /** entryWad for an open, exitWad for a close or liquidation. */
+    priceWad: bigint | null;
+}
+export interface ParchmentMarketStats {
+    marketId: string;
+    symbol: string | null;
+    /** Opened plus closed/liquidated notional in the last 24h (USDC base units). */
+    volume24h: bigint;
+    openedNotional24h: bigint;
+    closedNotional24h: bigint;
+    opens24h: bigint;
+    closes24h: bigint;
+    openInterestLong: bigint;
+    openInterestShort: bigint;
+    /** The newest price point at or before `sinceMs` (WAD); null while the market's history is younger. */
+    price24hAgoWad: bigint | null;
+    price24hAgoTsMs: bigint | null;
+}
+export interface ParchmentMarketStatsResponse {
+    sinceMs: bigint;
+    untilMs: bigint;
+    markets: ParchmentMarketStats[];
+}
+export interface ParchmentLpQueue {
+    queueLength: bigint;
+    totalOwed: bigint;
+    /** Null until `exchange_state.lp_cash` is indexed (fresh deploy). */
+    lpCash: bigint | null;
+    head: unknown;
+    claims: unknown;
+}
+export interface ParchmentFeed {
+    entries: ParchmentFeedEntry[];
+}
+export interface ParchmentPnlCard {
+    positionId: bigint;
+    walletAddress: string;
+    marketId: string;
+    pnl: bigint;
+    /** PnL over margin in basis points (`pnl * 10000 / margin`, integer): "1234" is 12.34%. */
+    pnlPct: bigint;
+    isLong: boolean;
+    /**
+     * Whether the service has indexed the position's close / liquidation (its `pnl` is then the
+     * realized, fee-inclusive result; before that it serves 0). Undefined when the service doesn't
+     * serve the flag (older deployments).
+     */
+    settled?: boolean;
+}
+/**
+ * Account-cap body for game actions. Only collect-mint issues PARCHMENT;
+ * daily, quest and crate rewards are XP/cosmetics. No `questId` and no treasury cap.
+ * Version and digest are sent only when provided.
+ */
+export interface ApiParchmentGameTxBody extends ApiParchmentAccountCap {
+    walletAddress: string;
+    accountId: string;
+    shared?: ApiParchmentSharedVersions;
+}
+export interface ApiParchmentClaimQuestTxBody extends ApiParchmentGameTxBody {
+    questId: string | bigint;
+}
+/** `open-crates` body: the game account-cap body plus the batch size. */
+export interface ApiParchmentOpenCratesTxBody extends ApiParchmentGameTxBody {
+    /**
+     * Crates to open in one transaction, a u64 of at least 1 (no app-level cap; the chain bounds it by
+     * the crates owned and Sui's per-transaction limits): a safe integer, a bigint or a decimal digit string. Anything else is a local `count_required` (missing or empty) or `bad_count`.
+     */
+    count: number | bigint | string;
+}
+/**
+ * `GET /staking`: the `parchment_token::staking` pool. Staker rewards stream linearly
+ * (`streamRemaining` vests until `streamEndMs`; each deposit re-streams the unvested remainder
+ * plus the new amount over `rewardStreamMs`). Amounts are base units, times are Unix ms
+ * strings. `null` from the API until the pool is indexed.
+ */
+export interface ParchmentStakingPool {
+    poolId: string;
+    configId: string | null;
+    totalStaked: bigint;
+    /** `acc_reward_per_share`, scaled by 1e27. */
+    accRewardPerShare: string;
+    /** Unvested staker rewards as of `streamLastMs` (`staking::stream_remaining`). */
+    streamRemaining: bigint;
+    streamLastMs: bigint;
+    /** `stream_remaining` is fully vested at this time (`staking::stream_end_ms`). */
+    streamEndMs: bigint;
+    /** The part of `streamRemaining` vested by `nowMs` and not yet credited to the index. */
+    streamVestedNow: bigint;
+    /** Vesting window for the next deposit (default 7 days; maximum is admin-configurable). */
+    rewardStreamMs: bigint;
+    /** Stake lock after each stake increase (default 0; maximum is admin-configurable). */
+    minStakeLockMs: bigint;
+    rewards: bigint;
+    /** Treasury-funded reserve for owed staking referral bonuses (`fund_referral_bonuses`); never above what is owed. */
+    referralReserve: bigint;
+    nowMs: bigint;
+    /** Swept vest early-exit penalties (PARCHMENT) dripping to stakers, as of `parchDripLastMs`. Absent on older services. */
+    parchDripRemaining?: bigint;
+    /** `parchDripRemaining` projected to `nowMs`. */
+    parchDripNow?: bigint;
+    parchDripLastMs?: bigint;
+    /** Projected end of the drip (moves forward while nobody stakes). */
+    parchDripEndMs?: bigint;
+    /**
+     * Locked yield: the USDC index is per unit of `totalWeight` = `totalStaked` +
+     * `lockedWeight` (all owners' locked weight as of their last sync). Absent on older services.
+     */
+    totalWeight?: bigint;
+    lockedWeight?: bigint;
+    /** Locked weight per locked or vesting PARCHMENT, bps (default 5000); null on a pool without locked yield. */
+    lockedWeightBps?: bigint | null;
+    /** Locked yield banked by syncs and not yet paid, all owners (`staking::locked_owed_total`). */
+    lockedOwedTotal?: bigint;
+}
+/** `GET /staking/{owner}`: one staker's position. */
+export interface ParchmentStaker {
+    owner: string;
+    staked: bigint;
+    rewardDebt: string;
+    stakedAtMs: bigint;
+    /** `staking::unlock_at_ms`: unstake aborts `EStakeLocked` (11) before this time. "0" without a position. */
+    unlockAtMs: bigint;
+    locked: boolean;
+    /** `staking::pending_now` at `nowMs`: includes the stream slice vested since the last accrual. */
+    pendingReward: bigint;
+    /**
+     * PARCHMENT owed from the forfeit drip (`staking::parch_pending`, 9 dp base units), paid by
+     * claim / stake / unstake. Absent on services that don't serve it yet (treat as 0).
+     */
+    parchPending?: bigint;
+    /**
+     * False when the service cannot serve `pendingReward` exactly (e.g. its copy of the reward debt is
+     * stale or unknown, or only a lower bound): `pendingReward` is then an estimate. Absent on services
+     * that don't serve it yet (treat as exact).
+     */
+    pendingRewardExact?: boolean;
+    /**
+     * Locked yield, absent on older services (treat as 0). `lockedWeight` is the weight as of
+     * the owner's last `sync_locked`, set from `lockedSyncedBalance` (a later ledger change counts
+     * after the next sync); `lockedPending` is `staking::locked_pending_now` at `nowMs`, of which
+     * `lockedOwed` is already banked. A claim pays `pendingReward + lockedPending` (the locked part
+     * books no referral bonus). `totalWeight` is `staked + lockedWeight`.
+     */
+    lockedWeight?: bigint;
+    lockedSyncedBalance?: bigint;
+    lockedPending?: bigint;
+    lockedOwed?: bigint;
+    totalWeight?: bigint;
+    nowMs: bigint;
+}
+/**
+ * Actions the gas sponsor serves: only the
+ * trade-only `*-as-delegate` kinds a session key signs. Owner (`AccountCap`) transactions, expire-order, deposit,
+ * withdraw, delegate changes, liquidate, ... are never sponsored.
+ */
+export declare const PARCHMENT_SPONSORED_ACTIONS: readonly ["request-open-as-delegate", "request-close-as-delegate", "cancel-order-as-delegate", "emergency-close-as-delegate", "close-retired-as-delegate"];
+export type ParchmentSponsoredAction = (typeof PARCHMENT_SPONSORED_ACTIONS)[number];
+/** `POST /api/parchment/sponsor` body: a session key's `*-as-delegate` trade kind. The account is read from the kind. */
+export interface ApiParchmentSponsorBody {
+    /** The session key's address (the delegate), sent as `sender`: the sender of the kind and of the sponsored tx. */
+    walletAddress: string;
+    /** Base64 BCS `TransactionKind`: {@link ParchmentBuiltTx.txBytesBase64}, or `tx.build({ onlyTransactionKind: true })`. */
+    txKindBase64: string;
+    /** The session key's personal-message signature of the proof (`signSponsorProof`). */
+    senderSignature: string;
+    /** Unix ms after which the service refuses the proof; at most 120 s ahead of its clock. */
+    expiresAtMs: bigint;
+}
+/**
+ * `POST /api/parchment/sponsor` 200 `data`. The session key signs `txBytesBase64` (full `TransactionData`, gas owner =
+ * sponsor, address-balance gas) unchanged; execute with `[sessionSignature, sponsorSignature]` within `validEpoch`.
+ * Amounts are MIST.
+ */
+export interface ParchmentSponsoredTx {
+    txBytesBase64: string;
+    sponsorSignature: string;
+    digest: string;
+    sender: string;
+    sponsor: string;
+    action: ParchmentSponsoredAction | string;
+    gasMode: string;
+    gasBudget: bigint;
+    gasPrice: bigint;
+    /** Simulated computation + storage (MIST), before the storage rebate. */
+    estimatedGas: bigint;
+    /** The only epoch the transaction can execute in. */
+    validEpoch: bigint;
+}
+export {};