@mysten/deepbook-v3 2.6.4 → 2.8.0

package/src/predict/tx/trade.ts

@@ -3,16 +3,13 @@
 import type { Transaction, TransactionResult } from '@mysten/sui/transactions';
 import type { GeneratedConfig } from '../config/generated.js';
 import { U64_MAX } from '../units.js';
+import { accountMoveCalls as account } from '../../account.js';
 import * as expiryMarket from '../../contracts/deepbook_predict/expiry_market.js';
 import { withAuth } from './common.js';
 
 // The trade calls with their `auth` argument already supplied (see `withAuth`): each
 // takes its generated options minus that slot and expands to auth → call.
 const authed = {
-	mintExactQuantity: withAuth(expiryMarket.mintExactQuantity),
-	mintExactAmount: withAuth(expiryMarket.mintExactAmount),
-	mintExactCost: withAuth(expiryMarket.mintExactCost),
-	redeemLive: withAuth(expiryMarket.redeemLive),
 	redeemSettled: withAuth(expiryMarket.redeemSettled),
 };
 
@@ -26,8 +23,9 @@ export interface MarketFeeds {
 }
 
 // Load a fresh `Pricer` from the live oracle feeds. Every live-flow trade call
-// (`mint_*`, `redeem_live`) borrows this `&Pricer` and it must be loaded first in the
-// PTB. Deployed sig `load_live_pricer` (expiry_market.move): market, config,
+// (`mint_*`, `redeem_live`) and every live quote (`quote_mint*`, the queue's `quote_redeem_open`) borrows
+// this `&Pricer` and it must be loaded first in the PTB. Queued orders (`enqueue_*`) don't take
+// one: they read the oracle objects directly. Deployed sig `load_live_pricer` (expiry_market.move): market, config,
 // propbook_registry (&OracleRegistry), pyth, bs_values, bs_svi, clock (auto-injected).
 // `config` and `propbook_registry` are supplied by the config slice, not named here.
 export function loadLivePricer(
@@ -49,16 +47,24 @@ export function loadLivePricer(
 }
 
 // The three commands every live-flow trade is: load a fresh market-bound `Pricer`, mint
-// owner auth, then the one `expiry_market::*` call that consumes both. Only the pricer is
-// composed here — `build` returns an `authed.*` call, which is the other two commands.
+// owner auth, then the one `expiry_market::*` call that consumes both.
+//
+// The live trades are retired: Predict v4 keeps their published signatures but names every
+// parameter with a leading underscore, which codegen renders as a capitalized key (`_market` →
+// `Market`). So the auth is minted here and passed as `Auth`, rather than through `withAuth`.
+// The emitted commands are unchanged, and still reach a pre-v4 package.
 function liveTrade(
 	config: GeneratedConfig,
 	args: { expiryMarketId: string } & MarketFeeds,
-	build: (pricer: TransactionResult) => (tx: Transaction) => TransactionResult,
+	build: (
+		pricer: TransactionResult,
+		auth: TransactionResult,
+	) => (tx: Transaction) => TransactionResult,
 ): (tx: Transaction) => TransactionResult {
 	return (tx) => {
 		const pricer = tx.add(loadLivePricer(config, args));
-		return tx.add(build(pricer));
+		const auth = tx.add(account.generateAuth({ config }));
+		return tx.add(build(pricer, auth));
 	};
 }
 
@@ -66,6 +72,11 @@ function liveTrade(
 // returning the new order id (u256). Command order is pricer → auth → mint (auth is a
 // hot potato consumed by this call). `maxCostRaw`/`maxProbabilityRaw` default to
 // `U64_MAX` (no slippage cap). Deployed sig `mint_exact_quantity`.
+/**
+ * @deprecated Retired by delayed execution (DBU-885): Predict v4's `mint_exact_quantity` always
+ * aborts `EDelayedExecutionRequired`, so this works only while the config's call target is a
+ * pre-v4 package. Use `enqueueExactQuantity` from `tx/queue.ts`.
+ */
 export function mintExactQuantity(
 	config: GeneratedConfig,
 	args: {
@@ -78,18 +89,19 @@ export function mintExactQuantity(
 		maxProbabilityRaw?: bigint;
 	} & MarketFeeds,
 ): (tx: Transaction) => TransactionResult {
-	return liveTrade(config, args, (pricer) =>
-		authed.mintExactQuantity({
+	return liveTrade(config, args, (pricer, auth) =>
+		expiryMarket.mintExactQuantity({
 			config,
 			arguments: {
-				market: args.expiryMarketId,
-				wrapper: args.wrapperId,
-				pricer,
-				lowerTick: args.lowerTick,
-				higherTick: args.higherTick,
-				quantity: args.quantityRaw,
-				maxCost: args.maxCostRaw ?? U64_MAX,
-				maxProbability: args.maxProbabilityRaw ?? U64_MAX,
+				Market: args.expiryMarketId,
+				Wrapper: args.wrapperId,
+				Auth: auth,
+				Pricer: pricer,
+				LowerTick: args.lowerTick,
+				HigherTick: args.higherTick,
+				Quantity: args.quantityRaw,
+				MaxCost: args.maxCostRaw ?? U64_MAX,
+				MaxProbability: args.maxProbabilityRaw ?? U64_MAX,
 			},
 		}),
 	);
@@ -99,6 +111,10 @@ export function mintExactQuantity(
 // floor on the position received and a `maxCostRaw` all-in ceiling, returning the new
 // order id (u256). Command order is pricer → auth → mint. Deployed sig
 // `mint_exact_amount`: …, max_premium, min_quantity, max_cost, root.
+/**
+ * @deprecated Retired by delayed execution (DBU-885): Predict v4 always aborts it
+ * (`EDelayedExecutionRequired`). Use `enqueueExactAmount`.
+ */
 export function mintExactAmount(
 	config: GeneratedConfig,
 	args: {
@@ -111,24 +127,29 @@ export function mintExactAmount(
 		maxCostRaw?: bigint;
 	} & MarketFeeds,
 ): (tx: Transaction) => TransactionResult {
-	return liveTrade(config, args, (pricer) =>
-		authed.mintExactAmount({
+	return liveTrade(config, args, (pricer, auth) =>
+		expiryMarket.mintExactAmount({
 			config,
 			arguments: {
-				market: args.expiryMarketId,
-				wrapper: args.wrapperId,
-				pricer,
-				lowerTick: args.lowerTick,
-				higherTick: args.higherTick,
-				maxPremium: args.maxPremiumRaw,
-				minQuantity: args.minQuantityRaw,
-				maxCost: args.maxCostRaw ?? U64_MAX,
+				Market: args.expiryMarketId,
+				Wrapper: args.wrapperId,
+				Auth: auth,
+				Pricer: pricer,
+				LowerTick: args.lowerTick,
+				HigherTick: args.higherTick,
+				MaxPremium: args.maxPremiumRaw,
+				MinQuantity: args.minQuantityRaw,
+				MaxCost: args.maxCostRaw ?? U64_MAX,
 			},
 		}),
 	);
 }
 
-/** Mint within an all-in budget, including fees, using the v2 entrypoint. */
+/**
+ * Mint within an all-in budget, including fees, using the v2 entrypoint.
+ * @deprecated Retired by delayed execution (DBU-885): Predict v4 always aborts it
+ * (`EDelayedExecutionRequired`). Use `enqueueExactCost`.
+ */
 export function mintExactCost(
 	config: GeneratedConfig,
 	args: {
@@ -140,17 +161,18 @@ export function mintExactCost(
 		minQuantityRaw: bigint;
 	} & MarketFeeds,
 ): (tx: Transaction) => TransactionResult {
-	return liveTrade(config, args, (pricer) =>
-		authed.mintExactCost({
+	return liveTrade(config, args, (pricer, auth) =>
+		expiryMarket.mintExactCost({
 			config,
 			arguments: {
-				market: args.expiryMarketId,
-				wrapper: args.wrapperId,
-				pricer,
-				lowerTick: args.lowerTick,
-				higherTick: args.higherTick,
-				maxCost: args.maxCostRaw,
-				minQuantity: args.minQuantityRaw,
+				Market: args.expiryMarketId,
+				Wrapper: args.wrapperId,
+				Auth: auth,
+				Pricer: pricer,
+				LowerTick: args.lowerTick,
+				HigherTick: args.higherTick,
+				MaxCost: args.maxCostRaw,
+				MinQuantity: args.minQuantityRaw,
 			},
 		}),
 	);
@@ -161,6 +183,11 @@ export function mintExactCost(
 // (`minProbabilityRaw`/`minProceedsRaw`, default 0 = uncapped). Returns `Option<u256>`:
 // the replacement order id when a partial close leaves quantity open, else none. Command
 // order is pricer → auth → redeem. Deployed sig `redeem_live`.
+/**
+ * @deprecated Retired by delayed execution (DBU-885): Predict v4 always aborts it
+ * (`EDelayedExecutionRequired`). Account positions then have no early exit; queued fills are Open
+ * records sold with `enqueueRedeemOpen`.
+ */
 export function redeemLive(
 	config: GeneratedConfig,
 	args: {
@@ -172,22 +199,26 @@ export function redeemLive(
 		minProceedsRaw?: bigint;
 	} & MarketFeeds,
 ): (tx: Transaction) => TransactionResult {
-	return liveTrade(config, args, (pricer) =>
-		authed.redeemLive({
+	return liveTrade(config, args, (pricer, auth) =>
+		expiryMarket.redeemLive({
 			config,
 			arguments: {
-				market: args.expiryMarketId,
-				wrapper: args.wrapperId,
-				pricer,
-				orderId: args.orderId,
-				closeQuantity: args.closeQuantityRaw,
-				minProbability: args.minProbabilityRaw ?? 0n,
-				minProceeds: args.minProceedsRaw ?? 0n,
+				Market: args.expiryMarketId,
+				Wrapper: args.wrapperId,
+				Auth: auth,
+				Pricer: pricer,
+				OrderId: args.orderId,
+				CloseQuantity: args.closeQuantityRaw,
+				MinProbability: args.minProbabilityRaw ?? 0n,
+				MinProceeds: args.minProceedsRaw ?? 0n,
 			},
 		}),
 	);
 }
 
+// Unchanged by delayed execution: still pays settled positions held in the account. It doesn't
+// pay Open queue records, which the queue's `settle_step` pays at settlement.
+//
 // Owner-authorized redeem of a settled position: closes `orderId` IN FULL against the
 // recorded settlement price (the deployed entrypoint takes no quantity — a settled claim
 // is all-or-nothing). No live pricer (settlement price is fixed); auth is consumed by the

package/src/sessions.ts

@@ -14,6 +14,7 @@ export { getDeployment, getUnits, TESTNET_DEPLOYMENT, TESTNET_UNITS } from './de
 export type { DeployedNetwork, NetworkArg } from './deployments/index.js';
 
 import { AccountContract } from './account.js';
+import { deriveQueueId } from './predict/queue-id.js';
 import type { DeepbookSessionsConfig } from './contracts/deepbook_sessions/config-arguments.js';
 import * as sessions from './contracts/deepbook_sessions/sessions.js';
 import { SessionsData } from './contracts/deepbook_sessions/sessions.js';
@@ -81,6 +82,49 @@ export function getSessionsConfig(
 	);
 }
 
+/** The market, queue, account and oracle objects every queued Predict session wrapper names. */
+export interface SessionsQueuedOrderTarget {
+	expiryMarketId: string;
+	wrapperId: string;
+	/**
+	 * The order-flow companion's shared `OrderDesk` (`deepbook_predict_orders`). Predict's
+	 * `PredictConfig.objects.orderDesk`.
+	 */
+	orderDesk: string;
+	/**
+	 * The order-flow companion's shared `QueueRegistry`, which every market's queue ID derives
+	 * from. Predict's `PredictConfig.objects.queueRegistry`.
+	 */
+	queueRegistry: string;
+	/**
+	 * The market's `MarketQueue`. Defaults to the ID derived from `queueRegistry` and the market
+	 * (`deriveQueueId`), which is where `queue::create_and_share` puts it.
+	 */
+	queueId?: string;
+	/** Predict's `ProtocolConfig`. */
+	protocolConfig: string;
+	/** Predict's `OracleRegistry` (the propbook registry). */
+	oracleRegistry: string;
+	/** The market's `PythFeed`. */
+	pythFeed: string;
+	/** The market's `BlockScholesValueStore`. */
+	blockScholesValueStore: string;
+	/** The market's `BlockScholesSVIStore`. */
+	blockScholesSviStore: string;
+}
+
+const U64_MAX = (1n << 64n) - 1n;
+
+// The chain refuses a zero or "unlimited" cap on every queued mint (`EMintCostCapRequired`).
+function assertQueuedMaxCost(maxCost: number | bigint): void {
+	const value = BigInt(maxCost);
+	if (value <= 0n || value >= U64_MAX) {
+		throw new Error(
+			`maxCost must be above 0 and below u64::MAX on a queued mint (EMintCostCapRequired), got ${value}`,
+		);
+	}
+}
+
 /** The maximum session duration the contract accepts: 30 days, in milliseconds. */
 export const MAX_SESSION_DURATION_MS = 30 * 24 * 60 * 60 * 1000;
 
@@ -276,6 +320,8 @@ export class SessionsContract {
 	 * effectively unbounded — the chain asserts `value <= cap`, so the max value can never
 	 * trip. Both are required; there is no default.
 	 * @returns A function that takes a Transaction object and returns the new order id (u256)
+	 * @deprecated Retired by delayed execution (DBU-885): always aborts through Predict v4
+	 * (`EDelayedExecutionRequired`). Use {@link SessionsContract.enqueueExactQuantity}.
 	 */
 	mintExactQuantity(params: {
 		expiryMarketId: string;
@@ -312,6 +358,8 @@ export class SessionsContract {
 	 * @description Mint by spending up to a premium budget, flooring the quantity received.
 	 * The chain requires `maxCost > 0`.
 	 * @returns A function that takes a Transaction object and returns the new order id (u256)
+	 * @deprecated Retired by delayed execution (DBU-885): always aborts through Predict v4.
+	 * Use {@link SessionsContract.enqueueExactAmount}.
 	 */
 	mintExactAmount(params: {
 		expiryMarketId: string;
@@ -346,7 +394,9 @@ export class SessionsContract {
 
 	/**
 	 * Mint within an all-in budget as a session. Amounts are raw Move units.
-	 * Requires Sessions/Predict v2 (currently Testnet; Mainnet is still v1).
+	 * Requires Sessions/Predict v2 or later.
+	 * @deprecated Retired by delayed execution (DBU-885): always aborts through Predict v4.
+	 * Use {@link SessionsContract.enqueueExactCost}.
 	 */
 	mintExactCost(params: {
 		expiryMarketId: string;
@@ -385,6 +435,9 @@ export class SessionsContract {
 	 * unless you mean to accept whatever the mark gives you.
 	 * @returns A function that takes a Transaction object and returns `Option<u256>` — the
 	 * replacement order id when a partial close leaves quantity open
+	 * @deprecated Retired by delayed execution (DBU-885): always aborts through Predict v4.
+	 * Account positions then have no early exit; queued fills are Open records sold with
+	 * {@link SessionsContract.enqueueRedeemOpen}.
 	 */
 	redeemLive(params: {
 		expiryMarketId: string;
@@ -442,6 +495,158 @@ export class SessionsContract {
 		};
 	}
 
+	// === Queued Predict wrappers (delayed execution, DBU-885) ===
+	//
+	// The session form of the order-flow companion's `queue::enqueue_*`, in Sessions v3. Each
+	// wrapper names the market's `MarketQueue` and the companion's `OrderDesk` next to the market.
+	// Placement takes no pricer: it reads the oracle objects directly, so each wrapper takes the
+	// market's three feed ids plus Predict's `OracleRegistry` (the propbook registry). Amounts are
+	// raw Move units. Each returns the new queue record ID (u64). The queue and Predict perform
+	// every check; the caps below are only the ones a session key should never send by accident.
+	//
+	// They need a config whose `sessionsPackageId` is a Sessions v3 publication, which both
+	// network records are. Sessions v1 and v2 have none of them.
+
+	/**
+	 * @description Queue a mint of an exact payout quantity, as `session`. `maxCost` (all-in cap)
+	 * and `maxProbability` (at most 1e9) are required, and the chain refuses an "unlimited"
+	 * `maxCost`.
+	 * @returns A function that takes a Transaction object and returns the record id (u64)
+	 */
+	enqueueExactQuantity(
+		params: SessionsQueuedOrderTarget & {
+			lowerTick: number | bigint;
+			higherTick: number | bigint;
+			quantity: number | bigint;
+			maxCost: number | bigint;
+			maxProbability: number | bigint;
+		},
+	) {
+		assertQueuedMaxCost(params.maxCost);
+		return (tx: Transaction): TransactionResult =>
+			tx.add(
+				sessions.enqueueExactQuantity({
+					config: this.#generatedConfig,
+					arguments: {
+						...this.#queuedTarget(params),
+						lowerTick: params.lowerTick,
+						higherTick: params.higherTick,
+						quantity: params.quantity,
+						maxCost: params.maxCost,
+						maxProbability: params.maxProbability,
+					},
+				}),
+			);
+	}
+
+	/**
+	 * @description Queue a premium-budget mint, as `session`: sized at τ under `maxPremium`, at
+	 * least `minQuantity`, with the all-in debit capped by the required `maxCost`.
+	 * @returns A function that takes a Transaction object and returns the record id (u64)
+	 */
+	enqueueExactAmount(
+		params: SessionsQueuedOrderTarget & {
+			lowerTick: number | bigint;
+			higherTick: number | bigint;
+			maxPremium: number | bigint;
+			minQuantity: number | bigint;
+			maxCost: number | bigint;
+		},
+	) {
+		assertQueuedMaxCost(params.maxCost);
+		return (tx: Transaction): TransactionResult =>
+			tx.add(
+				sessions.enqueueExactAmount({
+					config: this.#generatedConfig,
+					arguments: {
+						...this.#queuedTarget(params),
+						lowerTick: params.lowerTick,
+						higherTick: params.higherTick,
+						maxPremium: params.maxPremium,
+						minQuantity: params.minQuantity,
+						maxCost: params.maxCost,
+					},
+				}),
+			);
+	}
+
+	/**
+	 * @description Queue an all-in-budget mint, as `session`: sized at τ so the all-in cost fits
+	 * `maxCost`, at least `minQuantity`.
+	 * @returns A function that takes a Transaction object and returns the record id (u64)
+	 */
+	enqueueExactCost(
+		params: SessionsQueuedOrderTarget & {
+			lowerTick: number | bigint;
+			higherTick: number | bigint;
+			maxCost: number | bigint;
+			minQuantity: number | bigint;
+		},
+	) {
+		assertQueuedMaxCost(params.maxCost);
+		return (tx: Transaction): TransactionResult =>
+			tx.add(
+				sessions.enqueueExactCost({
+					config: this.#generatedConfig,
+					arguments: {
+						...this.#queuedTarget(params),
+						lowerTick: params.lowerTick,
+						higherTick: params.higherTick,
+						maxCost: params.maxCost,
+						minQuantity: params.minQuantity,
+					},
+				}),
+			);
+	}
+
+	/**
+	 * @description Queue an early sell of the Open record `recordId` (its queue record ID, not
+	 * the position's order ID), as `session`. `minProbability` and `minProceeds` are the close
+	 * floors at τ and are required: on a delegated key, `0` closes at any price, so pass it only
+	 * on purpose.
+	 * @returns A function that takes a Transaction object and returns the new record id (u64)
+	 */
+	enqueueRedeemOpen(
+		params: SessionsQueuedOrderTarget & {
+			recordId: number | bigint;
+			closeQuantity: number | bigint;
+			minProbability: number | bigint;
+			minProceeds: number | bigint;
+		},
+	) {
+		return (tx: Transaction): TransactionResult =>
+			tx.add(
+				sessions.enqueueRedeemOpen({
+					config: this.#generatedConfig,
+					arguments: {
+						...this.#queuedTarget(params),
+						recordId: params.recordId,
+						closeQuantity: params.closeQuantity,
+						minProbability: params.minProbability,
+						minProceeds: params.minProceeds,
+					},
+				}),
+			);
+	}
+
+	// The leading arguments every queued wrapper shares, in the Move order: `(queue, market,
+	// account_registry, wrapper, sessions_config, desk, config, propbook_registry, pyth, bs_values,
+	// bs_svi, …)`. `sessions_config` comes from the generated config.
+	#queuedTarget(params: SessionsQueuedOrderTarget) {
+		return {
+			queue: params.queueId ?? deriveQueueId(params.queueRegistry, params.expiryMarketId),
+			market: params.expiryMarketId,
+			accountRegistry: this.#config.accountRegistry,
+			wrapper: params.wrapperId,
+			desk: params.orderDesk,
+			config: params.protocolConfig,
+			propbookRegistry: params.oracleRegistry,
+			pyth: params.pythFeed,
+			bsValues: params.blockScholesValueStore,
+			bsSvi: params.blockScholesSviStore,
+		};
+	}
+
 	/**
 	 * @description Decode an Account's stored grants from the raw BCS content of its
 	 * `DataKey<SessionsApp>` dynamic FIELD object — the whole