@parchment-trade/sdk 0.0.0-stage → 1.0.1

package/dist/packages/parchment/onboarding.js

@@ -0,0 +1,48 @@
+import { bcs } from "@mysten/sui/bcs";
+import { deriveObjectID, normalizeSuiAddress } from "@mysten/sui/utils";
+function obj(tx, o) {
+    return typeof o === "string" ? tx.object(o) : o;
+}
+export function addOneSignatureOnboardingCalls(tx, input) {
+    const exchange = obj(tx, input.exchange);
+    const config = obj(tx, input.config);
+    const [account, cap, receipt] = tx.moveCall({
+        target: `${input.packageId}::exchange::new_account`,
+        typeArguments: [input.coinType],
+        arguments: [exchange, config],
+    });
+    if (input.deposit !== undefined) {
+        tx.moveCall({
+            target: `${input.packageId}::exchange::deposit`,
+            typeArguments: [input.coinType],
+            arguments: [exchange, config, account, cap, obj(tx, input.deposit)],
+        });
+    }
+    if (input.delegate) {
+        tx.moveCall({
+            target: `${input.packageId}::exchange::${input.delegate.closeDelegate === undefined ? "grant_delegate" : "grant_session_and_close_delegate"}`,
+            typeArguments: [input.coinType],
+            arguments: [
+                exchange,
+                account,
+                config,
+                cap,
+                tx.pure.address(input.delegate.address),
+                tx.pure.u64(BigInt(input.delegate.expiryMs)),
+                ...(input.delegate.closeDelegate === undefined ? [] : [tx.pure.address(input.delegate.closeDelegate)]),
+                tx.object.clock(),
+            ],
+        });
+    }
+    tx.moveCall({
+        target: `${input.packageId}::exchange::share_account`,
+        typeArguments: [input.coinType],
+        arguments: [account, cap, receipt],
+    });
+}
+const ACCOUNT_KEY = bcs.struct("AccountKey", { owner: bcs.Address, nonce: bcs.u64() });
+export function deriveAccountId(input) {
+    const keyType = `${normalizeSuiAddress(input.originalPackageId)}::account::AccountKey`;
+    const key = ACCOUNT_KEY.serialize({ owner: input.owner, nonce: BigInt(input.nonce ?? 0) }).toBytes();
+    return deriveObjectID(normalizeSuiAddress(input.exchangeId), keyType, key);
+}

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

@@ -0,0 +1,207 @@
+import type { ApiParchmentConfigResponse, Order, OrderKind, OrderRefundReason, OrderStatus } from "./parchmentTypes.js";
+/** An order created by a request-open / request-close transaction. */
+export interface RequestedOrderRef {
+    /** `OrderRequest` object id (0x + 64 hex). Pass it to `getOrder` / `waitForOrder`. */
+    orderId: string;
+    /** From the event; null when only the created object was found. */
+    kind: OrderKind | null;
+}
+/**
+ * One event as either client reports it: `@mysten/sui` 2.x core results (`eventType`, BCS bytes,
+ * `json`) or 1.x JSON-RPC `SuiEvent` (`type`, `bcs` a base64 or base58 string per `bcsEncoding`,
+ * `parsedJson`).
+ */
+export interface ParchmentExecutedEventLike {
+    eventType?: string;
+    type?: string;
+    bcs?: Uint8Array | string | null;
+    bcsEncoding?: "base64" | "base58" | string;
+    json?: Record<string, unknown> | null;
+    parsedJson?: unknown;
+}
+/**
+ * The parts of an executed-transaction result this module reads. Both result shapes are covered:
+ * `@mysten/sui` 2.x core results (`events[].eventType` + `bcs`/`json`, `effects.changedObjects`,
+ * `objectTypes`) and 1.x JSON-RPC responses (`events[].type` + string `bcs` / `parsedJson`,
+ * `objectChanges`, effects with `created` refs). A 2.x `{ $kind: "Transaction", Transaction }`
+ * wrapper is unwrapped. JSON-RPC effects carry no object types, so there a created order is found
+ * from `objectChanges` (request it with `showObjectChanges`). An `objectTypes` that is still a
+ * promise (1.x experimental core results) is not awaited and is ignored.
+ */
+export interface ParchmentExecutedTxLike {
+    events?: ReadonlyArray<ParchmentExecutedEventLike> | null;
+    effects?: {
+        /** 2.x core effects. */
+        changedObjects?: ReadonlyArray<{
+            objectId: string;
+            idOperation?: string;
+        }>;
+        /** 1.x JSON-RPC effects (untyped refs; not read). */
+        created?: ReadonlyArray<{
+            reference: {
+                objectId: string;
+            };
+        }> | null;
+    } | null;
+    objectTypes?: Record<string, string> | PromiseLike<Record<string, string>> | null;
+    objectChanges?: ReadonlyArray<{
+        type: string;
+        objectId?: string;
+        objectType?: string;
+    }> | null;
+}
+/**
+ * The Parchment package ids an executed tx's types are matched against: `/v1/config`'s fields
+ * (pass the config response). Events (`events` module) must come from a core `parchment` package
+ * (`packageId` / `packageIds`); the created `order::OrderRequest` object from a `parchment_trade`
+ * package (`tradePackageId` / `tradePackageIds`). Without a scope any package matches, which is
+ * only safe for a tx you built yourself. With or without a scope only the exact forms are read:
+ * `P::events::E` / `P::events::Event<P::events::E>` and a top-level `T::order::OrderRequest<...>`;
+ * a type wrapping them (e.g. `0xEVIL::fake::Wrapper<P::events::E>`) never matches.
+ */
+export type ParchmentPackageScope = Partial<Pick<ApiParchmentConfigResponse, "packageId" | "packageIds" | "tradePackageId" | "tradePackageIds">>;
+/**
+ * BCS layout of `parchment::events::OrderRequestedEventV1`, field for field in `events.move`
+ * order. `events::Event<T>` is a one-field positional wrapper, so its BCS is exactly T's.
+ */
+export declare const ORDER_REQUESTED_EVENT_BCS: import("@mysten/sui/bcs").BcsStruct<{
+    order_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    account_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    owner: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    requester: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    market_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    kind: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+    is_long: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+    margin: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    leverage: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    position_id: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    acceptable_price_wad: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    min_factor_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    max_fee_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    exec_fee: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    requested_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    fill_deadline_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    cancel_after_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    emergency_after_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Close requests: the exec fee part not escrowed (free balance was short), taken from a filled close's payout. */
+    fee_owed: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, string>;
+/** BCS layout of `parchment::events::OrderFinalizedEventV1`, in `events.move` field order. */
+export declare const ORDER_FINALIZED_EVENT_BCS: import("@mysten/sui/bcs").BcsStruct<{
+    order_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    account_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    owner: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    market_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    kind: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+    outcome: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+    position_id: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    price_wad: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    price_ts_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    refund: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    exec_fee: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    finalized_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    sender: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** The escrowed exec fee returned to free balance (refund outcomes, an expiry with no in-window storage write); 0 when paid. */
+    exec_fee_refunded: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, string>;
+export type OrderRequestedEventV1 = ReturnType<typeof ORDER_REQUESTED_EVENT_BCS.parse>;
+export type OrderFinalizedEventV1 = ReturnType<typeof ORDER_FINALIZED_EVENT_BCS.parse>;
+/** Decode an `OrderRequestedEventV1` (or its `Event<…>` wrapper) from BCS; null if it doesn't fit. */
+export declare function decodeOrderRequestedEvent(bytes: Uint8Array): OrderRequestedEventV1 | null;
+/** Decode an `OrderFinalizedEventV1` (or its `Event<…>` wrapper) from BCS; null if it doesn't fit. */
+export declare function decodeOrderFinalizedEvent(bytes: Uint8Array): OrderFinalizedEventV1 | null;
+/**
+ * Orders created by an executed request-open / request-close transaction, in event order.
+ *
+ * Reads `OrderRequestedEventV1`: BCS decoded with the full `events.move` layout (rejected unless
+ * it fits exactly), otherwise the JSON by field name. When the result carries no events, falls
+ * back to created `…::order::OrderRequest<…>` objects (needs `objectTypes` or `objectChanges`).
+ * Returns `[]` when nothing matched, e.g. a failed tx or a result fetched without events/types.
+ * Pass `scope` (the `/v1/config` response) to ignore look-alike types from other packages; see
+ * {@link ParchmentPackageScope}.
+ */
+export declare function requestedOrdersFromTx(result: ParchmentExecutedTxLike | {
+    Transaction: ParchmentExecutedTxLike;
+}, scope?: ParchmentPackageScope): RequestedOrderRef[];
+/**
+ * The single order id created by a request transaction, or null when there is none or more than
+ * one. See {@link requestedOrdersFromTx}.
+ */
+export declare function requestedOrderIdFromTx(result: ParchmentExecutedTxLike | {
+    Transaction: ParchmentExecutedTxLike;
+}, scope?: ParchmentPackageScope): string | null;
+/**
+ * Clock ms strictly after which `expire-order` is allowed, mirroring `order::expires_after_ms`:
+ * `fillDeadlineMs` for opens and for closes with emergency close disabled; otherwise
+ * `emergencyAfterMs + (fillDeadlineMs - requestedMs)`. Emergency close counts as disabled only for
+ * u64::MAX, as on chain. Null when a needed field is missing
+ * (the indexer saw the final event first).
+ */
+export declare function orderExpiresAfterMs(order: Pick<Order, "kind" | "requestedMs" | "fillDeadlineMs" | "emergencyAfterMs">): bigint | null;
+/** `order::MIN_CANCEL_DELAY_MS`: cancel is never allowed before `requestedMs + 5 s`. */
+export declare const MIN_CANCEL_DELAY_MS = 5000n;
+/**
+ * Clock ms from which `cancel-order` is allowed, mirroring the `order::cancel_after_ms` view:
+ * `max(cancelAfterMs, requestedMs + MIN_CANCEL_DELAY_MS)`. `cancelAfterMs` is the stored value
+ * (the order's / event's `cancelAfterMs`); without it, `requestedMs + cancelDelayMs` (the
+ * market's `OrderParamsV1.cancelDelayMs`). Null when `requestedMs` or both inputs are missing.
+ */
+export declare function effectiveCancelAfterMs(order: {
+    requestedMs: string | number | bigint | null;
+    cancelAfterMs?: string | number | bigint | null;
+    cancelDelayMs?: string | number | bigint | null;
+}): bigint | null;
+/**
+ * `OrderFinalizedEventV1.outcome` -> the service's `status` / `reason`, from the `OUTCOME_*`
+ * constants in `order.move` (same mapping as the service's `order_status`). Outcome 1 on a close
+ * is a liquidate-on-close fill; 11 is `emergency_close`; 10 is a close whose position was gone;
+ * 12 is reserved (the signed-band close refund, no longer emitted).
+ * 13 (`session`) is an order refunded because its equity market was being force-closed at session end
+ * (open or close filled while the session close was pending, or a close whose position the force close took).
+ * 14 (`retry`, the served wire name; `OUTCOME_REFUND_LIQ_PAUSED`; no pause emits it despite the name) is a fill refunded because the
+ * account's liquidation backlog exceeded the per-fill cleanup cap, or the keeper's cleanup refund when that cleanup
+ * is on a killed market: escrow and exec fee refunded, and a later try succeeds.
+ * 15 (`revoked`, `OUTCOME_REFUND_REVOKED`) is a delegate request whose requester is no longer a live
+ * delegate of the right type at the order's cancel point: escrow refunded, exec fee kept like a cancel
+ * (earlier contracts also refunded the fee), the order does not open or close.
+ * 9 (`risk`) covers every open-fill risk rung: market risk params, the account notional cap, and
+ * an order whose own notional exceeds `max_tx_notional`.
+ */
+export declare const ORDER_OUTCOMES: Readonly<Record<number, {
+    name: string;
+    status: OrderStatus;
+    reason: OrderRefundReason | null;
+}>>;
+/** Readable copy for outcome 13 (`OUTCOME_SESSION_CLOSED`, `refunded` / `session`). */
+export declare const ORDER_REFUND_SESSION_MESSAGE = "Refunded: session closed";
+/** Status and refund reason for an on-chain outcome code; `unknown` for a code this SDK predates. */
+export declare function orderOutcome(outcome: number): {
+    status: OrderStatus;
+    reason: OrderRefundReason | null;
+};
+/** An order finalized by an executed fill / cancel / expire / emergency-close transaction. */
+export interface FinalizedOrderRef {
+    orderId: string;
+    kind: OrderKind | null;
+    /** Raw `OUTCOME_*` code. */
+    outcome: number;
+    status: OrderStatus;
+    reason: OrderRefundReason | null;
+    positionId: string;
+    /** Fill / reference mid (WAD); "0" for cancel and expire. */
+    priceWad: string;
+    priceTsMs: string;
+    /** Escrow returned to free balance; "0" for a filled order. */
+    refund: string;
+    execFee: string;
+    /** Escrowed exec fee returned to free balance; "0" when the fee was paid. An EXPIRED order refunds it unless a keeper missed an in-window storage write. */
+    execFeeRefunded: string;
+}
+/**
+ * Orders finalized by an executed transaction, in event order. Reads `OrderFinalizedEventV1`:
+ * BCS decoded with the full `events.move` layout, otherwise the JSON by field name (`pos0`
+ * wrapper or inline). Events that fit neither are skipped.
+ */
+export declare function finalizedOrdersFromTx(result: ParchmentExecutedTxLike | {
+    Transaction: ParchmentExecutedTxLike;
+}, scope?: ParchmentPackageScope): FinalizedOrderRef[];

package/dist/packages/parchment/orderEffects.js

@@ -0,0 +1,268 @@
+import { bcs } from "@mysten/sui/bcs";
+import { fromBase58, fromBase64, normalizeSuiAddress } from "@mysten/sui/utils";
+import { isEmergencyAfterDisabled } from "./orderParams.js";
+function eventBcs(event) {
+    const raw = event.bcs;
+    if (raw == null)
+        return null;
+    if (typeof raw !== "string")
+        return raw.length > 0 ? raw : null;
+    try {
+        const bytes = event.bcsEncoding === "base58" ? fromBase58(raw) : fromBase64(raw);
+        return bytes.length > 0 ? bytes : null;
+    }
+    catch {
+        return null;
+    }
+}
+const ADDR = "0x[0-9a-fA-F]{1,64}";
+function eventType(name) {
+    return new RegExp(`^(?:(${ADDR})::events::Event<(${ADDR})::events::${name}>|(${ADDR})::events::${name})$`);
+}
+const REQUESTED_EVENT = eventType("OrderRequestedEventV1");
+const FINALIZED_EVENT = eventType("OrderFinalizedEventV1");
+const ORDER_TYPE = new RegExp(`^(${ADDR})::order::OrderRequest(<.*>)$`);
+function idSet(one, many) {
+    const out = new Set();
+    for (const id of [one, ...(many ?? [])])
+        if (id)
+            out.add(normalizeSuiAddress(id));
+    return out;
+}
+function inPackages(ids, allowed) {
+    return !allowed || ids.every((id) => allowed.has(normalizeSuiAddress(id)));
+}
+function isCoreEvent(type, pattern, allowed) {
+    const m = pattern.exec(type);
+    return !!m && inPackages(m.slice(1).filter((id) => !!id), allowed);
+}
+function oneTypeArgList(args) {
+    let depth = 0;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "<")
+            depth++;
+        else if (args[i] === ">" && --depth === 0 && i !== args.length - 1)
+            return false;
+        if (depth < 0)
+            return false;
+    }
+    return depth === 0;
+}
+function isOrderRequestType(type, allowed) {
+    const m = ORDER_TYPE.exec(type);
+    return !!m && oneTypeArgList(m[2]) && inPackages([m[1]], allowed);
+}
+function scopeSets(scope) {
+    if (!scope)
+        return { core: null, trade: null };
+    return { core: idSet(scope.packageId, scope.packageIds), trade: idSet(scope.tradePackageId, scope.tradePackageIds) };
+}
+export const ORDER_REQUESTED_EVENT_BCS = bcs.struct("OrderRequestedEventV1", {
+    order_id: bcs.Address,
+    account_id: bcs.Address,
+    owner: bcs.Address,
+    requester: bcs.Address,
+    market_id: bcs.Address,
+    kind: bcs.u8(),
+    is_long: bcs.bool(),
+    margin: bcs.u64(),
+    leverage: bcs.u64(),
+    position_id: bcs.u64(),
+    acceptable_price_wad: bcs.u128(),
+    min_factor_bps: bcs.u64(),
+    max_fee_bps: bcs.u64(),
+    exec_fee: bcs.u64(),
+    requested_ms: bcs.u64(),
+    fill_deadline_ms: bcs.u64(),
+    cancel_after_ms: bcs.u64(),
+    emergency_after_ms: bcs.u64(),
+    fee_owed: bcs.u64(),
+});
+export const ORDER_FINALIZED_EVENT_BCS = bcs.struct("OrderFinalizedEventV1", {
+    order_id: bcs.Address,
+    account_id: bcs.Address,
+    owner: bcs.Address,
+    market_id: bcs.Address,
+    kind: bcs.u8(),
+    outcome: bcs.u8(),
+    position_id: bcs.u64(),
+    price_wad: bcs.u128(),
+    price_ts_ms: bcs.u64(),
+    refund: bcs.u64(),
+    exec_fee: bcs.u64(),
+    finalized_ms: bcs.u64(),
+    sender: bcs.Address,
+    exec_fee_refunded: bcs.u64(),
+});
+function decodeExact(layout, bytes) {
+    try {
+        const value = layout.parse(bytes);
+        return layout.serialize(value).toBytes().length === bytes.length ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function decodeOrderRequestedEvent(bytes) {
+    return decodeExact(ORDER_REQUESTED_EVENT_BCS, bytes);
+}
+export function decodeOrderFinalizedEvent(bytes) {
+    return decodeExact(ORDER_FINALIZED_EVENT_BCS, bytes);
+}
+export function requestedOrdersFromTx(result, scope) {
+    const tx = "Transaction" in result && result.Transaction ? result.Transaction : result;
+    const { core, trade } = scopeSets(scope);
+    const isOrderType = (type) => isOrderRequestType(type, trade);
+    const fromEvents = [];
+    for (const event of tx.events ?? []) {
+        const type = event.eventType ?? event.type ?? "";
+        if (!isCoreEvent(type, REQUESTED_EVENT, core))
+            continue;
+        const ref = eventRef(event);
+        if (ref)
+            fromEvents.push(ref);
+    }
+    if (fromEvents.length > 0)
+        return fromEvents;
+    const ids = new Set();
+    for (const change of tx.objectChanges ?? []) {
+        if (change.type === "created" && change.objectId && isOrderType(change.objectType ?? "")) {
+            ids.add(normalizeSuiAddress(change.objectId));
+        }
+    }
+    const types = plainObjectTypes(tx.objectTypes);
+    for (const change of tx.effects?.changedObjects ?? []) {
+        if (change.idOperation === "Created" && isOrderType(types[change.objectId] ?? "")) {
+            ids.add(normalizeSuiAddress(change.objectId));
+        }
+    }
+    return [...ids].map((orderId) => ({ orderId, kind: null }));
+}
+export function requestedOrderIdFromTx(result, scope) {
+    const orders = requestedOrdersFromTx(result, scope);
+    return orders.length === 1 ? orders[0].orderId : null;
+}
+function plainObjectTypes(types) {
+    if (!types || typeof types.then === "function")
+        return {};
+    return types;
+}
+function eventRef(event) {
+    const bytes = eventBcs(event);
+    const decoded = bytes ? decodeOrderRequestedEvent(bytes) : null;
+    if (decoded)
+        return { orderId: normalizeSuiAddress(decoded.order_id), kind: kindOf(decoded.kind) };
+    const json = (event.json ?? event.parsedJson);
+    const inner = (json && typeof json.pos0 === "object" && json.pos0 !== null ? json.pos0 : json);
+    const id = inner?.order_id;
+    if (typeof id !== "string" || !/^0x[0-9a-fA-F]{1,64}$/.test(id))
+        return null;
+    return { orderId: normalizeSuiAddress(id), kind: kindOf(jsonInt(inner?.kind)) };
+}
+function jsonInt(v) {
+    if (typeof v === "number")
+        return Number.isSafeInteger(v) && v >= 0 ? v : NaN;
+    return typeof v === "string" && /^\d+$/.test(v) ? Number(v) : NaN;
+}
+function kindOf(raw) {
+    return raw === 0 ? "open" : raw === 1 ? "close" : null;
+}
+export function orderExpiresAfterMs(order) {
+    if (order.fillDeadlineMs === null)
+        return null;
+    const deadline = order.fillDeadlineMs;
+    if (order.kind === "open")
+        return deadline;
+    if (order.emergencyAfterMs === null || order.requestedMs === null)
+        return null;
+    if (isEmergencyAfterDisabled(order.emergencyAfterMs))
+        return deadline;
+    return order.emergencyAfterMs + (deadline - order.requestedMs);
+}
+export const MIN_CANCEL_DELAY_MS = 5000n;
+export function effectiveCancelAfterMs(order) {
+    if (order.requestedMs === null || order.requestedMs === undefined)
+        return null;
+    const requested = BigInt(order.requestedMs);
+    let stored;
+    if (order.cancelAfterMs !== null && order.cancelAfterMs !== undefined)
+        stored = BigInt(order.cancelAfterMs);
+    else if (order.cancelDelayMs !== null && order.cancelDelayMs !== undefined)
+        stored = requested + BigInt(order.cancelDelayMs);
+    else
+        return null;
+    const floor = requested + MIN_CANCEL_DELAY_MS;
+    return stored > floor ? stored : floor;
+}
+export const ORDER_OUTCOMES = {
+    0: { name: "OUTCOME_FILLED", status: "filled", reason: null },
+    1: { name: "OUTCOME_LIQUIDATED", status: "liquidated", reason: null },
+    2: { name: "OUTCOME_CANCELLED", status: "cancelled", reason: null },
+    3: { name: "OUTCOME_EXPIRED", status: "expired", reason: null },
+    5: { name: "OUTCOME_REFUND_PAUSED", status: "refunded", reason: "paused" },
+    6: { name: "OUTCOME_REFUND_KILLED", status: "refunded", reason: "killed" },
+    7: { name: "OUTCOME_REFUND_CLOSED", status: "refunded", reason: "closed" },
+    8: { name: "OUTCOME_REFUND_FEE", status: "refunded", reason: "fee" },
+    9: { name: "OUTCOME_REFUND_RISK", status: "refunded", reason: "risk" },
+    10: { name: "OUTCOME_VOID", status: "void", reason: null },
+    11: { name: "OUTCOME_EMERGENCY_CLOSED", status: "emergency_closed", reason: null },
+    12: { name: "OUTCOME_REFUND_BAND", status: "refunded", reason: "band" },
+    13: { name: "OUTCOME_SESSION_CLOSED", status: "refunded", reason: "session" },
+    14: { name: "OUTCOME_REFUND_LIQ_PAUSED", status: "refunded", reason: "retry" },
+    15: { name: "OUTCOME_REFUND_REVOKED", status: "refunded", reason: "revoked" },
+};
+export const ORDER_REFUND_SESSION_MESSAGE = "Refunded: session closed";
+export function orderOutcome(outcome) {
+    const known = Object.prototype.hasOwnProperty.call(ORDER_OUTCOMES, outcome) ? ORDER_OUTCOMES[outcome] : undefined;
+    return known ? { status: known.status, reason: known.reason } : { status: "unknown", reason: null };
+}
+export function finalizedOrdersFromTx(result, scope) {
+    const tx = "Transaction" in result && result.Transaction ? result.Transaction : result;
+    const { core } = scopeSets(scope);
+    const out = [];
+    for (const event of tx.events ?? []) {
+        const type = event.eventType ?? event.type ?? "";
+        if (!isCoreEvent(type, FINALIZED_EVENT, core))
+            continue;
+        const bytes = eventBcs(event);
+        const ev = (bytes ? decodeOrderFinalizedEvent(bytes) : null) ?? finalizedFromJson(event.json ?? event.parsedJson);
+        if (!ev)
+            continue;
+        out.push({
+            orderId: normalizeSuiAddress(ev.order_id),
+            kind: kindOf(Number(ev.kind)),
+            outcome: Number(ev.outcome),
+            ...orderOutcome(Number(ev.outcome)),
+            positionId: String(ev.position_id),
+            priceWad: String(ev.price_wad),
+            priceTsMs: String(ev.price_ts_ms),
+            refund: String(ev.refund),
+            execFee: String(ev.exec_fee),
+            execFeeRefunded: String(ev.exec_fee_refunded),
+        });
+    }
+    return out;
+}
+function finalizedFromJson(raw) {
+    const json = raw;
+    const inner = (json && typeof json.pos0 === "object" && json.pos0 !== null ? json.pos0 : json);
+    if (!inner || typeof inner.order_id !== "string" || !/^0x[0-9a-fA-F]{1,64}$/.test(inner.order_id))
+        return null;
+    const u = (k) => {
+        const v = inner[k];
+        if (typeof v === "string")
+            return /^\d+$/.test(v) ? v : null;
+        return typeof v === "number" && Number.isSafeInteger(v) && v >= 0 ? String(v) : null;
+    };
+    const outcome = jsonInt(inner.outcome);
+    const kind = jsonInt(inner.kind);
+    const fields = ["position_id", "price_wad", "price_ts_ms", "refund", "exec_fee", "exec_fee_refunded"].map(u);
+    if (!Number.isInteger(outcome) || !Number.isInteger(kind) || fields.some((f) => f === null))
+        return null;
+    const [position_id, price_wad, price_ts_ms, refund, exec_fee, exec_fee_refunded] = fields;
+    return {
+        order_id: inner.order_id, account_id: String(inner.account_id ?? ""), owner: String(inner.owner ?? ""),
+        market_id: String(inner.market_id ?? ""), kind, outcome, position_id, price_wad, price_ts_ms, refund, exec_fee,
+        finalized_ms: String(inner.finalized_ms ?? "0"), sender: String(inner.sender ?? ""), exec_fee_refunded,
+    };
+}

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

@@ -0,0 +1,72 @@
+/**
+ * BCS layout of `parchment::market::OrderParamsV1`, field for field in `market.move` order. This is
+ * the return value of `market::order_params<C>(&Market<C>)` (e.g. from a dev-inspect) and the
+ * `order` field of the market's `MarketStateV1`.
+ */
+export declare const ORDER_PARAMS_V1_BCS: import("@mysten/sui/bcs").BcsStruct<{
+    fill_window_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    fill_deadline_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    cancel_delay_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    emergency_after_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    exec_fee: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    one_step_spread_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    signed_window_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, string>;
+/** A market's two-step order parameters. All values are u64s as decimal strings. */
+export interface OrderParamsV1 {
+    /** W: the request-side window (D and the cancel delay are bounded by it). Fills read S. */
+    fillWindowMs: string;
+    /** D: a fill must land by requestedMs + D (clock). */
+    fillDeadlineMs: string;
+    /**
+     * Cancel is allowed from `max(requestedMs + this, requestedMs + 5 s)`: the chain floors it at
+     * `order::MIN_CANCEL_DELAY_MS` (5 s). See `effectiveCancelAfterMs`.
+     */
+    cancelDelayMs: string;
+    /** Close-request age before `order::emergency_close`; u64::MAX disables it. */
+    emergencyAfterMs: string;
+    /**
+     * Execution fee in collateral base units. Kept on fills, cancel, expiry and most refunds; returned
+     * with the escrow on REFUND_PAUSED (5) / REFUND_KILLED (6), SESSION_CLOSED (13, incl. expiry of a
+     * session-closed order) and REFUND_LIQ_PAUSED (14).
+     */
+    execFee: string;
+    /** Floor spread for the one-step user paths (emergency close). */
+    oneStepSpreadBps: string;
+    /**
+     * S (verify-in-fill): the keeper fills at the signed Lazer price whose feed update timestamp is in
+     * (requestedMs, requestedMs + S].
+     */
+    signedWindowMs: string;
+}
+/** `emergencyAfterMs` value that disables the emergency close. */
+export declare const EMERGENCY_CLOSE_DISABLED_MS = "18446744073709551615";
+/**
+ * Decode `OrderParamsV1` BCS (exactly 56 bytes). Null when the bytes don't fit the layout exactly,
+ * which means the on-chain struct changed.
+ */
+export declare function decodeOrderParams(bytes: Uint8Array): OrderParamsV1 | null;
+/**
+ * Read `OrderParamsV1` from its JSON rendering (snake_case keys, u64s as strings or numbers), e.g.
+ * the `order` field of a fetched `MarketStateV1`. A `{ fields: … }` wrapper (JSON-RPC
+ * `showContent`) is unwrapped. Null when a field is missing or not a u64.
+ */
+export declare function orderParamsFromJson(json: unknown): OrderParamsV1 | null;
+/**
+ * True when an `emergencyAfterMs` value means "emergency close disabled": exactly u64::MAX, as
+ * `order::expires_after_ms` checks. Accepts a decimal string, a number or a bigint; a number cannot
+ * hold u64::MAX exactly, and anything unparseable is false.
+ */
+export declare function isEmergencyAfterDisabled(value: string | number | bigint): boolean;
+/** True when the market has the emergency close disabled (`emergency_after_ms == u64::MAX`). */
+export declare function emergencyCloseDisabled(params: {
+    emergencyAfterMs: string | number | bigint;
+}): boolean;
+/**
+ * Whether an account with `pendingOpenOrders` live OPEN requests may place another open under the
+ * admin-set cap `maxPendingOrders` (`getConfig().maxPendingOrders`, the account record's
+ * `pendingOpenOrders`). Mirrors `order.move`'s opens-only `pending_open_orders(account) < max_pending_orders`
+ * check; an open past it aborts `order::ETooManyOrders` (11). Closes are never capped: do not gate
+ * close requests on this. Null when either value is missing (an older service that does not serve them).
+ */
+export declare function hasPendingOrderSlot(maxPendingOrders: bigint | null | undefined, pendingOpenOrders: bigint | null | undefined): boolean | null;

package/dist/packages/parchment/orderParams.js

@@ -0,0 +1,71 @@
+import { bcs } from "@mysten/sui/bcs";
+export const ORDER_PARAMS_V1_BCS = bcs.struct("OrderParamsV1", {
+    fill_window_ms: bcs.u64(),
+    fill_deadline_ms: bcs.u64(),
+    cancel_delay_ms: bcs.u64(),
+    emergency_after_ms: bcs.u64(),
+    exec_fee: bcs.u64(),
+    one_step_spread_bps: bcs.u64(),
+    signed_window_ms: bcs.u64(),
+});
+export const EMERGENCY_CLOSE_DISABLED_MS = "18446744073709551615";
+export function decodeOrderParams(bytes) {
+    if (bytes.length !== 56)
+        return null;
+    const raw = ORDER_PARAMS_V1_BCS.parse(bytes);
+    return {
+        fillWindowMs: raw.fill_window_ms,
+        fillDeadlineMs: raw.fill_deadline_ms,
+        cancelDelayMs: raw.cancel_delay_ms,
+        emergencyAfterMs: raw.emergency_after_ms,
+        execFee: raw.exec_fee,
+        oneStepSpreadBps: raw.one_step_spread_bps,
+        signedWindowMs: raw.signed_window_ms,
+    };
+}
+export function orderParamsFromJson(json) {
+    let obj = json;
+    if (obj && typeof obj === "object" && typeof obj.fields === "object" && obj.fields !== null) {
+        obj = obj.fields;
+    }
+    if (!obj || typeof obj !== "object")
+        return null;
+    const u64 = (key) => {
+        const camel = key.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+        const v = obj[key] ?? obj[camel];
+        const s = typeof v === "number" && Number.isSafeInteger(v) ? String(v) : typeof v === "string" ? v : null;
+        return s !== null && /^\d{1,20}$/.test(s) && BigInt(s) <= BigInt(EMERGENCY_CLOSE_DISABLED_MS) ? BigInt(s).toString() : null;
+    };
+    const fillWindowMs = u64("fill_window_ms");
+    const fillDeadlineMs = u64("fill_deadline_ms");
+    const cancelDelayMs = u64("cancel_delay_ms");
+    const emergencyAfterMs = u64("emergency_after_ms");
+    const execFee = u64("exec_fee");
+    const oneStepSpreadBps = u64("one_step_spread_bps");
+    const signedWindowMs = u64("signed_window_ms");
+    if (fillWindowMs === null || fillDeadlineMs === null || cancelDelayMs === null ||
+        emergencyAfterMs === null || execFee === null || oneStepSpreadBps === null || signedWindowMs === null) {
+        return null;
+    }
+    return { fillWindowMs, fillDeadlineMs, cancelDelayMs, emergencyAfterMs, execFee, oneStepSpreadBps, signedWindowMs };
+}
+export function isEmergencyAfterDisabled(value) {
+    if (typeof value === "number")
+        return false;
+    try {
+        return BigInt(value) === BigInt(EMERGENCY_CLOSE_DISABLED_MS);
+    }
+    catch {
+        return false;
+    }
+}
+export function emergencyCloseDisabled(params) {
+    return isEmergencyAfterDisabled(params.emergencyAfterMs);
+}
+export function hasPendingOrderSlot(maxPendingOrders, pendingOpenOrders) {
+    if (maxPendingOrders === null || maxPendingOrders === undefined)
+        return null;
+    if (pendingOpenOrders === null || pendingOpenOrders === undefined)
+        return null;
+    return pendingOpenOrders < maxPendingOrders;
+}