@mysten/deepbook-v3 2.6.4 → 2.8.0

package/dist/contracts/deepbook_predict_orders/queue.mjs

@@ -0,0 +1,912 @@
+import { __exportAll } from "../../_virtual/rolldown_runtime.mjs";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.mjs";
+import { OrderBook } from "./order_queue.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/deepbook_predict_orders/queue.ts
+/**************************************************************
+* THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+**************************************************************/
+/**
+* One expiry market's delayed-execution queue, `MarketQueue`, and its flows:
+* placement of queued mints and early sells, commit of verified Pyth Lazer prices,
+* resolve at the committed tick, the deadline and admin refunds, the settlement
+* drain and payout walk, cleanup, and the queue reads.
+*
+* Every money-moving step runs inside one of Predict's order-flow primitives,
+* which check their own gates and bindings when they run: admission (`admit_mint`,
+* `admit_sell`), `commit`, `try_fill`, `release`, and `try_pay_settled`. The queue
+* owns what Predict leaves to the companion: τ and the deadline, the stuck gate,
+* capacities and per-account caps, cohort order, the exact-or-backup tick choice,
+* escrow custody, refund routing, and the queue events. Each record holds
+* Predict's receipt for its order and that order's own escrow, so a refund pays
+* exactly that record's escrow.
+*
+* A queued fill never enters the account: it stays an Open record until
+* `enqueue_redeem_open` sells it or the settlement payout walk or `pay_open` pays
+* it.
+*
+* Mainnet USDC is a regulated coin: Sui aborts a transaction that sends it to an
+* address on its deny list for the current epoch, or to anyone while it is
+* globally paused. Every walker restarts at the same head record, so one such send
+* would block the market's fills, refunds, and payouts for good. So nothing here,
+* and nothing in Predict's primitives, sends to a denied address. Predict refuses
+* a fill for a denied receive address (reason 9), keeps a denied builder's or
+* referrer's fee in market cash, and skips a denied winner's payout. The queue
+* parks change and refunds it cannot send in the record, which finishes as usual
+* with the funds kept (`RecordFundsParked`). `claim_parked` sends them, and
+* `pay_open` pays a skipped Open record, once the address is clear. While USDC is
+* globally paused every address counts as denied: fills refuse, refunds park, and
+* payouts skip until the pause lifts.
+*/
+var queue_exports = /* @__PURE__ */ __exportAll({
+	MarketQueue: () => MarketQueue,
+	adminRefund: () => adminRefund,
+	claimParked: () => claimParked,
+	cleanup: () => cleanup,
+	commit: () => commit,
+	createAndShare: () => createAndShare,
+	deskId: () => deskId,
+	enqueueExactAmount: () => enqueueExactAmount,
+	enqueueExactCost: () => enqueueExactCost,
+	enqueueExactQuantity: () => enqueueExactQuantity,
+	enqueueRedeemOpen: () => enqueueRedeemOpen,
+	expiryMarketId: () => expiryMarketId,
+	id: () => id,
+	oldestUnfinishedTauMs: () => oldestUnfinishedTauMs,
+	order: () => order,
+	payOpen: () => payOpen,
+	payoutProgress: () => payoutProgress,
+	pendingCounts: () => pendingCounts,
+	phaseDone: () => phaseDone,
+	phaseDrain: () => phaseDrain,
+	phasePay: () => phasePay,
+	queueHeads: () => queueHeads,
+	queueId: () => queueId,
+	queueStuck: () => queueStuck,
+	quoteRedeemOpen: () => quoteRedeemOpen,
+	refund: () => refund,
+	resolve: () => resolve,
+	settleStep: () => settleStep,
+	waitingCohorts: () => waitingCohorts,
+	waitingOrders: () => waitingOrders
+});
+const $moduleName = "@local-pkg/deepbook_predict_orders::queue";
+const MarketQueue = new MoveStruct({
+	name: `${$moduleName}::MarketQueue`,
+	fields: {
+		id: bcs.Address,
+		desk_id: bcs.Address,
+		expiry_market_id: bcs.Address,
+		book: OrderBook,
+		payouts_completed: bcs.bool()
+	}
+});
+function phaseDrain(options = {}) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "phase_drain"
+	});
+}
+function phasePay(options = {}) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "phase_pay"
+	});
+}
+function phaseDone(options = {}) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "phase_done"
+	});
+}
+/**
+* Return the ID of `expiry_market_id`'s queue under the queue registry
+* `registry_id`, whether or not it exists yet. For PTB construction.
+*/
+function queueId(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = ["0x2::object::ID", "0x2::object::ID"];
+	const parameterNames = ["registryId", "expiryMarketId"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "queue_id",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function id(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [null];
+	const parameterNames = ["queue"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "id",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function deskId(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [null];
+	const parameterNames = ["queue"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "desk_id",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function expiryMarketId(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [null];
+	const parameterNames = ["queue"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "expiry_market_id",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/** Return one record, or `none` for a missing or deleted record ID. */
+function order(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [null, "u64"];
+	const parameterNames = ["queue", "recordId"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "order",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Return `(resolve_head, next_id, last_tau_ms, last_committed_tau_ms)`.
+* `resolve_head` is a lower bound on the first unfinished record.
+*/
+function queueHeads(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [null];
+	const parameterNames = ["queue"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "queue_heads",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Return `(payout_cursor, next_id, payouts_completed)`. The settlement payout walk
+* is finished once `payouts_completed` is set.
+*/
+function payoutProgress(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [null];
+	const parameterNames = ["queue"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "payout_progress",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Return
+* `(cohort count, oldest uncommitted τ, oldest uncommitted τ above  last_committed_tau_ms)`.
+* The third value is the cohort the stuck gate's first rule watches.
+*/
+function waitingCohorts(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [null];
+	const parameterNames = ["queue"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "waiting_cohorts",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Whether placement would refuse a new order as stuck right now (both rules of the
+* stuck gate). Drives the app's "pricing delayed" banner.
+*/
+function queueStuck(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		"0x2::clock::Clock"
+	];
+	const parameterNames = ["queue", "desk"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "queue_stuck",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Return `(pending_mints, pending_sells)`, the unfinished orders counted against
+* the policy capacities.
+*/
+function pendingCounts(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [null];
+	const parameterNames = ["queue"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "pending_counts",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Return the unfinished queued orders `account_id` holds in this queue, the count
+* the per-account cap checks. The settlement drain (`settle_step`) refunds without
+* lowering it, since no placement reads it once the market has expired, so after
+* expiry it can overstate what the account still has waiting. Read `order` for
+* each record's status instead.
+*/
+function waitingOrders(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [null, "0x2::object::ID"];
+	const parameterNames = ["queue", "accountId"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "waiting_orders",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/** Return τ of the oldest cohort with an unfinished order, for monitoring. */
+function oldestUnfinishedTauMs(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [null];
+	const parameterNames = ["queue"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "oldest_unfinished_tau_ms",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Quote an early sell of `close_quantity` from the Open record `record_id` at a
+* live `Pricer`, with the wrapper account's builder code, through Predict's
+* `quote_close`: the close a queued sell fills, with the trading fee at the clock
+* instead of a committed tick. `proceeds` is before the order fee. Changes
+* nothing. Aborts `ERecordNotOpen` for a missing or non-Open record, and otherwise
+* as `quote_close` does. Does not check that the account owns the record. For SDK
+* and devInspect pricing before `enqueue_redeem_open`.
+*/
+function quoteRedeemOpen(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"wrapper",
+		"pricer",
+		"recordId",
+		"closeQuantity"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "quote_redeem_open",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Create and share `market`'s queue under `desk`. Permissionless; the caller pays
+* its storage. The queue's ID is derived from the desk's registry and the market,
+* so a second call for the same market aborts. Writes only the registry, which no
+* trading call reads, so creation never contends with trading on the desk. Aborts
+* `EWrongDesk` for another desk's registry.
+*/
+function createAndShare(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"registry",
+		"desk",
+		"market"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "create_and_share",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			registry: options.arguments?.registry ?? options.config?.queueRegistry,
+			desk: options.arguments?.desk ?? options.config?.orderDesk
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Place a queued mint for an exact quantity, priced later at Pyth's signed price
+* for its τ. `max_cost` caps the all-in withdrawal and is mandatory;
+* `max_probability` caps the entry probability at τ. Escrows the budget,
+* `min(max_cost, quantity, available - order_fee)`, and the order fee, and returns
+* the new record ID.
+*
+* Aborts, charging nothing, when the queue refuses the order: the desk floor,
+* another desk's or market's queue (`EWrongDesk`, `EWrongMarket`), a stuck or full
+* queue (`EQueueStuck`, `EQueueFull`, `EAccountOrderCap`), τ at or past the cutoff
+* (`EPastCutoff`), an unlimited or zero `max_cost` (`EMintCostCapRequired`), or a
+* balance not above the order fee (`EFeeNotCovered`). Then Predict's `admit_mint`
+* applies its gates, the order's own limits at the clock, and the market's spare
+* cash.
+*/
+function enqueueExactQuantity(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"0x2::accumulator::AccumulatorRoot",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"wrapper",
+		"auth",
+		"desk",
+		"config",
+		"propbookRegistry",
+		"pyth",
+		"bsValues",
+		"bsSvi",
+		"lowerTick",
+		"higherTick",
+		"quantity",
+		"maxCost",
+		"maxProbability"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "enqueue_exact_quantity",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk,
+			config: options.arguments?.config ?? options.config?.protocolConfig,
+			propbookRegistry: options.arguments?.propbookRegistry ?? options.config?.oracleRegistry
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Place a queued premium-budget mint: sized at τ under `max_premium`, at least
+* `min_quantity`, with the all-in withdrawal capped by the mandatory `max_cost`.
+* Escrows `min(max_cost, available - order_fee)` and the order fee. Refuses orders
+* like `enqueue_exact_quantity`. Returns the new record ID.
+*/
+function enqueueExactAmount(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"0x2::accumulator::AccumulatorRoot",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"wrapper",
+		"auth",
+		"desk",
+		"config",
+		"propbookRegistry",
+		"pyth",
+		"bsValues",
+		"bsSvi",
+		"lowerTick",
+		"higherTick",
+		"maxPremium",
+		"minQuantity",
+		"maxCost"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "enqueue_exact_amount",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk,
+			config: options.arguments?.config ?? options.config?.protocolConfig,
+			propbookRegistry: options.arguments?.propbookRegistry ?? options.config?.oracleRegistry
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Place a queued all-in-budget mint: sized at τ so the all-in cost fits
+* `max_cost`, at least `min_quantity`. Escrows
+* `min(max_cost, available -  order_fee)` and the order fee. `max_cost` is
+* mandatory here too: the unlimited value is refused. Refuses orders like
+* `enqueue_exact_quantity`. Returns the new record ID.
+*/
+function enqueueExactCost(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"0x2::accumulator::AccumulatorRoot",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"wrapper",
+		"auth",
+		"desk",
+		"config",
+		"propbookRegistry",
+		"pyth",
+		"bsValues",
+		"bsSvi",
+		"lowerTick",
+		"higherTick",
+		"maxCost",
+		"minQuantity"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "enqueue_exact_cost",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk,
+			config: options.arguments?.config ?? options.config?.protocolConfig,
+			propbookRegistry: options.arguments?.propbookRegistry ?? options.config?.oracleRegistry
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Place a queued early sell of `close_quantity` of an Open record's position.
+* `record_id` is the record's queue ID, not the position's order ID. The source
+* record must belong to this account (`ENotRecordOwner`) and be Open
+* (`ERecordNotOpen`, also for a missing ID). It is marked Closed and its receipt
+* and whole position move into the new record until the sell fills or refunds.
+* `min_probability` and `min_proceeds` are the close-side floors at τ. Returns the
+* new record ID.
+*
+* Escrows only the order fee, so a balance equal to it is enough. Refuses a sell
+* below `min_sell_quantity` or one leaving a remainder below it (`EBelowMinSell`),
+* and otherwise like `enqueue_exact_quantity`. Predict's `admit_sell` is open
+* during the trading pause and a market mint pause and has no spare-cash check:
+* the keeper funds the market before τ, and resolve refunds a sell the market
+* still cannot cover.
+*/
+function enqueueRedeemOpen(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"0x2::accumulator::AccumulatorRoot",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"wrapper",
+		"auth",
+		"desk",
+		"config",
+		"propbookRegistry",
+		"pyth",
+		"bsValues",
+		"bsSvi",
+		"recordId",
+		"closeQuantity",
+		"minProbability",
+		"minProceeds"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "enqueue_redeem_open",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk,
+			config: options.arguments?.config ?? options.config?.protocolConfig,
+			propbookRegistry: options.arguments?.propbookRegistry ?? options.config?.oracleRegistry
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Attach verified Pyth Lazer prices to the waiting cohorts whose τ they match.
+* Permissionless. Each update must come from the Pyth Lazer verifier earlier in
+* the same PTB; their order in `updates` does not matter. An update that matches
+* no waiting cohort is skipped.
+*
+* Matching reads only the inline cohort list and picks at most one update per
+* waiting cohort before its deadline: the one stamped exactly its τ on its
+* channel, or else, once the price buffer is above zero and now is at least
+* `gap_wait_ms` past τ, the one stamped one tick of the cohort's own channel
+* later. Each matched cohort then commits whole or not at all: one price per feed
+* is decoded through `lazer_price::from_update`, every Pending order is checked
+* against it before any is written, and an empty price, a price generated before
+* τ, or an envelope after now leaves the cohort for a later commit or its deadline
+* refund. The decode aborts on an update that lacks an order's feed or one of its
+* properties, because the caller passed the wrong update. Each committed mint
+* escrows the subsidy Predict reserves for it.
+*
+* Uses Lazer's v1 `Update`, which Pyth marked deprecated on Mainnet but still
+* serves; v2 arrives with a later library constructor.
+*/
+function commit(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		"vector<null>",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"desk",
+		"config",
+		"updates"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "commit",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Fill or refund committed orders in τ order, visiting at most `max_orders`
+* records, and never more than 450 (each emits up to two events, and Sui caps a
+* transaction at 1,024). Permissionless. Returns how many orders it finished.
+*
+* Walks the cohorts in τ order and loads only committed or overdue ones; a cohort
+* still waiting for its price is skipped without loading a record. Every record
+* visited counts against `max_orders`, finished or missing ones included. The 450
+* cap bounds events, not loaded objects (`MAX_ORDERS_PER_CALL`), so the caller
+* sizes `max_orders` to stay inside Sui's per-transaction object limit. An order
+* at or past its deadline is refunded (reason 5), never filled. A committed order
+* goes to Predict's `try_fill`, which fills it or returns the refund reason (1, 2,
+* 4, 8, or 9); the queue returns the escrow Predict hands back to the trader, or
+* parks it in the record when the receive address is denied. Returns 0 on a
+* settled market, whose waiting orders the settlement drain refunds.
+*/
+function resolve(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"0x2::deny_list::DenyList",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"desk",
+		"config",
+		"maxOrders"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "resolve",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Refund waiting orders at or past their deadline (reason 5), visiting at most
+* `max_orders` records, refunded or not, and never more than 450, as `resolve`
+* does. It walks the cohorts in τ order and stops at the first one not yet due,
+* since deadlines never decrease along the queue. Permissionless, and available
+* while Predict is frozen or this companion's witness is disabled: Predict's
+* `release` checks only its version floor. A refund the receive address cannot
+* take is parked in its record. Returns how many orders it refunded: `0`, without
+* aborting, when none is due.
+*/
+function refund(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"0x2::deny_list::DenyList",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"desk",
+		"config",
+		"maxOrders"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "refund",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Refund the listed waiting orders at once (reason 7), wherever they sit in the
+* queue. Predict's `AdminCap` only, and available while Predict is frozen. Missing
+* and finished IDs are skipped, and a refund the receive address cannot take is
+* parked in its record.
+*/
+function adminRefund(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		null,
+		"vector<u64>",
+		"0x2::deny_list::DenyList",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"AdminCap",
+		"desk",
+		"config",
+		"recordIds"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "admin_refund",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Delete Refunded and Closed records of a settled market. Permissionless; the
+* storage rebate goes to the caller. Missing IDs, other statuses, and records
+* still holding a receipt or funds (parked funds included, until `claim_parked`)
+* are skipped; `QueuedOrdersCleaned` is emitted only when a record was deleted.
+* Takes `&Clock` only to stamp the event.
+*/
+function cleanup(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"vector<u64>",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"desk",
+		"recordIds"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "cleanup",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Run one bounded settlement phase on this queue and return the phase the queue is
+* in afterwards, which the next call runs (`phase_drain`, `phase_pay`, or
+* `phase_done`). Permissionless; aborts `EMarketNotExpired` before expiry.
+*
+* - DRAIN, while unfinished orders remain: refund them in τ order with reason 5,
+*   visiting at most the policy's `settle_refund_batch` records, refunded or not.
+*   No pruning and no account rows, so each refund loads its record alone. A
+*   refund the receive address cannot take is parked in its record. Runs before
+*   and after Predict settles, and while Predict is frozen.
+* - PAY, once nothing is unfinished and Predict has settled the market: from the
+*   payout cursor, visit at most `settle_payout_batch` records. Each Open record
+*   is paid its settled payout through `try_pay_settled` (zero for a loser),
+*   marked Closed, and reported with `OpenRecordSettled`. A record the market
+*   cannot pay, or whose receive address is denied, stays Open with
+*   `OpenRecordPayoutSkipped`, and `pay_open` pays it later. Before Predict
+*   settles, a PAY call changes nothing.
+* - DONE: the call whose walk reaches the last record emits
+*   `MarketPayoutsCompleted`; later calls change nothing. Skipped records are
+*   still paid through `pay_open`.
+*
+* The keeper sends one call per transaction until it returns `phase_done()`.
+*/
+function settleStep(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		"0x2::deny_list::DenyList",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"desk",
+		"config"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "settle_step",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Pay one Open record of a settled market its settled payout through Predict's
+* `try_pay_settled`, at any time after settlement, before or after `settle_step`
+* completes: the record the payout walk skipped because the market was short of
+* cash or its receive address was denied. Permissionless. Emits
+* `OpenRecordSettled` and closes the record, or emits `OpenRecordPayoutSkipped`
+* and leaves it Open if the cause persists. A missing or non-Open record is left
+* alone. Aborts `EMarketNotSettled` before Predict settles the market.
+*/
+function payOpen(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"0x2::deny_list::DenyList",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"market",
+		"desk",
+		"config",
+		"recordId"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "pay_open",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Send a finished record's parked funds, change or a refund its receive address
+* could not take, to that address once a send would go through (`denied` is
+* false). Permissionless: the funds go only to the record's own receive address.
+* Emits `RecordFundsClaimed` and returns the amount sent, or returns `0` and
+* changes nothing for a missing or unfinished record, one with nothing parked, or
+* an address still denied.
+*/
+function claimParked(options) {
+	const packageAddress = options.package ?? options.config?.predictOrdersPackageId ?? "@local-pkg/deepbook_predict_orders";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::deny_list::DenyList",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"queue",
+		"desk",
+		"recordId"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "queue",
+		function: "claim_parked",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			desk: options.arguments?.desk ?? options.config?.orderDesk
+		}, argumentsTypes, parameterNames)
+	});
+}
+
+//#endregion
+export { adminRefund, claimParked, cleanup, commit, createAndShare, enqueueExactAmount, enqueueExactCost, enqueueExactQuantity, enqueueRedeemOpen, order, payOpen, payoutProgress, pendingCounts, queueHeads, queueStuck, queue_exports, quoteRedeemOpen, refund, resolve, settleStep, waitingCohorts, waitingOrders };
+//# sourceMappingURL=queue.mjs.map