@mysten/deepbook-v3 2.6.4 → 2.8.0

package/src/contracts/deepbook_predict_orders/delayed_execution_config.ts

@@ -0,0 +1,430 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Admin-tunable policy for delayed execution: the timing, capacity, fee, and
+ * settlement-batch settings that queued mints and early sells run under.
+ *
+ * A leaf module, so `queue_events` can embed the policy and `desk` can store it.
+ * It owns the struct, its launch defaults, the field getters, and the package
+ * setters with every bound: each field's own range, the relational timing rules,
+ * and the per-account cap against the capacities. Predict caps what admission
+ * accepts on its side (`constants::max_svi_max_age_ms` and the deadline margin),
+ * and these bounds stay inside it.
+ */
+
+import { MoveStruct, normalizeMoveArguments } from '../utils/index.js';
+import { U64 } from '../../bcs/integers.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/deepbook_predict_orders::delayed_execution_config';
+export const DelayedExecutionPolicy = new MoveStruct({
+	name: `${$moduleName}::DelayedExecutionPolicy`,
+	fields: {
+		/**
+		 * Latest τ may fall after placement. τ rounds down to the policy channel's tick at
+		 * or before `t₀ + delay_ms`.
+		 */
+		delay_ms: U64,
+		/**
+		 * Sets each order's deadline:
+		 * `max(min(τ + stall_timeout_ms, expiry), last  deadline)`. At or past it the
+		 * order is refunded, never filled.
+		 */
+		stall_timeout_ms: U64,
+		/**
+		 * Placement refuses new orders while an uncommitted cohort is this far past its τ
+		 * with nothing newer committed, or while two or more uncommitted cohorts are each
+		 * this far past their τ.
+		 */
+		stuck_threshold_ms: U64,
+		/** Commit accepts a backup tick for a cohort only once now is this far past its τ. */
+		gap_wait_ms: U64,
+		/**
+		 * Switches the backup tick on or off. `0` accepts only the update stamped exactly
+		 * τ. Above `0`, once now is `gap_wait_ms` past τ, a cohort also accepts its single
+		 * backup: the update stamped one tick of its own stored channel after τ. The value
+		 * is not a window: the setter keeps it at `0` or one tick of the policy channel.
+		 */
+		pyth_price_buffer_ms: U64,
+		/**
+		 * Pyth Lazer channel new orders are priced on: `2` (`fixed_rate@50ms`) or `3`
+		 * (`fixed_rate@200ms`). Its tick period is τ's grid. Each order stores the channel
+		 * it was placed under.
+		 */
+		pyth_channel: bcs.u8(),
+		/**
+		 * Oldest Block Scholes SVI a placement accepts into an order's volatility
+		 * snapshot.
+		 */
+		svi_max_age_ms: U64,
+		/** Most unfinished queued mints per market. */
+		mint_capacity: U64,
+		/** Most unfinished queued sells per market. */
+		sell_capacity: U64,
+		/** Most unfinished queued orders per account per market. */
+		per_account_cap: U64,
+		/**
+		 * Flat fee charged at placement. Kept on a fill and on limit or admission refunds;
+		 * returned on every other refund.
+		 */
+		order_fee: U64,
+		/** Smallest early-sell close quantity. */
+		min_sell_quantity: U64,
+		/** Most records one `settle_step` call visits while refunding leftover orders. */
+		settle_refund_batch: U64,
+		/** Most records one `settle_step` call visits while paying Open records. */
+		settle_payout_batch: U64,
+	},
+});
+export interface DelayMsArguments {
+	policy: TransactionArgument;
+}
+export interface DelayMsOptions {
+	package?: string;
+	arguments: DelayMsArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function delayMs(options: DelayMsOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'delay_ms',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface StallTimeoutMsArguments {
+	policy: TransactionArgument;
+}
+export interface StallTimeoutMsOptions {
+	package?: string;
+	arguments: StallTimeoutMsArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function stallTimeoutMs(options: StallTimeoutMsOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'stall_timeout_ms',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface StuckThresholdMsArguments {
+	policy: TransactionArgument;
+}
+export interface StuckThresholdMsOptions {
+	package?: string;
+	arguments: StuckThresholdMsArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function stuckThresholdMs(options: StuckThresholdMsOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'stuck_threshold_ms',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface GapWaitMsArguments {
+	policy: TransactionArgument;
+}
+export interface GapWaitMsOptions {
+	package?: string;
+	arguments: GapWaitMsArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function gapWaitMs(options: GapWaitMsOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'gap_wait_ms',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface PythPriceBufferMsArguments {
+	policy: TransactionArgument;
+}
+export interface PythPriceBufferMsOptions {
+	package?: string;
+	arguments: PythPriceBufferMsArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function pythPriceBufferMs(options: PythPriceBufferMsOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'pyth_price_buffer_ms',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface PythChannelArguments {
+	policy: TransactionArgument;
+}
+export interface PythChannelOptions {
+	package?: string;
+	arguments: PythChannelArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function pythChannel(options: PythChannelOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'pyth_channel',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface SviMaxAgeMsArguments {
+	policy: TransactionArgument;
+}
+export interface SviMaxAgeMsOptions {
+	package?: string;
+	arguments: SviMaxAgeMsArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function sviMaxAgeMs(options: SviMaxAgeMsOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'svi_max_age_ms',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface MintCapacityArguments {
+	policy: TransactionArgument;
+}
+export interface MintCapacityOptions {
+	package?: string;
+	arguments: MintCapacityArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function mintCapacity(options: MintCapacityOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'mint_capacity',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface SellCapacityArguments {
+	policy: TransactionArgument;
+}
+export interface SellCapacityOptions {
+	package?: string;
+	arguments: SellCapacityArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function sellCapacity(options: SellCapacityOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'sell_capacity',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface PerAccountCapArguments {
+	policy: TransactionArgument;
+}
+export interface PerAccountCapOptions {
+	package?: string;
+	arguments: PerAccountCapArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function perAccountCap(options: PerAccountCapOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'per_account_cap',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface OrderFeeArguments {
+	policy: TransactionArgument;
+}
+export interface OrderFeeOptions {
+	package?: string;
+	arguments: OrderFeeArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function orderFee(options: OrderFeeOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'order_fee',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface MinSellQuantityArguments {
+	policy: TransactionArgument;
+}
+export interface MinSellQuantityOptions {
+	package?: string;
+	arguments: MinSellQuantityArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function minSellQuantity(options: MinSellQuantityOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'min_sell_quantity',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface SettleRefundBatchArguments {
+	policy: TransactionArgument;
+}
+export interface SettleRefundBatchOptions {
+	package?: string;
+	arguments: SettleRefundBatchArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function settleRefundBatch(options: SettleRefundBatchOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'settle_refund_batch',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface SettlePayoutBatchArguments {
+	policy: TransactionArgument;
+}
+export interface SettlePayoutBatchOptions {
+	package?: string;
+	arguments: SettlePayoutBatchArguments | [policy: TransactionArgument];
+	config?: {
+		predictOrdersPackageId?: string;
+	};
+}
+export function settlePayoutBatch(options: SettlePayoutBatchOptions) {
+	const packageAddress =
+		options.package ??
+		options.config?.predictOrdersPackageId ??
+		'@local-pkg/deepbook_predict_orders';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['policy'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'delayed_execution_config',
+			function: 'settle_payout_batch',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}

package/src/contracts/deepbook_predict_orders/deps/deepbook_predict/expiry_market.ts

@@ -0,0 +1,108 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Per-expiry Predict market.
+ *
+ * An ExpiryMarket is the hot shared object for one expiry. It owns trade
+ * execution, strike exposure state, and an embedded expiry-cash custody component,
+ * plus local sponsor-funded fee incentives. Live oracle validation is delegated to
+ * `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 } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { U64, U256 } from '../../../../bcs/integers.js';
+import * as pricing from './pricing.js';
+const $moduleName = 'deepbook_predict::expiry_market';
+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,
+	},
+});

package/src/contracts/deepbook_predict_orders/deps/deepbook_predict/pricing.ts

@@ -0,0 +1,58 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Pricing for Predict markets.
+ *
+ * This module reads canonical Propbook Pyth and Block Scholes feeds and computes
+ * SVI-adjusted digital probabilities. Live reads require fresh, pricing-safe Block
+ * Scholes spot, forward, and SVI observations. The latest forward is paired with
+ * an exact source-timestamp spot from Propbook's bounded recent history. The live
+ * forward comes from one of two admin-selected sources
+ * (`PricingConfig.use_pyth_spot_for_forward`): a fresh positive Pyth spot carrying
+ * the Block Scholes basis, or the Block Scholes forward directly. A load falls
+ * back to the Block Scholes forward when the selected Pyth spot is stale or
+ * unavailable; valuation prices on that fallback, while every live trade (mints,
+ * mint quotes, and live redeems) refuses it through `assert_pyth_spot_fresh`.
+ * Exact-history reads do not apply live freshness policy.
+ *
+ * Delayed execution splits that read in two. `load_vol` validates the same live
+ * inputs when an order is admitted and returns the raw Block Scholes basis and SVI
+ * its receipt stores; `pricer_at` later rebuilds a `Pricer` from them at the
+ * order's committed Pyth tick. The `try_*` reads price exactly as `up_price` and
+ * `range_price` do, and return `none` where those abort, so an order-flow fill
+ * never aborts on a surface.
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { U64 } from '../../../../bcs/integers.js';
+import * as i64 from '../fixed_math/i64.js';
+const $moduleName = 'deepbook_predict::pricing';
+export const VolSnapshot = new MoveStruct({
+	name: `${$moduleName}::VolSnapshot`,
+	fields: {
+		/**
+		 * Canonical Propbook Pyth source for the market's underlying; commit finds this
+		 * feed in each Lazer update.
+		 */
+		pyth_source_id: bcs.u32(),
+		/** The matched Block Scholes spot and forward, narrowed to Predict's width. */
+		bs_spot: U64,
+		bs_forward: U64,
+		/** Raw SVI parameters before roll-down, at 1e9. */
+		svi_a: i64.I64,
+		svi_b: U64,
+		svi_rho: i64.I64,
+		svi_m: i64.I64,
+		svi_sigma: U64,
+		/**
+		 * Provider source timestamps of the three reads. The SVI one is also the roll-down
+		 * anchor.
+		 */
+		bs_spot_source_timestamp_ms: U64,
+		bs_forward_source_timestamp_ms: U64,
+		svi_source_timestamp_ms: U64,
+	},
+});

package/src/contracts/deepbook_predict_orders/deps/fixed_math/i64.ts

@@ -0,0 +1,21 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Signed integers represented by a `u64` magnitude and a canonical nonnegative
+ * zero. Scaled multiplication and division use 1e9 fixed point and truncate the
+ * result's magnitude toward zero.
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { U64 } from '../../../../bcs/integers.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'fixed_math::i64';
+export const I64 = new MoveStruct({
+	name: `${$moduleName}::I64`,
+	fields: {
+		magnitude: U64,
+		is_negative: bcs.bool(),
+	},
+});

package/src/contracts/deepbook_predict_orders/deps/sui/balance.ts

@@ -0,0 +1,19 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A storable handler for Balances in general. Is used in the `Coin` module to
+ * allow balance operations and can be used to implement custom coins with `Supply`
+ * and `Balance`s.
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { U64 } from '../../../../bcs/integers.js';
+const $moduleName = '0x2::balance';
+export const Balance = new MoveStruct({
+	name: `${$moduleName}::Balance<phantom T>`,
+	fields: {
+		value: U64,
+	},
+});

package/src/contracts/deepbook_predict_orders/deps/sui/table.ts

@@ -0,0 +1,37 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A table is a map-like collection. But unlike a traditional collection, it's keys
+ * and values are not stored within the `Table` value, but instead are stored using
+ * Sui's object system. The `Table` struct acts only as a handle into the object
+ * system to retrieve those keys and values. Note that this means that `Table`
+ * values with exactly the same key-value mapping will not be equal, with `==`, at
+ * runtime. For example
+ *
+ * ```
+ * let table1 = table::new<u64, bool>();
+ * let table2 = table::new<u64, bool>();
+ * table::add(&mut table1, 0, false);
+ * table::add(&mut table1, 1, true);
+ * table::add(&mut table2, 0, false);
+ * table::add(&mut table2, 1, true);
+ * // table1 does not equal table2, despite having the same entries
+ * assert!(&table1 != &table2);
+ * ```
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { U64 } from '../../../../bcs/integers.js';
+const $moduleName = '0x2::table';
+export const Table = new MoveStruct({
+	name: `${$moduleName}::Table<phantom K, phantom V>`,
+	fields: {
+		/** the ID of this table */
+		id: bcs.Address,
+		/** the number of key-value pairs in the table */
+		size: U64,
+	},
+});