@mysten/deepbook-v3 2.6.4 → 2.8.0

package/dist/predict/client.mjs

@@ -1,22 +1,27 @@
 import { TESTNET_PREDICT } from "../deployments/testnet.mjs";
+import { deriveQueueId } from "./queue-id.mjs";
 import { getConfig } from "./config/index.mjs";
-import { toGeneratedConfig } from "./config/generated.mjs";
-import { PredictInputError } from "./errors.mjs";
+import { PredictInputError, PredictMoveError, PredictPreflightError } from "./errors.mjs";
+import { toGeneratedConfig, toOrdersConfig } from "./config/generated.mjs";
+import { boardPricer } from "./pricing.mjs";
+import { POS_INF_TICK, binaryRangeTicks } from "./ticks.mjs";
 import { fromRaw, priceToRaw, probabilityToRaw, rawToProbability, rawToUsdc, usdcToRaw } from "./units.mjs";
-import { decodeAccountsCreated, decodeBuilderCodeSets, decodeClaims, decodeDeposits, decodeMints, decodePlpCancels, decodePlpRequests, decodeRedeems, decodeWithdrawals, exactlyOne } from "./decode.mjs";
+import { MIN_PREMIUM, decodeOrderRange } from "./cost.mjs";
+import { ORDER_FLOW_PACKAGE_VERSION, ORDER_KIND, ORDER_STATUS, budgetMintLimits, cashNeedSell, channelTickMs, exactMintLimits, feeCovered, maxMintNow, mintBudget, mintCashNeed, orderKindName, orderView, previewTiming, sellLimits, slippageBand } from "./queue.mjs";
+import { decodeAccountsCreated, decodeBuilderCodeSets, decodeClaims, decodeCohortCommits, decodeDeposits, decodeEnqueues, decodeExpiryPnlRealized, decodeMarketPayoutsCompleted, decodeMints, decodeOpenRecordPayouts, decodePlpCancels, decodePlpRequests, decodePolicyUpdates, decodeQueueEvents, decodeQueueOps, decodeQueuedFills, decodeQueuedRefunds, decodeRecordFunds, decodeRedeems, decodeWithdrawals, exactlyOne } from "./decode.mjs";
 import { simulateWithEvents } from "./reads/inspect.mjs";
 import { accountContract, deriveAccountWrapperIdFrom } from "./tx/common.mjs";
+import { assertOrderFeeAtMost, claimParked, enqueueExactAmount, enqueueExactCost, enqueueExactQuantity, enqueueRedeemOpen, fill, payOpen, rebalanceExpiryCash, refund } from "./tx/queue.mjs";
+import { mintExactAmount, mintExactCost, mintExactQuantity, redeemLive, redeemSettled } from "./tx/trade.mjs";
+import { executionModeFor, lazerPackages, marketQueueState, orderFeeAndBalance, pendingFunds, queuedOrders, quoteMintAnonymous, quoteMintForAccount, quoteRedeemOpen, versionWatermark } from "./reads/queue.mjs";
 import { positionsFromTable, resolvePositionsTable } from "./reads/positions.mjs";
 import { accountBalance, hasPosition } from "./reads/balances.mjs";
-import { POS_INF_TICK, binaryRangeTicks } from "./ticks.mjs";
-import { mintExactAmount, mintExactCost, mintExactQuantity, redeemLive, redeemSettled } from "./tx/trade.mjs";
-import { activeMarketIds, currentNav, expiryMarketId, marketState, marketStates, rangePrices, referenceTick } from "./reads/markets.mjs";
+import { activeMarketIds, currentNav, expiryMarketId, marketFeePolicy, marketState, marketStates, rangePrices, referenceTick, settlementPrice } from "./reads/markets.mjs";
 import { poolStats } from "./reads/pool.mjs";
 import { readPricerSnapshot } from "./reads/pricing.mjs";
-import { boardPricer } from "./pricing.mjs";
 import { cancelSupplyRequest, cancelWithdrawRequest, depositFunds, requestSupply, requestWithdraw, setBuilderCode, unsetBuilderCode, withdrawFunds } from "./tx/authed.mjs";
 import { Transaction, coinWithBalance } from "@mysten/sui/transactions";
-import { isValidSuiObjectId } from "@mysten/sui/utils";
+import { isValidSuiObjectId, normalizeSuiAddress } from "@mysten/sui/utils";
 
 //#region src/predict/client.ts
 /**
@@ -24,6 +29,7 @@ import { isValidSuiObjectId } from "@mysten/sui/utils";
 * size of the config actually in play; this is the convenience constant for testnet callers.
 */
 const POSITION_LOT_SIZE = BigInt(TESTNET_PREDICT.units.positionLotSize);
+const NEAR_DOLLAR_PER_CONTRACT = 950000000n;
 function txOf(command) {
 	const tx = new Transaction();
 	tx.add(command);
@@ -51,6 +57,12 @@ function predict({ name = "predict", network, config }) {
 * returns a finished `Transaction`; callers composing their own PTBs use the generated
 * move-call bindings this subpath exports (`plpMoveCalls`, `expiryMarketMoveCalls`, …).
 */
+function isOrderFailsLimits(error) {
+	return error instanceof PredictMoveError && error.abortName === "EOrderFailsLimits";
+}
+function isPastExpiry(error) {
+	return error instanceof PredictMoveError && error.abortName === "ELivePricingExpired";
+}
 var PredictClient = class PredictClient {
 	get #config() {
 		return toGeneratedConfig(this.cfg);
@@ -58,6 +70,7 @@ var PredictClient = class PredictClient {
 	#client;
 	#marketCache = /* @__PURE__ */ new Map();
 	#positionsCache = /* @__PURE__ */ new Map();
+	#knownQueues = /* @__PURE__ */ new Set();
 	constructor(opts) {
 		this.tx = {
 			createManager: () => txOf(accountContract(this.cfg).createAccount()),
@@ -128,6 +141,118 @@ var PredictClient = class PredictClient {
 					orderId: opts$1.orderId
 				}));
 			},
+			enqueueMint: async (owner, m, opts$1) => {
+				const quantityRaw = usdcToRaw(opts$1.quantity);
+				this.#assertLot(quantityRaw);
+				const maxCostRaw = usdcToRaw(opts$1.maxCost);
+				const maxProbabilityRaw = probabilityToRaw(opts$1.maxProbability);
+				return this.#planMint(owner, m, {
+					kind: ORDER_KIND.EXACT_QUANTITY,
+					maxCostRaw,
+					quantityRaw
+				}, (orders, target) => enqueueExactQuantity(orders, {
+					...target,
+					quantityRaw,
+					maxCostRaw,
+					maxProbabilityRaw
+				}));
+			},
+			enqueueMintAmount: async (owner, m, opts$1) => {
+				const maxPremiumRaw = usdcToRaw(opts$1.spend);
+				const minQuantityRaw = usdcToRaw(opts$1.minQuantity);
+				const maxCostRaw = usdcToRaw(opts$1.maxCost);
+				if (maxPremiumRaw < MIN_PREMIUM) throw new PredictPreflightError("min-premium", `spend ${rawToUsdc(maxPremiumRaw)} is below the ${rawToUsdc(MIN_PREMIUM)} minimum premium`);
+				return this.#planMint(owner, m, {
+					kind: ORDER_KIND.EXACT_AMOUNT,
+					maxCostRaw,
+					maxPremiumRaw
+				}, (orders, target) => enqueueExactAmount(orders, {
+					...target,
+					maxPremiumRaw,
+					minQuantityRaw,
+					maxCostRaw
+				}));
+			},
+			enqueueMintCost: async (owner, m, opts$1) => {
+				const maxCostRaw = usdcToRaw(opts$1.spend);
+				const minQuantityRaw = usdcToRaw(opts$1.minQuantity);
+				return this.#planMint(owner, m, {
+					kind: ORDER_KIND.EXACT_COST,
+					maxCostRaw
+				}, (orders, target) => enqueueExactCost(orders, {
+					...target,
+					maxCostRaw,
+					minQuantityRaw
+				}));
+			},
+			enqueueSell: (owner, m, opts$1) => this.#planSell(owner, m, opts$1),
+			enqueuePlan: async (owner, m, plan) => {
+				if (plan.refusal != null) throw new PredictPreflightError(plan.refusal, `the plan was refused (${plan.refusal})`);
+				const target = plan.target;
+				const { id, state: marketState$1 } = await this.#resolveMarket(m);
+				if (normalizeSuiAddress(owner) !== normalizeSuiAddress(target.owner)) throw new PredictInputError(`the plan was made for owner ${target.owner}, not ${owner}`);
+				if (normalizeSuiAddress(id) !== normalizeSuiAddress(target.expiryMarketId)) throw new PredictInputError(`the plan was made for market ${target.expiryMarketId}, not ${id}`);
+				const order = plan.order;
+				const descriptor = "side" in m ? m : null;
+				let placed;
+				if (order.builder === "enqueueSell") {
+					if (order.options.recordId !== target.recordId) throw new PredictInputError(`the plan was made for record ${target.recordId}, not ${order.options.recordId}`);
+					placed = await this.tx.enqueueSell(owner, m, order.options);
+				} else {
+					if (descriptor == null) throw new PredictInputError("a mint plan needs the market descriptor it was planned with (its strike and side)");
+					const { lowerTick, higherTick } = await this.#strikeTicks(descriptor, id, marketState$1);
+					if (lowerTick !== target.lowerTick || higherTick !== target.higherTick) throw new PredictInputError("the market descriptor names a different strike or side than the plan, or its reference strike moved: plan again");
+					placed = order.builder === "enqueueMintCost" ? await this.tx.enqueueMintCost(owner, descriptor, order.options) : await this.tx.enqueueMint(owner, descriptor, order.options);
+				}
+				if (placed.preview.raw.orderFee > plan.raw.orderFee) throw new PredictInputError(`the order fee rose from ${rawToUsdc(plan.raw.orderFee)} to ${placed.preview.orderFee} since the plan: plan again`);
+				if (order.builder === "enqueueSell") return placed;
+				const planned = plan.raw.budget;
+				if (placed.preview.raw.budget < planned) throw new PredictPreflightError("fee", `the balance now escrows ${placed.preview.budget}, below the plan's ${rawToUsdc(planned)}`);
+				return placed;
+			},
+			refund: async (m, opts$1 = {}) => {
+				const orders = this.#requireDelayedExecution();
+				const { id } = await this.#resolveMarket(m);
+				return txOf(refund(orders, {
+					expiryMarketId: id,
+					queueId: await this.#existingQueueId(orders, id),
+					maxOrders: BigInt(opts$1.maxOrders ?? 100)
+				}));
+			},
+			claimParked: async (m, recordId) => {
+				const orders = this.#requireDelayedExecution();
+				const { id } = await this.#resolveMarket(m);
+				return txOf(claimParked(orders, {
+					expiryMarketId: id,
+					queueId: await this.#existingQueueId(orders, id),
+					recordId
+				}));
+			},
+			payOpen: async (m, recordId) => {
+				const orders = this.#requireDelayedExecution();
+				const { id } = await this.#resolveMarket(m);
+				return txOf(payOpen(orders, {
+					expiryMarketId: id,
+					queueId: await this.#existingQueueId(orders, id),
+					recordId
+				}));
+			},
+			fill: async (m, opts$1) => {
+				const orders = this.#requireDelayedExecution();
+				const stateId = opts$1.lazerStateId ?? this.cfg.oracle?.pythLazerState;
+				if (!stateId) throw new PredictInputError("fill needs the Pyth Lazer State: pass `lazerStateId`");
+				const { id } = await this.#resolveMarket(m);
+				const queueId = await this.#existingQueueId(orders, id);
+				const lazer = await lazerPackages(this.#client, stateId);
+				return txOf(fill(orders, {
+					expiryMarketId: id,
+					queueId,
+					payloads: opts$1.payloads,
+					lazer,
+					maxOrders: BigInt(opts$1.maxOrders ?? 15),
+					refundOverdue: opts$1.refundOverdue
+				}));
+			},
 			supplyPlp: (owner, amountUsdc, options = {}) => txOf(requestSupply({
 				config: this.#config,
 				arguments: {
@@ -215,10 +340,480 @@ var PredictClient = class PredictClient {
 				};
 			},
 			quoteMint: async (owner, m, opts$1) => {
+				if (this.cfg.packages.predictDelayedExecution) {
+					const orders = this.#requireDelayedExecution();
+					const feeds = this.#feeds(m.underlying);
+					const { id, state } = await this.#resolveMarket(m);
+					const quantityRaw = usdcToRaw(opts$1.quantity);
+					this.#assertLot(quantityRaw);
+					const { lowerTick, higherTick } = await this.#strikeTicks(m, id, state);
+					const { quote, policy } = await quoteMintForAccount(this.#client, this.#config, {
+						expiryMarketId: id,
+						wrapperId: this.wrapperIdFor(owner),
+						lowerTick,
+						higherTick,
+						request: {
+							shape: "exact-quantity",
+							quantityRaw
+						},
+						ordersConfig: orders,
+						...feeds
+					});
+					return PredictClient.#queuedMintQuote(quote, policy);
+				}
 				const tx = await this.#buildMint(owner, m, opts$1);
 				return this.#quoteMintTransaction(owner, tx);
 			},
-			quoteMintCost: async (owner, m, opts$1) => this.#quoteMintTransaction(owner, await this.#buildMintCost(owner, m, opts$1)),
+			quoteMintCost: async (owner, m, opts$1) => {
+				if (this.cfg.packages.predictDelayedExecution) {
+					const orders = this.#requireDelayedExecution();
+					const feeds = this.#feeds(m.underlying);
+					const { id, state } = await this.#resolveMarket(m);
+					const { lowerTick, higherTick } = await this.#strikeTicks(m, id, state);
+					const { policy, availableRaw } = await orderFeeAndBalance(this.#client, orders, owner, this.cfg.quoteCoinType);
+					const fee = policy.orderFee;
+					const spendRaw = usdcToRaw(opts$1.spend);
+					const escrowable = availableRaw > fee ? availableRaw - fee : 0n;
+					const { quote } = await quoteMintForAccount(this.#client, this.#config, {
+						expiryMarketId: id,
+						wrapperId: this.wrapperIdFor(owner),
+						lowerTick,
+						higherTick,
+						request: {
+							shape: "exact-cost",
+							maxCostRaw: spendRaw < escrowable ? spendRaw : escrowable,
+							minQuantityRaw: usdcToRaw(opts$1.minQuantity)
+						},
+						...feeds
+					});
+					return PredictClient.#queuedMintQuote(quote, policy);
+				}
+				return this.#quoteMintTransaction(owner, await this.#buildMintCost(owner, m, opts$1));
+			},
+			quoteSell: async (owner, m, opts$1) => {
+				const orders = this.#requireDelayedExecution();
+				const feeds = this.#feeds(m.underlying);
+				const { id } = await this.#resolveMarket(m);
+				const closeQuantityRaw = usdcToRaw(opts$1.quantity);
+				this.#assertLot(closeQuantityRaw);
+				const queueId = await this.#existingQueueId(orders, id);
+				const { quote, policy } = await quoteRedeemOpen(this.#client, orders, {
+					expiryMarketId: id,
+					queueId,
+					wrapperId: this.wrapperIdFor(owner),
+					recordId: opts$1.recordId,
+					closeQuantityRaw,
+					...feeds
+				});
+				const orderFee = policy.orderFee;
+				return {
+					probability: rawToProbability(quote.probability),
+					proceeds: rawToUsdc(quote.proceeds),
+					net: rawToUsdc(quote.proceeds - orderFee),
+					fees: {
+						trading: rawToUsdc(quote.tradingFee),
+						builder: rawToUsdc(quote.builderFee),
+						inventoryImpactRebate: rawToUsdc(quote.inventoryImpactRebate),
+						order: rawToUsdc(orderFee)
+					},
+					quantityClosed: rawToUsdc(quote.closeQuantity),
+					raw: {
+						probability: quote.probability,
+						proceeds: quote.proceeds,
+						orderFee,
+						quantityClosed: quote.closeQuantity
+					}
+				};
+			},
+			executionMode: async () => executionModeFor(await versionWatermark(this.#client, this.cfg.objects.protocolConfig), this.#recordsDelayedExecution(), this.cfg.packages.predictDelayedExecution != null),
+			queue: async (m, owner) => {
+				const orders = this.#requireDelayedExecution();
+				const { id } = await this.#resolveMarket(m);
+				const state = await this.#queueState(orders, id, { owner });
+				const nowMs = BigInt(Date.now());
+				const policy = state.desk.policy;
+				const mode = executionModeFor(state.protocol.versionWatermark, true);
+				const timing = previewTiming({
+					nowMs,
+					policy,
+					heads: state.heads,
+					expiryMs: state.expiryMs,
+					noTradeWindowMs: state.protocol.noTradeWindowMs
+				});
+				const refusalFor = (side) => {
+					try {
+						this.#assertQueueOpen(state, side, nowMs);
+						return null;
+					} catch (e) {
+						if (e instanceof PredictPreflightError) return e.code;
+						throw e;
+					}
+				};
+				const refusal = {
+					mint: refusalFor("mint"),
+					sell: refusalFor("sell")
+				};
+				return {
+					...state,
+					mode,
+					timing,
+					acceptingMints: refusal.mint == null,
+					acceptingSells: refusal.sell == null,
+					refusal,
+					maxMint: {
+						exactQuantity: maxMintNow({
+							shape: "exact-quantity",
+							spareCashRaw: state.spareCash,
+							minEntryProbability: state.minEntryProbability,
+							lotSize: BigInt(this.cfg.units.positionLotSize),
+							asOfMs: nowMs
+						}),
+						budget: maxMintNow({
+							shape: "budget",
+							spareCashRaw: state.spareCash,
+							minEntryProbability: state.minEntryProbability,
+							availableRaw: state.account?.availableRaw,
+							orderFeeRaw: policy.orderFee,
+							asOfMs: nowMs
+						})
+					}
+				};
+			},
+			planMint: async (owner, m, opts$1) => {
+				const orders = this.#requireDelayedExecution();
+				const feeds = this.#feeds(m.underlying);
+				const { id, state: market } = await this.#resolveMarket(m);
+				const { lowerTick, higherTick } = await this.#strikeTicks(m, id, market);
+				const hasAccount = await this.#hasAccount(owner);
+				const state = await this.#queueState(orders, id, hasAccount ? { owner } : {});
+				const nowMs = BigInt(Date.now());
+				const policy = state.desk.policy;
+				const fee = policy.orderFee;
+				const availableRaw = state.account?.availableRaw ?? null;
+				const lot = BigInt(this.cfg.units.positionLotSize);
+				const ticks = {
+					expiryMarketId: id,
+					lowerTick,
+					higherTick,
+					...feeds
+				};
+				const forAccount = (request) => quoteMintForAccount(this.#client, this.#config, {
+					...ticks,
+					wrapperId: this.wrapperIdFor(owner),
+					request
+				}).then((r) => r.quote);
+				let quote;
+				let quoteForAccount;
+				let budgetRequested = null;
+				if ("amount" in opts$1) {
+					const amountRaw = usdcToRaw(opts$1.amount);
+					budgetRequested = (opts$1.orderFee ?? "inclusive") === "inclusive" ? amountRaw > fee ? amountRaw - fee : 0n : amountRaw;
+					if (budgetRequested === 0n) throw new PredictPreflightError("min-premium", `${opts$1.amount} doesn't cover the ${rawToUsdc(fee)} order fee, so it buys no premium`);
+					if (budgetRequested < MIN_PREMIUM) throw new PredictPreflightError("min-premium", `a budget of ${rawToUsdc(budgetRequested)} is below the minimum premium (a mint's premium must be at least ${rawToUsdc(MIN_PREMIUM)} USDC)`);
+					quoteForAccount = availableRaw != null && availableRaw > fee && availableRaw - fee >= budgetRequested;
+					const budget = budgetRequested;
+					const search = () => this.#searchBudgetQuote(ticks, budget, lot).catch(async (error) => {
+						if (error instanceof PredictPreflightError && error.code === "min-premium") throw await this.#entryBandRefusal(m) ?? error;
+						throw await this.#quoteRefusal(error, { m });
+					});
+					if (quoteForAccount) try {
+						quote = await forAccount({
+							shape: "exact-cost",
+							maxCostRaw: budget,
+							minQuantityRaw: 0n
+						});
+					} catch (error) {
+						if (!isOrderFailsLimits(error)) throw await this.#quoteRefusal(error);
+						await search();
+						throw error;
+					}
+					else quote = await search();
+				} else {
+					const quantityRaw = usdcToRaw(opts$1.quantity);
+					this.#assertLot(quantityRaw);
+					quoteForAccount = hasAccount;
+					try {
+						quote = hasAccount ? await forAccount({
+							shape: "exact-quantity",
+							quantityRaw
+						}) : (await quoteMintAnonymous(this.#client, this.#config, {
+							...ticks,
+							request: {
+								shape: "exact-quantity",
+								quantityRaw
+							}
+						})).quote;
+					} catch (error) {
+						throw await this.#quoteRefusal(error, {
+							m,
+							quantityRaw
+						});
+					}
+				}
+				const costRaw = quote.allInCost - quote.penaltyFee;
+				const slippage = PredictClient.#appliedSlippage(opts$1, quote.entryProbability, state, nowMs);
+				const limitsIn = {
+					quoteCostRaw: costRaw,
+					quoteQuantityRaw: quote.quantity,
+					entryProbabilityRaw: quote.entryProbability,
+					slippageRaw: slippage.raw,
+					feeIncentiveSubsidyRaw: quote.feeIncentiveSubsidy,
+					lotSize: lot
+				};
+				let budgetRaw;
+				let minQuantityRaw;
+				let admitted = null;
+				let maxCostRaw = null;
+				let maxProbabilityRaw = null;
+				let price;
+				let order;
+				if (budgetRequested != null) {
+					const limits = budgetMintLimits({
+						...limitsIn,
+						budgetRaw: budgetRequested
+					});
+					budgetRaw = budgetRequested;
+					const unsubsidizedCost = costRaw + quote.feeIncentiveSubsidy;
+					const start = unsubsidizedCost === 0n ? quote.quantity : budgetRaw * quote.quantity / unsubsidizedCost / lot * lot;
+					admitted = await this.#admittedFloor((quantityRaw) => quoteForAccount ? forAccount({
+						shape: "exact-quantity",
+						quantityRaw
+					}) : quoteMintAnonymous(this.#client, this.#config, {
+						...ticks,
+						request: {
+							shape: "exact-quantity",
+							quantityRaw
+						}
+					}).then((r) => r.quote), budgetRaw, start < quote.quantity ? start : quote.quantity, lot, quote.entryProbability, quote.quantity === 0n ? 0n : unsubsidizedCost * 1000000000n / quote.quantity);
+					const ceiling = "quantity" in admitted ? admitted.quantity : 0n;
+					minQuantityRaw = limits.minQuantityRaw < ceiling ? limits.minQuantityRaw : ceiling;
+					price = limits.pricePerContract;
+					order = {
+						builder: "enqueueMintCost",
+						options: {
+							spend: rawToUsdc(budgetRaw),
+							minQuantity: rawToUsdc(minQuantityRaw)
+						}
+					};
+				} else {
+					const limits = exactMintLimits(limitsIn);
+					maxCostRaw = limits.maxCostRaw;
+					maxProbabilityRaw = limits.maxProbabilityRaw;
+					budgetRaw = maxCostRaw < quote.quantity ? maxCostRaw : quote.quantity;
+					minQuantityRaw = quote.quantity;
+					price = limits.pricePerContract;
+					order = {
+						builder: "enqueueMint",
+						options: {
+							quantity: rawToUsdc(quote.quantity),
+							maxCost: rawToUsdc(maxCostRaw),
+							maxProbability: rawToProbability(maxProbabilityRaw)
+						}
+					};
+				}
+				const totalDebitRaw = budgetRaw + fee;
+				const expectedDebitRaw = costRaw + fee;
+				const inclusive = "amount" in opts$1 && (opts$1.orderFee ?? "inclusive") === "inclusive";
+				const refusal = PredictClient.#refusal(() => {
+					this.#assertQueueOpen(state, "mint", nowMs);
+					if (availableRaw == null || availableRaw < totalDebitRaw) throw new PredictPreflightError("fee", `the balance doesn't cover the plan's ${rawToUsdc(totalDebitRaw)} debit`);
+					PredictClient.#assertMintOrder(state, policy, budgetRequested != null ? {
+						kind: ORDER_KIND.EXACT_COST,
+						maxCostRaw: budgetRaw
+					} : {
+						kind: ORDER_KIND.EXACT_QUANTITY,
+						maxCostRaw: maxCostRaw ?? budgetRaw,
+						quantityRaw: quote.quantity
+					});
+					if (costRaw + quote.feeIncentiveSubsidy > quote.quantity) throw new PredictPreflightError("cost-above-payout", "the all-in cost without the fee subsidy is above the payout");
+					if (admitted != null && "refusal" in admitted) throw new PredictPreflightError(admitted.refusal, admitted.refusal === "min-premium" ? `without the fee subsidy, ${rawToUsdc(budgetRaw)} buys no fill that clears the ${rawToUsdc(MIN_PREMIUM)} minimum premium` : admitted.refusal === "entry-band" ? "the entry probability left the market's entry band while the order was sized: plan again, or pick a strike nearer the money" : `without the fee subsidy, ${rawToUsdc(budgetRaw)} buys a fill near $1 a contract, whose admission sizing can't be previewed`);
+				});
+				let max = maxMintNow(budgetRequested != null ? {
+					shape: "budget",
+					spareCashRaw: state.spareCash,
+					minEntryProbability: state.minEntryProbability,
+					availableRaw: availableRaw ?? void 0,
+					orderFeeRaw: fee,
+					asOfMs: nowMs
+				} : {
+					shape: "exact-quantity",
+					spareCashRaw: state.spareCash,
+					minEntryProbability: state.minEntryProbability,
+					lotSize: lot,
+					asOfMs: nowMs
+				}).maxRaw;
+				if (budgetRequested == null && availableRaw != null && price.worstRaw > 0n) {
+					const spendable = availableRaw > fee ? availableRaw - fee : 0n;
+					const perContract = price.worstRaw < 1000000000n ? price.worstRaw : 1000000000n;
+					const byBalance = spendable * 1000000000n / perContract / lot * lot;
+					if (max == null || byBalance < max) max = byBalance;
+				}
+				return {
+					shape: budgetRequested != null ? "budget" : "exact-quantity",
+					target: {
+						owner: normalizeSuiAddress(owner),
+						expiryMarketId: id,
+						lowerTick,
+						higherTick
+					},
+					quote: PredictClient.#queuedMintQuote(quote, policy),
+					quoteForAccount,
+					slippage: slippage.applied,
+					potentialPayout: rawToUsdc(quote.quantity),
+					minPayout: rawToUsdc(minQuantityRaw),
+					payoutMultiple: Number(quote.quantity) / Number(expectedDebitRaw),
+					minPayoutMultiple: Number(minQuantityRaw) / Number(totalDebitRaw),
+					pricePerContract: rawToProbability(price.nowRaw),
+					worstPricePerContract: rawToProbability(price.worstRaw),
+					orderFee: rawToUsdc(fee),
+					budget: rawToUsdc(budgetRaw),
+					totalDebit: rawToUsdc(totalDebitRaw),
+					expectedDebit: rawToUsdc(expectedDebitRaw),
+					balance: {
+						hasAccount,
+						available: availableRaw == null ? null : rawToUsdc(availableRaw),
+						covers: availableRaw == null ? null : availableRaw >= totalDebitRaw
+					},
+					maxNow: max == null ? null : rawToUsdc(inclusive ? max + fee : max),
+					timing: previewTiming({
+						nowMs,
+						policy,
+						heads: state.heads,
+						expiryMs: state.expiryMs,
+						noTradeWindowMs: state.protocol.noTradeWindowMs
+					}),
+					accepting: refusal == null,
+					refusal,
+					order,
+					raw: {
+						budget: budgetRaw,
+						orderFee: fee,
+						totalDebit: totalDebitRaw,
+						slippage: slippage.raw,
+						minQuantity: minQuantityRaw,
+						maxCost: maxCostRaw,
+						maxProbability: maxProbabilityRaw,
+						pricePerContract: price.nowRaw,
+						worstPricePerContract: price.worstRaw
+					}
+				};
+			},
+			planSell: async (owner, m, opts$1) => {
+				const orders = this.#requireDelayedExecution();
+				const { id } = await this.#resolveMarket(m);
+				const state = await this.#queueState(orders, id, {
+					owner,
+					recordIds: [opts$1.recordId]
+				});
+				const record = PredictClient.#assertRecordOpen(state, opts$1.recordId);
+				this.#assertSellQuantity(record, usdcToRaw(opts$1.quantity));
+				const quote = await this.read.quoteSell(owner, m, {
+					recordId: opts$1.recordId,
+					quantity: opts$1.quantity
+				}).catch(async (error) => {
+					throw await this.#quoteRefusal(error);
+				});
+				const nowMs = BigInt(Date.now());
+				const slippage = PredictClient.#appliedSlippage(opts$1, quote.raw.probability, state, nowMs);
+				const limits = sellLimits({
+					proceedsRaw: quote.raw.proceeds,
+					closeQuantityRaw: quote.raw.quantityClosed,
+					probabilityRaw: quote.raw.probability,
+					slippageRaw: slippage.raw
+				});
+				const fee = quote.raw.orderFee;
+				const refusal = PredictClient.#refusal(() => {
+					const { policy } = this.#assertQueueOpen(state, "sell", nowMs);
+					this.#assertSellOrder(state, policy, opts$1.recordId, usdcToRaw(opts$1.quantity));
+				});
+				return {
+					target: {
+						owner: normalizeSuiAddress(owner),
+						expiryMarketId: id,
+						recordId: opts$1.recordId
+					},
+					quote,
+					slippage: slippage.applied,
+					proceeds: quote.proceeds,
+					net: quote.net,
+					minProceeds: rawToUsdc(limits.minProceedsRaw),
+					minNet: rawToUsdc(limits.minProceedsRaw - fee),
+					orderFee: rawToUsdc(fee),
+					timing: previewTiming({
+						nowMs,
+						policy: state.desk.policy,
+						heads: state.heads,
+						expiryMs: state.expiryMs,
+						noTradeWindowMs: state.protocol.noTradeWindowMs
+					}),
+					accepting: refusal == null,
+					refusal,
+					order: {
+						builder: "enqueueSell",
+						options: {
+							recordId: opts$1.recordId,
+							quantity: opts$1.quantity,
+							minProbability: rawToProbability(limits.minProbabilityRaw),
+							minProceeds: rawToUsdc(limits.minProceedsRaw)
+						}
+					},
+					raw: {
+						slippage: slippage.raw,
+						minProceeds: limits.minProceedsRaw,
+						minProbability: limits.minProbabilityRaw,
+						orderFee: fee
+					}
+				};
+			},
+			order: async (m, recordId) => (await this.read.orders(m, [recordId]))[0],
+			orders: async (m, recordIds) => {
+				const orders = this.#requireDelayedExecution();
+				const { id } = await this.#resolveMarket(m);
+				const queueId = await this.#existingQueueId(orders, id);
+				const records = await queuedOrders(this.#client, orders, {
+					expiryMarketId: id,
+					queueId
+				}, recordIds);
+				const nowMs = BigInt(Date.now());
+				return records.map((record, i) => record ? {
+					recordId: recordIds[i],
+					record,
+					view: orderView(record, nowMs, { lotSize: BigInt(this.cfg.units.positionLotSize) })
+				} : null);
+			},
+			waitForOutcome: async (m, recordId, opts$1 = {}) => {
+				const pollMs = opts$1.pollMs ?? 250;
+				const deadline = Date.now() + (opts$1.timeoutMs ?? 3e4);
+				let seen = false;
+				for (;;) {
+					const order = await this.read.order(m, recordId);
+					const timedOut = Date.now() + pollMs > deadline;
+					if (!order) {
+						if (seen || timedOut) return {
+							outcome: "gone",
+							order: null
+						};
+					} else {
+						seen = true;
+						const state = order.view.state;
+						if (state === "filled" || state === "refunded" || state === "closed") return {
+							outcome: state,
+							order
+						};
+						if (timedOut) return {
+							outcome: "timeout",
+							order
+						};
+					}
+					await sleep(pollMs, opts$1.signal);
+				}
+			},
+			pendingFunds: async (owner) => rawToUsdc(await pendingFunds(this.#client, this.wrapperIdFor(owner), this.cfg.quoteCoinType)),
+			lazerPackages: (stateId) => {
+				const id = stateId ?? this.cfg.oracle?.pythLazerState;
+				if (!id) throw new PredictInputError("pass the Pyth Lazer State id");
+				return lazerPackages(this.#client, id);
+			},
 			quoteRedeem: async (owner, m, opts$1) => {
 				const tx = await this.#buildRedeem(owner, m, opts$1);
 				const events = await simulateWithEvents(this.#client, tx, owner);
@@ -258,6 +853,19 @@ var PredictClient = class PredictClient {
 					referencePrice: PredictClient.#referencePriceOf(state)
 				};
 			},
+			settlement: async (m) => {
+				const { id, state } = await this.#resolveMarket(m);
+				const raw = await settlementPrice(this.#client, this.#config, id);
+				return {
+					marketId: id,
+					expiryMs: state.expiryMs,
+					settled: raw != null,
+					settlementPrice: raw == null ? null : fromRaw(raw, 9),
+					settlementPriceRaw: raw,
+					tickSizeRaw: state.tickSizeRaw
+				};
+			},
+			feePolicy: async (m) => marketFeePolicy(this.#client, (await this.#resolveMarket(m)).id),
 			balance: async (owner) => rawToUsdc(await accountBalance(this.#client, this.#config, owner, this.cfg.quoteCoinType)),
 			plpBalance: (owner) => accountBalance(this.#client, this.#config, owner, this.cfg.coinTypes.plp),
 			pool: async () => {
@@ -282,7 +890,19 @@ var PredictClient = class PredictClient {
 			withdraw: (r) => exactlyOne(decodeWithdrawals(this.cfg, r), "Withdrawn"),
 			plpRequest: (r) => exactlyOne(decodePlpRequests(this.cfg, r), "supply/withdraw-requested"),
 			plpCancel: (r) => exactlyOne(decodePlpCancels(this.cfg, r), "RequestCancelled"),
-			builderCode: (r) => exactlyOne(decodeBuilderCodeSets(this.cfg, r), "BuilderCodeSet")
+			builderCode: (r) => exactlyOne(decodeBuilderCodeSets(this.cfg, r), "BuilderCodeSet"),
+			enqueue: (r) => exactlyOne(decodeEnqueues(this.cfg, r), "OrderEnqueued"),
+			enqueues: (r) => decodeEnqueues(this.cfg, r),
+			queueEvents: (r) => decodeQueueEvents(this.cfg, r),
+			cohortCommits: (r) => decodeCohortCommits(this.cfg, r),
+			queuedFills: (r) => decodeQueuedFills(this.cfg, r),
+			queuedRefunds: (r) => decodeQueuedRefunds(this.cfg, r),
+			openRecordPayouts: (r) => decodeOpenRecordPayouts(this.cfg, r),
+			marketPayoutsCompleted: (r) => decodeMarketPayoutsCompleted(this.cfg, r),
+			queueOps: (r) => decodeQueueOps(this.cfg, r),
+			recordFunds: (r) => decodeRecordFunds(this.cfg, r),
+			policyUpdates: (r) => decodePolicyUpdates(this.cfg, r),
+			expiryPnlRealized: (r) => decodeExpiryPnlRealized(this.cfg, r)
 		};
 		this.cfg = opts.config ?? getConfig(opts.network);
 		this.#client = opts.client;
@@ -291,6 +911,14 @@ var PredictClient = class PredictClient {
 	wrapperIdFor(owner) {
 		return deriveAccountWrapperIdFrom(this.#config, owner);
 	}
+	/**
+	* The deterministic id of a market's `MarketQueue` under the config's queue registry, whether
+	* or not it exists yet — no chain read. Throws `PredictInputError` while the config doesn't
+	* record delayed execution.
+	*/
+	queueIdFor(marketId) {
+		return deriveQueueId(this.#requireDelayedExecution().queueRegistry, marketId);
+	}
 	#underlying(underlying) {
 		const u = this.cfg.underlyings[underlying];
 		if (!u) throw new PredictInputError(`unknown underlying: ${underlying}`);
@@ -380,6 +1008,134 @@ var PredictClient = class PredictClient {
 		const lot = BigInt(this.cfg.units.positionLotSize);
 		if (quantityRaw % lot !== 0n) throw new PredictInputError(`quantity ${quantityRaw} raw is not a whole ${lot}-unit lot (position_lot_size)`);
 	}
+	async #hasAccount(owner) {
+		const { objects: [wrapper] } = await this.#client.core.getObjects({ objectIds: [this.wrapperIdFor(owner)] });
+		return !(wrapper instanceof Error);
+	}
+	static #appliedSlippage(opts, probabilityRaw, state, nowMs) {
+		const cents = opts.slippageCents ?? "auto";
+		if (cents !== "auto") {
+			if (!(Number.isFinite(cents) && cents >= 0 && cents <= 100)) throw new PredictInputError(`slippageCents must be in [0, 100] cents per contract, got ${cents}`);
+			const raw$1 = BigInt(Math.round(cents * 1e7));
+			return {
+				raw: raw$1,
+				applied: {
+					cents: Number(raw$1) / 1e7,
+					source: "input",
+					band: null
+				}
+			};
+		}
+		const policy = state.desk.policy;
+		const band = slippageBand({
+			probability: Math.min(Math.max(rawToProbability(probabilityRaw), 1e-6), .999999),
+			timeToExpiryMs: Number(state.expiryMs > nowMs ? state.expiryMs - nowMs : 0n),
+			delayMs: Number(policy.delayMs),
+			tickMs: Number(channelTickMs(policy.pythChannel)),
+			k: opts.k
+		});
+		const raw = BigInt(Math.ceil(band.deltaProbability * 1e9));
+		return {
+			raw,
+			applied: {
+				cents: Number(raw) / 1e7,
+				source: "auto",
+				band
+			}
+		};
+	}
+	async #quoteRefusal(error, mint) {
+		if (isPastExpiry(error)) return new PredictPreflightError("past-cutoff", "the market reached its expiry, so it has no live price and takes no orders");
+		if (mint != null && isOrderFailsLimits(error)) return await this.#entryBandRefusal(mint.m, mint.quantityRaw) ?? error;
+		return error;
+	}
+	async #entryBandRefusal(m, quantityRaw) {
+		if (m.side === "range") return null;
+		const read = await Promise.all([this.read.price(m), this.read.feePolicy(m)]).catch(() => null);
+		if (read == null) return null;
+		const [prices, policy] = read;
+		const probability = probabilityToRaw(m.side === "up" ? prices.up : prices.down);
+		if (probability < policy.minEntryProbability || probability > policy.maxEntryProbability) return new PredictPreflightError("entry-band", `the ${m.side} probability ${rawToProbability(probability)} is outside the market's entry band [${rawToProbability(policy.minEntryProbability)}, ${rawToProbability(policy.maxEntryProbability)}]: pick a strike nearer the money`);
+		if (quantityRaw != null && quantityRaw * probability / 1000000000n < MIN_PREMIUM) return new PredictPreflightError("min-premium", `${rawToUsdc(quantityRaw)} contracts cost a premium below the ${rawToUsdc(MIN_PREMIUM)} USDC minimum`);
+		return null;
+	}
+	async #admittedFloor(quoteAt, budgetRaw, startRaw, lot, entryProbabilityRaw, unsubsidizedPricePerContractRaw) {
+		const ceilLot = (x) => (x + lot - 1n) / lot * lot;
+		const minPremiumQuantity = entryProbabilityRaw === 0n ? 0n : ceilLot((MIN_PREMIUM * 1000000000n + entryProbabilityRaw - 1n) / entryProbabilityRaw);
+		let quantity = startRaw;
+		let raised = false;
+		for (let probe = 0; probe < 5 && quantity > 0n; probe++) {
+			let quote;
+			try {
+				quote = await quoteAt(quantity);
+			} catch (e) {
+				if (!isOrderFailsLimits(e)) throw e;
+				if (!raised && quantity < minPremiumQuantity) {
+					raised = true;
+					quantity = minPremiumQuantity;
+					continue;
+				}
+				if (raised || quantity < minPremiumQuantity) return { refusal: "min-premium" };
+				return { refusal: unsubsidizedPricePerContractRaw < NEAR_DOLLAR_PER_CONTRACT ? "entry-band" : "cost-above-payout" };
+			}
+			const unsubsidized = quote.allInCost - quote.penaltyFee + quote.feeIncentiveSubsidy;
+			if (unsubsidized <= budgetRaw) return quantity >= budgetRaw ? { quantity } : { refusal: "cost-above-payout" };
+			if (raised) return { refusal: "min-premium" };
+			const next = quantity * budgetRaw / unsubsidized / lot * lot;
+			quantity = next < quantity ? next : quantity - lot;
+		}
+		return { refusal: "min-premium" };
+	}
+	async #searchBudgetQuote(ticks, budgetRaw, lot) {
+		const floorLot = (x) => x / lot * lot;
+		let refusal = null;
+		let priced = false;
+		const probeQuote = async (request) => {
+			try {
+				const { quote: quote$1 } = await quoteMintAnonymous(this.#client, this.#config, {
+					...ticks,
+					request
+				});
+				priced = true;
+				return quote$1;
+			} catch (e) {
+				if (!isOrderFailsLimits(e)) throw e;
+				refusal ??= e;
+				return null;
+			}
+		};
+		let best = null;
+		let quote = await probeQuote({
+			shape: "exact-amount",
+			maxPremiumRaw: budgetRaw,
+			minQuantityRaw: lot
+		});
+		for (let probe = 1; quote != null; probe++) {
+			const cost = quote.allInCost - quote.penaltyFee;
+			if (cost <= budgetRaw && (best == null || quote.quantity > best.quantity)) best = quote;
+			if (probe === 4) break;
+			const next = cost === 0n ? quote.quantity : floorLot(budgetRaw * quote.quantity / cost);
+			if (next === 0n || next === quote.quantity) break;
+			quote = await probeQuote({
+				shape: "exact-quantity",
+				quantityRaw: next
+			});
+		}
+		if (best == null) {
+			if (!priced && refusal != null && budgetRaw >= MIN_PREMIUM + lot) throw refusal;
+			throw new PredictPreflightError("min-premium", `a budget of ${rawToUsdc(budgetRaw)} buys no payout at the current price (a mint's premium must be at least ${rawToUsdc(MIN_PREMIUM)} USDC)`);
+		}
+		return best;
+	}
+	static #refusal(check) {
+		try {
+			check();
+			return null;
+		} catch (e) {
+			if (e instanceof PredictPreflightError) return e.code;
+			throw e;
+		}
+	}
 	async #buildMint(owner, m, opts) {
 		const feeds = this.#feeds(m.underlying);
 		const { id, state } = await this.#resolveMarket(m);
@@ -451,7 +1207,227 @@ var PredictClient = class PredictClient {
 		if (tick == null) throw new PredictInputError(`reference price not set yet for ${m.underlying} @ ${m.expiryMs} — retry shortly or pass a numeric strike`);
 		return tick * state.tickSizeRaw;
 	}
+	#requireDelayedExecution() {
+		return toOrdersConfig(this.cfg);
+	}
+	#recordsDelayedExecution() {
+		const { predictDelayedExecution, predictOrders } = this.cfg.packages;
+		const { orderDesk, queueRegistry } = this.cfg.objects;
+		return Boolean(predictDelayedExecution && predictOrders && orderDesk && queueRegistry);
+	}
+	async #existingQueueId(orders, marketId) {
+		const queueId = deriveQueueId(orders.queueRegistry, marketId);
+		if (this.#knownQueues.has(queueId)) return queueId;
+		const { objects: [queue] } = await this.#client.core.getObjects({ objectIds: [queueId] });
+		if (queue instanceof Error) throw new PredictPreflightError("no-queue", `market ${marketId} has no order queue yet (\`queue::create_and_share\` hasn't run for it)`);
+		this.#knownQueues.add(queueId);
+		return queueId;
+	}
+	async #queueState(orders, marketId, opts = {}) {
+		const queueId = await this.#existingQueueId(orders, marketId);
+		return marketQueueState(this.#client, orders, marketId, {
+			owner: opts.owner,
+			quoteCoinType: this.cfg.quoteCoinType,
+			recordIds: opts.recordIds,
+			queueId
+		});
+	}
+	#assertQueueOpen(state, side, nowMs) {
+		const policy = state.desk.policy;
+		if (!state.protocol.orderFlowEnabled) throw new PredictPreflightError("not-live", "queued orders aren't live yet: the protocol hasn't enabled the order-flow package");
+		const mode = executionModeFor(state.protocol.versionWatermark, true);
+		if (mode === "retired") throw new PredictPreflightError("retired", "the Predict package version this SDK calls is retired: update the SDK");
+		if (mode !== "delayed") throw new PredictPreflightError("not-live", "queued orders aren't live yet: the protocol's version watermark hasn't been raised");
+		if (state.desk.versionWatermark > ORDER_FLOW_PACKAGE_VERSION) throw new PredictPreflightError("retired", "the order-flow package version this SDK calls is retired: update the SDK");
+		if (state.protocol.frozen) throw new PredictPreflightError("paused", "the protocol is frozen");
+		if (side === "mint" && (state.protocol.tradingPaused || state.mintPaused)) throw new PredictPreflightError("paused", "minting is paused on this market");
+		if (state.stuck) throw new PredictPreflightError("stuck", "pricing is delayed for this market, try again shortly");
+		const [pending, capacity] = side === "mint" ? [state.pending.mints, policy.mintCapacity] : [state.pending.sells, policy.sellCapacity];
+		if (pending >= capacity) throw new PredictPreflightError("queue-full", `the market has ${pending} waiting ${side}s, its maximum`);
+		if (state.account && state.account.waitingOrders >= policy.perAccountCap) throw new PredictPreflightError("account-cap", `the account already has ${state.account.waitingOrders} waiting orders in this market, its maximum`);
+		const timing = previewTiming({
+			nowMs,
+			policy,
+			heads: state.heads,
+			expiryMs: state.expiryMs,
+			noTradeWindowMs: state.protocol.noTradeWindowMs
+		});
+		if (!timing.beforeCutoff) throw new PredictPreflightError("past-cutoff", "this market no longer takes orders before its expiry");
+		return {
+			policy,
+			timing
+		};
+	}
+	#preview(marketId, kind, timing, policy, budget, cashNeedRaw, spareCashRaw, funding) {
+		const totalDebit = budget + policy.orderFee;
+		return {
+			marketId,
+			kind,
+			kindName: orderKindName(kind),
+			timing,
+			orderFee: rawToUsdc(policy.orderFee),
+			budget: rawToUsdc(budget),
+			totalDebit: rawToUsdc(totalDebit),
+			cashNeedRaw,
+			spareCashRaw,
+			...funding,
+			raw: {
+				orderFee: policy.orderFee,
+				budget,
+				totalDebit
+			}
+		};
+	}
+	async #planMint(owner, m, order, build) {
+		const orders = this.#requireDelayedExecution();
+		const feeds = this.#feeds(m.underlying);
+		const { id, state: market } = await this.#resolveMarket(m);
+		const { lowerTick, higherTick } = await this.#strikeTicks(m, id, market);
+		const thunk = build(orders, {
+			expiryMarketId: id,
+			wrapperId: this.wrapperIdFor(owner),
+			lowerTick,
+			higherTick,
+			...feeds
+		});
+		const state = await this.#queueState(orders, id, { owner });
+		const { policy, timing } = this.#assertQueueOpen(state, "mint", BigInt(Date.now()));
+		const { budget, cashNeed } = PredictClient.#assertMintOrder(state, policy, order);
+		const tx = new Transaction();
+		tx.add(assertOrderFeeAtMost(orders, policy.orderFee));
+		tx.add(thunk);
+		return {
+			transaction: tx,
+			preview: this.#preview(id, order.kind, timing, policy, budget, cashNeed, state.spareCash, {
+				needsFunding: false,
+				fundedInTransaction: false
+			})
+		};
+	}
+	static #assertMintOrder(state, policy, order) {
+		const available = state.account?.availableRaw ?? 0n;
+		const budget = mintBudget({
+			kind: order.kind,
+			maxCostRaw: order.maxCostRaw,
+			availableRaw: available,
+			orderFeeRaw: policy.orderFee,
+			quantityRaw: order.quantityRaw
+		});
+		if (budget == null) throw new PredictPreflightError("fee", `the balance (${rawToUsdc(available)}) doesn't cover the ${rawToUsdc(policy.orderFee)} order fee`);
+		if (budget < MIN_PREMIUM) throw new PredictPreflightError("min-premium", `the escrowed budget ${rawToUsdc(budget)} is below the ${rawToUsdc(MIN_PREMIUM)} minimum premium`);
+		if (order.kind !== ORDER_KIND.EXACT_QUANTITY && state.minEntryProbability === 0n) throw new PredictPreflightError("market-cash", "this market takes no budget mints");
+		const cashNeed = mintCashNeed({
+			kind: order.kind,
+			budgetRaw: budget,
+			minEntryProbability: state.minEntryProbability,
+			quantityRaw: order.quantityRaw,
+			maxPremiumRaw: order.maxPremiumRaw
+		});
+		if (cashNeed > state.spareCash) throw new PredictPreflightError("market-cash", "this market can't take an order this size right now");
+		return {
+			budget,
+			cashNeed
+		};
+	}
+	static #assertRecordOpen(state, recordId) {
+		const record = state.records[0];
+		if (!record || record.status !== ORDER_STATUS.OPEN || record.position.order_id === 0n) throw new PredictPreflightError("record-not-open", `record ${recordId} isn't an Open position`);
+		return record;
+	}
+	#assertSellQuantity(record, closeQuantityRaw) {
+		const held = decodeOrderRange(record.position.order_id, BigInt(this.cfg.units.positionLotSize)).quantity;
+		if (closeQuantityRaw > held) throw new PredictInputError(`quantity ${rawToUsdc(closeQuantityRaw)} is above the record's ${rawToUsdc(held)}`);
+		return held;
+	}
+	#assertSellOrder(state, policy, recordId, closeQuantityRaw) {
+		const record = PredictClient.#assertRecordOpen(state, recordId);
+		if (!state.account || normalizeSuiAddress(record.account_id) !== normalizeSuiAddress(state.account.accountId)) throw new PredictPreflightError("not-record-owner", `record ${recordId} belongs to another account`);
+		if (!feeCovered("sell", state.account.availableRaw, policy.orderFee)) throw new PredictPreflightError("fee", `the balance doesn't cover the ${rawToUsdc(policy.orderFee)} order fee`);
+		const held = this.#assertSellQuantity(record, closeQuantityRaw);
+		const min = policy.minSellQuantity;
+		if (closeQuantityRaw < min || closeQuantityRaw < held && held - closeQuantityRaw < min) throw new PredictPreflightError("below-min-sell", `a sell must close at least ${rawToUsdc(min)} and leave either nothing or at least that much`);
+	}
+	async #planSell(owner, m, opts) {
+		const orders = this.#requireDelayedExecution();
+		const feeds = this.#feeds(m.underlying);
+		const { id } = await this.#resolveMarket(m);
+		const closeQuantityRaw = usdcToRaw(opts.quantity);
+		this.#assertLot(closeQuantityRaw);
+		const thunk = enqueueRedeemOpen(orders, {
+			expiryMarketId: id,
+			wrapperId: this.wrapperIdFor(owner),
+			recordId: opts.recordId,
+			closeQuantityRaw,
+			minProbabilityRaw: probabilityToRaw(opts.minProbability),
+			minProceedsRaw: usdcToRaw(opts.minProceeds),
+			...feeds
+		});
+		const state = await this.#queueState(orders, id, {
+			owner,
+			recordIds: [opts.recordId]
+		});
+		const { policy, timing } = this.#assertQueueOpen(state, "sell", BigInt(Date.now()));
+		this.#assertSellOrder(state, policy, opts.recordId, closeQuantityRaw);
+		const cashNeed = cashNeedSell(closeQuantityRaw, state.backingBufferLambda);
+		const needsFunding = cashNeed > state.spareCash;
+		const fund = opts.fundMarket ?? "auto";
+		const funded = fund === "always" || fund === "auto" && needsFunding;
+		const tx = new Transaction();
+		tx.add(assertOrderFeeAtMost(orders, policy.orderFee));
+		tx.add(thunk);
+		if (funded) tx.add(rebalanceExpiryCash(this.#config, { expiryMarketId: id }));
+		return {
+			transaction: tx,
+			preview: this.#preview(id, ORDER_KIND.REDEEM_OPEN, timing, policy, 0n, cashNeed, state.spareCash, {
+				needsFunding,
+				fundedInTransaction: funded
+			})
+		};
+	}
+	static #queuedMintQuote(q, policy) {
+		const costRaw = q.allInCost - q.penaltyFee;
+		return {
+			entryProbability: rawToProbability(q.entryProbability),
+			premium: rawToUsdc(q.premium),
+			fees: {
+				trading: rawToUsdc(q.tradingFee),
+				subsidy: rawToUsdc(q.feeIncentiveSubsidy),
+				builder: rawToUsdc(q.builderFee),
+				penalty: 0,
+				referral: 0,
+				inventoryImpact: rawToUsdc(q.inventoryImpactCharge)
+			},
+			cost: rawToUsdc(costRaw),
+			quantity: rawToUsdc(q.quantity),
+			raw: {
+				premium: q.premium,
+				cost: costRaw,
+				quantity: q.quantity,
+				entryProbability: q.entryProbability
+			},
+			feesExact: true,
+			queued: true,
+			orderFee: policy ? rawToUsdc(policy.orderFee) : void 0
+		};
+	}
 };
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason);
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
 
 //#endregion
 export { POSITION_LOT_SIZE, PredictClient, predict };