@mysten/deepbook-v3 2.6.4 → 2.8.0

package/dist/contracts/deepbook_predict/expiry_market.mjs

@@ -1,6 +1,7 @@
-import { __exportAll } from "../../_virtual/rolldown_runtime.mjs";
-import { MoveStruct, normalizeMoveArguments } from "../utils/index.mjs";
-import { U64 } from "../../bcs/integers.mjs";
+import { MoveStruct, MoveTuple, normalizeMoveArguments } from "../utils/index.mjs";
+import { U256, U64 } from "../../bcs/integers.mjs";
+import { VecMap } from "./deps/sui/vec_map.mjs";
+import { VolSnapshot } from "./pricing.mjs";
 import { Balance } from "./deps/sui/balance.mjs";
 import { ExpiryCash } from "./expiry_cash.mjs";
 import { StrikeExposure } from "./strike_exposure.mjs";
@@ -20,59 +21,25 @@ import { bcs } from "@mysten/sui/bcs";
 * `pricing::load_live_pricer`; this module owns market flow policy and then passes
 * loaded `Pricer` snapshots into exposure business logic. Pool-wide PLP accounting
 * and profit accounting remain outside this module.
+*
+* It also owns the order-flow primitives an order-flow companion package drives.
+* `admit_mint` and `admit_sell` admit one queued order, pin a mint's boundary
+* nodes, record the order's cash need in the market's `OrderFlowLedger`, and issue
+* or advance its `OrderReceipt`. `commit` stores the bounded Pyth price the order
+* fills at, `try_fill` fills or refunds it, `release` takes it out without
+* filling, and `try_pay_settled` pays a queue-held position after settlement. A
+* queued fill never enters the account: its position stays in the receipt.
+* Admission, commit, and fill need an allowlisted companion witness; release and
+* the settled payout need only the receipt. The queue itself, its escrow, its
+* policy, and its events live in the companion.
+*
+* Mainnet USDC is a regulated coin: Sui aborts a transaction that sends it to an
+* address on its deny list, or to anyone while it is globally paused. So the fill,
+* the fee routing, and the settled payout read `sui::deny_list` first and never
+* send to such an address. A fill for a denied receive address is refused, a
+* denied builder or referrer's fee stays in market cash, and a denied winner's
+* payout is skipped for a later `try_pay_settled`.
 */
-var expiry_market_exports = /* @__PURE__ */ __exportAll({
-	ExpiryMarket: () => ExpiryMarket,
-	MintQuote: () => MintQuote,
-	ValuationStamp: () => ValuationStamp,
-	admissionTickSize: () => admissionTickSize,
-	allInCost: () => allInCost,
-	backingBufferLambda: () => backingBufferLambda,
-	builderFee: () => builderFee,
-	cashBalance: () => cashBalance,
-	currentNav: () => currentNav,
-	entryProbability: () => entryProbability,
-	expiry: () => expiry,
-	expiryFeeMaxMultiplier: () => expiryFeeMaxMultiplier,
-	expiryFeeWindowMs: () => expiryFeeWindowMs,
-	feeIncentiveBalance: () => feeIncentiveBalance,
-	feeIncentiveSubsidy: () => feeIncentiveSubsidy,
-	id: () => id,
-	inventoryImpactCharge: () => inventoryImpactCharge,
-	inventoryImpactMaxRate: () => inventoryImpactMaxRate,
-	inventoryImpactReserve: () => inventoryImpactReserve,
-	inventoryImpactScale: () => inventoryImpactScale,
-	isPendingValuation: () => isPendingValuation,
-	isSettled: () => isSettled,
-	liveOrderValue: () => liveOrderValue,
-	loadLivePricer: () => loadLivePricer,
-	mintExactAmount: () => mintExactAmount,
-	mintExactCost: () => mintExactCost,
-	mintExactQuantity: () => mintExactQuantity,
-	mintPaused: () => mintPaused,
-	payoutLiability: () => payoutLiability,
-	penaltyFee: () => penaltyFee,
-	premium: () => premium,
-	propbookUnderlyingId: () => propbookUnderlyingId,
-	quantity: () => quantity,
-	quoteMint: () => quoteMint,
-	quoteMintExactCostForAccount: () => quoteMintExactCostForAccount,
-	quoteMintForAccount: () => quoteMintForAccount,
-	redeemLive: () => redeemLive,
-	redeemSettled: () => redeemSettled,
-	redeemSettledPermissionless: () => redeemSettledPermissionless,
-	referenceTick: () => referenceTick,
-	referenceTickSourceTimestampMs: () => referenceTickSourceTimestampMs,
-	requiredCash: () => requiredCash,
-	setMintPaused: () => setMintPaused,
-	setReferenceTick: () => setReferenceTick,
-	settledOrderPayout: () => settledOrderPayout,
-	settlementPrice: () => settlementPrice,
-	tickSize: () => tickSize,
-	tradingFee: () => tradingFee,
-	trySettle: () => trySettle,
-	trySettlementPrice: () => trySettlementPrice
-});
 const $moduleName = "@local-pkg/deepbook_predict::expiry_market";
 const ValuationStamp = new MoveStruct({
 	name: `${$moduleName}::ValuationStamp`,
@@ -110,6 +77,73 @@ const MintQuote = new MoveStruct({
 		all_in_cost: U64
 	}
 });
+const RedeemQuote = new MoveStruct({
+	name: `${$moduleName}::RedeemQuote`,
+	fields: {
+		close_quantity: U64,
+		probability: U64,
+		proceeds: U64,
+		trading_fee: U64,
+		builder_fee: U64,
+		inventory_impact_rebate: U64
+	}
+});
+const OrderParties = new MoveStruct({
+	name: `${$moduleName}::OrderParties`,
+	fields: {
+		account_id: bcs.Address,
+		owner: bcs.Address,
+		receive_address: bcs.Address,
+		referrer_account_id: bcs.option(bcs.Address),
+		referrer_receive_address: bcs.option(bcs.Address),
+		builder_code_id: bcs.option(bcs.Address)
+	}
+});
+const OrderReceipt = new MoveStruct({
+	name: `${$moduleName}::OrderReceipt`,
+	fields: {
+		expiry_market_id: bcs.Address,
+		stage: bcs.u8(),
+		kind: bcs.u8(),
+		parties: OrderParties,
+		lower_tick: U64,
+		higher_tick: U64,
+		quantity: U64,
+		max_premium: U64,
+		min_quantity: U64,
+		max_probability: U64,
+		min_probability: U64,
+		min_proceeds: U64,
+		tau_ms: U64,
+		deadline_ms: U64,
+		channel: bcs.u8(),
+		vol: VolSnapshot,
+		budget: U64,
+		order_fee: U64,
+		cash_need: U64,
+		subsidy_bound: U64,
+		subsidy_rate: U64,
+		subsidy_reserved: U64,
+		spot: U64,
+		tick_ms: U64,
+		generation_us: U64,
+		order_id: U256,
+		root_id: U256,
+		opened_at_ms: U64,
+		held_quantity: U64
+	}
+});
+const OrderFlowLedgerKey = new MoveTuple({
+	name: `${$moduleName}::OrderFlowLedgerKey`,
+	fields: [bcs.bool()]
+});
+const OrderFlowLedger = new MoveStruct({
+	name: `${$moduleName}::OrderFlowLedger`,
+	fields: {
+		pins: VecMap(U64, U64),
+		waiting_cash_need: U64
+	}
+});
 /** Return the market object ID for external discovery and PTB construction. */
 function id(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -500,12 +534,14 @@ function mintPaused(options) {
 	});
 }
 /**
-* Quote the all-in cost of a mint request for an anonymous taker (no builder code)
-* without mutating any market state. Exact-quantity mode uses `min_quantity`;
-* budget mode conservatively sizes a lot-rounded fill under `max_premium`. The
-* quote applies live-mint and admission gates but does not preflight account
-* balance, slippage caps, or exposure-index capacity. Its penalty uses the current
-* pre-update EWMA state. Public for SDK and devInspect pre-trade pricing.
+* Quote a prospective mint at a market-bound `Pricer`, priced like a queued fill
+* at the clock, for SDK and devInspect previews. `exact_quantity` quotes
+* `min_quantity` exactly; otherwise the largest quantity whose premium fits
+* `max_premium`, at least `min_quantity`. No builder fee. The fee subsidy is the
+* configured rate capped by the market's incentive balance, and `penalty_fee` is
+* always 0. Gated only on the pricer binding (`EWrongPricer`) and `now < expiry`
+* (`EInvalidOrderTiming`). Aborts `EOrderFailsLimits` when the mint would be
+* refused at the clock.
 */
 function quoteMint(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -541,9 +577,8 @@ function quoteMint(options) {
 	});
 }
 /**
-* Quote the all-in cost of a mint request for one account, reading its builder
-* code. Budget mode caps premium by total account balance, including unsettled
-* accumulator funds. Public for SDK and devInspect pre-trade pricing.
+* `quote_mint` for the wrapper's account: `max_premium` is capped at the account's
+* balance and the account's builder fee is charged.
 */
 function quoteMintForAccount(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -582,13 +617,10 @@ function quoteMintForAccount(options) {
 	});
 }
 /**
-* Quote `mint_exact_cost` for one account: the fill that mint would size for
-* `max_cost`, capped by total account balance including unsettled accumulator
-* funds, with that fill's cost decomposition. Applies the mint's live-mint gates,
-* sizing, `min_quantity` floor, and admission, but does not preflight
-* exposure-index capacity or cash backing. `quantity` is the figure to derive a
-* `min_quantity` slippage floor from. Public for SDK and devInspect pre-trade
-* pricing.
+* Quote the largest mint whose all-in cost fits `min(max_cost, account  balance)`,
+* at least `min_quantity`, for the wrapper's account, priced like a queued
+* exact-cost fill at the clock. Charges the account's builder fee, and otherwise
+* prices and gates like `quote_mint`.
 */
 function quoteMintExactCostForAccount(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -624,6 +656,42 @@ function quoteMintExactCostForAccount(options) {
 		}, argumentsTypes, parameterNames)
 	});
 }
+/**
+* Return `(waiting_cash_need, payout_tree_node_count, min_entry_probability)`: the
+* summed cash need of the market's admitted orders, above required cash, that
+* `rebalance_expiry_cash` keeps a live market funded with; the payout tree's node
+* count, pinned zero nodes included, which sizes the keeper's fill batches; and
+* the snapshotted minimum entry probability the SDK computes a queued mint's cash
+* need from. For SDK, keeper, and devInspect reads.
+*/
+function orderFlowState(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["market"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "order_flow_state",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Return a receipt's
+* `(expiry_market_id, stage, account_id, order_id,  pyth_source_id, cash_need, subsidy_bound, vol)`.
+* For the order-flow companion's queue events and Lazer decoding, and devInspect
+* reads of queue records.
+*/
+function receiptInfo(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["receipt"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "receipt_info",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
 /** Return the sized quantity for SDK and devInspect quote consumers. */
 function quantity(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -738,20 +806,109 @@ function allInCost(options) {
 		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
 	});
 }
+function redeemCloseQuantity(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["quote"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "redeem_close_quantity",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function redeemProbability(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["quote"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "redeem_probability",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function redeemProceeds(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["quote"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "redeem_proceeds",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function redeemTradingFee(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["quote"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "redeem_trading_fee",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function redeemBuilderFee(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["quote"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "redeem_builder_fee",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function redeemInventoryImpactRebate(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["quote"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "redeem_inventory_impact_rebate",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
 /**
-* Mint an exact live position quantity against this expiry market.
-*
-* Requires the running package version to be at or above the protocol version
-* watermark, per-market mint pause to be off, trading globally enabled, valid
-* owner or authorized-app account auth, a market-bound live `Pricer`, and enough
-* expiry cash to back the post-mint max payout. Mint fees are paid by routing a
-* withdraw through the loaded account. The position's strike range is the tick
-* pair `(lower_tick, higher_tick]` (`lower_tick = 0` is `-inf`,
-* `higher_tick = pos_inf_tick` is `+inf`); the SDK converts raw strikes to ticks.
-* `max_cost` caps the all-in USDC withdrawal, while `max_probability` caps the
-* quoted per-contract probability before fees. Callers can pass
-* `std::u64::max_value!()` for either uncapped guard. Returns the minted order ID
-* for future order-scoped flows.
+* Quote an early sell of `close_quantity` of an open receipt's position at a
+* market-bound `Pricer` and the clock, charging `builder_code_id`'s builder fee:
+* the close a sell fill prices, without the trader's floors. `proceeds` is before
+* the order fee. Changes nothing. Aborts on the pricer binding (`EWrongPricer`),
+* another market's receipt (`EWrongMarket`), a receipt that is not open
+* (`EWrongStage`), `now >= expiry` (`EInvalidOrderTiming`), or a close that cannot
+* be priced (`EOrderFailsLimits`). Public for the order-flow companion's sell
+* preview and SDK reads.
+*/
+function quoteClose(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"u64",
+		"0x1::option::Option<0x2::object::ID>",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"market",
+		"pricer",
+		"receipt",
+		"closeQuantity",
+		"builderCodeId"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "quote_close",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Retired by delayed execution: always aborts `EDelayedExecutionRequired`. Mints
+* are queued through the order-flow companion.
 */
 function mintExactQuantity(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -770,16 +927,16 @@ function mintExactQuantity(options) {
 		"0x2::clock::Clock"
 	];
 	const parameterNames = [
-		"market",
-		"wrapper",
-		"auth",
-		"config",
-		"pricer",
-		"lowerTick",
-		"higherTick",
-		"quantity",
-		"maxCost",
-		"maxProbability"
+		"Market",
+		"Wrapper",
+		"Auth",
+		"Config",
+		"Pricer",
+		"LowerTick",
+		"HigherTick",
+		"Quantity",
+		"MaxCost",
+		"MaxProbability"
 	];
 	return (tx) => tx.moveCall({
 		package: packageAddress,
@@ -787,24 +944,13 @@ function mintExactQuantity(options) {
 		function: "mint_exact_quantity",
 		arguments: normalizeMoveArguments({
 			...options.arguments,
-			config: options.arguments?.config ?? options.config?.protocolConfig
+			Config: options.arguments?.Config ?? options.config?.protocolConfig
 		}, argumentsTypes, parameterNames)
 	});
 }
 /**
-* Mint a conservatively sized lot-rounded position whose premium does not exceed
-* `max_premium`. The result may be one lot below the largest fitting quantity and
-* must meet `min_quantity`.
-*
-* Fees, builder fees, and EWMA congestion penalties are charged on top of
-* `max_premium`, so `max_cost` — not `max_premium` — bounds the all-in USDC
-* withdrawal (`premium + trader-paid fee + builder_fee + EWMA penalty`).
-* `max_cost` is required: unlike `mint_exact_quantity`'s guards there is no value
-* that disables it, because the budget shape exists to bound spend. The sizing
-* budget is first capped to the account's available USDC after settlement; fees
-* still require additional available USDC at payment time. Any unspent premium
-* dust remains in the account because order quantity must be an integer number of
-* `position_lot_size` lots.
+* Retired by delayed execution: always aborts `EDelayedExecutionRequired`. Mints
+* are queued through the order-flow companion.
 */
 function mintExactAmount(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -823,16 +969,16 @@ function mintExactAmount(options) {
 		"0x2::clock::Clock"
 	];
 	const parameterNames = [
-		"market",
-		"wrapper",
-		"auth",
-		"config",
-		"pricer",
-		"lowerTick",
-		"higherTick",
-		"maxPremium",
-		"minQuantity",
-		"maxCost"
+		"Market",
+		"Wrapper",
+		"Auth",
+		"Config",
+		"Pricer",
+		"LowerTick",
+		"HigherTick",
+		"MaxPremium",
+		"MinQuantity",
+		"MaxCost"
 	];
 	return (tx) => tx.moveCall({
 		package: packageAddress,
@@ -840,41 +986,13 @@ function mintExactAmount(options) {
 		function: "mint_exact_amount",
 		arguments: normalizeMoveArguments({
 			...options.arguments,
-			config: options.arguments?.config ?? options.config?.protocolConfig
+			Config: options.arguments?.Config ?? options.config?.protocolConfig
 		}, argumentsTypes, parameterNames)
 	});
 }
 /**
-* Mint a lot-rounded position within an all-in `max_cost` budget.
-*
-* Unlike `mint_exact_amount`, fees are sized inside the budget: the quantity
-* search evaluates the all-in withdrawal the mint charges
-* (`premium +  trader-paid fee + builder_fee + EWMA penalty + inventory_impact_charge`)
-* against the fee-incentive, congestion, and book state at execution, so the debit
-* never exceeds `max_cost`. `max_cost` is first capped to the account's available
-* USDC after settlement, so `std::u64::max_value!()` sizes against the whole
-* balance.
-*
-* The budget search finds the largest fitting quantity. If that quantity costs
-* more than its maximum payout, a conservative search tries a smaller fill;
-* rounding can make that fallback miss a larger admissible fill. Only when the
-* budget is the limiting constraint is the remainder less than the incremental
-* all-in cost of one more lot. Payout-limited fills and lot-cap saturation can
-* leave more. Insufficient expiry cash backing aborts the mint; sizing does not
-* shrink the fill to available backing, and the quote does not preflight it.
-*
-* `min_quantity` is this entrypoint's slippage guard. The budget is fixed, so
-* every adverse move between building the transaction and executing it — the
-* price, the congestion surcharge, the sponsor subsidy, the inventory-impact
-* charge — shows up as fewer contracts, and a fill below `min_quantity` aborts
-* `EMintQuantityBelowMin`. It bounds the all-in price per contract at
-* `max_cost / min_quantity`, which is why the shape carries no separate
-* probability cap; passing `0` accepts any fill the budget buys. A budget too
-* small to admit `constants::min_premium` aborts `EPremiumBelowMinimum` rather
-* than minting nothing, and zero is such a budget: unlike `mint_exact_amount`
-* there is no `max_cost` cap to require, because here the budget IS the sizing
-* input. Other requirements match `mint_exact_quantity`. Returns the minted order
-* ID.
+* Retired by delayed execution: always aborts `EDelayedExecutionRequired`. Mints
+* are queued through the order-flow companion.
 */
 function mintExactCost(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -892,15 +1010,15 @@ function mintExactCost(options) {
 		"0x2::clock::Clock"
 	];
 	const parameterNames = [
-		"market",
-		"wrapper",
-		"auth",
-		"config",
-		"pricer",
-		"lowerTick",
-		"higherTick",
-		"maxCost",
-		"minQuantity"
+		"Market",
+		"Wrapper",
+		"Auth",
+		"Config",
+		"Pricer",
+		"LowerTick",
+		"HigherTick",
+		"MaxCost",
+		"MinQuantity"
 	];
 	return (tx) => tx.moveCall({
 		package: packageAddress,
@@ -908,23 +1026,14 @@ function mintExactCost(options) {
 		function: "mint_exact_cost",
 		arguments: normalizeMoveArguments({
 			...options.arguments,
-			config: options.arguments?.config ?? options.config?.protocolConfig
+			Config: options.arguments?.Config ?? options.config?.protocolConfig
 		}, argumentsTypes, parameterNames)
 	});
 }
 /**
-* Redeem a live order you hold account authority over.
-*
-* A live order is priced and closed (partial or full). Settled orders must use
-* `redeem_settled`. Returns a replacement order ID only when a partial close
-* leaves quantity open.
-*
-* Two close-side slippage floors, the mirror of mint's `max_probability` /
-* `max_cost` pair; pass `0` to disable either. `min_probability` floors the quoted
-* per-contract range probability (same units as mint's `max_probability`).
-* `min_proceeds` floors the all-in net USDC credited to the account
-* (`redeem_amount` minus trading fee, builder fee, and EWMA penalty), the mirror
-* of mint's all-in `max_cost`.
+* Retired by delayed execution: always aborts `EDelayedExecutionRequired`. Early
+* sells of queue-held positions go through the order-flow companion; account-held
+* positions exit through `redeem_settled` after settlement.
 */
 function redeemLive(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -942,15 +1051,15 @@ function redeemLive(options) {
 		"0x2::clock::Clock"
 	];
 	const parameterNames = [
-		"market",
-		"wrapper",
-		"auth",
-		"config",
-		"pricer",
-		"orderId",
-		"closeQuantity",
-		"minProbability",
-		"minProceeds"
+		"Market",
+		"Wrapper",
+		"Auth",
+		"Config",
+		"Pricer",
+		"OrderId",
+		"CloseQuantity",
+		"MinProbability",
+		"MinProceeds"
 	];
 	return (tx) => tx.moveCall({
 		package: packageAddress,
@@ -958,7 +1067,7 @@ function redeemLive(options) {
 		function: "redeem_live",
 		arguments: normalizeMoveArguments({
 			...options.arguments,
-			config: options.arguments?.config ?? options.config?.protocolConfig
+			Config: options.arguments?.Config ?? options.config?.protocolConfig
 		}, argumentsTypes, parameterNames)
 	});
 }
@@ -998,11 +1107,15 @@ function redeemSettled(options) {
 	});
 }
 /**
-* Permissionlessly redeem a settled order without account-owner authority.
+* Redeem a settled order without account-owner authority, as an allowlisted
+* keeper.
 *
-* This keeper path uses Predict app-auth from the account registry, so
-* `deauthorize_app<PredictApp>` disables this automation. Owners can still use
-* `redeem_settled` with owner auth to redeem their own settled positions.
+* Despite the name, only a sender admin has added through
+* `protocol_config::add_settled_redeem_keeper` may call this; the allowlist starts
+* empty. The payout still goes to the order's account. This keeper path uses
+* Predict app-auth from the account registry, so `deauthorize_app<PredictApp>`
+* also disables it. Owners can still use `redeem_settled` with owner auth to
+* redeem their own settled positions.
 */
 function redeemSettledPermissionless(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -1100,6 +1213,12 @@ function setMintPaused(options) {
 * Block Scholes minute-boundary spot when Pyth remains unavailable after the
 * compiled grace period. Permissionless and idempotent; missing or unusable
 * observations leave the market unsettled.
+*
+* Settlement reads nothing from the order-flow queue. Every admission's deadline
+* is at least `constants::deadline_expiry_margin_ms!()` before expiry, so at
+* expiry a waiting order can only be released, and the settled liability already
+* covers every queue-held position, which lives in the payout tree. The companion
+* drains and pays its queue afterwards.
 */
 function trySettle(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -1129,7 +1248,354 @@ function trySettle(options) {
 		}, argumentsTypes, parameterNames)
 	});
 }
+/**
+* Admit one queued mint for the order-flow companion and return its receipt.
+*
+* `kind` is a `constants` mint kind. The companion has already taken
+* `budget +  order_fee` from the account and escrows it. `budget` caps the fill's
+* all-in cost; the companion sets it to `min(max_cost, balance - order_fee)`, and
+* to at most `quantity` for an exact-quantity mint. The order prices at a Pyth
+* price on Lazer channel `channel`, generated at or after `tau_ms`, and must fill
+* before `deadline_ms`.
+*
+* Aborts unless `W` is allowlisted, the version and cutover gates pass, trading
+* and this market's mints are unpaused, and the snapshot stage is closed. The
+* timing must fit (`EInvalidOrderTiming`): `channel` a supported fixed-rate
+* channel (`lazer_price::channel_fixed_rate_*`), `tau_ms` on its grid, at most one
+* of its ticks before now, and before `deadline_ms`, τ before the no-trade window,
+* and the deadline at least `constants::deadline_expiry_margin_ms!()` before
+* expiry. Then `svi_max_age_ms` must be within `constants::max_svi_max_age_ms!()`
+* and `kind` a mint kind (`EInvalidOrderTerms`), the volatility snapshot must
+* load, `budget` must be positive (`EMintCostCapRequired`), the order must pass
+* its own limits at the clock without subsidy (`EOrderFailsLimits`), and its cash
+* need must fit the market's spare cash (`EInsufficientMarketCash`). Admission
+* then pins both boundary nodes, creating them under the node cap, and adds the
+* cash need to the ledger.
+*/
+function admitMint(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		`${options.typeArguments[0]}`,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		"u8",
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u8",
+		"u64",
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"W",
+		"market",
+		"config",
+		"account",
+		"propbookRegistry",
+		"pyth",
+		"bsValues",
+		"bsSvi",
+		"kind",
+		"lowerTick",
+		"higherTick",
+		"quantity",
+		"maxPremium",
+		"minQuantity",
+		"maxProbability",
+		"budget",
+		"orderFee",
+		"sviMaxAgeMs",
+		"channel",
+		"tauMs",
+		"deadlineMs"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "admit_mint",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig,
+			propbookRegistry: options.arguments?.propbookRegistry ?? options.config?.oracleRegistry
+		}, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Admit an early sell of `close_quantity` of an open receipt's position: the
+* receipt moves to the sell stage in place, with the sell's request, the account's
+* current owner and builder code, a fresh volatility snapshot, τ, the deadline,
+* and no price. The companion escrows `order_fee` and owns the minimum-sell
+* checks.
+*
+* Open during the trading pause and a market mint pause. Aborts unless `W` is
+* allowlisted, the version, cutover, and snapshot-stage gates and `admit_mint`'s
+* timing and SVI-age checks pass, the receipt is this market's (`EWrongMarket`),
+* open (`EWrongStage`), and `account`'s (`ENotRecordOwner`), the volatility
+* snapshot loads, and the close passes its own floors at the clock
+* (`EOrderFailsLimits`). Then adds the sell's cash need,
+* `ceil(close_quantity * (1 - backing_buffer_lambda)) + 1`, to the ledger: a close
+* lowers payout liability by at least `lambda * close_quantity` and pays at most
+* `close_quantity`. There is no spare-cash check. The keeper funds the market
+* before τ, and the fill refunds a sell the market cannot cover.
+*/
+function admitSell(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		`${options.typeArguments[0]}`,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u8",
+		"u64",
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"W",
+		"market",
+		"config",
+		"account",
+		"receipt",
+		"propbookRegistry",
+		"pyth",
+		"bsValues",
+		"bsSvi",
+		"closeQuantity",
+		"minProbability",
+		"minProceeds",
+		"orderFee",
+		"sviMaxAgeMs",
+		"channel",
+		"tauMs",
+		"deadlineMs"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "admit_sell",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig,
+			propbookRegistry: options.arguments?.propbookRegistry ?? options.config?.oracleRegistry
+		}, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Commit the Pyth price an admitted order fills at: a `LazerPrice`, which only the
+* `deepbook_predict_math` library builds, from a Pyth-verified Lazer update.
+* Stores the spot, the envelope time (the tick the fill prices at), and the feed's
+* generation time. For a mint it also reserves the fee subsidy,
+* `min(subsidy_bound * fee_incentive_subsidy_rate, incentives left)`, records the
+* rate and amount, and returns the reservation for the companion to escrow with
+* the order. A sell returns a zero balance.
+*
+* The price must be the receipt's: its Pyth feed and channel, an envelope at
+* exactly τ or one tick of that channel later (the backup tick), a generation time
+* between τ and the envelope, an envelope at or before now, and a pricing-safe
+* spot (`EWrongPrice`). Aborts unless `W` is allowlisted, the version gate passes,
+* the receipt is this market's (`EWrongMarket`), admitted with no price yet
+* (`EWrongStage`), and before its deadline (`EInvalidOrderTiming`).
+*/
+function commit(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		`${options.typeArguments[0]}`,
+		null,
+		null,
+		null,
+		null,
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"W",
+		"market",
+		"config",
+		"receipt",
+		"price"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "commit",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Fill or refund one committed order at its committed price and consume or return
+* its receipt. `escrow` is the order's escrowed budget, order fee, and reserved
+* subsidy. Returns
+* `(reason, receipt to keep, escrow left over,  quantity, amount, trading_fee, builder_fee, referral_fee, subsidy_used,  inventory_impact)`.
+* The amounts are zero on a refund. For a mint `amount` is the all-in cost and
+* `inventory_impact` the charge; for a sell `amount` is the proceeds and
+* `inventory_impact` the rebate.
+*
+* Aborts only on a companion bookkeeping error: `W` not allowlisted, the version,
+* freeze, or snapshot-stage gate, another market's receipt (`EWrongMarket`), a
+* receipt not admitted or without a price (`EWrongStage`), or `escrow` below
+* `budget + order_fee + subsidy_reserved` (`EEscrowMismatch`). Every market
+* condition returns a refund reason instead, `0` for a fill: 5 at or past the
+* deadline, which also covers expiry and settlement; 9 when USDC sent to the
+* receipt's receive address would abort the transaction (`denied`: the address is
+* on USDC's deny list for the current epoch, or USDC is globally paused), so
+* nothing is sent there; 2 when no `Pricer` exists at the tick; then the fill's
+* own 1 (the order's limits), 2 (admission), 4 (a pinned node is missing, a
+* backstop), and 8 (the market's cash after the fill would not cover its required
+* cash).
+*
+* A mint fill pays the premium, the trading fee net of the referral share, the
+* used subsidy, the order fee, and the inventory-impact charge into market cash,
+* sends the builder and referral fees, returns unused subsidy to the incentive
+* balance, emits `OrderMinted` with no congestion penalty, and returns the receipt
+* open. A sell fill pays the proceeds (redeem value plus inventory-impact rebate,
+* less the trading and builder fees) to the receipt's receive address, keeps the
+* trading and order fees in market cash, emits `LiveOrderRedeemed`, and returns
+* the receipt open with the replacement position of a partial close, or consumes
+* it on a full close. A builder or referral fee whose recipient is denied stays in
+* market cash instead, and the events still report it as charged. A refund keeps
+* the order fee in market cash for reasons 1 and 2, returns the reserved subsidy
+* to the incentive balance, prunes a mint's emptied unpinned nodes, returns the
+* rest of the escrow, and returns a sell's receipt open or consumes a mint's.
+* Every outcome takes the order out of the ledger.
+*/
+function tryFill(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		`${options.typeArguments[0]}`,
+		null,
+		null,
+		null,
+		null,
+		"0x2::deny_list::DenyList",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"W",
+		"market",
+		"config",
+		"receipt",
+		"escrow"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "try_fill",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Take an admitted order out without filling it: the companion's deadline, admin,
+* and settlement-drain refunds release their receipt here. `escrow` is the order's
+* escrowed budget, order fee, and reserved subsidy, and `reason` the refund's
+* `constants::fill_reason_*` code. The order fee follows `try_fill`'s refund rule:
+* reasons 1 and 2 keep it in market cash, and every other reason leaves it in the
+* escrow returned. Returns the reservation to the incentive balance, subtracts the
+* exact cash need from the ledger, and unpins a mint's boundary ticks, pruning
+* emptied, unpinned, unretained nodes only when `prune` and the market is
+* unsettled. Returns a sell's receipt open, still holding its position, or `none`
+* for a mint's, which it consumes, and the rest of the escrow.
+*
+* Needs no allowlisting and checks only the version floor, so the drain works
+* while the protocol is frozen and after the witness is removed. Keeping an order
+* fee moves market cash, so like a fill it aborts inside the keeper's snapshot
+* stage (`ESnapshotInProgress`). Aborts on another market's receipt
+* (`EWrongMarket`), a receipt not admitted (`EWrongStage`), or `escrow` below
+* `budget + order_fee + subsidy_reserved` (`EEscrowMismatch`).
+*/
+function release(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		"u8",
+		"bool"
+	];
+	const parameterNames = [
+		"market",
+		"config",
+		"receipt",
+		"escrow",
+		"reason",
+		"prune"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "release",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Pay an open receipt's settled payout, zero for a loser, to its receive address
+* and consume the receipt. Returns the payout and `none`. When the payout is above
+* market cash or above the settled liability left, or a nonzero payout's receive
+* address is denied (`try_fill`'s reason 9: on USDC's deny list for the current
+* epoch, or USDC globally paused), changes nothing and returns that payout with
+* the receipt, so the companion's payout walk moves on and a later call pays it
+* once the cause clears. Needs no allowlisting and checks only the version floor.
+* Aborts on another market's receipt (`EWrongMarket`), a receipt that is not open
+* (`EWrongStage`), or an unsettled market (`EMarketNotSettled`).
+*/
+function tryPaySettled(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"0x2::deny_list::DenyList"
+	];
+	const parameterNames = [
+		"market",
+		"config",
+		"receipt"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "expiry_market",
+		function: "try_pay_settled",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
 
 //#endregion
-export { admissionTickSize, currentNav, expiry, expiry_market_exports, loadLivePricer, mintExactAmount, mintExactCost, mintExactQuantity, mintPaused, redeemLive, redeemSettled, referenceTick, tickSize };
+export { ExpiryMarket, MintQuote, OrderFlowLedger, OrderFlowLedgerKey, OrderParties, OrderReceipt, RedeemQuote, ValuationStamp, admissionTickSize, admitMint, admitSell, allInCost, backingBufferLambda, builderFee, cashBalance, commit, currentNav, entryProbability, expiry, expiryFeeMaxMultiplier, expiryFeeWindowMs, feeIncentiveBalance, feeIncentiveSubsidy, id, inventoryImpactCharge, inventoryImpactMaxRate, inventoryImpactReserve, inventoryImpactScale, isPendingValuation, isSettled, liveOrderValue, loadLivePricer, mintExactAmount, mintExactCost, mintExactQuantity, mintPaused, orderFlowState, payoutLiability, penaltyFee, premium, propbookUnderlyingId, quantity, quoteClose, quoteMint, quoteMintExactCostForAccount, quoteMintForAccount, receiptInfo, redeemBuilderFee, redeemCloseQuantity, redeemInventoryImpactRebate, redeemLive, redeemProbability, redeemProceeds, redeemSettled, redeemSettledPermissionless, redeemTradingFee, referenceTick, referenceTickSourceTimestampMs, release, requiredCash, setMintPaused, setReferenceTick, settledOrderPayout, settlementPrice, tickSize, tradingFee, tryFill, tryPaySettled, trySettle, trySettlementPrice };
 //# sourceMappingURL=expiry_market.mjs.map