@mysten/deepbook-v3 2.1.4 → 2.3.0

package/src/contracts/deepbook_predict/pricing.ts

@@ -32,6 +32,18 @@ export const PricingSVI = new MoveStruct({
 		sigma: U64,
 	},
 });
+export const FrozenPricer = new MoveStruct({
+	name: `${$moduleName}::FrozenPricer`,
+	fields: {
+		expiry_market_id: bcs.Address,
+		forward: U64,
+		svi: PricingSVI,
+		pyth_spot_source_timestamp_ms: U64,
+		block_scholes_spot_source_timestamp_ms: U64,
+		block_scholes_forward_source_timestamp_ms: U64,
+		block_scholes_svi_source_timestamp_ms: U64,
+	},
+});
 export const Pricer = new MoveStruct({
 	name: `${$moduleName}::Pricer`,
 	fields: {
@@ -42,10 +54,10 @@ export const Pricer = new MoveStruct({
 		/**
 		 * Timestamps of the oracle observations this snapshot validated, as trade events
 		 * report them — each observation's own economic clock. Pyth carries its source
-		 * timestamp (`0` only when no usable normalized observation exists); the Block
-		 * Scholes reads carry their batch envelope time (`source_timestamp_ms`), the clock
-		 * freshness gated and the SVI roll-down anchored on. The provider's calibration
-		 * (model) times stay on the stored observations and their ingestion events.
+		 * timestamp (`0` only when no usable normalized observation exists); Block Scholes
+		 * spot and forward carry the provider `value_timestamp`, and SVI carries the
+		 * provider `svi_timestamp`. Those timestamps are the clocks freshness gates and
+		 * SVI roll-down use.
 		 */
 		pyth_spot_source_timestamp_ms: U64,
 		block_scholes_spot_source_timestamp_ms: U64,

package/src/contracts/deepbook_predict/protocol_config.ts

@@ -6,8 +6,10 @@
  * Protocol-wide configuration and flow gates for Predict.
  *
  * This shared object owns the admin-tunable config structs, the trading pause
- * gate, the protocol-wide emergency freeze, and the transaction-local full-pool
- * valuation lock. Flow modules decide which gates apply before they mutate expiry,
+ * gate, the protocol-wide emergency freeze, and the full-pool valuation in-flight
+ * state (flag + flush ordinal, held across the transactions a flush spans;
+ * keeper/config flows gate on it, trading flows read it only to discard stale
+ * stamps lazily). Flow modules decide which gates apply before they mutate expiry,
  * oracle, pool, or account state.
  */
 
@@ -41,7 +43,7 @@ export const ProtocolConfig = new MoveStruct({
 		referral_fee_rate: U64,
 		/**
 		 * Fee charged on an executed PLP supply fill, in FLOAT_SCALING, deducted from the
-		 * DUSDC taken in before shares are priced. Ships at zero — a deposit dilutes the
+		 * USDC taken in before shares are priced. Ships at zero — a deposit dilutes the
 		 * pool's risk per dollar rather than concentrating it, so it is not taxed; the
 		 * knob exists to keep that reversible.
 		 */
@@ -62,10 +64,25 @@ export const ProtocolConfig = new MoveStruct({
 		lp_request_limit_flush_attempts: U64,
 		/**
 		 * Ceiling on LP-attributable pool value that queued supplies may raise the pool
-		 * to, enforced at the flush against the frozen mark. Defaults to `u64::MAX`, so
-		 * the pool is uncapped until an operator sets a figure (RP-23).
+		 * to, enforced at the flush against the frozen mark. Defaults to 500,000 USDC
+		 * (RP-23).
 		 */
 		max_lp_pool_value: U64,
+		/**
+		 * Hard staleness bound: `finish_flush` refuses to complete a flush in flight
+		 * longer than this, so no LP request fills at a mark older than the window; past
+		 * it the operator starts a fresh flush (which discards the stale one). A stalled
+		 * flush blocks only LP queue fills and the flush-set markets' settlement — trading
+		 * continues — so this also bounds LP-fill latency and is tuned alongside flush
+		 * cadence (RP-29).
+		 */
+		max_valuation_window_ms: U64,
+		/**
+		 * Window before a market's expiry in which live quotes, mints, and live redeems
+		 * abort. Read live at trade time rather than snapshotted per market, so it can be
+		 * widened on markets already trading. `0` disables.
+		 */
+		no_trade_window_ms: U64,
 		strike_exposure_template_config: strike_exposure_config.StrikeExposureConfig,
 		ewma_config: ewma_config.EwmaConfig,
 		/**
@@ -88,10 +105,30 @@ export const ProtocolConfig = new MoveStruct({
 		 */
 		frozen: bcs.bool(),
 		/**
-		 * Transaction-local lock held while a full-pool valuation is assembled, so no
-		 * NAV-changing op can interleave between per-market value steps in the PTB.
+		 * True for the whole duration of a full-pool valuation, across every transaction
+		 * it spans. Keeper cash flows, market lifecycle, and config mutations gate on it;
+		 * trading flows do NOT — they read it (with `flush_seq`) only to discard a stale
+		 * valuation stamp lazily; a pending market's snapshot state is captured, never
+		 * recorded per trade (see `plp`).
 		 */
 		valuation_in_progress: bcs.bool(),
+		/**
+		 * True ONLY while the atomic snapshot stage is open — set by `begin_snapshot` at
+		 * `start_pool_valuation` and cleared by `end_snapshot` at
+		 * `seal_valuation_snapshot`. Both live in one PTB (the `SnapshotStage` hot potato
+		 * forces it), so this can never be observed across transactions: it blocks only a
+		 * trade the keeper composes INTO its own snapshot PTB, where a mid-stamp cash move
+		 * would skew the figures the seal freezes. The resumable valuation stage after the
+		 * seal leaves it false, so trading stays live.
+		 */
+		snapshot_in_progress: bcs.bool(),
+		/**
+		 * Monotonic flush ordinal, bumped by `begin_valuation`. A market's valuation stamp
+		 * names the flush that made it; a stamp whose ordinal is not the current one — or
+		 * held while no valuation is in flight — is stale and is lazily discarded by the
+		 * next trade, so aborting a flush never has to visit its stamped markets.
+		 */
+		flush_seq: U64,
 	},
 });
 export interface IdArguments {
@@ -193,6 +230,43 @@ export function frozen(options: FrozenOptions) {
 			),
 		});
 }
+export interface ValuationInProgressArguments {
+	config?: RawTransactionArgument<string>;
+}
+export interface ValuationInProgressOptions {
+	package?: string;
+	arguments?: ValuationInProgressArguments;
+	config?: {
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Return whether a full-pool valuation is in flight, for SDK and devInspect reads.
+ * The flush spans transactions, so "in flight" is an observable state: a keeper
+ * reads it to notice a flush it must finish or discard, and an integrator reads it
+ * to explain a gated keeper/config transaction. Trading is not gated on it.
+ */
+export function valuationInProgress(options: ValuationInProgressOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['config'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'protocol_config',
+			function: 'valuation_in_progress',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
 export interface ReferralFeeRateArguments {
 	config?: RawTransactionArgument<string>;
 }
@@ -225,6 +299,43 @@ export function referralFeeRate(options: ReferralFeeRateOptions) {
 			),
 		});
 }
+export interface NoTradeWindowMsArguments {
+	config?: RawTransactionArgument<string>;
+}
+export interface NoTradeWindowMsOptions {
+	package?: string;
+	arguments?: NoTradeWindowMsArguments;
+	config?: {
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Window before expiry in which live quotes, mints, and live redeems abort.
+ * `public` for SDK and devInspect reads: a client that cannot see this value can
+ * only learn the window closed by decoding `ETradeWindowClosed` from a failed
+ * quote.
+ */
+export function noTradeWindowMs(options: NoTradeWindowMsOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['config'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'protocol_config',
+			function: 'no_trade_window_ms',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
 export interface SetTemplateBaseFeeArguments {
 	config?: RawTransactionArgument<string>;
 	AdminCap: RawTransactionArgument<string>;
@@ -690,6 +801,47 @@ export function setLpRequestLimitFlushAttempts(options: SetLpRequestLimitFlushAt
 			),
 		});
 }
+export interface SetMaxValuationWindowMsArguments {
+	config?: RawTransactionArgument<string>;
+	AdminCap: RawTransactionArgument<string>;
+	windowMs: RawTransactionArgument<number | bigint>;
+}
+export interface SetMaxValuationWindowMsOptions {
+	package?: string;
+	arguments: SetMaxValuationWindowMsArguments;
+	config?: {
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Set how long a started full-pool valuation may stay in flight before anyone may
+ * discard it. A stalled flush costs LP-fill latency (and settlement latency for
+ * its own market set), not a trading pause, so this is an operator liveness knob:
+ * too short and a legitimate long flush can be discarded from under the keeper,
+ * too long and an abandoned one delays queued LP fills for that duration. See
+ * RP-29.
+ */
+export function setMaxValuationWindowMs(options: SetMaxValuationWindowMsOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null, null, 'u64'] satisfies (string | null)[];
+	const parameterNames = ['config', 'AdminCap', 'windowMs'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'protocol_config',
+			function: 'set_max_valuation_window_ms',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
 export interface SetMaxLpPoolValueArguments {
 	config?: RawTransactionArgument<string>;
 	AdminCap: RawTransactionArgument<string>;
@@ -802,6 +954,49 @@ export function setEwmaEnabled(options: SetEwmaEnabledOptions) {
 			),
 		});
 }
+export interface SetNoTradeWindowMsArguments {
+	config?: RawTransactionArgument<string>;
+	AdminCap: RawTransactionArgument<string>;
+	value: RawTransactionArgument<number | bigint>;
+}
+export interface SetNoTradeWindowMsOptions {
+	package?: string;
+	arguments: SetNoTradeWindowMsArguments;
+	config?: {
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Set the window before expiry in which live quotes, mints, and live redeems
+ * abort. `0` disables the block. Read live at trade time, so a change applies to
+ * markets already trading and stays available as an incident control.
+ *
+ * Deliberately not gated on `assert_not_valuation_in_progress`, matching
+ * `set_trading_paused`: a stalled flush must not be able to trap a safety control.
+ * Nothing in the flush reads this value, so a mid-valuation change cannot skew a
+ * frozen mark.
+ */
+export function setNoTradeWindowMs(options: SetNoTradeWindowMsOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null, null, 'u64', '0x2::clock::Clock'] satisfies (string | null)[];
+	const parameterNames = ['config', 'AdminCap', 'value'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'protocol_config',
+			function: 'set_no_trade_window_ms',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
 export interface SetTradingPausedArguments {
 	config?: RawTransactionArgument<string>;
 	AdminCap: RawTransactionArgument<string>;

package/src/contracts/deepbook_predict/registry.ts

@@ -38,11 +38,15 @@ export const Registry = new MoveStruct({
 		 */
 		allowed_pause_caps: vec_set.VecSet(bcs.Address),
 		/**
-		 * IDs of `MarketLifecycleCap` objects currently authorized for privileged
-		 * lifecycle entries such as market creation and full-pool valuation. Admin mints
-		 * into this set and revokes from it.
+		 * IDs of `MarketLifecycleCap` objects currently authorized to create expiry
+		 * markets. Admin mints into this set and revokes from it.
 		 */
 		allowed_lifecycle_caps: vec_set.VecSet(bcs.Address),
+		/**
+		 * IDs of `PoolValuationCap` objects currently authorized to start the full-pool
+		 * valuation. Admin mints into this set and revokes from it.
+		 */
+		allowed_pool_valuation_caps: vec_set.VecSet(bcs.Address),
 	},
 });
 export interface IdArguments {
@@ -269,10 +273,7 @@ export interface MintLifecycleCapOptions {
 		predictPackageId?: string;
 	};
 }
-/**
- * Mint a version-gated `MarketLifecycleCap` with market-creation and valuation
- * authority.
- */
+/** Mint a version-gated `MarketLifecycleCap` with market-creation authority. */
 export function mintLifecycleCap(options: MintLifecycleCapOptions) {
 	const packageAddress =
 		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
@@ -328,33 +329,106 @@ export function revokeLifecycleCap(options: RevokeLifecycleCapOptions) {
 			),
 		});
 }
-export interface GenerateLifecycleProofArguments {
+export interface MintPoolValuationCapArguments {
 	registry?: RawTransactionArgument<string>;
-	lifecycleCap: RawTransactionArgument<string>;
+	AdminCap: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+}
+export interface MintPoolValuationCapOptions {
+	package?: string;
+	arguments: MintPoolValuationCapArguments;
+	config?: {
+		registry: ConfigValue;
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Mint a version-gated `PoolValuationCap` with authority to start the full-pool
+ * valuation.
+ */
+export function mintPoolValuationCap(options: MintPoolValuationCapOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null, null, null] satisfies (string | null)[];
+	const parameterNames = ['registry', 'AdminCap', 'config'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'mint_pool_valuation_cap',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.registry,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface RevokePoolValuationCapArguments {
+	registry?: RawTransactionArgument<string>;
+	AdminCap: RawTransactionArgument<string>;
+	poolValuationCapId: RawTransactionArgument<string>;
+}
+export interface RevokePoolValuationCapOptions {
+	package?: string;
+	arguments: RevokePoolValuationCapArguments;
+	config?: {
+		registry: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Revoke a `PoolValuationCap` by ID without applying the version gate. */
+export function revokePoolValuationCap(options: RevokePoolValuationCapOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null, null, '0x2::object::ID'] satisfies (string | null)[];
+	const parameterNames = ['registry', 'AdminCap', 'poolValuationCapId'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'revoke_pool_valuation_cap',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.registry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface GeneratePoolValuationProofArguments {
+	registry?: RawTransactionArgument<string>;
+	poolValuationCap: RawTransactionArgument<string>;
 }
-export interface GenerateLifecycleProofOptions {
+export interface GeneratePoolValuationProofOptions {
 	package?: string;
-	arguments: GenerateLifecycleProofArguments;
+	arguments: GeneratePoolValuationProofArguments;
 	config?: {
 		registry: ConfigValue;
 		predictPackageId?: string;
 	};
 }
 /**
- * Generate a transaction-local proof that `lifecycle_cap` is currently
- * allowlisted. Consumers take the proof by value so a revoked lifecycle cap cannot
- * authorize cross-module lifecycle actions.
+ * Generate a transaction-local proof that `pool_valuation_cap` is currently
+ * allowlisted. `plp::start_pool_valuation` takes the proof by value so a revoked
+ * cap cannot start a valuation.
  */
-export function generateLifecycleProof(options: GenerateLifecycleProofOptions) {
+export function generatePoolValuationProof(options: GeneratePoolValuationProofOptions) {
 	const packageAddress =
 		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
 	const argumentsTypes = [null, null] satisfies (string | null)[];
-	const parameterNames = ['registry', 'lifecycleCap'];
+	const parameterNames = ['registry', 'poolValuationCap'];
 	return (tx: Transaction) =>
 		tx.moveCall({
 			package: packageAddress,
 			module: 'registry',
-			function: 'generate_lifecycle_proof',
+			function: 'generate_pool_valuation_proof',
 			arguments: normalizeMoveArguments(
 				{
 					...options.arguments,

package/src/contracts/deepbook_predict/strike_exposure.ts

@@ -36,7 +36,7 @@ export const StrikeExposure = new MoveStruct({
 		/** Snapshotted exposure and fee policy for this expiry. */
 		config: strike_exposure_config.StrikeExposureConfig,
 		/**
-		 * Immutable DUSDC scale for the inventory-impact curve. This is the expiry's
+		 * Immutable USDC scale for the inventory-impact curve. This is the expiry's
 		 * snapshotted maximum pool allocation: a risk-capacity parameter, not live pool
 		 * equity, so LP flows cannot reprice an existing book.
 		 */

package/src/contracts/deepbook_predict/strike_payout_tree.ts

@@ -31,6 +31,12 @@
  * abort depends on which prefixes a given shape happens to visit, so it is not a
  * desync detector — the per-boundary underflow in `apply_net_delta` is the
  * authority.
+ *
+ * The module also owns the valuation snapshot for the resumable flush: while a
+ * flush generation is active, each node lazily captures its boundary quantities
+ * immediately before its first mutation under that generation (an untouched node
+ * is its own snapshot), and `walk_linear_frozen` prices the tree exactly as it
+ * stood at the snapshot instant through the same walk the live read uses.
  */
 
 import { MoveStruct } from '../utils/index.js';
@@ -49,6 +55,19 @@ export const StrikePayoutTree = new MoveStruct({
 		 * settled payout.
 		 */
 		base: U64,
+		/**
+		 * Flush generation whose snapshot this tree holds. Node shadows are valid only
+		 * against this value; monotonically increasing, 0 = never snapshotted.
+		 */
+		snapshot_seq: U64,
+		/**
+		 * True from `activate_snapshot` until `release_snapshot`/`deactivate_snapshot`.
+		 * While set, mutations capture shadows and emptied nodes with shadow quantities
+		 * are retained for the frozen walk instead of removed.
+		 */
+		snapshot_active: bcs.bool(),
+		/** `base` as of the snapshot instant, captured eagerly at activation. */
+		snapshot_base: U64,
 	},
 });
 export const PayoutSummary = new MoveStruct({
@@ -84,6 +103,14 @@ export const PayoutNode = new MoveStruct({
 		 */
 		local_start: U64,
 		local_end: U64,
+		/**
+		 * Boundary terms at generation `snapshot_seq`'s instant, captured before the first
+		 * mutation under it. Active generation + zero shadows = created post-snapshot;
+		 * older generation = untouched, live terms ARE the shadow.
+		 */
+		snapshot_local_start: U64,
+		snapshot_local_end: U64,
+		snapshot_seq: U64,
 		summary: PayoutSummary,
 	},
 });

package/src/contracts/deepbook_predict/vault_events.ts

@@ -63,7 +63,7 @@ export const WithdrawRequested = new MoveStruct({
 		recipient: bcs.Address,
 		index: U64,
 		amount: U64,
-		min_dusdc_out: U64,
+		min_usdc_out: U64,
 		requests_pending_after: U64,
 	},
 });
@@ -107,20 +107,20 @@ export const SupplyFilled = new MoveStruct({
 		recipient: bcs.Address,
 		index: U64,
 		/**
-		 * DUSDC actually taken into the pool, which is less than the request's escrow when
+		 * USDC actually taken into the pool, which is less than the request's escrow when
 		 * the supply cap left only part of it room. Shares were priced on
-		 * `dusdc_amount - fee_dusdc`.
+		 * `usdc_amount - fee_usdc`.
 		 */
-		dusdc_amount: U64,
+		usdc_amount: U64,
 		shares_minted: U64,
-		/** Supply fee withheld from `dusdc_amount` and retained by the pool. */
-		fee_dusdc: U64,
+		/** Supply fee withheld from `usdc_amount` and retained by the pool. */
+		fee_usdc: U64,
 		/**
 		 * Escrow still queued at the head after a partial fill; `0` on a full fill, in
-		 * which case the request is gone. `dusdc_amount + dusdc_remaining` is the amount
-		 * the request carried into this flush.
+		 * which case the request is gone. `usdc_amount + usdc_remaining` is the amount the
+		 * request carried into this flush.
 		 */
-		dusdc_remaining: U64,
+		usdc_remaining: U64,
 		requests_pending_after: U64,
 	},
 });
@@ -133,12 +133,12 @@ export const WithdrawFilled = new MoveStruct({
 		index: U64,
 		shares_burned: U64,
 		/**
-		 * Net DUSDC delivered to `recipient`. The gross marked value of `shares_burned`
-		 * was `dusdc_amount + fee_dusdc`.
+		 * Net USDC delivered to `recipient`. The gross marked value of `shares_burned` was
+		 * `usdc_amount + fee_usdc`.
 		 */
-		dusdc_amount: U64,
+		usdc_amount: U64,
 		/** Withdraw fee withheld from the payout and retained by the pool. */
-		fee_dusdc: U64,
+		fee_usdc: U64,
 		/**
 		 * Escrowed PLP still queued at the head after a partial fill; `0` on a full fill,
 		 * in which case the request is gone. `shares_burned + shares_remaining` is the
@@ -174,14 +174,45 @@ export const FlushExecuted = new MoveStruct({
 		active_market_nav: U64,
 		/** Number of active markets valued for this flush. */
 		market_count: U64,
-		/** Idle DUSDC held by the pool at valuation time, before the drain. */
+		/**
+		 * LIVE idle USDC read at finish time, immediately before the drain — NOT a mark
+		 * input. It brackets the drain with `idle_balance_after`; because maintenance,
+		 * settlement sweeps, and trading run mid-window, it can differ from
+		 * `frozen_idle_balance` below. Drain telemetry, not the mark.
+		 */
 		idle_balance_before: U64,
+		/**
+		 * The mark's idle component: idle USDC FROZEN at the seal. `frozen_idle_balance
+		 *
+		 * - active_market_nav`reconstructs the priced mark's gross; every fill in the  flush is priced from this, never from`idle_balance_before`.
+		 */
+		frozen_idle_balance: U64,
 		supplies_filled: U64,
 		withdrawals_filled: U64,
 		requests_processed: U64,
 		idle_balance_after: U64,
 		/** PLP supply after the drain's completed mints and burns. */
 		total_supply_after: U64,
+		/**
+		 * Each queue's `next_index` at this flush's snapshot instant; the drain filled
+		 * only requests indexed strictly below these.
+		 */
+		supply_request_cutoff: U64,
+		withdraw_request_cutoff: U64,
+		/**
+		 * Clock instant the snapshot stage froze every market's pricer — the moment the
+		 * mark prices the pool at. Fills execute later in the same flush; this is the
+		 * timestamp they were priced as of.
+		 */
+		snapshot_timestamp_ms: U64,
+	},
+});
+export const FlushRestarted = new MoveStruct({
+	name: `${$moduleName}::FlushRestarted`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		expected_market_count: U64,
+		valued_market_count: U64,
 	},
 });
 export const CapitalLocked = new MoveStruct({