@mysten/deepbook-v3 2.6.4 → 2.8.0

package/src/contracts/deepbook_predict/expiry_market.ts

@@ -11,21 +11,42 @@
  * `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`.
  */
 
 import {
 	MoveStruct,
+	MoveTuple,
 	normalizeMoveArguments,
 	type RawTransactionArgument,
 	type ConfigValue,
 } from '../utils/index.js';
-import { U64 } from '../../bcs/integers.js';
-import { bcs } from '@mysten/sui/bcs';
+import { U64, U256 } from '../../bcs/integers.js';
+import { bcs, type BcsType } from '@mysten/sui/bcs';
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 import * as expiry_cash from './expiry_cash.js';
 import * as balance from './deps/sui/balance.js';
 import * as strike_exposure from './strike_exposure.js';
 import * as ewma from './ewma.js';
+import * as pricing from './pricing.js';
+import * as vec_map from './deps/sui/vec_map.js';
 const $moduleName = '@local-pkg/deepbook_predict::expiry_market';
 export const ValuationStamp = new MoveStruct({
 	name: `${$moduleName}::ValuationStamp`,
@@ -82,6 +103,106 @@ export const MintQuote = new MoveStruct({
 		all_in_cost: U64,
 	},
 });
+export 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,
+	},
+});
+export const OrderParties = new MoveStruct({
+	name: `${$moduleName}::OrderParties`,
+	fields: {
+		account_id: bcs.Address,
+		owner: bcs.Address,
+		/** Sell proceeds and the settled payout go only here. */
+		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),
+	},
+});
+export const OrderReceipt = new MoveStruct({
+	name: `${$moduleName}::OrderReceipt`,
+	fields: {
+		expiry_market_id: bcs.Address,
+		stage: bcs.u8(),
+		/** A `constants` mint kind, or `order_kind_sell` once a sell is admitted. */
+		kind: bcs.u8(),
+		/** The account's snapshot at the last admission. */
+		parties: OrderParties,
+		lower_tick: U64,
+		higher_tick: U64,
+		/** The exact mint quantity, or the sell's close quantity. */
+		quantity: U64,
+		max_premium: U64,
+		min_quantity: U64,
+		max_probability: U64,
+		min_probability: U64,
+		min_proceeds: U64,
+		/** Earliest Pyth generation time the order may price at. */
+		tau_ms: U64,
+		/** At or past it the order is refunded, never filled. */
+		deadline_ms: U64,
+		/** The Lazer channel τ was planned on; the committed price must come from it. */
+		channel: bcs.u8(),
+		vol: pricing.VolSnapshot,
+		budget: U64,
+		order_fee: U64,
+		/**
+		 * Worst-case market cash the fill can consume. Counted in the ledger's
+		 * `waiting_cash_need` while the order is admitted.
+		 */
+		cash_need: U64,
+		/**
+		 * The t₀ quote's pre-subsidy trading fee, capped at `budget`. Bounds the subsidy
+		 * `commit` reserves.
+		 */
+		subsidy_bound: U64,
+		subsidy_rate: U64,
+		subsidy_reserved: U64,
+		/** The committed Pyth price, 1e9-normalized; `0` until `commit`. */
+		spot: U64,
+		/** The committed update's envelope, in ms. The fill prices at it. */
+		tick_ms: U64,
+		/** The committed feed's own update time, in µs. */
+		generation_us: U64,
+		/** The open position's order ID; `0` until the mint fills. */
+		order_id: U256,
+		/** Stable economic-position handle, constant across partial closes. */
+		root_id: U256,
+		opened_at_ms: U64,
+		/**
+		 * The open position's size, the quantity `order_id` names. The request's
+		 * `quantity` is the mint or close quantity, so a sell admission never overwrites
+		 * the size it closes.
+		 */
+		held_quantity: U64,
+	},
+});
+export const OrderFlowLedgerKey = new MoveTuple({
+	name: `${$moduleName}::OrderFlowLedgerKey`,
+	fields: [bcs.bool()],
+});
+export const OrderFlowLedger = new MoveStruct({
+	name: `${$moduleName}::OrderFlowLedger`,
+	fields: {
+		/**
+		 * Admitted mints per payout-tree tick (tick -> count). A pinned node is never
+		 * pruned, so a fill never creates one.
+		 */
+		pins: vec_map.VecMap(U64, U64),
+		/**
+		 * Sum of the admitted orders' cash needs. `rebalance_expiry_cash` funds a live
+		 * market to at least required cash plus this.
+		 */
+		waiting_cash_need: U64,
+	},
+});
 export interface IdArguments {
 	market: RawTransactionArgument<string>;
 }
@@ -811,12 +932,14 @@ export interface QuoteMintOptions {
 	};
 }
 /**
- * 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.
  */
 export function quoteMint(options: QuoteMintOptions) {
 	const packageAddress =
@@ -877,9 +1000,8 @@ export interface QuoteMintForAccountOptions {
 	};
 }
 /**
- * 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.
  */
 export function quoteMintForAccount(options: QuoteMintForAccountOptions) {
 	const packageAddress =
@@ -942,13 +1064,10 @@ export interface QuoteMintExactCostForAccountOptions {
 	};
 }
 /**
- * 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`.
  */
 export function quoteMintExactCostForAccount(options: QuoteMintExactCostForAccountOptions) {
 	const packageAddress =
@@ -990,6 +1109,66 @@ export function quoteMintExactCostForAccount(options: QuoteMintExactCostForAccou
 			),
 		});
 }
+export interface OrderFlowStateArguments {
+	market: RawTransactionArgument<string>;
+}
+export interface OrderFlowStateOptions {
+	package?: string;
+	arguments: OrderFlowStateArguments | [market: RawTransactionArgument<string>];
+	config?: {
+		predictPackageId?: string;
+	};
+}
+/**
+ * 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.
+ */
+export function orderFlowState(options: OrderFlowStateOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['market'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'expiry_market',
+			function: 'order_flow_state',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface ReceiptInfoArguments {
+	receipt: TransactionArgument;
+}
+export interface ReceiptInfoOptions {
+	package?: string;
+	arguments: ReceiptInfoArguments | [receipt: TransactionArgument];
+	config?: {
+		predictPackageId?: string;
+	};
+}
+/**
+ * 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.
+ */
+export function receiptInfo(options: ReceiptInfoOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['receipt'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'expiry_market',
+			function: 'receipt_info',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
 export interface QuantityArguments {
 	quote: TransactionArgument;
 }
@@ -1212,17 +1391,207 @@ export function allInCost(options: AllInCostOptions) {
 			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
 		});
 }
-export interface MintExactQuantityArguments {
+export interface RedeemCloseQuantityArguments {
+	quote: TransactionArgument;
+}
+export interface RedeemCloseQuantityOptions {
+	package?: string;
+	arguments: RedeemCloseQuantityArguments | [quote: TransactionArgument];
+	config?: {
+		predictPackageId?: string;
+	};
+}
+export function redeemCloseQuantity(options: RedeemCloseQuantityOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['quote'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'expiry_market',
+			function: 'redeem_close_quantity',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface RedeemProbabilityArguments {
+	quote: TransactionArgument;
+}
+export interface RedeemProbabilityOptions {
+	package?: string;
+	arguments: RedeemProbabilityArguments | [quote: TransactionArgument];
+	config?: {
+		predictPackageId?: string;
+	};
+}
+export function redeemProbability(options: RedeemProbabilityOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['quote'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'expiry_market',
+			function: 'redeem_probability',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface RedeemProceedsArguments {
+	quote: TransactionArgument;
+}
+export interface RedeemProceedsOptions {
+	package?: string;
+	arguments: RedeemProceedsArguments | [quote: TransactionArgument];
+	config?: {
+		predictPackageId?: string;
+	};
+}
+export function redeemProceeds(options: RedeemProceedsOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['quote'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'expiry_market',
+			function: 'redeem_proceeds',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface RedeemTradingFeeArguments {
+	quote: TransactionArgument;
+}
+export interface RedeemTradingFeeOptions {
+	package?: string;
+	arguments: RedeemTradingFeeArguments | [quote: TransactionArgument];
+	config?: {
+		predictPackageId?: string;
+	};
+}
+export function redeemTradingFee(options: RedeemTradingFeeOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['quote'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'expiry_market',
+			function: 'redeem_trading_fee',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface RedeemBuilderFeeArguments {
+	quote: TransactionArgument;
+}
+export interface RedeemBuilderFeeOptions {
+	package?: string;
+	arguments: RedeemBuilderFeeArguments | [quote: TransactionArgument];
+	config?: {
+		predictPackageId?: string;
+	};
+}
+export function redeemBuilderFee(options: RedeemBuilderFeeOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['quote'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'expiry_market',
+			function: 'redeem_builder_fee',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface RedeemInventoryImpactRebateArguments {
+	quote: TransactionArgument;
+}
+export interface RedeemInventoryImpactRebateOptions {
+	package?: string;
+	arguments: RedeemInventoryImpactRebateArguments | [quote: TransactionArgument];
+	config?: {
+		predictPackageId?: string;
+	};
+}
+export function redeemInventoryImpactRebate(options: RedeemInventoryImpactRebateOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['quote'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'expiry_market',
+			function: 'redeem_inventory_impact_rebate',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface QuoteCloseArguments {
 	market: RawTransactionArgument<string>;
-	wrapper: RawTransactionArgument<string>;
-	auth: TransactionArgument;
-	config?: RawTransactionArgument<string>;
 	pricer: TransactionArgument;
-	lowerTick: RawTransactionArgument<number | bigint>;
-	higherTick: RawTransactionArgument<number | bigint>;
-	quantity: RawTransactionArgument<number | bigint>;
-	maxCost: RawTransactionArgument<number | bigint>;
-	maxProbability: RawTransactionArgument<number | bigint>;
+	receipt: TransactionArgument;
+	closeQuantity: RawTransactionArgument<number | bigint>;
+	builderCodeId: RawTransactionArgument<string | null>;
+}
+export interface QuoteCloseOptions {
+	package?: string;
+	arguments:
+		| QuoteCloseArguments
+		| [
+				market: RawTransactionArgument<string>,
+				pricer: TransactionArgument,
+				receipt: TransactionArgument,
+				closeQuantity: RawTransactionArgument<number | bigint>,
+				builderCodeId: RawTransactionArgument<string | null>,
+		  ];
+	config?: {
+		predictPackageId?: string;
+	};
+}
+/**
+ * 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.
+ */
+export function quoteClose(options: QuoteCloseOptions) {
+	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',
+	] satisfies (string | null)[];
+	const parameterNames = ['market', 'pricer', 'receipt', 'closeQuantity', 'builderCodeId'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'expiry_market',
+			function: 'quote_close',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface MintExactQuantityArguments {
+	Market: RawTransactionArgument<string>;
+	Wrapper: RawTransactionArgument<string>;
+	Auth: TransactionArgument;
+	Config?: RawTransactionArgument<string>;
+	Pricer: TransactionArgument;
+	LowerTick: RawTransactionArgument<number | bigint>;
+	HigherTick: RawTransactionArgument<number | bigint>;
+	Quantity: RawTransactionArgument<number | bigint>;
+	MaxCost: RawTransactionArgument<number | bigint>;
+	MaxProbability: RawTransactionArgument<number | bigint>;
 }
 export interface MintExactQuantityOptions {
 	package?: string;
@@ -1233,19 +1602,8 @@ export interface MintExactQuantityOptions {
 	};
 }
 /**
- * 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.
+ * Retired by delayed execution: always aborts `EDelayedExecutionRequired`. Mints
+ * are queued through the order-flow companion.
  */
 export function mintExactQuantity(options: MintExactQuantityOptions) {
 	const packageAddress =
@@ -1265,16 +1623,16 @@ export function mintExactQuantity(options: MintExactQuantityOptions) {
 		'0x2::clock::Clock',
 	] satisfies (string | null)[];
 	const parameterNames = [
-		'market',
-		'wrapper',
-		'auth',
-		'config',
-		'pricer',
-		'lowerTick',
-		'higherTick',
-		'quantity',
-		'maxCost',
-		'maxProbability',
+		'Market',
+		'Wrapper',
+		'Auth',
+		'Config',
+		'Pricer',
+		'LowerTick',
+		'HigherTick',
+		'Quantity',
+		'MaxCost',
+		'MaxProbability',
 	];
 	return (tx: Transaction) =>
 		tx.moveCall({
@@ -1284,7 +1642,7 @@ export function mintExactQuantity(options: MintExactQuantityOptions) {
 			arguments: normalizeMoveArguments(
 				{
 					...options.arguments,
-					config: options.arguments?.config ?? options.config?.protocolConfig,
+					Config: options.arguments?.Config ?? options.config?.protocolConfig,
 				},
 				argumentsTypes,
 				parameterNames,
@@ -1292,16 +1650,16 @@ export function mintExactQuantity(options: MintExactQuantityOptions) {
 		});
 }
 export interface MintExactAmountArguments {
-	market: RawTransactionArgument<string>;
-	wrapper: RawTransactionArgument<string>;
-	auth: TransactionArgument;
-	config?: RawTransactionArgument<string>;
-	pricer: TransactionArgument;
-	lowerTick: RawTransactionArgument<number | bigint>;
-	higherTick: RawTransactionArgument<number | bigint>;
-	maxPremium: RawTransactionArgument<number | bigint>;
-	minQuantity: RawTransactionArgument<number | bigint>;
-	maxCost: RawTransactionArgument<number | bigint>;
+	Market: RawTransactionArgument<string>;
+	Wrapper: RawTransactionArgument<string>;
+	Auth: TransactionArgument;
+	Config?: RawTransactionArgument<string>;
+	Pricer: TransactionArgument;
+	LowerTick: RawTransactionArgument<number | bigint>;
+	HigherTick: RawTransactionArgument<number | bigint>;
+	MaxPremium: RawTransactionArgument<number | bigint>;
+	MinQuantity: RawTransactionArgument<number | bigint>;
+	MaxCost: RawTransactionArgument<number | bigint>;
 }
 export interface MintExactAmountOptions {
 	package?: string;
@@ -1312,19 +1670,8 @@ export interface MintExactAmountOptions {
 	};
 }
 /**
- * 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.
  */
 export function mintExactAmount(options: MintExactAmountOptions) {
 	const packageAddress =
@@ -1344,16 +1691,16 @@ export function mintExactAmount(options: MintExactAmountOptions) {
 		'0x2::clock::Clock',
 	] satisfies (string | null)[];
 	const parameterNames = [
-		'market',
-		'wrapper',
-		'auth',
-		'config',
-		'pricer',
-		'lowerTick',
-		'higherTick',
-		'maxPremium',
-		'minQuantity',
-		'maxCost',
+		'Market',
+		'Wrapper',
+		'Auth',
+		'Config',
+		'Pricer',
+		'LowerTick',
+		'HigherTick',
+		'MaxPremium',
+		'MinQuantity',
+		'MaxCost',
 	];
 	return (tx: Transaction) =>
 		tx.moveCall({
@@ -1363,7 +1710,7 @@ export function mintExactAmount(options: MintExactAmountOptions) {
 			arguments: normalizeMoveArguments(
 				{
 					...options.arguments,
-					config: options.arguments?.config ?? options.config?.protocolConfig,
+					Config: options.arguments?.Config ?? options.config?.protocolConfig,
 				},
 				argumentsTypes,
 				parameterNames,
@@ -1371,15 +1718,15 @@ export function mintExactAmount(options: MintExactAmountOptions) {
 		});
 }
 export interface MintExactCostArguments {
-	market: RawTransactionArgument<string>;
-	wrapper: RawTransactionArgument<string>;
-	auth: TransactionArgument;
-	config?: RawTransactionArgument<string>;
-	pricer: TransactionArgument;
-	lowerTick: RawTransactionArgument<number | bigint>;
-	higherTick: RawTransactionArgument<number | bigint>;
-	maxCost: RawTransactionArgument<number | bigint>;
-	minQuantity: RawTransactionArgument<number | bigint>;
+	Market: RawTransactionArgument<string>;
+	Wrapper: RawTransactionArgument<string>;
+	Auth: TransactionArgument;
+	Config?: RawTransactionArgument<string>;
+	Pricer: TransactionArgument;
+	LowerTick: RawTransactionArgument<number | bigint>;
+	HigherTick: RawTransactionArgument<number | bigint>;
+	MaxCost: RawTransactionArgument<number | bigint>;
+	MinQuantity: RawTransactionArgument<number | bigint>;
 }
 export interface MintExactCostOptions {
 	package?: string;
@@ -1390,36 +1737,8 @@ export interface MintExactCostOptions {
 	};
 }
 /**
- * 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.
  */
 export function mintExactCost(options: MintExactCostOptions) {
 	const packageAddress =
@@ -1438,15 +1757,15 @@ export function mintExactCost(options: MintExactCostOptions) {
 		'0x2::clock::Clock',
 	] satisfies (string | null)[];
 	const parameterNames = [
-		'market',
-		'wrapper',
-		'auth',
-		'config',
-		'pricer',
-		'lowerTick',
-		'higherTick',
-		'maxCost',
-		'minQuantity',
+		'Market',
+		'Wrapper',
+		'Auth',
+		'Config',
+		'Pricer',
+		'LowerTick',
+		'HigherTick',
+		'MaxCost',
+		'MinQuantity',
 	];
 	return (tx: Transaction) =>
 		tx.moveCall({
@@ -1456,7 +1775,7 @@ export function mintExactCost(options: MintExactCostOptions) {
 			arguments: normalizeMoveArguments(
 				{
 					...options.arguments,
-					config: options.arguments?.config ?? options.config?.protocolConfig,
+					Config: options.arguments?.Config ?? options.config?.protocolConfig,
 				},
 				argumentsTypes,
 				parameterNames,
@@ -1464,15 +1783,15 @@ export function mintExactCost(options: MintExactCostOptions) {
 		});
 }
 export interface RedeemLiveArguments {
-	market: RawTransactionArgument<string>;
-	wrapper: RawTransactionArgument<string>;
-	auth: TransactionArgument;
-	config?: RawTransactionArgument<string>;
-	pricer: TransactionArgument;
-	orderId: RawTransactionArgument<number | bigint>;
-	closeQuantity: RawTransactionArgument<number | bigint>;
-	minProbability: RawTransactionArgument<number | bigint>;
-	minProceeds: RawTransactionArgument<number | bigint>;
+	Market: RawTransactionArgument<string>;
+	Wrapper: RawTransactionArgument<string>;
+	Auth: TransactionArgument;
+	Config?: RawTransactionArgument<string>;
+	Pricer: TransactionArgument;
+	OrderId: RawTransactionArgument<number | bigint>;
+	CloseQuantity: RawTransactionArgument<number | bigint>;
+	MinProbability: RawTransactionArgument<number | bigint>;
+	MinProceeds: RawTransactionArgument<number | bigint>;
 }
 export interface RedeemLiveOptions {
 	package?: string;
@@ -1483,18 +1802,9 @@ export interface RedeemLiveOptions {
 	};
 }
 /**
- * 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.
  */
 export function redeemLive(options: RedeemLiveOptions) {
 	const packageAddress =
@@ -1513,15 +1823,15 @@ export function redeemLive(options: RedeemLiveOptions) {
 		'0x2::clock::Clock',
 	] satisfies (string | null)[];
 	const parameterNames = [
-		'market',
-		'wrapper',
-		'auth',
-		'config',
-		'pricer',
-		'orderId',
-		'closeQuantity',
-		'minProbability',
-		'minProceeds',
+		'Market',
+		'Wrapper',
+		'Auth',
+		'Config',
+		'Pricer',
+		'OrderId',
+		'CloseQuantity',
+		'MinProbability',
+		'MinProceeds',
 	];
 	return (tx: Transaction) =>
 		tx.moveCall({
@@ -1531,7 +1841,7 @@ export function redeemLive(options: RedeemLiveOptions) {
 			arguments: normalizeMoveArguments(
 				{
 					...options.arguments,
-					config: options.arguments?.config ?? options.config?.protocolConfig,
+					Config: options.arguments?.Config ?? options.config?.protocolConfig,
 				},
 				argumentsTypes,
 				parameterNames,
@@ -1604,11 +1914,15 @@ export interface RedeemSettledPermissionlessOptions {
 	};
 }
 /**
- * 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.
  */
 export function redeemSettledPermissionless(options: RedeemSettledPermissionlessOptions) {
 	const packageAddress =
@@ -1742,6 +2056,12 @@ export interface TrySettleOptions {
  * 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.
  */
 export function trySettle(options: TrySettleOptions) {
 	const packageAddress =
@@ -1766,3 +2086,474 @@ export function trySettle(options: TrySettleOptions) {
 			),
 		});
 }
+export interface AdmitMintArguments<W extends BcsType<any>> {
+	W: RawTransactionArgument<W>;
+	market: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+	account: TransactionArgument;
+	propbookRegistry?: RawTransactionArgument<string>;
+	pyth: RawTransactionArgument<string>;
+	bsValues: RawTransactionArgument<string>;
+	bsSvi: RawTransactionArgument<string>;
+	kind: RawTransactionArgument<number>;
+	lowerTick: RawTransactionArgument<number | bigint>;
+	higherTick: RawTransactionArgument<number | bigint>;
+	quantity: RawTransactionArgument<number | bigint>;
+	maxPremium: RawTransactionArgument<number | bigint>;
+	minQuantity: RawTransactionArgument<number | bigint>;
+	maxProbability: RawTransactionArgument<number | bigint>;
+	budget: RawTransactionArgument<number | bigint>;
+	orderFee: RawTransactionArgument<number | bigint>;
+	sviMaxAgeMs: RawTransactionArgument<number | bigint>;
+	channel: RawTransactionArgument<number>;
+	tauMs: RawTransactionArgument<number | bigint>;
+	deadlineMs: RawTransactionArgument<number | bigint>;
+}
+export interface AdmitMintOptions<W extends BcsType<any>> {
+	package?: string;
+	arguments: AdmitMintArguments<W>;
+	config?: {
+		protocolConfig: ConfigValue;
+		oracleRegistry: ConfigValue;
+		predictPackageId?: string;
+	};
+	typeArguments: [string];
+}
+/**
+ * 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.
+ */
+export function admitMint<W extends BcsType<any>>(options: AdmitMintOptions<W>) {
+	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',
+	] satisfies (string | null)[];
+	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: Transaction) =>
+		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,
+		});
+}
+export interface AdmitSellArguments<W extends BcsType<any>> {
+	W: RawTransactionArgument<W>;
+	market: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+	account: TransactionArgument;
+	receipt: TransactionArgument;
+	propbookRegistry?: RawTransactionArgument<string>;
+	pyth: RawTransactionArgument<string>;
+	bsValues: RawTransactionArgument<string>;
+	bsSvi: RawTransactionArgument<string>;
+	closeQuantity: RawTransactionArgument<number | bigint>;
+	minProbability: RawTransactionArgument<number | bigint>;
+	minProceeds: RawTransactionArgument<number | bigint>;
+	orderFee: RawTransactionArgument<number | bigint>;
+	sviMaxAgeMs: RawTransactionArgument<number | bigint>;
+	channel: RawTransactionArgument<number>;
+	tauMs: RawTransactionArgument<number | bigint>;
+	deadlineMs: RawTransactionArgument<number | bigint>;
+}
+export interface AdmitSellOptions<W extends BcsType<any>> {
+	package?: string;
+	arguments: AdmitSellArguments<W>;
+	config?: {
+		protocolConfig: ConfigValue;
+		oracleRegistry: ConfigValue;
+		predictPackageId?: string;
+	};
+	typeArguments: [string];
+}
+/**
+ * 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.
+ */
+export function admitSell<W extends BcsType<any>>(options: AdmitSellOptions<W>) {
+	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',
+	] satisfies (string | null)[];
+	const parameterNames = [
+		'W',
+		'market',
+		'config',
+		'account',
+		'receipt',
+		'propbookRegistry',
+		'pyth',
+		'bsValues',
+		'bsSvi',
+		'closeQuantity',
+		'minProbability',
+		'minProceeds',
+		'orderFee',
+		'sviMaxAgeMs',
+		'channel',
+		'tauMs',
+		'deadlineMs',
+	];
+	return (tx: Transaction) =>
+		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,
+		});
+}
+export interface CommitArguments<W extends BcsType<any>> {
+	W: RawTransactionArgument<W>;
+	market: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+	receipt: TransactionArgument;
+	price: TransactionArgument;
+}
+export interface CommitOptions<W extends BcsType<any>> {
+	package?: string;
+	arguments: CommitArguments<W>;
+	config?: {
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+	typeArguments: [string];
+}
+/**
+ * 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`).
+ */
+export function commit<W extends BcsType<any>>(options: CommitOptions<W>) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [
+		`${options.typeArguments[0]}`,
+		null,
+		null,
+		null,
+		null,
+		'0x2::clock::Clock',
+	] satisfies (string | null)[];
+	const parameterNames = ['W', 'market', 'config', 'receipt', 'price'];
+	return (tx: Transaction) =>
+		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,
+		});
+}
+export interface TryFillArguments<W extends BcsType<any>> {
+	W: RawTransactionArgument<W>;
+	market: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+	receipt: TransactionArgument;
+	escrow: TransactionArgument;
+}
+export interface TryFillOptions<W extends BcsType<any>> {
+	package?: string;
+	arguments: TryFillArguments<W>;
+	config?: {
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+	typeArguments: [string];
+}
+/**
+ * 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.
+ */
+export function tryFill<W extends BcsType<any>>(options: TryFillOptions<W>) {
+	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',
+	] satisfies (string | null)[];
+	const parameterNames = ['W', 'market', 'config', 'receipt', 'escrow'];
+	return (tx: Transaction) =>
+		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,
+		});
+}
+export interface ReleaseArguments {
+	market: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+	receipt: TransactionArgument;
+	escrow: TransactionArgument;
+	reason: RawTransactionArgument<number>;
+	prune: RawTransactionArgument<boolean>;
+}
+export interface ReleaseOptions {
+	package?: string;
+	arguments: ReleaseArguments;
+	config?: {
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * 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`).
+ */
+export function release(options: ReleaseOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null, null, null, null, 'u8', 'bool'] satisfies (string | null)[];
+	const parameterNames = ['market', 'config', 'receipt', 'escrow', 'reason', 'prune'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'expiry_market',
+			function: 'release',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface TryPaySettledArguments {
+	market: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+	receipt: TransactionArgument;
+}
+export interface TryPaySettledOptions {
+	package?: string;
+	arguments: TryPaySettledArguments;
+	config?: {
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * 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`).
+ */
+export function tryPaySettled(options: TryPaySettledOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null, null, null, '0x2::deny_list::DenyList'] satisfies (string | null)[];
+	const parameterNames = ['market', 'config', 'receipt'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'expiry_market',
+			function: 'try_pay_settled',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}