@parchment-trade/sdk 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,53 @@
+import type { ApiParchmentConfigResponse } from "./parchmentTypes.js";
+/**
+ * Modules whose published call targets live in `parchment_trade`. `game_events` is not one of
+ * them: its emitters are `public(package)` in `parchment_game`.
+ */
+export declare const PARCHMENT_TRADE_MODULES: readonly ["trade", "order", "oracle", "game", "game_book", "referral", "builder", "fees", "fee_mint", "launch", "keeper", "auth", "locked_mint", "mint_cap", "harvest", "account_transfer", "event_guard"];
+/**
+ * Modules that moved from core `parchment` into `parchment_base`. Call targets use
+ * `basePackageId`. A missing id is null; the core package is not a fallback.
+ */
+export declare const PARCHMENT_BASE_MODULES: readonly ["builder_book", "holder_book", "liq_book", "lp", "position", "safety", "constants"];
+export type ParchmentTradeModule = (typeof PARCHMENT_TRADE_MODULES)[number];
+/**
+ * Published call targets that stayed in core `parchment`. `extended_field` and `init` are not
+ * call targets. `game_events` is not in this list: its emitters are `public(package)`.
+ */
+export declare const PARCHMENT_CORE_MODULES: readonly ["access", "account", "authority", "config", "events", "exchange", "market", "referral_book", "timelock"];
+type PackageIds = Pick<ApiParchmentConfigResponse, "packageId" | "tradePackageId" | "tradePackageIds" | "basePackageId">;
+/** Whether `module` lives in `parchment_trade`. */
+export declare function isParchmentTradeModule(module: string): module is ParchmentTradeModule;
+/**
+ * Package id for a Move call target `${id}::${module}::${fn}`: the latest `parchment_trade` for
+ * moved modules, `basePackageId` for `parchment_base`, the core package for modules that stayed
+ * there. Null when that package is not configured. A module with no published call target
+ * (`game_events`, or any other name) throws. `parchment_oracle::adapter` and `parchment_token`
+ * modules are not covered.
+ */
+export declare function parchmentCallPackageId(config: PackageIds, module: string): string | null;
+type OriginalPackageIds = Pick<ApiParchmentConfigResponse, "packageId" | "packageIds" | "tradePackageId" | "tradePackageIds" | "basePackageId" | "basePackageIds" | "gamePackageId" | "gamePackageIds" | "mintPackageId" | "mintPackageIds">;
+/**
+ * Defining (original) `parchment_trade` id for type strings that still live there, such as
+ * `${id}::oracle::PriceReceipt` and `${id}::fees::StakingSink`.
+ * `game_book` and `game_events` types use {@link parchmentGameTypePackageId}. `locked_mint` and
+ * `mint_cap` types use {@link parchmentMintTypePackageId}. This function returns only the trade type id.
+ */
+export declare function parchmentTradeTypePackageId(config: PackageIds): string | null;
+/** Defining (original) core `parchment` id. Move calls use `packageId` (the latest). */
+export declare function parchmentCoreTypePackageId(config: Pick<OriginalPackageIds, "packageId" | "packageIds">): string | null;
+/** Defining (original) `parchment_base` id. */
+export declare function parchmentBaseTypePackageId(config: Pick<OriginalPackageIds, "basePackageId" | "basePackageIds">): string | null;
+/** Defining (original) `parchment_game` id (`game_book`, `game_events`). */
+export declare function parchmentGameTypePackageId(config: Pick<OriginalPackageIds, "gamePackageId" | "gamePackageIds">): string | null;
+/** Defining (original) `parchment_mint` id (`MintCapKey`, `locked_mint`, `mint_cap`). */
+export declare function parchmentMintTypePackageId(config: Pick<OriginalPackageIds, "mintPackageId" | "mintPackageIds">): string | null;
+/**
+ * A configured `/config` (a core or trade package id) must name the split packages. An
+ * unconfigured response, with both ids empty, still loads. There is no fallback to the trade
+ * package id. A mint id that is a trade package id is rejected: that address derives the wrong
+ * `MintCapKey` field. Any other shared id among core, trade, base, game and mint is rejected too.
+ * The same id twice in one list is rejected. A singular id that repeats the list's only entry is not.
+ */
+export declare function requireSplitPackageIds<T extends OriginalPackageIds>(config: T): T;
+export {};

package/dist/packages/parchment/packageIds.js

@@ -0,0 +1,149 @@
+import { normalizeSuiAddress } from "@mysten/sui/utils";
+import { ParchmentApiError } from "../../general/utils/errors.js";
+export const PARCHMENT_TRADE_MODULES = [
+    "trade",
+    "order",
+    "oracle",
+    "game",
+    "game_book",
+    "referral",
+    "builder",
+    "fees",
+    "fee_mint",
+    "launch",
+    "keeper",
+    "auth",
+    "locked_mint",
+    "mint_cap",
+    "harvest",
+    "account_transfer",
+    "event_guard",
+];
+export const PARCHMENT_BASE_MODULES = [
+    "builder_book",
+    "holder_book",
+    "liq_book",
+    "lp",
+    "position",
+    "safety",
+    "constants",
+];
+export const PARCHMENT_CORE_MODULES = [
+    "access",
+    "account",
+    "authority",
+    "config",
+    "events",
+    "exchange",
+    "market",
+    "referral_book",
+    "timelock",
+];
+export function isParchmentTradeModule(module) {
+    return PARCHMENT_TRADE_MODULES.includes(module);
+}
+export function parchmentCallPackageId(config, module) {
+    if (isParchmentTradeModule(module))
+        return config.tradePackageId;
+    if (PARCHMENT_BASE_MODULES.includes(module)) {
+        return config.basePackageId ?? null;
+    }
+    if (PARCHMENT_CORE_MODULES.includes(module))
+        return config.packageId;
+    const message = module === "game_events"
+        ? "game_events is not a published call target; its emitters are public(package) in parchment_game"
+        : `${module} is not a published call target`;
+    throw new ParchmentApiError(0, "unpublished_module", message);
+}
+function originalPackageId(list, single) {
+    const listed = list?.find(nonempty);
+    if (listed)
+        return listed;
+    return nonempty(single) ? single : null;
+}
+export function parchmentTradeTypePackageId(config) {
+    return originalPackageId(config.tradePackageIds, config.tradePackageId);
+}
+export function parchmentCoreTypePackageId(config) {
+    return originalPackageId(config.packageIds, config.packageId);
+}
+export function parchmentBaseTypePackageId(config) {
+    return originalPackageId(config.basePackageIds, config.basePackageId);
+}
+export function parchmentGameTypePackageId(config) {
+    return originalPackageId(config.gamePackageIds, config.gamePackageId);
+}
+export function parchmentMintTypePackageId(config) {
+    return originalPackageId(config.mintPackageIds, config.mintPackageId);
+}
+function nonempty(id) {
+    return typeof id === "string" && id.length > 0;
+}
+function canonPackageId(id) {
+    try {
+        return normalizeSuiAddress(id);
+    }
+    catch {
+        return id;
+    }
+}
+function packageIdList(single, list) {
+    const ids = [...(list ?? [])];
+    if (nonempty(single))
+        ids.push(single);
+    return ids.filter(nonempty).map(canonPackageId);
+}
+function duplicatePackageId(list) {
+    const seen = new Set();
+    for (const id of list ?? []) {
+        if (!nonempty(id))
+            continue;
+        const canon = canonPackageId(id);
+        if (seen.has(canon))
+            return true;
+        seen.add(canon);
+    }
+    return false;
+}
+export function requireSplitPackageIds(config) {
+    if (!nonempty(config.packageId) && !nonempty(config.tradePackageId))
+        return config;
+    const missing = ["basePackageId", "gamePackageId", "mintPackageId"].filter((name) => !nonempty(config[name]));
+    if (missing.length > 0) {
+        throw new ParchmentApiError(0, "split_packages_unset", `config is missing ${missing.join(", ")}; it does not fall back to the trade package`);
+    }
+    const lists = [
+        ["packageIds", config.packageIds],
+        ["tradePackageIds", config.tradePackageIds],
+        ["basePackageIds", config.basePackageIds],
+        ["gamePackageIds", config.gamePackageIds],
+        ["mintPackageIds", config.mintPackageIds],
+    ];
+    for (const [name, list] of lists) {
+        if (duplicatePackageId(list)) {
+            throw new ParchmentApiError(0, "package_ids_duplicate", `${name} lists an id more than once; ids in one package list must be unique`);
+        }
+    }
+    const groups = [
+        ["packageId", packageIdList(config.packageId, config.packageIds)],
+        ["tradePackageId", packageIdList(config.tradePackageId, config.tradePackageIds)],
+        ["basePackageId", packageIdList(config.basePackageId, config.basePackageIds)],
+        ["gamePackageId", packageIdList(config.gamePackageId, config.gamePackageIds)],
+        ["mintPackageId", packageIdList(config.mintPackageId, config.mintPackageIds)],
+    ];
+    const trade = new Set(groups[1][1]);
+    if (groups[4][1].some((id) => trade.has(id))) {
+        throw new ParchmentApiError(0, "mint_package_is_trade", "mintPackageId is a trade package id; MintCapKey is defined in parchment_mint, not parchment_trade");
+    }
+    for (let i = 0; i < groups.length; i++) {
+        for (let j = i + 1; j < groups.length; j++) {
+            if (groups[i][0] === "tradePackageId" && groups[j][0] === "mintPackageId")
+                continue;
+            const left = new Set(groups[i][1]);
+            if (groups[j][1].some((id) => left.has(id))) {
+                throw new ParchmentApiError(0, "package_ids_overlap", `${groups[i][0]} and ${groups[j][0]} share an id; package lists must be disjoint`);
+            }
+        }
+    }
+    return config;
+}

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

@@ -0,0 +1,442 @@
+import { type ParchmentMonitoring, type ParchmentStakingHistory, type ParchmentStakingHistoryDays, type ParchmentStatsActivity } from "./monitoring.js";
+import { Caller } from "../../general/utils/caller.js";
+import type { ParchmentOptions, RequestOptionsUpdate } from "../../general/types/configTypes.js";
+import { ParchmentAccount } from "./parchmentAccount.js";
+import { ParchmentMarket } from "./parchmentMarket.js";
+import type { ParchmentLivePrice, ParchmentTrade, ApiParchmentSponsorBody, ParchmentSponsoredTx, ApiParchmentBindReferrerTxBody, ApiParchmentBindTradingReferrerTxBody, ApiParchmentTransferAccountTxBody, ApiParchmentClaimQuestTxBody, ApiParchmentClaimTxBody, ApiParchmentExitEarlyBoundedTxBody, ApiParchmentExitEarlyTxBody, ApiParchmentReleaseUnlockedTxBody, ApiParchmentClosePreviewBody, ApiParchmentClosePreviewResponse, ApiParchmentCancelOrderAsDelegateTxBody, ApiParchmentCancelOrderTxBody, ApiParchmentConfigResponse, ApiParchmentEmergencyCloseAsDelegateTxBody, ApiParchmentEmergencyCloseTxBody, ApiParchmentCloseRetiredAsDelegateTxBody, ApiParchmentCloseRetiredTxBody, ApiParchmentExpireOrderTxBody, ApiParchmentOrdersQuery, ApiParchmentOrdersResponse, ApiParchmentRequestCloseAsDelegateTxBody, ApiParchmentRequestCloseTxBody, ApiParchmentRequestOpenAsDelegateTxBody, ApiParchmentRequestOpenTxBody, Order, ApiParchmentDepositTxBody, ApiParchmentGameTxBody, ApiParchmentOpenCratesTxBody, ApiParchmentGrantDelegateTxBody, ApiParchmentGrantCloseDelegateTxBody, ApiParchmentGrantSessionAndTriggerTxBody, ApiParchmentRevokeSessionAndTriggerTxBody, ParchmentTrigger, ParchmentTriggers, ApiParchmentInstallTreasuryTxBody, ApiParchmentAuthRegisterTxBody, ApiParchmentLiquidateTxBody, ApiParchmentHistoryBody, ApiParchmentHistoryResponse, ApiParchmentEquityHistoryBody, ApiParchmentEquityHistoryResponse, ApiParchmentLimitsResponse, ApiParchmentLpHarvestTxBody, ApiParchmentSweepTxBody, ApiParchmentSweepSurplusTxBody, ApiParchmentClaimPendingMintTxBody, ApiParchmentLpResponse, ParchmentStaker, ParchmentStakingPool, ApiParchmentOpenAccountTxBody, ApiParchmentOpenPreviewBody, ApiParchmentOpenPreviewResponse, ApiParchmentPositionsResponse, ParchmentPageQuery, ApiParchmentPriceHistoryBody, ApiParchmentPriceHistoryResponse, ApiParchmentCandlesBatchBody, ApiParchmentCandlesBatchResponse, ApiParchmentCandlesBody, ApiParchmentCandlesResponse, ApiParchmentPricesResponse, ApiParchmentProtocolResponse, ApiParchmentReferralsResponse, ApiParchmentRegisterBuilderTxBody, ApiParchmentCreateBuilderTxBody, ApiParchmentSetBuilderCreateFeeTxBody, ApiParchmentSetBuilderFeeTxBody, ApiParchmentBuilderOwnerTxBody, ApiParchmentTransferBuilderTxBody, ApiParchmentApproveBuilderTxBody, ApiParchmentRevokeBuilderApprovalTxBody, ApiParchmentRevokeDelegateTxBody, ApiParchmentSetBuilderPayoutTxBody, ApiParchmentStakeTxBody, ApiParchmentUnstakeTxBody, ApiParchmentWithdrawTxBody, ParchmentAccountQueue, ParchmentBuiltTx, ParchmentBuilder, ParchmentBuilderAllowance, ParchmentBuilderApproval, ParchmentFeed, ParchmentGame, ParchmentLeaderboard, ParchmentLeaderboardQuery, ParchmentGameDefinitions, ParchmentRecentPosition, ParchmentMarketStatsResponse, ParchmentLpQueue, ParchmentPnlCard, ParchmentQueue, ParchmentTradingReferral } from "./parchmentTypes.js";
+import { type TriggerProofInput, type TriggerSigner } from "./triggers.js";
+/**
+ * Parchment API client.
+ *
+ * Construct it with {@link Parchment.create}. The caller prefix is `"parchment"`,
+ * so requests resolve under `{baseUrl}/api/parchment/...`.
+ *
+ * Reads use {@link Caller.fetchApi}. Transaction builders use
+ * {@link Caller.fetchApiTxObject} and return an unsigned `Transaction`.
+ */
+export declare class Parchment extends Caller {
+    /**
+     * Creates a client. This does not contact the network.
+     *
+     * @param options - API origin. `baseUrl` is the origin only.
+     */
+    static create(options: ParchmentOptions): Promise<Parchment>;
+    constructor(options: ParchmentOptions);
+    /**
+     * Returns a client for the same API whose requests use these opt-in limits (see
+     * {@link RequestOptions}). A field left out (or `undefined`) keeps this client's value; an explicit
+     * `null` clears it, e.g. `{ signal: null }` drops an inherited signal. This client is unchanged.
+     *
+     * @example
+     * const order = await parchment.withRequestOptions({ timeoutMs: 5_000 }).getOrder(orderId);
+     */
+    withRequestOptions(options: RequestOptionsUpdate): Parchment;
+    getConfig(): Promise<ApiParchmentConfigResponse>;
+    getLimits(): Promise<ApiParchmentLimitsResponse>;
+    getMarkets(): Promise<{
+        markets: ParchmentMarket[];
+    }>;
+    getMarket(input: {
+        marketId: string;
+    }): Promise<ParchmentMarket>;
+    getPriceHistory(input: ApiParchmentPriceHistoryBody): Promise<ApiParchmentPriceHistoryResponse>;
+    /** OHLC candles of one market: the newest `limit` intervals of `[fromMs, toMs]` (at most 500), oldest first. */
+    getCandles(input: ApiParchmentCandlesBody): Promise<ApiParchmentCandlesResponse>;
+    /**
+     * {@link getCandles} for up to 12 markets in one request (`GET /markets/candles`), one window for all: a
+     * multi-chart layout's load and poll. `series` has one entry per market, in `marketIds` order (repeats
+     * dropped); a market that fails carries its own `error` (`code`, `message`) instead of `candles`, and the
+     * others are still served. No market, a malformed id (`bad_request`) or more than 12 (`too_many_markets`)
+     * throws without a request.
+     */
+    getCandlesBatch(input: ApiParchmentCandlesBatchBody): Promise<ApiParchmentCandlesBatchResponse>;
+    getPrices(): Promise<ApiParchmentPricesResponse>;
+    /**
+     * URL of the display-only live price stream for an `EventSource`: `GET prices/stream`, Server-Sent
+     * Events `price` (decode with {@link parseLivePrice}) and `heartbeat` (every 15 s). `marketIds`
+     * narrows it (at most 64). A 503 (`stream_unavailable` on a service without live prices, or
+     * `overloaded`) means: keep polling {@link getPrices}.
+     */
+    pricesStreamUrl(input?: {
+        marketIds?: readonly string[];
+    }): string;
+    /**
+     * URL of the live trade stream for an `EventSource`: `GET trades/stream`, Server-Sent Events
+     * `trade` (every trader's opens, closes and liquidations; decode with {@link parseTrade}; the
+     * event's SSE id is the trade id) and `heartbeat` (every 15 s). With `after` (the last trade id
+     * received), every later trade comes, however far back, oldest first, so a new `EventSource`
+     * neither misses nor repeats any; `EventSource`'s own reconnects resume from `Last-Event-ID`.
+     * Without it a client first gets the last 30, oldest first. `reset` (data `{}`): `after` is past
+     * the newest trade (another deployment); drop the trades held and the cursor, close that
+     * `EventSource` and open a new one on a URL without `after` (its own reconnects would send the
+     * stale `after` again and reset again); the new one starts with the last 30. 503 `overloaded`:
+     * retry later.
+     */
+    tradesStreamUrl(input?: {
+        after?: bigint;
+    }): string;
+    /**
+     * Accounts, positions and queue claims are each paged (service default 50, `limit` applies to every
+     * list). Follow `accountsNextCursor` / `positionsNextCursor` / `queue.claimsNextCursor` with the
+     * matching cursor; a non-null next cursor means the list is incomplete.
+     */
+    getAccount(input: {
+        walletAddress: string;
+        limit?: number | bigint;
+        accountsCursor?: string | null;
+        positionsCursor?: string | number | bigint | null;
+        claimsCursor?: string | number | bigint | null;
+    }): Promise<ParchmentAccount>;
+    /** One page of open positions (service default 50). Follow `nextCursor` until it is null. */
+    getPositions(input: {
+        walletAddress: string;
+    } & ParchmentPageQuery): Promise<ApiParchmentPositionsResponse>;
+    /** The owner's account equity over time (hourly snapshots); `range` is `24h`, `7d`, `30d` or `all`. */
+    getEquityHistory(input: ApiParchmentEquityHistoryBody): Promise<ApiParchmentEquityHistoryResponse>;
+    getHistory(input: ApiParchmentHistoryBody): Promise<ApiParchmentHistoryResponse>;
+    getLp(): Promise<ApiParchmentLpResponse>;
+    /** Staking pool stream and lock parameters. `null` until the pool is indexed. */
+    getStakingPool(): Promise<ParchmentStakingPool | null>;
+    /**
+     * One staker's position. `pendingReward` replays `staking::pending_now` (stream vesting
+     * included); `unlockAtMs` is when `unstake` stops aborting `EStakeLocked`.
+     */
+    getStaker(input: {
+        walletAddress: string;
+    }): Promise<ParchmentStaker>;
+    /** Protocol FIFO queue. `lpCash` and `instantlyPayable` are null until known. */
+    getQueue(): Promise<ParchmentQueue>;
+    /** This wallet's place in the FIFO queue. `rank` is null when there is no claim. */
+    getAccountQueue(input: {
+        walletAddress: string;
+    }): Promise<ParchmentAccountQueue>;
+    /**
+     * Direct and second-level binds. `estimatedDirectBonus` and `estimatedSecondBonus`
+     * are estimates, not settled amounts.
+     */
+    getReferrals(input: {
+        walletAddress: string;
+        limit?: number | bigint;
+        /** `asReferrer.directNextCursor` from the previous page. */
+        directCursor?: string | null;
+        /** `asReferrer.secondLevelNextCursor` from the previous page. */
+        secondLevelCursor?: string | null;
+    }): Promise<ApiParchmentReferralsResponse>;
+    /**
+     * Trading referral for this wallet. Amounts are base units.
+     * `referrer` is null when the wallet is unbound.
+     */
+    getTradingReferral(input: {
+        walletAddress: string;
+    }): Promise<ParchmentTradingReferral>;
+    /** One builder code. Amounts are base units. */
+    getBuilder(input: {
+        code: string;
+    }): Promise<ParchmentBuilder>;
+    /** Every code this wallet owns, lowest id first. */
+    getOwnedBuilders(input: {
+        walletAddress: string;
+    }): Promise<ParchmentBuilder[]>;
+    /** This wallet's self-serve allowance: live codes it created (not codes it owns), limit 3. */
+    getBuilderAllowance(input: {
+        walletAddress: string;
+    }): Promise<ParchmentBuilderAllowance>;
+    /** The builders this trading account approved, each with its fee ceiling. */
+    getBuilderApprovals(input: {
+        accountId: string;
+    }): Promise<ParchmentBuilderApproval[]>;
+    /** This wallet's builder, or null when it has none. */
+    getAccountBuilder(input: {
+        walletAddress: string;
+    }): Promise<ParchmentBuilder | null>;
+    /**
+     * Quest, achievement and cosmetic definitions plus the fee-backed achievement mint fraction.
+     * Quests, daily claims and crates grant XP/cosmetics only; FEES_PAID achievements are the
+     * only game path that mints PARCHMENT.
+     */
+    getGameDefinitions(): Promise<ParchmentGameDefinitions>;
+    /** Game state for one wallet. XP is notional. Amounts are base units. */
+    getGame(input: {
+        walletAddress: string;
+    }): Promise<ParchmentGame>;
+    /**
+     * Ranked rows. `period` is daily, weekly, all, or season.
+     * `by` is pnl, pnlPct, volume, winStreak, or xp.
+     */
+    getLeaderboard(input: ParchmentLeaderboardQuery): Promise<ParchmentLeaderboard>;
+    /** Whale opens/closes, newest first. `limit` as the service's `?limit` (default 50, max-page-limit cap). */
+    getWhaleFeed(input?: {
+        limit?: number | bigint;
+    }): Promise<ParchmentFeed>;
+    /** Liquidations, newest first. `limit` as the service's `?limit` (default 50, max-page-limit cap). */
+    getRektFeed(input?: {
+        limit?: number | bigint;
+    }): Promise<ParchmentFeed>;
+    getPnlCard(input: {
+        positionId: string | bigint;
+    }): Promise<ParchmentPnlCard>;
+    getProtocol(): Promise<ApiParchmentProtocolResponse>;
+    /** Ticker: recent opens (entryWad), closes and liquidations (exitWad), newest first. */
+    getRecentPositions(input?: {
+        limit?: number | bigint;
+    }): Promise<ParchmentRecentPosition[]>;
+    /** Per-market 24h volume, opens/closes and open interest. */
+    getMarketStats(): Promise<ParchmentMarketStatsResponse>;
+    /**
+     * Protocol monitoring (`GET stats/monitoring`): the daily mint cap, the payout queue, side
+     * exposure against the caps, the fee split, two-step fill timing and short-hold PnL, now and per
+     * UTC day over the last `days` (the service defaults to 90 and serves at most 366).
+     */
+    getMonitoring(input?: {
+        days?: number | bigint;
+    }): Promise<ParchmentMonitoring>;
+    /**
+     * Daily trading activity (`GET stats/activity`): per-market volume, liquidations and fills and
+     * collateral deposits vs withdrawals, one row per UTC day with since-launch totals.
+     */
+    getStatsActivity(input?: {
+        days?: number | bigint;
+    }): Promise<ParchmentStatsActivity>;
+    /**
+     * Staking APR / APY history (`GET stats/staking-history?days=7|30|90|all`): the pool's realized
+     * rate over the window and its 15-minute snapshots (at most 500, oldest first).
+     */
+    getStakingHistory(input: {
+        days: ParchmentStakingHistoryDays;
+    }): Promise<ParchmentStakingHistory>;
+    /** LP vault payout queue. */
+    getLpQueue(): Promise<ParchmentLpQueue>;
+    /** Two-step orders for an owner wallet. `status` defaults to the service default. */
+    getOrders(owner: string, input?: ApiParchmentOrdersQuery): Promise<ApiParchmentOrdersResponse>;
+    /**
+     * One order. A body without the requested `orderId`, an `accountId` / `owner` / `marketId`, a
+     * known `kind` or a known `status` is `bad_body` (so {@link waitForOrder} retries it instead of
+     * treating it as final).
+     */
+    getOrder(orderId: string, signal?: AbortSignal): Promise<Order>;
+    /**
+     * Poll {@link getOrder} until the order has a known final status. Rejects with an Error after
+     * `timeoutMs`. Read errors (for example 404 before the indexer catches up) are retried.
+     * Each read is aborted at the deadline, so a hung request cannot run past `timeoutMs`.
+     * Pass `signal` to stop waiting early; the promise then rejects with the signal's reason.
+     */
+    waitForOrder(orderId: string, { timeoutMs, pollMs, signal: callerSignal }?: {
+        timeoutMs?: number;
+        pollMs?: number;
+        signal?: AbortSignal;
+    }): Promise<Order>;
+    getPreviewOpen(input: ApiParchmentOpenPreviewBody): Promise<ApiParchmentOpenPreviewResponse>;
+    getPreviewClose(input: ApiParchmentClosePreviewBody): Promise<ApiParchmentClosePreviewResponse>;
+    getOpenAccountTx(input: ApiParchmentOpenAccountTxBody): Promise<ParchmentBuiltTx>;
+    getDepositTx(input: ApiParchmentDepositTxBody): Promise<ParchmentBuiltTx>;
+    /** Withdraw. Requires `accountCapId`, the owned AccountCap. */
+    getWithdrawTx(input: ApiParchmentWithdrawTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Request a keeper-filled open (`request-open`). The keeper fills at the plain oracle mid inside
+     * the fill window, or the order is refunded/expired. No oracle update is needed. Escrows margin +
+     * the exec fee from free balance (optional wallet `topUp`). The exec fee is kept on a fill, cancel,
+     * expiry and most refunds, and returned with the escrow on pause / kill-switch refunds (outcomes 5,
+     * 6), session refunds (13) and liquidation-pause refunds (14).
+     */
+    getRequestOpenTx(input: ApiParchmentRequestOpenTxBody): Promise<ParchmentBuiltTx>;
+    /** Delegate open request. No AccountCap. */
+    getRequestOpenAsDelegateTx(input: ApiParchmentRequestOpenAsDelegateTxBody): Promise<ParchmentBuiltTx>;
+    /** Request a keeper-filled close (`request-close`). Optional wallet `topUp` covers the exec fee. */
+    getRequestCloseTx(input: ApiParchmentRequestCloseTxBody): Promise<ParchmentBuiltTx>;
+    /** Delegate close request. No AccountCap. */
+    getRequestCloseAsDelegateTx(input: ApiParchmentRequestCloseAsDelegateTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Cancel a pending order at or after `effectiveCancelAfterMs(order)`, i.e.
+     * `max(cancelAfterMs, requestedMs + 5 s)`; earlier aborts. Runs under every pause. Escrow is
+     * refunded; the exec fee is kept.
+     */
+    getCancelOrderTx(input: ApiParchmentCancelOrderTxBody): Promise<ParchmentBuiltTx>;
+    /** Delegate cancel. No AccountCap. */
+    getCancelOrderAsDelegateTx(input: ApiParchmentCancelOrderAsDelegateTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Permissionless expiry, allowed strictly after `orderExpiresAfterMs(order)` (the fill deadline
+     * for opens; for closes, `emergencyAfterMs` plus the fill-deadline span
+     * `fillDeadlineMs - requestedMs`). Earlier gives `ENotExpired`.
+     */
+    getExpireOrderTx(input: ApiParchmentExpireOrderTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Emergency close of a pending close order after `emergencyAfterMs`. `update` is the signed
+     * Lazer update the caller already has. There is no exit bound to pass, and the request's stored
+     * `acceptablePriceWad` is not checked: `order::emergency_close` passes `trade::no_price_bound()`,
+     * so the close fills at the one-step price whatever it is.
+     */
+    getEmergencyCloseTx(input: ApiParchmentEmergencyCloseTxBody): Promise<ParchmentBuiltTx>;
+    /** Delegate emergency close. No AccountCap. */
+    getEmergencyCloseAsDelegateTx(input: ApiParchmentEmergencyCloseAsDelegateTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * One-step close on a retired market (no orders there, no price bound). Runs under every pause;
+     * aborts `trade::EOracleKilled` (20) only under the market's oracle kill switch.
+     */
+    getCloseRetiredTx(input: ApiParchmentCloseRetiredTxBody): Promise<ParchmentBuiltTx>;
+    /** Delegate close on a retired market. No AccountCap. */
+    getCloseRetiredAsDelegateTx(input: ApiParchmentCloseRetiredAsDelegateTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Liquidate. A stale `update` aborts `oracle::EPriceStale` (oracle 1) in `oracle::begin_price`; a
+     * storage mid that has not crossed bust aborts `trade::ENotLiquidatable` (15). `update` is caller-supplied. Account-free: no
+     * AccountCap and no accountId. Order keepers only: any other sender aborts `trade::EKeeperOnlyLiquidation` (36). The
+     * bounty coin goes to `walletAddress`.
+     */
+    getLiquidateTx(input: ApiParchmentLiquidateTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Keeper crank over one market's liquidation book. Order keepers only: any other sender aborts
+     * `trade::EKeeperOnlyLiquidation` (36). Bounties go to `walletAddress`.
+     */
+    getSweepTx(input: ApiParchmentSweepTxBody): Promise<ParchmentBuiltTx>;
+    /** Permissionless hourly sweep: 1% of the cash above max(150% of R, $250k), at most 1% of R (launch defaults, admin-tunable). */
+    getSweepSurplusTx(input: ApiParchmentSweepSurplusTxBody): Promise<ParchmentBuiltTx>;
+    /** Mint PARCHMENT against fee-mint basis parked when the account was liquidated without it. */
+    getClaimPendingMintTx(input: ApiParchmentClaimPendingMintTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * User-triggered FIFO crank. Credits the exchange-side free balance and does
+     * not transfer a coin to the wallet. `maxEntries` defaults to 32 and must be
+     * from 1 to 128. This call takes no account objects.
+     */
+    getHarvestTx(input: ApiParchmentLpHarvestTxBody): Promise<ParchmentBuiltTx>;
+    /** Bind a staking referrer. A zero `referrer` (`0x0`) is a local `zero_referrer` (chain `staking::EZeroReferrer`, 13). */
+    getBindReferrerTx(input: ApiParchmentBindReferrerTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Bind a trading referrer. Requires `accountCapId` and `referrer`. The referrer cannot be the zero
+     * address: `0x0` is a local `zero_referrer` (chain `referral::EZeroReferrer`, 5).
+     * Version and digest are sent only when the caller provides them.
+     * Accrued credits stay in free balance and are withdrawn with `getWithdrawTx`.
+     */
+    getBindTradingReferrerTx(input: ApiParchmentBindTradingReferrerTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Transfer the whole account to `recipient` in one step (no accept). See `ApiParchmentTransferAccountTxBody`.
+     * After it lands the caller no longer owns an account and may open a new one.
+     */
+    getTransferAccountTx(input: ApiParchmentTransferAccountTxBody): Promise<ParchmentBuiltTx>;
+    getStakeTx(input: ApiParchmentStakeTxBody): Promise<ParchmentBuiltTx>;
+    getUnstakeTx(input: ApiParchmentUnstakeTxBody): Promise<ParchmentBuiltTx>;
+    /** Staking reward claim. The staker keeps 100%; a referred claim records the referrers' bonus as owed, paid from the treasury share. */
+    getClaimTx(input: ApiParchmentClaimTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * `release-unlocked`: pays the vested part of `who`'s locked PARCHMENT (default the sender) to
+     * that owner, never the caller. Permissionless; pays 0 when nothing has vested.
+     */
+    getReleaseUnlockedTx(input: ApiParchmentReleaseUnlockedTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Vest `exit-early`: the sender takes everything past the lock now, less `earlyExitPenaltyNow`.
+     * Unbounded: `locked_mint::exit_early` exits every bucket eligible when the transaction
+     * executes, with no bound on the buckets or the penalty, so a prompt left open across another
+     * bucket's unlock exits (and penalizes) that bucket too. Re-read the preview right before signing.
+     */
+    getExitEarlyTx(input: ApiParchmentExitEarlyTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Vest `exit-early-bounded`: `locked_mint::exit_early_bounded` exits only `unlocks` and
+     * aborts (`locked_mint` 5, `EPenaltyAboveMax`) above `maxPenalty`. Pass the game profile's
+     * `earlyExitUnlocks` and `earlyExitPenaltyNow` the owner confirmed.
+     */
+    getExitEarlyBoundedTx(input: ApiParchmentExitEarlyBoundedTxBody): Promise<ParchmentBuiltTx>;
+    /** Delegate expiry uses the shared on-chain Clock (0x6); legacy `nowMs` is ignored. */
+    getGrantDelegateTx(input: ApiParchmentGrantDelegateTxBody): Promise<ParchmentBuiltTx>;
+    getRevokeDelegateTx(input: ApiParchmentRevokeDelegateTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * One programmable transaction that grants the browser session key and the service's close-only
+     * trigger delegate. The wallet signs it once. The session key expires; the close-only delegate does not.
+     */
+    getGrantSessionAndTriggerTx(input: ApiParchmentGrantSessionAndTriggerTxBody): Promise<ParchmentBuiltTx>;
+    /** Revoke the browser session key and the close-only trigger delegate in one transaction. */
+    getRevokeSessionAndTriggerTx(input: ApiParchmentRevokeSessionAndTriggerTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Grant the service's configured close-only take-profit and stop-loss delegate (`config.triggerDelegate`) alone
+     * (no expiry; `getRevokeDelegateTx` removes it).
+     */
+    getGrantCloseDelegateTx(input: ApiParchmentGrantCloseDelegateTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * One page (service default 50) of the live take-profit and stop-loss rows for `walletAddress` (pending,
+     * armed, firing, submitted, and idle with `stopLossDropped`). Follow `nextCursor` until it is null.
+     */
+    getTriggers(input: {
+        walletAddress: string;
+        cursor?: string | null;
+        limit?: number | bigint;
+    }): Promise<ParchmentTriggers>;
+    /**
+     * Set both legs of one position, or of the position the open request in a signed, not yet sent
+     * transaction creates (`{ openTxDigest, marketId, isLong, openTxBytesBase64 }`; send the open only after this
+     * resolves): `signer` is the owner, who signs one proof; null clears a leg. Each leg closes the
+     * whole position. 503 `price_unavailable`: the service has no current price for the market yet;
+     * retry in a moment.
+     */
+    setTriggers(input: Omit<TriggerProofInput, "expiresAtMs">, signer: TriggerSigner, nowMs?: number): Promise<ParchmentTrigger>;
+    /**
+     * Register a builder code (admin). Requires the authority cap id, code, payout, owner, and feeBps.
+     * Version and digest are sent only when the caller provides them.
+     */
+    getRegisterBuilderTx(input: ApiParchmentRegisterBuilderTxBody): Promise<ParchmentBuiltTx>;
+    /** Point a builder's payout at a new address. Rewards already in free balance stay there. */
+    getSetBuilderPayoutTx(input: ApiParchmentSetBuilderPayoutTxBody): Promise<ParchmentBuiltTx>;
+    /** Create a code the sender owns. The service splits exactly `getConfig().builders.createFee` from `coin`. */
+    getCreateBuilderTx(input: ApiParchmentCreateBuilderTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Set the self-serve creation price (admin, `config::set_builder_create_fee`): USDC base units,
+     * 0 to 100 USDC. Read the live price from `getConfig().builders.createFee`.
+     */
+    getSetBuilderCreateFeeTx(input: ApiParchmentSetBuilderCreateFeeTxBody): Promise<ParchmentBuiltTx>;
+    /** Set the owner's code fee in bps of profit, up to the owner limit. */
+    getSetBuilderFeeTx(input: ApiParchmentSetBuilderFeeTxBody): Promise<ParchmentBuiltTx>;
+    /** Pause the owner's code: new opens stop naming it. */
+    getPauseBuilderTx(input: ApiParchmentBuilderOwnerTxBody): Promise<ParchmentBuiltTx>;
+    /** Resume an owner-paused code. An admin suspend stays. */
+    getResumeBuilderTx(input: ApiParchmentBuilderOwnerTxBody): Promise<ParchmentBuiltTx>;
+    /** Hand the code to a new owner in one transaction. The payout is unchanged. */
+    getTransferBuilderTx(input: ApiParchmentTransferBuilderTxBody): Promise<ParchmentBuiltTx>;
+    /** Approve a builder's fee on this account's profit, up to `maxFeeBps` (account owner only). */
+    getApproveBuilderTx(input: ApiParchmentApproveBuilderTxBody): Promise<ParchmentBuiltTx>;
+    /** Stop paying a builder on later opens. Works under every pause. */
+    getRevokeBuilderApprovalTx(input: ApiParchmentRevokeBuilderApprovalTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Install the single PARCHMENT treasury cap once.
+     * Version and digest are sent only when the caller provides them.
+     */
+    getInstallTreasuryTx(input: ApiParchmentInstallTreasuryTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Admin package-split setup: `parchment_trade::auth::register<C>(config, exchange, admin_cap)`
+     * registers the trade package on Config and Exchange. Run once per exchange after publishing
+     * `parchment_trade`; trading, game, fee mint and staking sinks abort until it has run.
+     * Version and digest are sent only when the caller provides them.
+     */
+    getAuthRegisterTx(input: ApiParchmentAuthRegisterTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Admin package-split setup, once per exchange after `getAuthRegisterTx`:
+     * `parchment_trade::game_book::attach<C>(config, exchange, admin_cap)` attaches the GameBook
+     * (and the GameConfig on first use). A repeat aborts `game_book::EAlreadyAttached` (0).
+     * Same body as `getAuthRegisterTx`.
+     */
+    getGameAttachTx(input: ApiParchmentAuthRegisterTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Asks the gas sponsor to pay for a session key's trade: a `*-as-delegate` kind (see {@link PARCHMENT_SPONSORED_ACTIONS};
+     * a Close All batch of up to 16 closes is one kind) whose sender, `walletAddress`, is a live delegate of the account
+     * the kind trades on. Pass the kind a builder returned (`built.txBytesBase64`) and the session key's proof for it
+     * (`signSponsorProof`: `senderSignature`, `expiresAtMs`). The session key signs the returned
+     * `txBytesBase64` unchanged (`signSessionSponsoredTx`); execute it with `[sessionSignature, sponsorSignature]` within
+     * `validEpoch`. On a rejection, {@link shouldPayOwnGas} says whether to use the wallet path instead and
+     * {@link isSessionKeyRevoked} whether to forget the session key (403 `not_delegate`).
+     * A bad sender, proof or kind is `bad_request` / `bad_tx_kind` before any request.
+     */
+    sponsorTransaction(input: ApiParchmentSponsorBody, signal?: AbortSignal): Promise<ParchmentSponsoredTx>;
+    /** Daily streak XP only; no coin result. Omits `questId`. Version and digest are sent only when provided. */
+    getClaimDailyTx(input: ApiParchmentGameTxBody): Promise<ParchmentBuiltTx>;
+    /** XP/cosmetic crate via a private entry MoveCall using on-chain randomness; no result. Omits `questId`. */
+    getOpenCrateTx(input: ApiParchmentGameTxBody): Promise<ParchmentBuiltTx>;
+    /**
+     * Open `count` crates (at least 1, no app-level cap) in one private entry MoveCall using on-chain randomness; no
+     * result, one `CrateOpened` event per crate. `count` is checked locally (`count_required` / `bad_count`).
+     * The batch's tier-ups and XP crate grants are deferred to the player's next open or XP grant.
+     */
+    getOpenCratesTx(input: ApiParchmentOpenCratesTxBody): Promise<ParchmentBuiltTx>;
+    /** Claim one quest for XP/cosmetics; no coin result. Version and digest are sent only when provided. */
+    getClaimQuestTx(input: ApiParchmentClaimQuestTxBody): Promise<ParchmentBuiltTx>;
+    /** Issue pending fee-backed achievement PARCHMENT using Clock and daily caps; returns a coin to transfer. */
+    getCollectMintTx(input: ApiParchmentGameTxBody): Promise<ParchmentBuiltTx>;
+}
+/** A `prices/stream` `price` event's data as a {@link ParchmentLivePrice}; anything else is `bad_body`. */
+export declare function parseLivePrice(data: string): ParchmentLivePrice;
+/** A `trades/stream` `trade` event's data as a {@link ParchmentTrade}; anything else is `bad_body`. */
+export declare function parseTrade(data: string): ParchmentTrade;