@mysten/deepbook-v3 2.6.4 → 2.8.0

package/src/contracts/deepbook_predict/strike_payout_tree.ts

@@ -15,28 +15,33 @@
  * anything the caller supplies: rotations are driven by measured subtree height,
  * which bounds depth at `O(log n)` for _every_ tick set rather than in expectation
  * over a random one. Depth is the cost model that matters — each node is a
- * dynamic-field child, and `apply_at` and `settlement_prefix_payout` touch one per
- * level against a per-transaction cached-object ceiling.
+ * dynamic-field child, and `apply_at` and `prefix_pay` touch one per level against
+ * a per-transaction cached-object ceiling.
  *
  * It tracks each order's quantity, which is also its settled payout: a winning
  * order pays its full quantity. Live cash backing is the max-point payout plus a
  * buffer over the disjoint-book gap; the tree's max-point term is the floor anchor
  * of that enforced reserve.
  *
- * Shape carries no value for a consistent index: `combine_summaries` is
- * associative over the in-order sequence, so any arrangement of the same
- * boundaries yields identical summaries, settlement prefixes, and linear-walk
- * totals. That holds only while every prefix is non-negative, which a consistent
- * book guarantees. Under a caller/index desync the settlement walk's underflow
- * 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.
+ * Shape carries no value for a consistent index: `combine` is associative over the
+ * in-order sequence, so any arrangement of the same boundaries yields identical
+ * summaries, settlement prefixes, and linear-walk totals. That holds only while
+ * every prefix is non-negative, which a consistent book guarantees. Under a
+ * caller/index desync the settlement walk's underflow 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` 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.
+ * is its own snapshot), and `walk_frozen` prices the tree exactly as it stood at
+ * the snapshot instant through the same walk the live read uses.
+ *
+ * Delayed execution adds pins: a waiting order's boundary ticks, passed in as
+ * `pins` (tick -> count of waiting orders; a key is present only while its count
+ * is positive). Enqueue creates the nodes up front (`ensure_node`), no deletion
+ * path removes a pinned node, and a resolve fill inserts over existing nodes only
+ * (`insert_exist`), so the keeper never creates a node.
  */
 
 import { MoveStruct } from '../utils/index.js';
@@ -61,9 +66,9 @@ export const StrikePayoutTree = new MoveStruct({
 		 */
 		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.
+		 * True from `snap_on` until `snap_done`/`snap_off`. 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. */
@@ -76,12 +81,11 @@ export const PayoutSummary = new MoveStruct({
 		start: U64,
 		end: U64,
 		/**
-		 * Never exceeds `start`, by construction in `boundary_summary` and
-		 * `combine_summaries`. That bound is what makes `combine_summaries` associative at
-		 * u64 scale — and therefore what makes the tree's shape irrelevant to every value
-		 * it reports. A summary term that could outgrow `start` would break
-		 * shape-independence with no test to catch it, and would also abort
-		 * `strike_exposure`'s plain `total - max` subtraction.
+		 * Never exceeds `start`, by construction in `bound_sum` and `combine`. That bound
+		 * is what makes `combine` associative at u64 scale — and therefore what makes the
+		 * tree's shape irrelevant to every value it reports. A summary term that could
+		 * outgrow `start` would break shape-independence with no test to catch it, and
+		 * would also abort `strike_exposure`'s plain `total - max` subtraction.
 		 */
 		max_payout_prefix_gain: U64,
 	},

package/src/contracts/deepbook_predict/vault_events.ts

@@ -43,6 +43,47 @@ export const ExpiryProfitMaterialized = new MoveStruct({
 		pending_protocol_profit_after: U64,
 	},
 });
+export const ExpiryPnl = new MoveStruct({
+	name: `${$moduleName}::ExpiryPnl`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		expiry_market_id: bcs.Address,
+		propbook_underlying_id: bcs.u32(),
+		/**
+		 * Start of the market's cadence period (`expiry` minus the cadence period), in
+		 * milliseconds. The market's creation transaction may land before it.
+		 */
+		period_start_ms: U64,
+		expiry: U64,
+		settlement_price: U64,
+		sent_to_expiry: U64,
+		received_from_expiry: U64,
+		/**
+		 * True when `received_from_expiry >= sent_to_expiry`; break-even reports a zero
+		 * profit.
+		 */
+		in_profit: bcs.bool(),
+		/** Absolute difference between `received_from_expiry` and `sent_to_expiry`. */
+		amount: U64,
+	},
+});
+export const ExpiryPnlRealized = new MoveStruct({
+	name: `${$moduleName}::ExpiryPnlRealized`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		expiry_market_id: bcs.Address,
+		propbook_underlying_id: bcs.u32(),
+		expiry: U64,
+		settlement_price: U64,
+		/** False only for a loss, which only an expiry's first emission can report. */
+		in_profit: bcs.bool(),
+		/**
+		 * Magnitude of the change in the gross realized result since the previous
+		 * emission.
+		 */
+		amount: U64,
+	},
+});
 export const SupplyRequested = new MoveStruct({
 	name: `${$moduleName}::SupplyRequested`,
 	fields: {
@@ -222,6 +263,14 @@ export const CapitalLocked = new MoveStruct({
 		amount: U64,
 	},
 });
+export const UsdcAddedToPlp = new MoveStruct({
+	name: `${$moduleName}::UsdcAddedToPlp`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		contributor: bcs.Address,
+		amount: U64,
+	},
+});
 export const FeeIncentivesSponsored = new MoveStruct({
 	name: `${$moduleName}::FeeIncentivesSponsored`,
 	fields: {
@@ -231,6 +280,22 @@ export const FeeIncentivesSponsored = new MoveStruct({
 		reserve_after: U64,
 	},
 });
+export const FeeIncentivesWithdrawn = new MoveStruct({
+	name: `${$moduleName}::FeeIncentivesWithdrawn`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		amount: U64,
+		reserve_after: U64,
+	},
+});
+export const FeeIncentiveLifetimeCapSnapshotted = new MoveStruct({
+	name: `${$moduleName}::FeeIncentiveLifetimeCapSnapshotted`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		expiry_market_id: bcs.Address,
+		fee_incentive_lifetime_cap: U64,
+	},
+});
 export const FeeIncentivesAllocated = new MoveStruct({
 	name: `${$moduleName}::FeeIncentivesAllocated`,
 	fields: {

package/src/contracts/deepbook_predict_math/config-arguments.ts

@@ -0,0 +1,6 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+export interface DeepbookPredictMathConfig {
+	predictMathPackageId?: string;
+}

package/src/contracts/deepbook_predict_math/lazer_price.ts

@@ -0,0 +1,196 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A Pyth Lazer price decoded from a verified update, for Predict's order-flow
+ * commit.
+ *
+ * A `LazerPrice` is built only from a `pyth_lazer::update::Update`, which only
+ * Pyth's verifier produces, so holding one proves a Pyth signature over its feed,
+ * channel, timestamps, and price. It has `copy` and `drop` but not `store`, so it
+ * lives within one transaction. The decode is Predict v4's queue commit decode: it
+ * aborts on an update that does not carry the requested feed or lacks its price,
+ * exponent, or feed-update-time property, because the caller then passed the wrong
+ * update, and it returns `none` only when the feed has no usable price at that
+ * tick: an empty price or update time, or a price that does not normalize to
+ * Predict's pricing-safe 1e9 spot.
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { U64 } from '../../bcs/integers.js';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/deepbook_predict_math::lazer_price';
+export const LazerPrice = new MoveStruct({
+	name: `${$moduleName}::LazerPrice`,
+	fields: {
+		feed_id: bcs.u32(),
+		/**
+		 * A Lazer channel id: `channel_fixed_rate_50ms!()`, `channel_fixed_rate_200ms!()`,
+		 * or `1` for real-time.
+		 */
+		channel: bcs.u8(),
+		/** The update's timestamp, in µs. */
+		envelope_us: U64,
+		/** The feed's own update time, in µs. Never after the envelope. */
+		generation_us: U64,
+		/**
+		 * The price normalized to 1e9, rounded down when the source is finer; positive and
+		 * at most `u64::MAX / 100`.
+		 */
+		spot: U64,
+	},
+});
+export interface FromUpdateArguments {
+	update: TransactionArgument;
+	feedId: RawTransactionArgument<number>;
+}
+export interface FromUpdateOptions {
+	package?: string;
+	arguments:
+		FromUpdateArguments | [update: TransactionArgument, feedId: RawTransactionArgument<number>];
+	config?: {
+		predictMathPackageId?: string;
+	};
+}
+/**
+ * Decode `feed_id` from a verified Lazer update. `none` when the feed's price or
+ * update time is empty at this tick, or its price does not normalize to a
+ * pricing-safe spot. Aborts `EFeedMissing` when the update does not carry the feed
+ * and `EPropertyNotRequested` when the feed lacks the price, exponent, or
+ * update-time property, because the caller then passed the wrong update, and
+ * `EGenerationAfterEnvelope` when the feed claims an update time after the
+ * envelope that carries it.
+ *
+ * Uses Lazer's v1 `Update`, which Pyth marked deprecated on Mainnet but still
+ * serves; a later library upgrade adds a constructor for v2.
+ */
+export function fromUpdate(options: FromUpdateOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';
+	const argumentsTypes = [null, 'u32'] satisfies (string | null)[];
+	const parameterNames = ['update', 'feedId'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'lazer_price',
+			function: 'from_update',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface FeedIdArguments {
+	price: TransactionArgument;
+}
+export interface FeedIdOptions {
+	package?: string;
+	arguments: FeedIdArguments | [price: TransactionArgument];
+	config?: {
+		predictMathPackageId?: string;
+	};
+}
+export function feedId(options: FeedIdOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['price'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'lazer_price',
+			function: 'feed_id',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface ChannelArguments {
+	price: TransactionArgument;
+}
+export interface ChannelOptions {
+	package?: string;
+	arguments: ChannelArguments | [price: TransactionArgument];
+	config?: {
+		predictMathPackageId?: string;
+	};
+}
+export function channel(options: ChannelOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['price'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'lazer_price',
+			function: 'channel',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface EnvelopeUsArguments {
+	price: TransactionArgument;
+}
+export interface EnvelopeUsOptions {
+	package?: string;
+	arguments: EnvelopeUsArguments | [price: TransactionArgument];
+	config?: {
+		predictMathPackageId?: string;
+	};
+}
+export function envelopeUs(options: EnvelopeUsOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['price'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'lazer_price',
+			function: 'envelope_us',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface GenerationUsArguments {
+	price: TransactionArgument;
+}
+export interface GenerationUsOptions {
+	package?: string;
+	arguments: GenerationUsArguments | [price: TransactionArgument];
+	config?: {
+		predictMathPackageId?: string;
+	};
+}
+export function generationUs(options: GenerationUsOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['price'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'lazer_price',
+			function: 'generation_us',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface SpotArguments {
+	price: TransactionArgument;
+}
+export interface SpotOptions {
+	package?: string;
+	arguments: SpotArguments | [price: TransactionArgument];
+	config?: {
+		predictMathPackageId?: string;
+	};
+}
+export function spot(options: SpotOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['price'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'lazer_price',
+			function: 'spot',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}