@mysten/deepbook-v3 2.0.0 → 2.1.3

package/src/contracts/deepbook_predict/strike_exposure.ts

@@ -0,0 +1,77 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Expiry-local exposure book for one expiry market.
+ *
+ * This module interprets `Order` terms against the expiry's `tick_size`,
+ * recovering raw strikes from order ticks only at the pricing/settlement boundary.
+ * It owns the payout-liability view of the active contracts used for cash backing.
+ * Order accounting is static and needs no clock: a winning order pays its full
+ * quantity. Expiry-market cash custody, account positions, and payout movement
+ * stay outside this module.
+ */
+
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { U64 } from '../../bcs/integers.js';
+import * as strike_exposure_config from './strike_exposure_config.js';
+import * as strike_payout_tree from './strike_payout_tree.js';
+import * as order from './order.js';
+const $moduleName = '@local-pkg/deepbook_predict::strike_exposure';
+export const StrikeExposure = new MoveStruct({
+	name: `${$moduleName}::StrikeExposure`,
+	fields: {
+		/** Expiry market that owns this exposure book. */
+		expiry_market_id: bcs.Address,
+		/** Raw-price-per-tick conversion factor; `raw_strike = tick * tick_size`. */
+		tick_size: U64,
+		/** Coarser raw-price step that new finite mint boundaries must align to. */
+		admission_tick_size: U64,
+		/** Exact Propbook Pyth source timestamp used to derive the reference tick. */
+		reference_tick_source_timestamp_ms: U64,
+		/** Reference fine-grid tick that may bypass the coarser admission grid once set. */
+		reference_tick: bcs.option(U64),
+		/** 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
+		 * snapshotted maximum pool allocation: a risk-capacity parameter, not live pool
+		 * equity, so LP flows cannot reprice an existing book.
+		 */
+		inventory_impact_scale: U64,
+		next_order_sequence: U64,
+		/** Terminal settlement price once the exposure has entered its settled phase. */
+		settlement_price: bcs.option(U64),
+		/** Remaining payout liability in the settled phase. */
+		settled_payout_liability: U64,
+		/** Sparse payout tree for live cash backing and settled liability. */
+		payout: strike_payout_tree.StrikePayoutTree,
+	},
+});
+export const MintTerms = new MoveStruct({
+	name: `${$moduleName}::MintTerms`,
+	fields: {
+		expiry_market_id: bcs.Address,
+		lower_tick: U64,
+		higher_tick: U64,
+		quantity: U64,
+		entry_probability: U64,
+		premium: U64,
+		/** Separate inventory-impact charge, sampled against the pre-mint book. */
+		inventory_impact_charge: U64,
+	},
+});
+export const LiveCloseTerms = new MoveStruct({
+	name: `${$moduleName}::LiveCloseTerms`,
+	fields: {
+		expiry_market_id: bcs.Address,
+		order: order.Order,
+		close_quantity: U64,
+		redeem_amount: U64,
+		range_probability: U64,
+		/** Separate inventory-impact rebate, sampled against the pre-close book. */
+		inventory_impact_rebate: U64,
+	},
+});

package/src/contracts/deepbook_predict/strike_exposure_config.ts

@@ -0,0 +1,46 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Stored strike-exposure policy config.
+ *
+ * ProtocolConfig owns the current global template. Each StrikeExposure stores a
+ * snapshot initialized from that template, so later admin updates do not reprice
+ * active markets. Fee policy lives here because fees consume prices but are not
+ * themselves contract probability.
+ */
+
+import { MoveStruct } from '../utils/index.js';
+import { U64 } from '../../bcs/integers.js';
+const $moduleName = '@local-pkg/deepbook_predict::strike_exposure_config';
+export const StrikeExposureConfig = new MoveStruct({
+	name: `${$moduleName}::StrikeExposureConfig`,
+	fields: {
+		/**
+		 * Fraction of the disjoint-book backing gap reserved for early exits. A value of
+		 * 1.0 reserves the full gap.
+		 */
+		backing_buffer_lambda: U64,
+		/**
+		 * Base fee multiplier for Bernoulli scaling. Effective base fee = base_fee *
+		 * sqrt(price * (1 - price)).
+		 */
+		base_fee: U64,
+		/** Minimum per-unit fee floor; live trade fees never go below this value. */
+		min_fee: U64,
+		/** Minimum raw entry probability allowed for mint admission. */
+		min_entry_probability: U64,
+		/** Maximum raw entry probability allowed for mint admission. */
+		max_entry_probability: U64,
+		/** Window before expiry over which trade fees ramp up. */
+		expiry_fee_window_ms: U64,
+		/** Fee multiplier reached at expiry, in FLOAT_SCALING; 1x disables the ramp. */
+		expiry_fee_max_multiplier: U64,
+		/**
+		 * Maximum marginal rate of the path-independent inventory-impact curve, in
+		 * FLOAT_SCALING. `0` disables both charges and rebates.
+		 */
+		inventory_impact_max_rate: U64,
+	},
+});

package/src/contracts/deepbook_predict/strike_payout_tree.ts

@@ -0,0 +1,89 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Sparse strike exposure index for payout-liability accounting.
+ *
+ * The tree keys finite interval boundaries by absolute tick, matching the tick
+ * pair packed into the durable order ID. Raw strikes are recovered only at the
+ * pricing/settlement boundary, where callers pass the owning market's `tick_size`
+ * (`raw_strike = tick * tick_size`); the tree stores no grid geometry.
+ *
+ * This height-balanced (AVL) tree stores finite interval boundaries touched by
+ * positions. Boundary ticks are caller-chosen, so the balancing rule must not read
+ * 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.
+ *
+ * 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.
+ */
+
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { U64 } from '../../bcs/integers.js';
+import * as table from './deps/sui/table.js';
+const $moduleName = '@local-pkg/deepbook_predict::strike_payout_tree';
+export const StrikePayoutTree = new MoveStruct({
+	name: `${$moduleName}::StrikePayoutTree`,
+	fields: {
+		root: bcs.option(U64),
+		nodes: table.Table,
+		node_count: U64,
+		/**
+		 * Aggregate order quantity over the open-lower prefix, which is also its aggregate
+		 * settled payout.
+		 */
+		base: U64,
+	},
+});
+export const PayoutSummary = new MoveStruct({
+	name: `${$moduleName}::PayoutSummary`,
+	fields: {
+		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.
+		 */
+		max_payout_prefix_gain: U64,
+	},
+});
+export const PayoutNode = new MoveStruct({
+	name: `${$moduleName}::PayoutNode`,
+	fields: {
+		/**
+		 * Longest root-to-leaf path in this subtree, counting this node. A leaf is 1; an
+		 * absent child is 0. Maintained by `resummarize` alongside `summary`, and read
+		 * only by `rebalance` — never by a caller, and never derived from a tick.
+		 */
+		height: U64,
+		left: bcs.option(U64),
+		right: bcs.option(U64),
+		/**
+		 * This node's own boundary terms, stored so the subtree `summary` can be
+		 * recomputed without deriving locals by subtracting child summaries.
+		 */
+		local_start: U64,
+		local_end: U64,
+		summary: PayoutSummary,
+	},
+});

package/src/contracts/deepbook_predict/vault_events.ts

@@ -0,0 +1,222 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Pool-vault events for expiry cash and profit, fee incentives, and the queued LP
+ * request lifecycle. A flush records the frozen pool mark used by fills.
+ */
+
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { U64 } from '../../bcs/integers.js';
+const $moduleName = '@local-pkg/deepbook_predict::vault_events';
+export const ExpiryCashReceived = new MoveStruct({
+	name: `${$moduleName}::ExpiryCashReceived`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		expiry_market_id: bcs.Address,
+		settlement_price: U64,
+		amount: U64,
+	},
+});
+export const ExpiryCashRebalanced = new MoveStruct({
+	name: `${$moduleName}::ExpiryCashRebalanced`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		expiry_market_id: bcs.Address,
+		amount: U64,
+		to_expiry: bcs.bool(),
+		target_cash: U64,
+		protocol_profit_realized: U64,
+	},
+});
+export const ExpiryProfitMaterialized = new MoveStruct({
+	name: `${$moduleName}::ExpiryProfitMaterialized`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		expiry_market_id: bcs.Address,
+		lp_profit: U64,
+		protocol_profit: U64,
+		protocol_reserve_balance_after: U64,
+		profit_basis_after: U64,
+		pending_protocol_profit_after: U64,
+	},
+});
+export const SupplyRequested = new MoveStruct({
+	name: `${$moduleName}::SupplyRequested`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		account_id: bcs.Address,
+		recipient: bcs.Address,
+		index: U64,
+		amount: U64,
+		min_plp_out: U64,
+		requests_pending_after: U64,
+	},
+});
+export const WithdrawRequested = new MoveStruct({
+	name: `${$moduleName}::WithdrawRequested`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		account_id: bcs.Address,
+		recipient: bcs.Address,
+		index: U64,
+		amount: U64,
+		min_dusdc_out: U64,
+		requests_pending_after: U64,
+	},
+});
+export const RequestCancelled = new MoveStruct({
+	name: `${$moduleName}::RequestCancelled`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		account_id: bcs.Address,
+		recipient: bcs.Address,
+		index: U64,
+		amount: U64,
+		is_supply: bcs.bool(),
+		/**
+		 * 0=user, 1=non-executable frozen mark, 2=quote below the request's minimum
+		 * output.
+		 */
+		reason: bcs.u8(),
+		requests_pending_after: U64,
+	},
+});
+export const RequestLimitMissed = new MoveStruct({
+	name: `${$moduleName}::RequestLimitMissed`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		account_id: bcs.Address,
+		recipient: bcs.Address,
+		index: U64,
+		amount: U64,
+		is_supply: bcs.bool(),
+		quoted_output: U64,
+		min_output: U64,
+		missed_flushes: U64,
+		max_misses: U64,
+	},
+});
+export const SupplyFilled = new MoveStruct({
+	name: `${$moduleName}::SupplyFilled`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		account_id: bcs.Address,
+		recipient: bcs.Address,
+		index: U64,
+		/**
+		 * DUSDC 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`.
+		 */
+		dusdc_amount: U64,
+		shares_minted: U64,
+		/** Supply fee withheld from `dusdc_amount` and retained by the pool. */
+		fee_dusdc: 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.
+		 */
+		dusdc_remaining: U64,
+		requests_pending_after: U64,
+	},
+});
+export const WithdrawFilled = new MoveStruct({
+	name: `${$moduleName}::WithdrawFilled`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		account_id: bcs.Address,
+		recipient: bcs.Address,
+		index: U64,
+		shares_burned: U64,
+		/**
+		 * Net DUSDC delivered to `recipient`. The gross marked value of `shares_burned`
+		 * was `dusdc_amount + fee_dusdc`.
+		 */
+		dusdc_amount: U64,
+		/** Withdraw fee withheld from the payout and retained by the pool. */
+		fee_dusdc: 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
+		 * amount the request carried into this flush.
+		 */
+		shares_remaining: U64,
+		requests_pending_after: U64,
+	},
+});
+export const FlushExecuted = new MoveStruct({
+	name: `${$moduleName}::FlushExecuted`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		epoch: U64,
+		/**
+		 * LP-attributable pool NAV every fill was priced at: idle plus
+		 * `active_market_nav`, excluding unrealized and pending protocol profit.
+		 */
+		pool_value: U64,
+		/** PLP supply in the frozen pre-drain mark used to price every fill. */
+		total_supply: U64,
+		/**
+		 * Supply-leg fee rate in FLOAT_SCALING, frozen with the mark and charged on every
+		 * supply fill in this flush.
+		 */
+		supply_fee_rate: U64,
+		/** Withdraw-leg fee rate in FLOAT_SCALING, frozen alongside it. */
+		withdraw_fee_rate: U64,
+		/**
+		 * Sum of the marked NAV contributed by each active market; settled markets add
+		 * zero.
+		 */
+		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. */
+		idle_balance_before: 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,
+	},
+});
+export const CapitalLocked = new MoveStruct({
+	name: `${$moduleName}::CapitalLocked`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		amount: U64,
+	},
+});
+export const FeeIncentivesSponsored = new MoveStruct({
+	name: `${$moduleName}::FeeIncentivesSponsored`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		sponsor: bcs.Address,
+		amount: U64,
+		reserve_after: U64,
+	},
+});
+export const FeeIncentivesAllocated = new MoveStruct({
+	name: `${$moduleName}::FeeIncentivesAllocated`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		expiry_market_id: bcs.Address,
+		amount: U64,
+		pool_reserve_after: U64,
+		expiry_incentive_balance_after: U64,
+		expiry_incentives_allocated_after: U64,
+	},
+});
+export const FeeIncentivesReturned = new MoveStruct({
+	name: `${$moduleName}::FeeIncentivesReturned`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		expiry_market_id: bcs.Address,
+		amount: U64,
+		pool_reserve_after: U64,
+	},
+});

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

@@ -0,0 +1,8 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type ConfigValue } from '../utils/index.js';
+export interface DeepbookSessionsConfig {
+	sessionsPackageId?: string;
+	sessionsConfig: ConfigValue;
+}

package/src/contracts/deepbook_sessions/deps/sui/vec_map.ts

@@ -0,0 +1,33 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {
+	return new MoveStruct({
+		name: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,
+		fields: {
+			key: typeParameters[0],
+			value: typeParameters[1],
+		},
+	});
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {
+	return new MoveStruct({
+		name: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,
+		fields: {
+			contents: bcs.vector(Entry(typeParameters[0], typeParameters[1])),
+		},
+	});
+}

package/src/contracts/deepbook_sessions/session_config.ts

@@ -0,0 +1,130 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/** Owns the Sessions package version floor and the authority that advances it. */
+
+import {
+	MoveStruct,
+	normalizeMoveArguments,
+	type RawTransactionArgument,
+	type ConfigValue,
+} from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { U64 } from '../../bcs/integers.js';
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/deepbook_sessions::session_config';
+export const SessionsConfig = new MoveStruct({
+	name: `${$moduleName}::SessionsConfig`,
+	fields: {
+		id: bcs.Address,
+		version_watermark: U64,
+	},
+});
+export const SessionsAdminCap = new MoveStruct({
+	name: `${$moduleName}::SessionsAdminCap`,
+	fields: {
+		id: bcs.Address,
+	},
+});
+export interface IdArguments {
+	config?: RawTransactionArgument<string>;
+}
+export interface IdOptions {
+	package?: string;
+	arguments?: IdArguments;
+	config?: {
+		sessionsConfig: ConfigValue;
+		sessionsPackageId?: string;
+	};
+}
+/** Return the config object ID for external PTB construction. */
+export function id(options: IdOptions) {
+	const packageAddress =
+		options.package ?? options.config?.sessionsPackageId ?? '@local-pkg/deepbook_sessions';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['config'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'session_config',
+			function: 'id',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					config: options.arguments?.config ?? options.config?.sessionsConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface VersionWatermarkArguments {
+	config?: RawTransactionArgument<string>;
+}
+export interface VersionWatermarkOptions {
+	package?: string;
+	arguments?: VersionWatermarkArguments;
+	config?: {
+		sessionsConfig: ConfigValue;
+		sessionsPackageId?: string;
+	};
+}
+/** Return the minimum Sessions package version accepted by gated entrypoints. */
+export function versionWatermark(options: VersionWatermarkOptions) {
+	const packageAddress =
+		options.package ?? options.config?.sessionsPackageId ?? '@local-pkg/deepbook_sessions';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['config'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'session_config',
+			function: 'version_watermark',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					config: options.arguments?.config ?? options.config?.sessionsConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface BumpVersionWatermarkArguments {
+	config?: RawTransactionArgument<string>;
+	AdminCap: RawTransactionArgument<string>;
+}
+export interface BumpVersionWatermarkOptions {
+	package?: string;
+	arguments: BumpVersionWatermarkArguments;
+	config?: {
+		sessionsConfig: ConfigValue;
+		sessionsPackageId?: string;
+	};
+}
+/**
+ * Advance the version floor to this package's compiled-in version. This is ungated
+ * so an upgraded package can retire older versions, and it cannot accept a
+ * caller-selected target.
+ */
+export function bumpVersionWatermark(options: BumpVersionWatermarkOptions) {
+	const packageAddress =
+		options.package ?? options.config?.sessionsPackageId ?? '@local-pkg/deepbook_sessions';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['config', 'AdminCap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'session_config',
+			function: 'bump_version_watermark',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					config: options.arguments?.config ?? options.config?.sessionsConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}