@mysten/deepbook-v3 2.0.1 → 2.1.4

package/src/contracts/deepbook_predict/plp.ts

@@ -0,0 +1,987 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * PLP token and pool vault.
+ *
+ * PoolVault owns the PLP treasury cap, idle DUSDC, the protocol reserve,
+ * sponsor-funded fee incentives, per-expiry cash accounting, and the queued LP
+ * supply/withdraw requests. It coordinates the full-pool NAV valuation (a
+ * hot-potato aggregation over every active market) and the unified per-market cash
+ * flow (initial funding, live rebalance/sweep, and settled-market sweep with
+ * terminal profit materialization). LPs queue supply/withdraw requests routed
+ * through a loaded Account; each flush (`finish_flush`) drains them at the frozen
+ * pool NAV, minting/burning PLP and delivering fills to each account via the
+ * balance accumulator.
+ */
+
+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, type TransactionArgument } from '@mysten/sui/transactions';
+import * as balance from './deps/sui/balance.js';
+import * as lp_book from './lp_book.js';
+import * as pool_accounting from './pool_accounting.js';
+const $moduleName = '@local-pkg/deepbook_predict::plp';
+export const PLP = new MoveStruct({
+	name: `${$moduleName}::PLP`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
+export const PoolVault = new MoveStruct({
+	name: `${$moduleName}::PoolVault`,
+	fields: {
+		id: bcs.Address,
+		/**
+		 * Protocol-owned DUSDC excluded from PLP redemption. No package entrypoint
+		 * withdraws this balance.
+		 */
+		protocol_reserve_balance: balance.Balance,
+		/** Sponsor-funded DUSDC reserved for taker fee sponsorship, excluded from PLP NAV. */
+		fee_incentive_reserve: balance.Balance,
+		/** PLP share issuance plus queued supply/withdraw escrow. */
+		lp: lp_book.LpBook,
+		/** Idle DUSDC custody, registered expiries, and per-expiry cash-flow rows. */
+		expiry_accounting: pool_accounting.Ledger,
+	},
+});
+export const PoolValuation = new MoveStruct({
+	name: `${$moduleName}::PoolValuation`,
+	fields: {
+		pool_vault_id: bcs.Address,
+		/** Active expiry markets snapshotted at start; every one must be valued. */
+		expected_expiry_markets: bcs.vector(bcs.Address),
+		/** Markets valued so far this flow; folded against `expected` at finish. */
+		valued_expiry_markets: bcs.vector(bcs.Address),
+		/** Running Σ of each valued market's NAV (settled markets contribute 0). */
+		total_nav: U64,
+	},
+});
+export interface IdArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface IdOptions {
+	package?: string;
+	arguments?: IdArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return the pool vault object ID for external discovery and PTB construction. */
+export function id(options: IdOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'id',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface IdleBalanceArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface IdleBalanceOptions {
+	package?: string;
+	arguments?: IdleBalanceArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return idle DUSDC for SDK and devInspect state reads. */
+export function idleBalance(options: IdleBalanceOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'idle_balance',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface ProtocolReserveBalanceArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface ProtocolReserveBalanceOptions {
+	package?: string;
+	arguments?: ProtocolReserveBalanceArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return protocol-owned DUSDC for SDK and devInspect state reads. */
+export function protocolReserveBalance(options: ProtocolReserveBalanceOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'protocol_reserve_balance',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface FeeIncentiveReserveArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface FeeIncentiveReserveOptions {
+	package?: string;
+	arguments?: FeeIncentiveReserveArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return sponsor-funded fee reserves for SDK and devInspect state reads. */
+export function feeIncentiveReserve(options: FeeIncentiveReserveOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'fee_incentive_reserve',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface PlpTotalSupplyArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface PlpTotalSupplyOptions {
+	package?: string;
+	arguments?: PlpTotalSupplyArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return total PLP supply for SDK and devInspect state reads. */
+export function plpTotalSupply(options: PlpTotalSupplyOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'plp_total_supply',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface SupplyRequestsPendingArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface SupplyRequestsPendingOptions {
+	package?: string;
+	arguments?: SupplyRequestsPendingArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return pending LP supply count for SDK and devInspect queue reads. */
+export function supplyRequestsPending(options: SupplyRequestsPendingOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'supply_requests_pending',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface WithdrawRequestsPendingArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface WithdrawRequestsPendingOptions {
+	package?: string;
+	arguments?: WithdrawRequestsPendingArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return pending LP withdrawal count for SDK and devInspect queue reads. */
+export function withdrawRequestsPending(options: WithdrawRequestsPendingOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'withdraw_requests_pending',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface ActiveExpiryMarketsArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface ActiveExpiryMarketsOptions {
+	package?: string;
+	arguments?: ActiveExpiryMarketsArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return active expiry IDs for external PTB construction and pool inspection. */
+export function activeExpiryMarkets(options: ActiveExpiryMarketsOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'active_expiry_markets',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface ActiveLiveExpiryCountArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface ActiveLiveExpiryCountOptions {
+	package?: string;
+	arguments?: ActiveLiveExpiryCountArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return the pre-expiry active count for SDK and devInspect capacity reads. */
+export function activeLiveExpiryCount(options: ActiveLiveExpiryCountOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null, '0x2::clock::Clock'] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'active_live_expiry_count',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface ProfitBasisDebitsArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface ProfitBasisDebitsOptions {
+	package?: string;
+	arguments?: ProfitBasisDebitsArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return the profit-basis debits for external accounting observability. */
+export function profitBasisDebits(options: ProfitBasisDebitsOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'profit_basis_debits',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface ProfitBasisCreditsArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface ProfitBasisCreditsOptions {
+	package?: string;
+	arguments?: ProfitBasisCreditsArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return the profit-basis credits for external accounting observability. */
+export function profitBasisCredits(options: ProfitBasisCreditsOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'profit_basis_credits',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface PendingProtocolProfitArguments {
+	vault?: RawTransactionArgument<string>;
+}
+export interface PendingProtocolProfitOptions {
+	package?: string;
+	arguments?: PendingProtocolProfitArguments;
+	config?: {
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/** Return deferred protocol profit for external accounting observability. */
+export function pendingProtocolProfit(options: PendingProtocolProfitOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['vault'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'pending_protocol_profit',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface StartPoolValuationArguments {
+	config?: RawTransactionArgument<string>;
+	vault?: RawTransactionArgument<string>;
+	lifecycleProof: TransactionArgument;
+}
+export interface StartPoolValuationOptions {
+	package?: string;
+	arguments: StartPoolValuationArguments;
+	config?: {
+		protocolConfig: ConfigValue;
+		poolVault: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Begin a full-pool valuation using a registry-issued lifecycle proof. The proof
+ * grants control over when current oracle state is frozen for queued LP fills.
+ * Starting engages the transaction-local valuation lock and snapshots every active
+ * expiry that must be included before the queues can drain.
+ */
+export function startPoolValuation(options: StartPoolValuationOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null, null, null] satisfies (string | null)[];
+	const parameterNames = ['config', 'vault', 'lifecycleProof'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'start_pool_valuation',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface ValueExpiryArguments {
+	valuation: TransactionArgument;
+	vault?: RawTransactionArgument<string>;
+	market: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+	propbookRegistry?: RawTransactionArgument<string>;
+	pyth: RawTransactionArgument<string>;
+	bsValues: RawTransactionArgument<string>;
+	bsSvi: RawTransactionArgument<string>;
+}
+export interface ValueExpiryOptions {
+	package?: string;
+	arguments: ValueExpiryArguments;
+	config?: {
+		poolVault: ConfigValue;
+		protocolConfig: ConfigValue;
+		oracleRegistry: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Run the per-market cash flow for one snapshotted market, then fold its NAV into
+ * the running total. The market must be in the snapshot and not already valued. A
+ * settled market is swept (deactivated, cash returned, profit materialized) and
+ * contributes 0; a live market is rebalanced to target and valued on its current
+ * cash.
+ *
+ * Settlement is a separate PTB step through `expiry_market::try_settle`. An
+ * expired unsettled market cannot produce the live pricer required here.
+ */
+export function valueExpiry(options: ValueExpiryOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		'0x2::clock::Clock',
+	] satisfies (string | null)[];
+	const parameterNames = [
+		'valuation',
+		'vault',
+		'market',
+		'config',
+		'propbookRegistry',
+		'pyth',
+		'bsValues',
+		'bsSvi',
+	];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'value_expiry',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+					propbookRegistry: options.arguments?.propbookRegistry ?? options.config?.oracleRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface FinishFlushArguments {
+	valuation: TransactionArgument;
+	vault?: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+	supplyBudget: RawTransactionArgument<number | bigint | null>;
+	withdrawBudget: RawTransactionArgument<number | bigint | null>;
+}
+export interface FinishFlushOptions {
+	package?: string;
+	arguments: FinishFlushArguments;
+	config?: {
+		poolVault: ConfigValue;
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Finish a full-pool valuation and run the LP flush: prove every snapshotted
+ * market was valued exactly once, price the pool NAV, then drain the
+ * supply/withdraw queues at that frozen mark (mint PLP for supplies, burn PLP and
+ * pay DUSDC for withdrawals), release the valuation lock, consume the potato, and
+ * return the LP-attributable pool-wide DUSDC NAV (idle + Σ active NAV, net of the
+ * pending-protocol-profit exclusion priced from the aggregate profit basis).
+ *
+ * `supply_budget` and `withdraw_budget` bound how many requests each queue may
+ * process this flush (`None` = unbounded). Fills — whole or partial — and
+ * protocol-refunded heads — non-executable, or quoting below the request's own
+ * minimum output — all count as processed. At `ProtocolConfig`'s shipped attempt
+ * count of one, a head that misses its limit is refunded by the flush that reaches
+ * it; above one it stays queued and stops that queue for the flush. The budgets
+ * are independent, so a supply backlog does not consume withdrawal capacity.
+ *
+ * Capacity bounds each pass on top of the budgets and refunds nothing: supplies
+ * fill only up to `ProtocolConfig`'s LP pool-value cap, withdrawals only up to
+ * idle. A head larger than the room left fills to the room, spends flush budget,
+ * and keeps its remainder queued at a rescaled limit; a head with no usable room
+ * carries untouched and spends none. Either way the pass stops, so an unbounded
+ * budget does not mean every queued request is processed (RP-23).
+ *
+ * Because queueing is permissionless and a refunded request returns its escrow in
+ * the same transaction, an operator should bound both budgets in production rather
+ * than rely on queue length staying small — see RP-12.
+ */
+export function finishFlush(options: FinishFlushOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		'0x1::option::Option<u64>',
+		'0x1::option::Option<u64>',
+	] satisfies (string | null)[];
+	const parameterNames = ['valuation', 'vault', 'config', 'supplyBudget', 'withdrawBudget'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'finish_flush',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface RebalanceExpiryCashArguments {
+	vault?: RawTransactionArgument<string>;
+	market: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+}
+export interface RebalanceExpiryCashOptions {
+	package?: string;
+	arguments: RebalanceExpiryCashArguments;
+	config?: {
+		poolVault: ConfigValue;
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Move cash between pool idle liquidity and one expiry market.
+ *
+ * Permissionless and standalone: anyone may call it at any cadence. Handles all
+ * three per-market cases — initial funding of a freshly registered (unfunded)
+ * market, ongoing live rebalance/surplus-sweep toward target, and the
+ * settled-market sweep (deactivate, return all free cash, materialize profit).
+ * Call `expiry_market::try_settle` first in the same PTB when settlement may be
+ * due. An expired unsettled market is a no-op until that transition succeeds. Mint
+ * asserts backing but never pulls pool cash, so this is what makes a market
+ * mintable. The market must already be registered to this vault
+ * (`registry::create_and_share_expiry_market`). Blocked while a full-pool
+ * valuation is in progress.
+ */
+export function rebalanceExpiryCash(options: RebalanceExpiryCashOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null, null, null, '0x2::clock::Clock'] satisfies (string | null)[];
+	const parameterNames = ['vault', 'market', 'config'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'rebalance_expiry_cash',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface SponsorFeeIncentivesArguments {
+	vault?: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+	payment: RawTransactionArgument<string>;
+}
+export interface SponsorFeeIncentivesOptions {
+	package?: string;
+	arguments: SponsorFeeIncentivesArguments;
+	config?: {
+		poolVault: ConfigValue;
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Sponsor taker fee incentives with DUSDC. Anyone may contribute; the payment
+ * joins a pool-level reserve that is excluded from PLP NAV and later allocated to
+ * expiry markets by the normal rebalance flow.
+ */
+export function sponsorFeeIncentives(options: SponsorFeeIncentivesOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null, null, null] satisfies (string | null)[];
+	const parameterNames = ['vault', 'config', 'payment'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'sponsor_fee_incentives',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface LockCapitalArguments {
+	vault?: RawTransactionArgument<string>;
+	config?: RawTransactionArgument<string>;
+	AdminCap: RawTransactionArgument<string>;
+	payment: RawTransactionArgument<string>;
+}
+export interface LockCapitalOptions {
+	package?: string;
+	arguments: LockCapitalArguments;
+	config?: {
+		poolVault: ConfigValue;
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Bootstrap the pool exactly once: permanently lock `payment` DUSDC of minimum
+ * liquidity. Mints matching PLP (1:1) into the book's locked balance — never
+ * withdrawable, so the caller receives no shares — and joins the DUSDC into idle.
+ * This keeps `total_supply > 0` while the vault exists and gives rounding dust a
+ * non-withdrawable PLP holder. Requires root authority and zero existing supply.
+ * Supply, withdrawal, and flush flows remain disabled until the locked liquidity
+ * has been created.
+ */
+export function lockCapital(options: LockCapitalOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null, null, null, null] satisfies (string | null)[];
+	const parameterNames = ['vault', 'config', 'AdminCap', 'payment'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'lock_capital',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface RequestSupplyArguments {
+	vault?: RawTransactionArgument<string>;
+	wrapper: RawTransactionArgument<string>;
+	auth: TransactionArgument;
+	config?: RawTransactionArgument<string>;
+	amount: RawTransactionArgument<number | bigint>;
+	minPlpOut: RawTransactionArgument<number | bigint>;
+}
+export interface RequestSupplyOptions {
+	package?: string;
+	arguments: RequestSupplyArguments;
+	config?: {
+		poolVault: ConfigValue;
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Queue a supply request: pull `amount` DUSDC from account custody into queue
+ * escrow, recording the account's receive address as the fill recipient. The pull
+ * auto-settles any flush-delivered DUSDC first. The flush charges the protocol's
+ * supply fee — zero by default — on the DUSDC it takes in and prices shares on the
+ * remainder, so `min_plp_out` is measured after that fee. The account receives
+ * minted PLP only at a mark that mints at least `min_plp_out` for the whole
+ * `amount` — a **price floor**, not a promise of that many shares: if the pool cap
+ * leaves room for only part of the deposit, the fill is proportionally smaller at
+ * the same price and the remainder stays queued with its limit rescaled. At the
+ * shipped attempt count of one, a flush whose mark quotes less cancels and refunds
+ * the request there and then; a higher configured count lets it rest and retry
+ * that many flushes first. Returns the queue index, the handle used to cancel
+ * before the flush.
+ */
+export function requestSupply(options: RequestSupplyOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		'u64',
+		'u64',
+		'0x2::accumulator::AccumulatorRoot',
+		'0x2::clock::Clock',
+	] satisfies (string | null)[];
+	const parameterNames = ['vault', 'wrapper', 'auth', 'config', 'amount', 'minPlpOut'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'request_supply',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface RequestWithdrawArguments {
+	vault?: RawTransactionArgument<string>;
+	wrapper: RawTransactionArgument<string>;
+	auth: TransactionArgument;
+	config?: RawTransactionArgument<string>;
+	amount: RawTransactionArgument<number | bigint>;
+	minDusdcOut: RawTransactionArgument<number | bigint>;
+}
+export interface RequestWithdrawOptions {
+	package?: string;
+	arguments: RequestWithdrawArguments;
+	config?: {
+		poolVault: ConfigValue;
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Queue a withdraw request: pull `amount` PLP shares from account custody into
+ * queue escrow, recording the account's receive address as the fill recipient. The
+ * pull auto-settles any flush-delivered PLP first. The flush withholds the
+ * protocol's withdraw fee from the marked payout, so `min_dusdc_out` is measured
+ * after the fee. The account is paid only at a mark that quotes at least
+ * `min_dusdc_out` for the whole `amount` — a **price floor**, not a promise of
+ * that much DUSDC: if idle liquidity covers only part of the payout, only the
+ * shares idle affords are burned, the fill is proportionally smaller at the same
+ * price, and the remainder stays queued with its limit rescaled. At the shipped
+ * attempt count of one, a flush whose mark quotes less cancels and refunds the
+ * request there and then; a higher configured count lets it rest and retry that
+ * many flushes first. Returns the queue index used to cancel before the flush.
+ */
+export function requestWithdraw(options: RequestWithdrawOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		'u64',
+		'u64',
+		'0x2::accumulator::AccumulatorRoot',
+		'0x2::clock::Clock',
+	] satisfies (string | null)[];
+	const parameterNames = ['vault', 'wrapper', 'auth', 'config', 'amount', 'minDusdcOut'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'request_withdraw',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface CancelSupplyRequestArguments {
+	vault?: RawTransactionArgument<string>;
+	wrapper: RawTransactionArgument<string>;
+	auth: TransactionArgument;
+	config?: RawTransactionArgument<string>;
+	index: RawTransactionArgument<number | bigint>;
+}
+export interface CancelSupplyRequestOptions {
+	package?: string;
+	arguments: CancelSupplyRequestArguments;
+	config?: {
+		poolVault: ConfigValue;
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Cancel a still-pending supply request, refunding its escrowed DUSDC straight
+ * into the requesting account. `account` must be the request's recorded recipient.
+ */
+export function cancelSupplyRequest(options: CancelSupplyRequestOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		'u64',
+		'0x2::accumulator::AccumulatorRoot',
+		'0x2::clock::Clock',
+	] satisfies (string | null)[];
+	const parameterNames = ['vault', 'wrapper', 'auth', 'config', 'index'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'cancel_supply_request',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface CancelWithdrawRequestArguments {
+	vault?: RawTransactionArgument<string>;
+	wrapper: RawTransactionArgument<string>;
+	auth: TransactionArgument;
+	config?: RawTransactionArgument<string>;
+	index: RawTransactionArgument<number | bigint>;
+}
+export interface CancelWithdrawRequestOptions {
+	package?: string;
+	arguments: CancelWithdrawRequestArguments;
+	config?: {
+		poolVault: ConfigValue;
+		protocolConfig: ConfigValue;
+		predictPackageId?: string;
+	};
+}
+/**
+ * Cancel a still-pending withdraw request, refunding its escrowed PLP straight
+ * into the requesting account. `account` must be the request's recorded recipient.
+ */
+export function cancelWithdrawRequest(options: CancelWithdrawRequestOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		'u64',
+		'0x2::accumulator::AccumulatorRoot',
+		'0x2::clock::Clock',
+	] satisfies (string | null)[];
+	const parameterNames = ['vault', 'wrapper', 'auth', 'config', 'index'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'plp',
+			function: 'cancel_withdraw_request',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					vault: options.arguments?.vault ?? options.config?.poolVault,
+					config: options.arguments?.config ?? options.config?.protocolConfig,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}