@mysten/deepbook-v3 2.6.4 → 2.8.0

package/dist/predict/tx/common.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"common.mjs","names":["account.generateAuth"],"sources":["../../../src/predict/tx/common.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport type { Transaction, TransactionArgument, TransactionResult } from '@mysten/sui/transactions';\nimport { toGeneratedConfig, type GeneratedConfig } from '../config/generated.js';\nimport type { PredictConfig } from '../config/index.js';\nimport { AccountContract, accountMoveCalls as account } from '../../account.js';\n\n// Predict's accounts ARE the shared on-chain account primitive (`packages/account`), so the\n// builders live in `@mysten/deepbook-v3/account` and this is the thin adapter that drives them with\n// Predict's deployed ids. The generated thunks are still used directly by `withAuth` below, which\n// wraps Predict's own entrypoints too — those take the same `Auth` hot potato.\nexport function accountContract(cfg: PredictConfig): AccountContract {\n\treturn new AccountContract({\n\t\taccountPackageId: cfg.packages.account,\n\t\taccountRegistry: cfg.objects.accountRegistry,\n\t});\n}\n\n/**\n * Owner authority is a hot-potato `Auth` minted from the tx sender (`ctx` is implicit in a PTB)\n * and consumed by the very next account-loading call (`load_account_mut` inside `deposit_funds` /\n * `withdraw_funds` / `mint` / …). It resolves to owner auth for whoever signs the transaction.\n * See `packages/account/sources/account.move`.\n */\nexport function generateAuth(cfg: PredictConfig): (tx: Transaction) => TransactionResult {\n\treturn account.generateAuth({ config: toGeneratedConfig(cfg) });\n}\n\n// The shape every generated binding shares: options in, one PTB command out.\ntype GeneratedCall<Options> = (options: Options) => (tx: Transaction) => TransactionResult;\n\n// The generated options of a call that consumes the hot-potato `Auth`. Codegen types\n// `arguments` as the named form OR a positional tuple; only the named form is used here.\ninterface AuthCallOptions {\n\targuments: { auth: TransactionArgument } | readonly unknown[];\n\tconfig?: object;\n\tpackage?: string;\n}\n\n// The named-`arguments` arm of such an options type (the tuple arm has no `auth` property).\ntype NamedArguments<Options extends AuthCallOptions> = Extract<\n\tOptions['arguments'],\n\t{ auth: TransactionArgument }\n>;\n\n/**\n * The options {@link withAuth} leaves to the caller: the generated ones, minus the `auth`\n * argument it supplies itself, with the projected config required (it is what mints the auth).\n */\nexport type WithAuthOptions<Options extends AuthCallOptions> = Omit<\n\tOptions,\n\t'arguments' | 'config'\n> & {\n\tconfig: GeneratedConfig;\n\targuments: Omit<NamedArguments<Options>, 'auth'>;\n};\n\n/**\n * Every owner-authorized call in this SDK is the same two commands — mint the hot-potato `Auth`,\n * then make the generated call that consumes it. This lifts a generated binding into that pair,\n * so such a builder is declared rather than written: `withAuth(account.depositFunds)` takes\n * `deposit_funds`'s own options with the `auth` slot already filled.\n */\nexport function withAuth<Options extends AuthCallOptions>(\n\tcall: GeneratedCall<Options>,\n): (options: WithAuthOptions<Options>) => (tx: Transaction) => TransactionResult {\n\treturn (options) => (tx) => {\n\t\tconst auth = tx.add(account.generateAuth({ config: options.config }));\n\t\t// The one unchecked step: with `Options` still generic, TS cannot see that putting `auth`\n\t\t// back makes the arguments whole again. Callers get the fully checked type above.\n\t\treturn tx.add(\n\t\t\tcall({ ...options, arguments: { ...options.arguments, auth } } as unknown as Options),\n\t\t);\n\t};\n}\n\n// The derivation must agree with on-chain `derive_address`, so it is owned in one place:\n// `@mysten/deepbook-v3/account`. This projects Predict's config onto that contract.\nexport function deriveAccountWrapperIdFrom(\n\tconfig: Pick<GeneratedConfig, 'accountRegistry' | 'accountPackageId'>,\n\towner: string,\n): string {\n\treturn new AccountContract({\n\t\taccountPackageId: config.accountPackageId,\n\t\taccountRegistry: config.accountRegistry,\n\t}).deriveAccountWrapperId(owner);\n}\n\n/** The deterministic id of an owner's canonical account wrapper — no chain read needed. */\nexport function deriveAccountWrapperId(cfg: PredictConfig, owner: string): string {\n\treturn deriveAccountWrapperIdFrom(toGeneratedConfig(cfg), owner);\n}\n"],"mappings":";;;;;AAWA,SAAgB,gBAAgB,KAAqC;AACpE,QAAO,IAAI,gBAAgB;EAC1B,kBAAkB,IAAI,SAAS;EAC/B,iBAAiB,IAAI,QAAQ;EAC7B,CAAC;;;;;;;;AASH,SAAgB,aAAa,KAA4D;AACxF,QAAOA,eAAqB,EAAE,QAAQ,kBAAkB,IAAI,EAAE,CAAC;;;;;;;;AAsChE,SAAgB,SACf,MACgF;AAChF,SAAQ,aAAa,OAAO;EAC3B,MAAM,OAAO,GAAG,IAAIA,eAAqB,EAAE,QAAQ,QAAQ,QAAQ,CAAC,CAAC;AAGrE,SAAO,GAAG,IACT,KAAK;GAAE,GAAG;GAAS,WAAW;IAAE,GAAG,QAAQ;IAAW;IAAM;GAAE,CAAuB,CACrF;;;AAMH,SAAgB,2BACf,QACA,OACS;AACT,QAAO,IAAI,gBAAgB;EAC1B,kBAAkB,OAAO;EACzB,iBAAiB,OAAO;EACxB,CAAC,CAAC,uBAAuB,MAAM;;;AAIjC,SAAgB,uBAAuB,KAAoB,OAAuB;AACjF,QAAO,2BAA2B,kBAAkB,IAAI,EAAE,MAAM"}
+{"version":3,"file":"common.mjs","names":["account.generateAuth"],"sources":["../../../src/predict/tx/common.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { bcs } from '@mysten/sui/bcs';\nimport type { Transaction, TransactionArgument, TransactionResult } from '@mysten/sui/transactions';\nimport { deriveObjectID } from '@mysten/sui/utils';\nimport { toGeneratedConfig, type GeneratedConfig } from '../config/generated.js';\nimport type { PredictConfig } from '../config/index.js';\nimport { AccountContract, accountMoveCalls as account } from '../../account.js';\n\n// Predict's accounts ARE the shared on-chain account primitive (`packages/account`), so the\n// builders live in `@mysten/deepbook-v3/account` and this is the thin adapter that drives them with\n// Predict's deployed ids. The generated thunks are still used directly by `withAuth` below, which\n// wraps Predict's own entrypoints too — those take the same `Auth` hot potato.\nexport function accountContract(cfg: PredictConfig): AccountContract {\n\treturn new AccountContract({\n\t\taccountPackageId: cfg.packages.account,\n\t\taccountRegistry: cfg.objects.accountRegistry,\n\t});\n}\n\n/**\n * Owner authority is a hot-potato `Auth` minted from the tx sender (`ctx` is implicit in a PTB)\n * and consumed by the very next account-loading call (`load_account_mut` inside `deposit_funds` /\n * `withdraw_funds` / `mint` / …). It resolves to owner auth for whoever signs the transaction.\n * See `packages/account/sources/account.move`.\n */\nexport function generateAuth(cfg: PredictConfig): (tx: Transaction) => TransactionResult {\n\treturn account.generateAuth({ config: toGeneratedConfig(cfg) });\n}\n\n// The shape every generated binding shares: options in, one PTB command out.\ntype GeneratedCall<Options> = (options: Options) => (tx: Transaction) => TransactionResult;\n\n// The generated options of a call that consumes the hot-potato `Auth`. Codegen types\n// `arguments` as the named form OR a positional tuple; only the named form is used here.\ninterface AuthCallOptions {\n\targuments: { auth: TransactionArgument } | readonly unknown[];\n\tconfig?: object;\n\tpackage?: string;\n}\n\n// The named-`arguments` arm of such an options type (the tuple arm has no `auth` property).\ntype NamedArguments<Options extends AuthCallOptions> = Extract<\n\tOptions['arguments'],\n\t{ auth: TransactionArgument }\n>;\n\n/**\n * The options {@link withAuth} leaves to the caller: the generated ones, minus the `auth`\n * argument it supplies itself, with the projected config required (it is what mints the auth).\n * The config must also carry every key the wrapped call resolves, so a call into the order-flow\n * companion can't be handed a slice without its desk.\n */\nexport type WithAuthOptions<Options extends AuthCallOptions> = Omit<\n\tOptions,\n\t'arguments' | 'config'\n> & {\n\tconfig: GeneratedConfig & NonNullable<Options['config']>;\n\targuments: Omit<NamedArguments<Options>, 'auth'>;\n};\n\n/**\n * Every owner-authorized call in this SDK is the same two commands — mint the hot-potato `Auth`,\n * then make the generated call that consumes it. This lifts a generated binding into that pair,\n * so such a builder is declared rather than written: `withAuth(account.depositFunds)` takes\n * `deposit_funds`'s own options with the `auth` slot already filled.\n */\nexport function withAuth<Options extends AuthCallOptions>(\n\tcall: GeneratedCall<Options>,\n): (options: WithAuthOptions<Options>) => (tx: Transaction) => TransactionResult {\n\treturn (options) => (tx) => {\n\t\tconst auth = tx.add(account.generateAuth({ config: options.config }));\n\t\t// The one unchecked step: with `Options` still generic, TS cannot see that putting `auth`\n\t\t// back makes the arguments whole again. Callers get the fully checked type above.\n\t\treturn tx.add(\n\t\t\tcall({ ...options, arguments: { ...options.arguments, auth } } as unknown as Options),\n\t\t);\n\t};\n}\n\n// The derivation must agree with on-chain `derive_address`, so it is owned in one place:\n// `@mysten/deepbook-v3/account`. This projects Predict's config onto that contract.\nexport function deriveAccountWrapperIdFrom(\n\tconfig: Pick<GeneratedConfig, 'accountRegistry' | 'accountPackageId'>,\n\towner: string,\n): string {\n\treturn new AccountContract({\n\t\taccountPackageId: config.accountPackageId,\n\t\taccountRegistry: config.accountRegistry,\n\t}).deriveAccountWrapperId(owner);\n}\n\n/** The deterministic id of an owner's canonical account wrapper — no chain read needed. */\nexport function deriveAccountWrapperId(cfg: PredictConfig, owner: string): string {\n\treturn deriveAccountWrapperIdFrom(toGeneratedConfig(cfg), owner);\n}\n\n// `account_registry::AccountKey(owner)`: a one-field positional struct, so its BCS is the bare\n// 32-byte address.\nconst AccountKey = bcs.struct('AccountKey', { pos0: bcs.Address });\n\n/**\n * The owner's canonical ACCOUNT id (`Account.account_id`), a different derived object from the\n * wrapper: `derive_address(registry, AccountKey(owner))`. Queue records and events name accounts\n * by it, and `queue::waiting_orders` takes it.\n */\nexport function deriveAccountIdFrom(\n\tconfig: Pick<GeneratedConfig, 'accountRegistry' | 'accountPackageId'>,\n\towner: string,\n): string {\n\treturn deriveObjectID(\n\t\tconfig.accountRegistry,\n\t\t`${config.accountPackageId}::account_registry::AccountKey`,\n\t\tAccountKey.serialize({ pos0: owner }).toBytes(),\n\t);\n}\n"],"mappings":";;;;;;;AAaA,SAAgB,gBAAgB,KAAqC;AACpE,QAAO,IAAI,gBAAgB;EAC1B,kBAAkB,IAAI,SAAS;EAC/B,iBAAiB,IAAI,QAAQ;EAC7B,CAAC;;;;;;;;AASH,SAAgB,aAAa,KAA4D;AACxF,QAAOA,eAAqB,EAAE,QAAQ,kBAAkB,IAAI,EAAE,CAAC;;;;;;;;AAwChE,SAAgB,SACf,MACgF;AAChF,SAAQ,aAAa,OAAO;EAC3B,MAAM,OAAO,GAAG,IAAIA,eAAqB,EAAE,QAAQ,QAAQ,QAAQ,CAAC,CAAC;AAGrE,SAAO,GAAG,IACT,KAAK;GAAE,GAAG;GAAS,WAAW;IAAE,GAAG,QAAQ;IAAW;IAAM;GAAE,CAAuB,CACrF;;;AAMH,SAAgB,2BACf,QACA,OACS;AACT,QAAO,IAAI,gBAAgB;EAC1B,kBAAkB,OAAO;EACzB,iBAAiB,OAAO;EACxB,CAAC,CAAC,uBAAuB,MAAM;;;AAIjC,SAAgB,uBAAuB,KAAoB,OAAuB;AACjF,QAAO,2BAA2B,kBAAkB,IAAI,EAAE,MAAM;;AAKjE,MAAM,aAAa,IAAI,OAAO,cAAc,EAAE,MAAM,IAAI,SAAS,CAAC;;;;;;AAOlE,SAAgB,oBACf,QACA,OACS;AACT,QAAO,eACN,OAAO,iBACP,GAAG,OAAO,iBAAiB,iCAC3B,WAAW,UAAU,EAAE,MAAM,OAAO,CAAC,CAAC,SAAS,CAC/C"}

package/dist/predict/tx/queue.d.mts

@@ -0,0 +1,220 @@
+import { GeneratedConfig, OrdersGeneratedConfig } from "../config/generated.mjs";
+import { MarketFeeds } from "./trade.mjs";
+import { Transaction, TransactionResult } from "@mysten/sui/transactions";
+
+//#region src/predict/tx/queue.d.ts
+declare namespace queue_d_exports {
+  export { LazerPackages, QueueTarget, adminRefund, assertOrderFeeAtMost, claimParked, cleanup, commit, createQueue, enqueueExactAmount, enqueueExactCost, enqueueExactQuantity, enqueueRedeemOpen, fill, parseLazerUpdate, payOpen, queueIdOf, rebalanceExpiryCash, refund, resolve, settleStep };
+}
+/** One market's queue. */
+interface QueueTarget {
+  expiryMarketId: string;
+  /**
+   * The market's `MarketQueue`. Defaults to `deriveQueueId(config.queueRegistry, expiryMarketId)`,
+   * the ID `queue::create_and_share` gives it, so pass it only to address another registry's
+   * queue.
+   */
+  queueId?: string;
+}
+/** The queue ID a thunk addresses: the given one, or the one derived from the config's registry. */
+declare function queueIdOf(config: Pick<OrdersGeneratedConfig, 'queueRegistry'>, args: QueueTarget): string;
+/** The market, queue and account every queued order names. */
+interface QueuedOrderTarget extends MarketFeeds, QueueTarget {
+  wrapperId: string;
+}
+/**
+ * Queue a mint of an exact payout quantity, priced at Pyth's signed price for its τ
+ * (`queue::enqueue_exact_quantity`). Returns the record ID (u64). `maxCostRaw` (all-in cap) and
+ * `maxProbabilityRaw` (entry-probability cap, at most 1e9) are required: there is no "unlimited"
+ * default on the queued path. Escrows `min(max_cost, quantity, available − fee)` plus the order
+ * fee. Command order is auth → enqueue.
+ */
+declare function enqueueExactQuantity(config: OrdersGeneratedConfig, args: QueuedOrderTarget & {
+  lowerTick: bigint;
+  higherTick: bigint;
+  quantityRaw: bigint;
+  maxCostRaw: bigint;
+  maxProbabilityRaw: bigint;
+}): (tx: Transaction) => TransactionResult;
+/**
+ * Queue a premium-budget mint (`queue::enqueue_exact_amount`): sized at τ under
+ * `maxPremiumRaw`, at least `minQuantityRaw`, with the all-in withdrawal capped by the required
+ * `maxCostRaw`. Escrows `min(max_cost, available − fee)` plus the order fee. Returns the record
+ * ID. Command order is auth → enqueue. `maxPremiumRaw` below the minimum premium (1 USDC) is
+ * refused: the fill could never buy enough premium, so Predict's admission dry run would abort
+ * `EOrderFailsLimits`.
+ */
+declare function enqueueExactAmount(config: OrdersGeneratedConfig, args: QueuedOrderTarget & {
+  lowerTick: bigint;
+  higherTick: bigint;
+  maxPremiumRaw: bigint;
+  minQuantityRaw: bigint;
+  maxCostRaw: bigint;
+}): (tx: Transaction) => TransactionResult;
+/**
+ * Queue an all-in-budget mint (`queue::enqueue_exact_cost`): sized at τ so the all-in cost fits
+ * `maxCostRaw`, at least `minQuantityRaw`. `maxCostRaw` is the budget and must be a real cap.
+ * Escrows `min(max_cost, available − fee)` plus the order fee. Returns the record ID. Command
+ * order is auth → enqueue.
+ */
+declare function enqueueExactCost(config: OrdersGeneratedConfig, args: QueuedOrderTarget & {
+  lowerTick: bigint;
+  higherTick: bigint;
+  maxCostRaw: bigint;
+  minQuantityRaw: bigint;
+}): (tx: Transaction) => TransactionResult;
+/**
+ * Queue an early sell of `closeQuantityRaw` from the Open record `recordId`
+ * (`queue::enqueue_redeem_open`; the queue record ID, not the position's u256 order ID). The
+ * only early sell: a position held in the account can't be sold early. The record must be Open
+ * and belong to this account. `minProbabilityRaw` and `minProceedsRaw` are the close-side floors
+ * at τ and are required (`0n` disables either, so pass it on purpose). Escrows only the order
+ * fee. Returns the new record ID, which holds the position until the sell fills or refunds.
+ * Command order is auth → enqueue.
+ */
+declare function enqueueRedeemOpen(config: OrdersGeneratedConfig, args: QueuedOrderTarget & {
+  recordId: bigint;
+  closeQuantityRaw: bigint;
+  minProbabilityRaw: bigint;
+  minProceedsRaw: bigint;
+}): (tx: Transaction) => TransactionResult;
+/**
+ * Abort the transaction unless the order desk's fee is at most `maxOrderFeeRaw` when it executes.
+ * The enqueues charge the desk's fee at execution and take no fee bound, so add this BEFORE an
+ * enqueue to hold it to the fee its preview showed. It reads the desk's policy, and
+ * `0x1::u64::checked_sub(max, fee)` is none once the fee is above the bound, so
+ * `0x1::option::destroy_some` aborts (`option::EOPTION_NOT_SET`, code 0x40001) before the
+ * enqueue debits anything. Read-only on the desk.
+ */
+declare function assertOrderFeeAtMost(config: OrdersGeneratedConfig, maxOrderFeeRaw: bigint): (tx: Transaction) => void;
+/**
+ * Fund a live market from the pool vault to `max(required × (1 + rebalance %), initial cash,
+ * required + waiting_cash_need)` (Predict's `plp::rebalance_expiry_cash`). Permissionless, and
+ * takes no target. Add it AFTER a big sell's enqueue in the same PTB: the enqueue has already
+ * added the sell's cash need to Predict's waiting total, so the rebalance funds it at once. It
+ * takes the hot `PoolVault`, so add it only when a sell's cash need is above spare cash.
+ */
+declare function rebalanceExpiryCash(config: GeneratedConfig, args: {
+  expiryMarketId: string;
+}): (tx: Transaction) => TransactionResult;
+/**
+ * Create and share a market's `MarketQueue` (`queue::create_and_share(registry, desk, market)`),
+ * at the ID `deriveQueueId(config.queueRegistry, expiryMarketId)`. Takes the registry mutably and
+ * the desk read-only, so it never contends with trading. Permissionless and once per market (a
+ * second call aborts, since the ID is taken); the caller pays its storage. The market-creation
+ * keeper sends it after each new `ExpiryMarket`. Returns the queue ID.
+ */
+declare function createQueue(config: OrdersGeneratedConfig, args: {
+  expiryMarketId: string;
+}): (tx: Transaction) => TransactionResult;
+/**
+ * Refund this market's waiting orders at or past their deadline (`queue::refund`, reason 5),
+ * visiting at most `maxOrders` records (the chain caps one call at 450). Permissionless: no auth,
+ * session or Pyth key, and it works during a freeze. Returns how many it refunded, `0` without
+ * aborting when none is due. Send it only from the app's refund button, never prepended to other
+ * transactions: keepers refund on their own. Every visited record counts toward Sui's
+ * per-transaction object limit.
+ */
+declare function refund(config: OrdersGeneratedConfig, args: QueueTarget & {
+  maxOrders: bigint | number;
+}): (tx: Transaction) => TransactionResult;
+/**
+ * Refund the listed waiting orders at once (`queue::admin_refund`, reason 7), wherever they sit
+ * in the queue. Takes Predict's `AdminCap`, and works while Predict is frozen. Missing and
+ * finished record IDs are skipped.
+ */
+declare function adminRefund(config: OrdersGeneratedConfig, args: QueueTarget & {
+  adminCapId: string;
+  recordIds: readonly bigint[];
+}): (tx: Transaction) => TransactionResult;
+/**
+ * Delete Refunded and Closed records of a settled market (`queue::cleanup`). Permissionless; the
+ * storage rebate goes to the sender. Missing IDs, other statuses and records still holding a
+ * receipt or funds (parked funds included, until `claimParked`) are skipped. Aborts
+ * `EMarketNotSettled` before settlement.
+ */
+declare function cleanup(config: OrdersGeneratedConfig, args: QueueTarget & {
+  recordIds: readonly bigint[];
+}): (tx: Transaction) => TransactionResult;
+/**
+ * Run one bounded settlement phase on a market's queue (`queue::settle_step`) and return the
+ * phase the queue is in afterwards (u8, `queue.SETTLE_PHASE`): `0` DRAIN refunds the waiting
+ * orders, `1` PAY pays the Open records once Predict has settled the market, `2` DONE once the
+ * payout walk has reached the last record. Send one call per transaction until it returns `2` (or
+ * `MarketPayoutsCompleted` is emitted), after Predict's `try_settle`. A record the market couldn't
+ * pay stays Open with `OpenRecordPayoutSkipped`, even after DONE. Permissionless. Aborts
+ * `EMarketNotExpired` before expiry.
+ */
+declare function settleStep(config: OrdersGeneratedConfig, args: QueueTarget): (tx: Transaction) => TransactionResult;
+/**
+ * Pay one Open record of a settled market its settled payout (`queue::pay_open`), at any time
+ * after settlement, before or after `settle_step` completes: a record the payout walk skipped
+ * because the market was short of cash or its receive address was denied. Permissionless: the
+ * payout goes only to the record's own receive address. Emits `OpenRecordSettled`, or
+ * `OpenRecordPayoutSkipped` again while the cause persists. A missing or non-Open record is left
+ * alone. Aborts `EMarketNotSettled` before Predict settles the market.
+ */
+declare function payOpen(config: OrdersGeneratedConfig, args: QueueTarget & {
+  recordId: bigint;
+}): (tx: Transaction) => TransactionResult;
+/**
+ * Send a finished record's parked funds (`queue::claim_parked`): change or a refund its receive
+ * address couldn't take while it was on USDC's deny list or USDC was paused. Permissionless: the
+ * funds go only to the record's own receive address. Returns the amount sent (u64), or `0` and
+ * changes nothing for a missing or unfinished record, one with nothing parked, or an address still
+ * denied. Emits `RecordFundsClaimed`. Takes no market: `expiryMarketId` only derives the queue.
+ */
+declare function claimParked(config: OrdersGeneratedConfig, args: QueueTarget & {
+  recordId: bigint;
+}): (tx: Transaction) => TransactionResult;
+/** The current Pyth Lazer package and the original ID that types its `Update`. */
+interface LazerPackages {
+  /** Lazer's shared `State`. */
+  stateId: string;
+  /** The package to call `parse_and_verify_le_ecdsa_update` on: `State.upgrade_cap.package`. */
+  packageId: string;
+  /** The original package ID, which `update::Update` is typed by. */
+  originalId: string;
+}
+/**
+ * Verify one signed Lazer payload with the current Lazer package. A positional call on purpose:
+ * the oracle-construction packages are not generated (see `sui-codegen.config.ts`).
+ */
+declare function parseLazerUpdate(lazer: Pick<LazerPackages, 'stateId' | 'packageId'>, payload: Uint8Array): (tx: Transaction) => TransactionResult;
+/**
+ * Verify the signed Lazer payloads and commit them to the market's waiting cohorts
+ * (`queue::commit`). Permissionless. Pass the payloads for a cohort's exact τ, or a backup tick
+ * once τ + gap wait has passed with τ uncommitted (when the policy's price buffer is on). Commit
+ * matches each update to its own cohort by τ and skips one that matches nothing, so no
+ * head-of-line ordering is assumed. Resolve `lazer` per batch with `read.lazerPackages` and never
+ * cache it: a Pyth upgrade retires the old package at once.
+ */
+declare function commit(config: OrdersGeneratedConfig, args: QueueTarget & {
+  payloads: readonly Uint8Array[];
+  lazer: LazerPackages;
+}): (tx: Transaction) => TransactionResult;
+/**
+ * Fill or refund committed orders in τ order (`queue::resolve`), visiting at most `maxOrders`
+ * records (the chain caps one call at 450, since a fill emits two events and Sui allows 1,024
+ * per transaction). Permissionless. Returns how many orders it finished. An order the market
+ * can't cover is refunded with reason 8. Size `maxOrders` against the payout tree
+ * (`payoutTreeNodeCount`): about 10 to 15 fills fit one transaction in a full tree.
+ */
+declare function resolve(config: OrdersGeneratedConfig, args: QueueTarget & {
+  maxOrders: bigint | number;
+}): (tx: Transaction) => TransactionResult;
+/**
+ * The open filler (no cap exists): {@link commit} the signed Lazer payloads, then
+ * {@link resolve} up to `maxOrders` records. Anyone with Pyth Lazer access can run it. With
+ * `refundOverdue`, a final `refund` call sweeps orders past their deadline. Returns the resolve
+ * result. Split commit from resolve when the payout tree is large.
+ */
+declare function fill(config: OrdersGeneratedConfig, args: QueueTarget & {
+  payloads: readonly Uint8Array[];
+  lazer: LazerPackages;
+  maxOrders: bigint | number;
+  refundOverdue?: boolean;
+}): (tx: Transaction) => TransactionResult;
+//#endregion
+export { LazerPackages, queue_d_exports };
+//# sourceMappingURL=queue.d.mts.map

package/dist/predict/tx/queue.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.mts","names":[],"sources":["../../../src/predict/tx/queue.ts"],"mappings":"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"}

package/dist/predict/tx/queue.mjs

@@ -0,0 +1,399 @@
+import { __exportAll } from "../../_virtual/rolldown_runtime.mjs";
+import { deriveQueueId } from "../queue-id.mjs";
+import { PredictInputError } from "../errors.mjs";
+import { U64_MAX } from "../units.mjs";
+import { MIN_PREMIUM } from "../cost.mjs";
+import { orderFee } from "../../contracts/deepbook_predict_orders/delayed_execution_config.mjs";
+import { withAuth } from "./common.mjs";
+import { rebalanceExpiryCash as rebalanceExpiryCash$1 } from "../../contracts/deepbook_predict/plp.mjs";
+import { policy } from "../../contracts/deepbook_predict_orders/desk.mjs";
+import { adminRefund as adminRefund$1, claimParked as claimParked$1, cleanup as cleanup$1, commit as commit$1, createAndShare, enqueueExactAmount as enqueueExactAmount$1, enqueueExactCost as enqueueExactCost$1, enqueueExactQuantity as enqueueExactQuantity$1, enqueueRedeemOpen as enqueueRedeemOpen$1, payOpen as payOpen$1, refund as refund$1, resolve as resolve$1, settleStep as settleStep$1 } from "../../contracts/deepbook_predict_orders/queue.mjs";
+
+//#region src/predict/tx/queue.ts
+var queue_exports = /* @__PURE__ */ __exportAll({
+	adminRefund: () => adminRefund,
+	assertOrderFeeAtMost: () => assertOrderFeeAtMost,
+	claimParked: () => claimParked,
+	cleanup: () => cleanup,
+	commit: () => commit,
+	createQueue: () => createQueue,
+	enqueueExactAmount: () => enqueueExactAmount,
+	enqueueExactCost: () => enqueueExactCost,
+	enqueueExactQuantity: () => enqueueExactQuantity,
+	enqueueRedeemOpen: () => enqueueRedeemOpen,
+	fill: () => fill,
+	parseLazerUpdate: () => parseLazerUpdate,
+	payOpen: () => payOpen,
+	queueIdOf: () => queueIdOf,
+	rebalanceExpiryCash: () => rebalanceExpiryCash,
+	refund: () => refund,
+	resolve: () => resolve,
+	settleStep: () => settleStep
+});
+const FLOAT_SCALING = 1000000000n;
+const authed = {
+	enqueueExactQuantity: withAuth(enqueueExactQuantity$1),
+	enqueueExactAmount: withAuth(enqueueExactAmount$1),
+	enqueueExactCost: withAuth(enqueueExactCost$1),
+	enqueueRedeemOpen: withAuth(enqueueRedeemOpen$1)
+};
+/** The queue ID a thunk addresses: the given one, or the one derived from the config's registry. */
+function queueIdOf(config, args) {
+	return args.queueId ?? deriveQueueId(config.queueRegistry, args.expiryMarketId);
+}
+function placement(config, args) {
+	return {
+		queue: queueIdOf(config, args),
+		market: args.expiryMarketId,
+		wrapper: args.wrapperId,
+		pyth: args.pythFeed,
+		bsValues: args.blockScholesValueStore,
+		bsSvi: args.blockScholesSviStore
+	};
+}
+function assertMaxCost(maxCostRaw) {
+	if (typeof maxCostRaw !== "bigint" || maxCostRaw <= 0n || maxCostRaw >= U64_MAX) throw new PredictInputError(`maxCostRaw must be above 0 and below u64::MAX (a queued mint requires a real cap), got ${String(maxCostRaw)}`);
+}
+function assertU64(value, name) {
+	if (typeof value !== "bigint" || value < 0n || value > U64_MAX) throw new PredictInputError(`${name} must be a u64 bigint, got ${String(value)}`);
+}
+/**
+* Queue a mint of an exact payout quantity, priced at Pyth's signed price for its τ
+* (`queue::enqueue_exact_quantity`). Returns the record ID (u64). `maxCostRaw` (all-in cap) and
+* `maxProbabilityRaw` (entry-probability cap, at most 1e9) are required: there is no "unlimited"
+* default on the queued path. Escrows `min(max_cost, quantity, available − fee)` plus the order
+* fee. Command order is auth → enqueue.
+*/
+function enqueueExactQuantity(config, args) {
+	assertMaxCost(args.maxCostRaw);
+	assertU64(args.quantityRaw, "quantityRaw");
+	if (typeof args.maxProbabilityRaw !== "bigint" || args.maxProbabilityRaw <= 0n || args.maxProbabilityRaw > FLOAT_SCALING) throw new PredictInputError(`maxProbabilityRaw must be in (0, 1e9], got ${String(args.maxProbabilityRaw)}`);
+	return authed.enqueueExactQuantity({
+		config,
+		arguments: {
+			...placement(config, args),
+			lowerTick: args.lowerTick,
+			higherTick: args.higherTick,
+			quantity: args.quantityRaw,
+			maxCost: args.maxCostRaw,
+			maxProbability: args.maxProbabilityRaw
+		}
+	});
+}
+/**
+* Queue a premium-budget mint (`queue::enqueue_exact_amount`): sized at τ under
+* `maxPremiumRaw`, at least `minQuantityRaw`, with the all-in withdrawal capped by the required
+* `maxCostRaw`. Escrows `min(max_cost, available − fee)` plus the order fee. Returns the record
+* ID. Command order is auth → enqueue. `maxPremiumRaw` below the minimum premium (1 USDC) is
+* refused: the fill could never buy enough premium, so Predict's admission dry run would abort
+* `EOrderFailsLimits`.
+*/
+function enqueueExactAmount(config, args) {
+	assertMaxCost(args.maxCostRaw);
+	assertU64(args.maxPremiumRaw, "maxPremiumRaw");
+	assertU64(args.minQuantityRaw, "minQuantityRaw");
+	if (args.maxPremiumRaw < MIN_PREMIUM) throw new PredictInputError(`maxPremiumRaw ${args.maxPremiumRaw} is below the ${MIN_PREMIUM} minimum premium (EOrderFailsLimits)`);
+	return authed.enqueueExactAmount({
+		config,
+		arguments: {
+			...placement(config, args),
+			lowerTick: args.lowerTick,
+			higherTick: args.higherTick,
+			maxPremium: args.maxPremiumRaw,
+			minQuantity: args.minQuantityRaw,
+			maxCost: args.maxCostRaw
+		}
+	});
+}
+/**
+* Queue an all-in-budget mint (`queue::enqueue_exact_cost`): sized at τ so the all-in cost fits
+* `maxCostRaw`, at least `minQuantityRaw`. `maxCostRaw` is the budget and must be a real cap.
+* Escrows `min(max_cost, available − fee)` plus the order fee. Returns the record ID. Command
+* order is auth → enqueue.
+*/
+function enqueueExactCost(config, args) {
+	assertMaxCost(args.maxCostRaw);
+	assertU64(args.minQuantityRaw, "minQuantityRaw");
+	return authed.enqueueExactCost({
+		config,
+		arguments: {
+			...placement(config, args),
+			lowerTick: args.lowerTick,
+			higherTick: args.higherTick,
+			maxCost: args.maxCostRaw,
+			minQuantity: args.minQuantityRaw
+		}
+	});
+}
+/**
+* Queue an early sell of `closeQuantityRaw` from the Open record `recordId`
+* (`queue::enqueue_redeem_open`; the queue record ID, not the position's u256 order ID). The
+* only early sell: a position held in the account can't be sold early. The record must be Open
+* and belong to this account. `minProbabilityRaw` and `minProceedsRaw` are the close-side floors
+* at τ and are required (`0n` disables either, so pass it on purpose). Escrows only the order
+* fee. Returns the new record ID, which holds the position until the sell fills or refunds.
+* Command order is auth → enqueue.
+*/
+function enqueueRedeemOpen(config, args) {
+	assertU64(args.recordId, "recordId");
+	assertU64(args.minProbabilityRaw, "minProbabilityRaw");
+	assertU64(args.minProceedsRaw, "minProceedsRaw");
+	if (typeof args.closeQuantityRaw !== "bigint" || args.closeQuantityRaw <= 0n) throw new PredictInputError(`closeQuantityRaw must be above 0, got ${String(args.closeQuantityRaw)}`);
+	return authed.enqueueRedeemOpen({
+		config,
+		arguments: {
+			...placement(config, args),
+			recordId: args.recordId,
+			closeQuantity: args.closeQuantityRaw,
+			minProbability: args.minProbabilityRaw,
+			minProceeds: args.minProceedsRaw
+		}
+	});
+}
+/**
+* Abort the transaction unless the order desk's fee is at most `maxOrderFeeRaw` when it executes.
+* The enqueues charge the desk's fee at execution and take no fee bound, so add this BEFORE an
+* enqueue to hold it to the fee its preview showed. It reads the desk's policy, and
+* `0x1::u64::checked_sub(max, fee)` is none once the fee is above the bound, so
+* `0x1::option::destroy_some` aborts (`option::EOPTION_NOT_SET`, code 0x40001) before the
+* enqueue debits anything. Read-only on the desk.
+*/
+function assertOrderFeeAtMost(config, maxOrderFeeRaw) {
+	assertU64(maxOrderFeeRaw, "maxOrderFeeRaw");
+	return (tx) => {
+		const policy$1 = tx.add(policy({ config }));
+		const fee = tx.add(orderFee({
+			config,
+			arguments: { policy: policy$1 }
+		}));
+		const headroom = tx.moveCall({
+			target: "0x1::u64::checked_sub",
+			arguments: [tx.pure.u64(maxOrderFeeRaw), fee]
+		});
+		tx.moveCall({
+			target: "0x1::option::destroy_some",
+			typeArguments: ["u64"],
+			arguments: [headroom]
+		});
+	};
+}
+/**
+* Fund a live market from the pool vault to `max(required × (1 + rebalance %), initial cash,
+* required + waiting_cash_need)` (Predict's `plp::rebalance_expiry_cash`). Permissionless, and
+* takes no target. Add it AFTER a big sell's enqueue in the same PTB: the enqueue has already
+* added the sell's cash need to Predict's waiting total, so the rebalance funds it at once. It
+* takes the hot `PoolVault`, so add it only when a sell's cash need is above spare cash.
+*/
+function rebalanceExpiryCash(config, args) {
+	return rebalanceExpiryCash$1({
+		config,
+		arguments: { market: args.expiryMarketId }
+	});
+}
+/**
+* Create and share a market's `MarketQueue` (`queue::create_and_share(registry, desk, market)`),
+* at the ID `deriveQueueId(config.queueRegistry, expiryMarketId)`. Takes the registry mutably and
+* the desk read-only, so it never contends with trading. Permissionless and once per market (a
+* second call aborts, since the ID is taken); the caller pays its storage. The market-creation
+* keeper sends it after each new `ExpiryMarket`. Returns the queue ID.
+*/
+function createQueue(config, args) {
+	return createAndShare({
+		config,
+		arguments: { market: args.expiryMarketId }
+	});
+}
+/**
+* Refund this market's waiting orders at or past their deadline (`queue::refund`, reason 5),
+* visiting at most `maxOrders` records (the chain caps one call at 450). Permissionless: no auth,
+* session or Pyth key, and it works during a freeze. Returns how many it refunded, `0` without
+* aborting when none is due. Send it only from the app's refund button, never prepended to other
+* transactions: keepers refund on their own. Every visited record counts toward Sui's
+* per-transaction object limit.
+*/
+function refund(config, args) {
+	return refund$1({
+		config,
+		arguments: {
+			queue: queueIdOf(config, args),
+			market: args.expiryMarketId,
+			maxOrders: args.maxOrders
+		}
+	});
+}
+/**
+* Refund the listed waiting orders at once (`queue::admin_refund`, reason 7), wherever they sit
+* in the queue. Takes Predict's `AdminCap`, and works while Predict is frozen. Missing and
+* finished record IDs are skipped.
+*/
+function adminRefund(config, args) {
+	return adminRefund$1({
+		config,
+		arguments: {
+			queue: queueIdOf(config, args),
+			market: args.expiryMarketId,
+			AdminCap: args.adminCapId,
+			recordIds: [...args.recordIds]
+		}
+	});
+}
+/**
+* Delete Refunded and Closed records of a settled market (`queue::cleanup`). Permissionless; the
+* storage rebate goes to the sender. Missing IDs, other statuses and records still holding a
+* receipt or funds (parked funds included, until `claimParked`) are skipped. Aborts
+* `EMarketNotSettled` before settlement.
+*/
+function cleanup(config, args) {
+	return cleanup$1({
+		config,
+		arguments: {
+			queue: queueIdOf(config, args),
+			market: args.expiryMarketId,
+			recordIds: [...args.recordIds]
+		}
+	});
+}
+/**
+* Run one bounded settlement phase on a market's queue (`queue::settle_step`) and return the
+* phase the queue is in afterwards (u8, `queue.SETTLE_PHASE`): `0` DRAIN refunds the waiting
+* orders, `1` PAY pays the Open records once Predict has settled the market, `2` DONE once the
+* payout walk has reached the last record. Send one call per transaction until it returns `2` (or
+* `MarketPayoutsCompleted` is emitted), after Predict's `try_settle`. A record the market couldn't
+* pay stays Open with `OpenRecordPayoutSkipped`, even after DONE. Permissionless. Aborts
+* `EMarketNotExpired` before expiry.
+*/
+function settleStep(config, args) {
+	return settleStep$1({
+		config,
+		arguments: {
+			queue: queueIdOf(config, args),
+			market: args.expiryMarketId
+		}
+	});
+}
+/**
+* Pay one Open record of a settled market its settled payout (`queue::pay_open`), at any time
+* after settlement, before or after `settle_step` completes: a record the payout walk skipped
+* because the market was short of cash or its receive address was denied. Permissionless: the
+* payout goes only to the record's own receive address. Emits `OpenRecordSettled`, or
+* `OpenRecordPayoutSkipped` again while the cause persists. A missing or non-Open record is left
+* alone. Aborts `EMarketNotSettled` before Predict settles the market.
+*/
+function payOpen(config, args) {
+	assertU64(args.recordId, "recordId");
+	return payOpen$1({
+		config,
+		arguments: {
+			queue: queueIdOf(config, args),
+			market: args.expiryMarketId,
+			recordId: args.recordId
+		}
+	});
+}
+/**
+* Send a finished record's parked funds (`queue::claim_parked`): change or a refund its receive
+* address couldn't take while it was on USDC's deny list or USDC was paused. Permissionless: the
+* funds go only to the record's own receive address. Returns the amount sent (u64), or `0` and
+* changes nothing for a missing or unfinished record, one with nothing parked, or an address still
+* denied. Emits `RecordFundsClaimed`. Takes no market: `expiryMarketId` only derives the queue.
+*/
+function claimParked(config, args) {
+	assertU64(args.recordId, "recordId");
+	return claimParked$1({
+		config,
+		arguments: {
+			queue: queueIdOf(config, args),
+			recordId: args.recordId
+		}
+	});
+}
+/**
+* Verify one signed Lazer payload with the current Lazer package. A positional call on purpose:
+* the oracle-construction packages are not generated (see `sui-codegen.config.ts`).
+*/
+function parseLazerUpdate(lazer, payload) {
+	return (tx) => tx.moveCall({
+		target: `${lazer.packageId}::pyth_lazer::parse_and_verify_le_ecdsa_update`,
+		arguments: [
+			tx.object(lazer.stateId),
+			tx.object.clock(),
+			tx.pure.vector("u8", payload)
+		]
+	});
+}
+/**
+* Verify the signed Lazer payloads and commit them to the market's waiting cohorts
+* (`queue::commit`). Permissionless. Pass the payloads for a cohort's exact τ, or a backup tick
+* once τ + gap wait has passed with τ uncommitted (when the policy's price buffer is on). Commit
+* matches each update to its own cohort by τ and skips one that matches nothing, so no
+* head-of-line ordering is assumed. Resolve `lazer` per batch with `read.lazerPackages` and never
+* cache it: a Pyth upgrade retires the old package at once.
+*/
+function commit(config, args) {
+	if (args.payloads.length === 0) throw new PredictInputError("commit needs at least one signed Lazer payload");
+	return (tx) => {
+		const updates = args.payloads.map((payload) => tx.add(parseLazerUpdate(args.lazer, payload)));
+		const vector = tx.makeMoveVec({
+			type: `${args.lazer.originalId}::update::Update`,
+			elements: updates
+		});
+		return tx.add(commit$1({
+			config,
+			arguments: {
+				queue: queueIdOf(config, args),
+				market: args.expiryMarketId,
+				updates: vector
+			}
+		}));
+	};
+}
+/**
+* Fill or refund committed orders in τ order (`queue::resolve`), visiting at most `maxOrders`
+* records (the chain caps one call at 450, since a fill emits two events and Sui allows 1,024
+* per transaction). Permissionless. Returns how many orders it finished. An order the market
+* can't cover is refunded with reason 8. Size `maxOrders` against the payout tree
+* (`payoutTreeNodeCount`): about 10 to 15 fills fit one transaction in a full tree.
+*/
+function resolve(config, args) {
+	return resolve$1({
+		config,
+		arguments: {
+			queue: queueIdOf(config, args),
+			market: args.expiryMarketId,
+			maxOrders: args.maxOrders
+		}
+	});
+}
+/**
+* The open filler (no cap exists): {@link commit} the signed Lazer payloads, then
+* {@link resolve} up to `maxOrders` records. Anyone with Pyth Lazer access can run it. With
+* `refundOverdue`, a final `refund` call sweeps orders past their deadline. Returns the resolve
+* result. Split commit from resolve when the payout tree is large.
+*/
+function fill(config, args) {
+	if (args.payloads.length === 0) throw new PredictInputError("fill needs at least one signed Lazer payload");
+	const target = {
+		expiryMarketId: args.expiryMarketId,
+		queueId: queueIdOf(config, args)
+	};
+	return (tx) => {
+		tx.add(commit(config, {
+			...target,
+			payloads: args.payloads,
+			lazer: args.lazer
+		}));
+		const resolved = tx.add(resolve(config, {
+			...target,
+			maxOrders: args.maxOrders
+		}));
+		if (args.refundOverdue) tx.add(refund(config, {
+			...target,
+			maxOrders: args.maxOrders
+		}));
+		return resolved;
+	};
+}
+
+//#endregion
+export { assertOrderFeeAtMost, claimParked, enqueueExactAmount, enqueueExactCost, enqueueExactQuantity, enqueueRedeemOpen, fill, payOpen, queueIdOf, queue_exports, rebalanceExpiryCash, refund };
+//# sourceMappingURL=queue.mjs.map