@mysten/deepbook-v3 2.6.4 → 2.8.0

package/dist/contracts/deepbook_predict_orders/queue.d.mts

@@ -0,0 +1,683 @@
+import { ConfigValue, MoveStruct, RawTransactionArgument } from "../utils/index.mjs";
+import * as _mysten_sui_bcs440 from "@mysten/sui/bcs";
+import * as _mysten_sui_transactions224 from "@mysten/sui/transactions";
+import { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+
+//#region src/contracts/deepbook_predict_orders/queue.d.ts
+declare namespace queue_d_exports {
+  export { AdminRefundArguments, AdminRefundOptions, ClaimParkedArguments, ClaimParkedOptions, CleanupArguments, CleanupOptions, CommitArguments, CommitOptions, CreateAndShareArguments, CreateAndShareOptions, DeskIdArguments, DeskIdOptions, EnqueueExactAmountArguments, EnqueueExactAmountOptions, EnqueueExactCostArguments, EnqueueExactCostOptions, EnqueueExactQuantityArguments, EnqueueExactQuantityOptions, EnqueueRedeemOpenArguments, EnqueueRedeemOpenOptions, ExpiryMarketIdArguments, ExpiryMarketIdOptions, IdArguments, IdOptions, MarketQueue, OldestUnfinishedTauMsArguments, OldestUnfinishedTauMsOptions, OrderArguments, OrderOptions, PayOpenArguments, PayOpenOptions, PayoutProgressArguments, PayoutProgressOptions, PendingCountsArguments, PendingCountsOptions, PhaseDoneOptions, PhaseDrainOptions, PhasePayOptions, QueueHeadsArguments, QueueHeadsOptions, QueueIdArguments, QueueIdOptions, QueueStuckArguments, QueueStuckOptions, QuoteRedeemOpenArguments, QuoteRedeemOpenOptions, RefundArguments, RefundOptions, ResolveArguments, ResolveOptions, SettleStepArguments, SettleStepOptions, WaitingCohortsArguments, WaitingCohortsOptions, WaitingOrdersArguments, WaitingOrdersOptions, adminRefund, claimParked, cleanup, commit, createAndShare, deskId, enqueueExactAmount, enqueueExactCost, enqueueExactQuantity, enqueueRedeemOpen, expiryMarketId, id, oldestUnfinishedTauMs, order, payOpen, payoutProgress, pendingCounts, phaseDone, phaseDrain, phasePay, queueHeads, queueId, queueStuck, quoteRedeemOpen, refund, resolve, settleStep, waitingCohorts, waitingOrders };
+}
+declare const MarketQueue: MoveStruct<{
+  id: _mysten_sui_bcs440.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  desk_id: _mysten_sui_bcs440.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  expiry_market_id: _mysten_sui_bcs440.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  book: MoveStruct<{
+    orders: MoveStruct<{
+      id: _mysten_sui_bcs440.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      size: _mysten_sui_bcs440.BcsType<bigint, string | number | bigint, "u64">;
+    }, "0x2::table::Table<phantom K, phantom V>">;
+    next_id: _mysten_sui_bcs440.BcsType<bigint, string | number | bigint, "u64">;
+    resolve_head: _mysten_sui_bcs440.BcsType<bigint, string | number | bigint, "u64">;
+    payout_cursor: _mysten_sui_bcs440.BcsType<bigint, string | number | bigint, "u64">;
+    cohorts: _mysten_sui_bcs440.BcsType<{
+      tau_ms: bigint;
+      deadline_ms: bigint;
+      first_id: bigint;
+      end_id: bigint;
+      pyth_channel: number;
+      committed: boolean;
+      unfinished: bigint;
+    }[], Iterable<{
+      tau_ms: string | number | bigint;
+      deadline_ms: string | number | bigint;
+      first_id: string | number | bigint;
+      end_id: string | number | bigint;
+      pyth_channel: number;
+      committed: boolean;
+      unfinished: string | number | bigint;
+    }> & {
+      length: number;
+    }, string>;
+    last_tau_ms: _mysten_sui_bcs440.BcsType<bigint, string | number | bigint, "u64">;
+    last_committed_tau_ms: _mysten_sui_bcs440.BcsType<bigint, string | number | bigint, "u64">;
+    last_deadline_ms: _mysten_sui_bcs440.BcsType<bigint, string | number | bigint, "u64">;
+    last_channel: _mysten_sui_bcs440.BcsType<number, number, "u8">;
+    per_account: MoveStruct<{
+      id: _mysten_sui_bcs440.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      size: _mysten_sui_bcs440.BcsType<bigint, string | number | bigint, "u64">;
+    }, "0x2::table::Table<phantom K, phantom V>">;
+    pending_mints: _mysten_sui_bcs440.BcsType<bigint, string | number | bigint, "u64">;
+    pending_sells: _mysten_sui_bcs440.BcsType<bigint, string | number | bigint, "u64">;
+  }, "@local-pkg/deepbook_predict_orders::order_queue::OrderBook">; /** Set by the `settle_step` call that emits `MarketPayoutsCompleted`. */
+  payouts_completed: _mysten_sui_bcs440.BcsType<boolean, boolean, "bool">;
+}, "@local-pkg/deepbook_predict_orders::queue::MarketQueue">;
+interface PhaseDrainOptions {
+  package?: string;
+  arguments?: [];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function phaseDrain(options?: PhaseDrainOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface PhasePayOptions {
+  package?: string;
+  arguments?: [];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function phasePay(options?: PhasePayOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface PhaseDoneOptions {
+  package?: string;
+  arguments?: [];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function phaseDone(options?: PhaseDoneOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface QueueIdArguments {
+  registryId: RawTransactionArgument<string>;
+  expiryMarketId: RawTransactionArgument<string>;
+}
+interface QueueIdOptions {
+  package?: string;
+  arguments: QueueIdArguments | [registryId: RawTransactionArgument<string>, expiryMarketId: RawTransactionArgument<string>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * Return the ID of `expiry_market_id`'s queue under the queue registry
+ * `registry_id`, whether or not it exists yet. For PTB construction.
+ */
+declare function queueId(options: QueueIdOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface IdArguments {
+  queue: RawTransactionArgument<string>;
+}
+interface IdOptions {
+  package?: string;
+  arguments: IdArguments | [queue: RawTransactionArgument<string>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function id(options: IdOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface DeskIdArguments {
+  queue: RawTransactionArgument<string>;
+}
+interface DeskIdOptions {
+  package?: string;
+  arguments: DeskIdArguments | [queue: RawTransactionArgument<string>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function deskId(options: DeskIdOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface ExpiryMarketIdArguments {
+  queue: RawTransactionArgument<string>;
+}
+interface ExpiryMarketIdOptions {
+  package?: string;
+  arguments: ExpiryMarketIdArguments | [queue: RawTransactionArgument<string>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function expiryMarketId(options: ExpiryMarketIdOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface OrderArguments {
+  queue: RawTransactionArgument<string>;
+  recordId: RawTransactionArgument<number | bigint>;
+}
+interface OrderOptions {
+  package?: string;
+  arguments: OrderArguments | [queue: RawTransactionArgument<string>, recordId: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+/** Return one record, or `none` for a missing or deleted record ID. */
+declare function order(options: OrderOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface QueueHeadsArguments {
+  queue: RawTransactionArgument<string>;
+}
+interface QueueHeadsOptions {
+  package?: string;
+  arguments: QueueHeadsArguments | [queue: RawTransactionArgument<string>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * Return `(resolve_head, next_id, last_tau_ms, last_committed_tau_ms)`.
+ * `resolve_head` is a lower bound on the first unfinished record.
+ */
+declare function queueHeads(options: QueueHeadsOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface PayoutProgressArguments {
+  queue: RawTransactionArgument<string>;
+}
+interface PayoutProgressOptions {
+  package?: string;
+  arguments: PayoutProgressArguments | [queue: RawTransactionArgument<string>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * Return `(payout_cursor, next_id, payouts_completed)`. The settlement payout walk
+ * is finished once `payouts_completed` is set.
+ */
+declare function payoutProgress(options: PayoutProgressOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface WaitingCohortsArguments {
+  queue: RawTransactionArgument<string>;
+}
+interface WaitingCohortsOptions {
+  package?: string;
+  arguments: WaitingCohortsArguments | [queue: RawTransactionArgument<string>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function waitingCohorts(options: WaitingCohortsOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface QueueStuckArguments {
+  queue: RawTransactionArgument<string>;
+  desk?: RawTransactionArgument<string>;
+}
+interface QueueStuckOptions {
+  package?: string;
+  arguments: QueueStuckArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * Whether placement would refuse a new order as stuck right now (both rules of the
+ * stuck gate). Drives the app's "pricing delayed" banner.
+ */
+declare function queueStuck(options: QueueStuckOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface PendingCountsArguments {
+  queue: RawTransactionArgument<string>;
+}
+interface PendingCountsOptions {
+  package?: string;
+  arguments: PendingCountsArguments | [queue: RawTransactionArgument<string>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * Return `(pending_mints, pending_sells)`, the unfinished orders counted against
+ * the policy capacities.
+ */
+declare function pendingCounts(options: PendingCountsOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface WaitingOrdersArguments {
+  queue: RawTransactionArgument<string>;
+  accountId: RawTransactionArgument<string>;
+}
+interface WaitingOrdersOptions {
+  package?: string;
+  arguments: WaitingOrdersArguments | [queue: RawTransactionArgument<string>, accountId: RawTransactionArgument<string>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function waitingOrders(options: WaitingOrdersOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface OldestUnfinishedTauMsArguments {
+  queue: RawTransactionArgument<string>;
+}
+interface OldestUnfinishedTauMsOptions {
+  package?: string;
+  arguments: OldestUnfinishedTauMsArguments | [queue: RawTransactionArgument<string>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+/** Return τ of the oldest cohort with an unfinished order, for monitoring. */
+declare function oldestUnfinishedTauMs(options: OldestUnfinishedTauMsOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface QuoteRedeemOpenArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  wrapper: RawTransactionArgument<string>;
+  pricer: TransactionArgument;
+  recordId: RawTransactionArgument<number | bigint>;
+  closeQuantity: RawTransactionArgument<number | bigint>;
+}
+interface QuoteRedeemOpenOptions {
+  package?: string;
+  arguments: QuoteRedeemOpenArguments | [queue: RawTransactionArgument<string>, market: RawTransactionArgument<string>, wrapper: RawTransactionArgument<string>, pricer: TransactionArgument, recordId: RawTransactionArgument<number | bigint>, closeQuantity: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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`.
+ */
+declare function quoteRedeemOpen(options: QuoteRedeemOpenOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface CreateAndShareArguments {
+  registry?: RawTransactionArgument<string>;
+  desk?: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+}
+interface CreateAndShareOptions {
+  package?: string;
+  arguments: CreateAndShareArguments;
+  config?: {
+    queueRegistry: ConfigValue;
+    orderDesk: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function createAndShare(options: CreateAndShareOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface EnqueueExactQuantityArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  wrapper: RawTransactionArgument<string>;
+  auth: TransactionArgument;
+  desk?: RawTransactionArgument<string>;
+  config?: RawTransactionArgument<string>;
+  propbookRegistry?: RawTransactionArgument<string>;
+  pyth: RawTransactionArgument<string>;
+  bsValues: RawTransactionArgument<string>;
+  bsSvi: RawTransactionArgument<string>;
+  lowerTick: RawTransactionArgument<number | bigint>;
+  higherTick: RawTransactionArgument<number | bigint>;
+  quantity: RawTransactionArgument<number | bigint>;
+  maxCost: RawTransactionArgument<number | bigint>;
+  maxProbability: RawTransactionArgument<number | bigint>;
+}
+interface EnqueueExactQuantityOptions {
+  package?: string;
+  arguments: EnqueueExactQuantityArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    protocolConfig: ConfigValue;
+    oracleRegistry: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function enqueueExactQuantity(options: EnqueueExactQuantityOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface EnqueueExactAmountArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  wrapper: RawTransactionArgument<string>;
+  auth: TransactionArgument;
+  desk?: RawTransactionArgument<string>;
+  config?: RawTransactionArgument<string>;
+  propbookRegistry?: RawTransactionArgument<string>;
+  pyth: RawTransactionArgument<string>;
+  bsValues: RawTransactionArgument<string>;
+  bsSvi: RawTransactionArgument<string>;
+  lowerTick: RawTransactionArgument<number | bigint>;
+  higherTick: RawTransactionArgument<number | bigint>;
+  maxPremium: RawTransactionArgument<number | bigint>;
+  minQuantity: RawTransactionArgument<number | bigint>;
+  maxCost: RawTransactionArgument<number | bigint>;
+}
+interface EnqueueExactAmountOptions {
+  package?: string;
+  arguments: EnqueueExactAmountArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    protocolConfig: ConfigValue;
+    oracleRegistry: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function enqueueExactAmount(options: EnqueueExactAmountOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface EnqueueExactCostArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  wrapper: RawTransactionArgument<string>;
+  auth: TransactionArgument;
+  desk?: RawTransactionArgument<string>;
+  config?: RawTransactionArgument<string>;
+  propbookRegistry?: RawTransactionArgument<string>;
+  pyth: RawTransactionArgument<string>;
+  bsValues: RawTransactionArgument<string>;
+  bsSvi: RawTransactionArgument<string>;
+  lowerTick: RawTransactionArgument<number | bigint>;
+  higherTick: RawTransactionArgument<number | bigint>;
+  maxCost: RawTransactionArgument<number | bigint>;
+  minQuantity: RawTransactionArgument<number | bigint>;
+}
+interface EnqueueExactCostOptions {
+  package?: string;
+  arguments: EnqueueExactCostArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    protocolConfig: ConfigValue;
+    oracleRegistry: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function enqueueExactCost(options: EnqueueExactCostOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface EnqueueRedeemOpenArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  wrapper: RawTransactionArgument<string>;
+  auth: TransactionArgument;
+  desk?: RawTransactionArgument<string>;
+  config?: RawTransactionArgument<string>;
+  propbookRegistry?: RawTransactionArgument<string>;
+  pyth: RawTransactionArgument<string>;
+  bsValues: RawTransactionArgument<string>;
+  bsSvi: RawTransactionArgument<string>;
+  recordId: RawTransactionArgument<number | bigint>;
+  closeQuantity: RawTransactionArgument<number | bigint>;
+  minProbability: RawTransactionArgument<number | bigint>;
+  minProceeds: RawTransactionArgument<number | bigint>;
+}
+interface EnqueueRedeemOpenOptions {
+  package?: string;
+  arguments: EnqueueRedeemOpenArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    protocolConfig: ConfigValue;
+    oracleRegistry: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function enqueueRedeemOpen(options: EnqueueRedeemOpenOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface CommitArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  desk?: RawTransactionArgument<string>;
+  config?: RawTransactionArgument<string>;
+  updates: TransactionArgument;
+}
+interface CommitOptions {
+  package?: string;
+  arguments: CommitArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    protocolConfig: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function commit(options: CommitOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface ResolveArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  desk?: RawTransactionArgument<string>;
+  config?: RawTransactionArgument<string>;
+  maxOrders: RawTransactionArgument<number | bigint>;
+}
+interface ResolveOptions {
+  package?: string;
+  arguments: ResolveArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    protocolConfig: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function resolve(options: ResolveOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface RefundArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  desk?: RawTransactionArgument<string>;
+  config?: RawTransactionArgument<string>;
+  maxOrders: RawTransactionArgument<number | bigint>;
+}
+interface RefundOptions {
+  package?: string;
+  arguments: RefundArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    protocolConfig: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function refund(options: RefundOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface AdminRefundArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  desk?: RawTransactionArgument<string>;
+  config?: RawTransactionArgument<string>;
+  recordIds: RawTransactionArgument<Array<number | bigint>>;
+}
+interface AdminRefundOptions {
+  package?: string;
+  arguments: AdminRefundArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    protocolConfig: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function adminRefund(options: AdminRefundOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface CleanupArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  desk?: RawTransactionArgument<string>;
+  recordIds: RawTransactionArgument<Array<number | bigint>>;
+}
+interface CleanupOptions {
+  package?: string;
+  arguments: CleanupArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function cleanup(options: CleanupOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface SettleStepArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  desk?: RawTransactionArgument<string>;
+  config?: RawTransactionArgument<string>;
+}
+interface SettleStepOptions {
+  package?: string;
+  arguments: SettleStepArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    protocolConfig: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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()`.
+ */
+declare function settleStep(options: SettleStepOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface PayOpenArguments {
+  queue: RawTransactionArgument<string>;
+  market: RawTransactionArgument<string>;
+  desk?: RawTransactionArgument<string>;
+  config?: RawTransactionArgument<string>;
+  recordId: RawTransactionArgument<number | bigint>;
+}
+interface PayOpenOptions {
+  package?: string;
+  arguments: PayOpenArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    protocolConfig: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function payOpen(options: PayOpenOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+interface ClaimParkedArguments {
+  queue: RawTransactionArgument<string>;
+  desk?: RawTransactionArgument<string>;
+  recordId: RawTransactionArgument<number | bigint>;
+}
+interface ClaimParkedOptions {
+  package?: string;
+  arguments: ClaimParkedArguments;
+  config?: {
+    orderDesk: ConfigValue;
+    predictOrdersPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function claimParked(options: ClaimParkedOptions): (tx: Transaction) => _mysten_sui_transactions224.TransactionResult;
+//#endregion
+export { queue_d_exports };
+//# sourceMappingURL=queue.d.mts.map