@mysten/deepbook-v3 2.1.4 → 2.4.0

package/dist/contracts/deepbook_predict/plp.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plp.d.mts","names":[],"sources":["../../../src/contracts/deepbook_predict/plp.ts"],"mappings":";;;;;;;;;cAkCa,GAAA,EAAG,UAAA;eAKd,kBAAA,CAAA,OAAA;AAAA;AAAA,cACW,kBAAA,EAAkB,UAAA;eAK7B,kBAAA,CAAA,OAAA;AAAA;AAAA,cACW,aAAA,EAAa,UAAA;eAKxB,kBAAA,CAAA,OAAA;AAAA;AAAA,cACW,aAAA,EAAa,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEADxB;;EALwB;;;;;;AAM1B;;;;;;;;;;;;;;;;;;;;;;;cAuDa,SAAA,EAAS,UAAA;;;;;;;;0CAvDI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA6ET,WAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,SAAA;EAChB,OAAA;EACA,SAAA,GAAY,WAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,EAAA,CAAG,OAAA,EAAS,SAAA,IAKnB,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,oBAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,kBAAA;EAChB,OAAA;EACA,SAAA,GAAY,oBAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,WAAA,CAAY,OAAA,EAAS,kBAAA,IAK5B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,+BAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,6BAAA;EAChB,OAAA;EACA,SAAA,GAAY,+BAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,sBAAA,CAAuB,OAAA,EAAS,6BAAA,IAKvC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,4BAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,0BAAA;EAChB,OAAA;EACA,SAAA,GAAY,4BAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,mBAAA,CAAoB,OAAA,EAAS,0BAAA,IAKpC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,uBAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,qBAAA;EAChB,OAAA;EACA,SAAA,GAAY,uBAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,cAAA,CAAe,OAAA,EAAS,qBAAA,IAK/B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,8BAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,4BAAA;EAChB,OAAA;EACA,SAAA,GAAY,8BAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,qBAAA,CAAsB,OAAA,EAAS,4BAAA,IAKtC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,gCAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,8BAAA;EAChB,OAAA;EACA,SAAA,GAAY,gCAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,uBAAA,CAAwB,OAAA,EAAS,8BAAA,IAKxC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,4BAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,0BAAA;EAChB,OAAA;EACA,SAAA,GAAY,4BAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,mBAAA,CAAoB,OAAA,EAAS,0BAAA,IAKpC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,8BAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,4BAAA;EAChB,OAAA;EACA,SAAA,GAAY,8BAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,qBAAA,CAAsB,OAAA,EAAS,4BAAA,IAKtC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,0BAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,wBAAA;EAChB,OAAA;EACA,SAAA,GAAY,0BAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,iBAAA,CAAkB,OAAA,EAAS,wBAAA,IAKlC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,2BAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,yBAAA;EAChB,OAAA;EACA,SAAA,GAAY,2BAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,kBAAA,CAAmB,OAAA,EAAS,yBAAA,IAKnC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,8BAAA;EAChB,KAAA,GAAQ,sBAAA;AAAA;AAAA,UAEQ,4BAAA;EAChB,OAAA;EACA,SAAA,GAAY,8BAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;iBAIc,qBAAA,CAAsB,OAAA,EAAS,4BAAA,IAKtC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAeP,2BAAA;EAChB,MAAA,GAAS,sBAAA;EACT,KAAA,GAAQ,sBAAA;EACR,cAAA,EAAgB,mBAAA;EAChB,YAAA,EAAc,sBAAA;EACd,cAAA,EAAgB,sBAAA;AAAA;AAAA,UAEA,yBAAA;EAChB,OAAA;EACA,SAAA,EAAW,2BAAA;EACX,MAAA;IACC,cAAA,EAAgB,WAAA;IAChB,SAAA,EAAW,WAAA;IACX,gBAAA;EAAA;AAAA;;;;;;;;;iBAWc,kBAAA,CAAmB,OAAA,EAAS,yBAAA,IAYnC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAgBP,6BAAA;EAChB,KAAA,GAAQ,sBAAA;EACR,KAAA,EAAO,mBAAA;EACP,MAAA,EAAQ,sBAAA;EACR,MAAA,GAAS,sBAAA;EACT,gBAAA,GAAmB,sBAAA;EACnB,IAAA,EAAM,sBAAA;EACN,QAAA,EAAU,sBAAA;EACV,KAAA,EAAO,sBAAA;AAAA;AAAA,UAES,2BAAA;EAChB,OAAA;EACA,SAAA,EAAW,6BAAA;EACX,MAAA;IACC,SAAA,EAAW,WAAA;IACX,cAAA,EAAgB,WAAA;IAChB,cAAA,EAAgB,WAAA;IAChB,gBAAA;EAAA;AAAA;;;;;;;;;AAzbF;;;;;;;;;;;;;;iBAkdgB,oBAAA,CAAqB,OAAA,EAAS,2BAAA,IAwBrC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAiBP,8BAAA;EAChB,KAAA,GAAQ,sBAAA;EACR,KAAA,EAAO,mBAAA;EACP,MAAA,GAAS,sBAAA;AAAA;AAAA,UAEO,4BAAA;EAChB,OAAA;EACA,SAAA,EAAW,8BAAA;EACX,MAAA;IACC,SAAA,EAAW,WAAA;IACX,cAAA,EAAgB,WAAA;IAChB,gBAAA;EAAA;AAAA;;;;;AAteF;;;;;;;;;iBAsfgB,qBAAA,CAAsB,OAAA,EAAS,4BAAA,IAKtC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAgBP,oBAAA;EAChB,KAAA,GAAQ,sBAAA;EACR,MAAA,EAAQ,sBAAA;EACR,MAAA,GAAS,sBAAA;AAAA;AAAA,UAEO,kBAAA;EAChB,OAAA;EACA,SAAA,EAAW,oBAAA;EACX,MAAA;IACC,SAAA,EAAW,WAAA;IACX,cAAA,EAAgB,WAAA;IAChB,gBAAA;EAAA;AAAA;;;;;;;;;;AAtfF;;;;;;iBAwgBgB,WAAA,CAAY,OAAA,EAAS,kBAAA,IAK5B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAgBP,oBAAA;EAChB,KAAA,GAAQ,sBAAA;EACR,MAAA,GAAS,sBAAA;AAAA;AAAA,UAEO,kBAAA;EAChB,OAAA;EACA,SAAA,GAAY,oBAAA;EACZ,MAAA;IACC,SAAA,EAAW,WAAA;IACX,cAAA,EAAgB,WAAA;IAChB,gBAAA;EAAA;AAAA;AAhhBF;;;;;;;;;;;;;AASA;;;;;;;;;;;;;;;AAoBA;;AA7BA,iBAijBgB,WAAA,CAAY,OAAA,EAAS,kBAAA,IAK5B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAgBP,4BAAA;EAChB,KAAA,GAAQ,sBAAA;EACR,MAAA,EAAQ,sBAAA;EACR,MAAA,GAAS,sBAAA;AAAA;AAAA,UAEO,0BAAA;EAChB,OAAA;EACA,SAAA,EAAW,4BAAA;EACX,MAAA;IACC,SAAA,EAAW,WAAA;IACX,cAAA,EAAgB,WAAA;IAChB,gBAAA;EAAA;AAAA;;AAxiBF;;;;;;;;;;;;;;;AAoBA;;iBAyiBgB,mBAAA,CAAoB,OAAA,EAAS,0BAAA,IAKpC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAgBP,6BAAA;EAChB,KAAA,GAAQ,sBAAA;EACR,MAAA,GAAS,sBAAA;EACT,OAAA,EAAS,sBAAA;AAAA;AAAA,UAEO,2BAAA;EAChB,OAAA;EACA,SAAA,EAAW,6BAAA;EACX,MAAA;IACC,SAAA,EAAW,WAAA;IACX,cAAA,EAAgB,WAAA;IAChB,gBAAA;EAAA;AAAA;;AA7jBF;;;;iBAqkBgB,oBAAA,CAAqB,OAAA,EAAS,2BAAA,IAKrC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAgBP,oBAAA;EAChB,KAAA,GAAQ,sBAAA;EACR,MAAA,GAAS,sBAAA;EACT,QAAA,EAAU,sBAAA;EACV,OAAA,EAAS,sBAAA;AAAA;AAAA,UAEO,kBAAA;EAChB,OAAA;EACA,SAAA,EAAW,oBAAA;EACX,MAAA;IACC,SAAA,EAAW,WAAA;IACX,cAAA,EAAgB,WAAA;IAChB,gBAAA;EAAA;AAAA;AA/kBF;;;;;;;;;AAAA,iBA2lBgB,WAAA,CAAY,OAAA,EAAS,kBAAA,IAK5B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAgBP,sBAAA;EAChB,KAAA,GAAQ,sBAAA;EACR,OAAA,EAAS,sBAAA;EACT,IAAA,EAAM,mBAAA;EACN,MAAA,GAAS,sBAAA;EACT,MAAA,EAAQ,sBAAA;EACR,SAAA,EAAW,sBAAA;AAAA;AAAA,UAEK,oBAAA;EAChB,OAAA;EACA,SAAA,EAAW,sBAAA;EACX,MAAA;IACC,SAAA,EAAW,WAAA;IACX,cAAA,EAAgB,WAAA;IAChB,gBAAA;EAAA;AAAA;;AAjmBF;;;;;AAGA;;;;;;;;;iBAgnBgB,aAAA,CAAc,OAAA,EAAS,oBAAA,IAc9B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAgBP,wBAAA;EAChB,KAAA,GAAQ,sBAAA;EACR,OAAA,EAAS,sBAAA;EACT,IAAA,EAAM,mBAAA;EACN,MAAA,GAAS,sBAAA;EACT,MAAA,EAAQ,sBAAA;EACR,UAAA,EAAY,sBAAA;AAAA;AAAA,UAEI,sBAAA;EAChB,OAAA;EACA,SAAA,EAAW,wBAAA;EACX,MAAA;IACC,SAAA,EAAW,WAAA;IACX,cAAA,EAAgB,WAAA;IAChB,gBAAA;EAAA;AAAA;;AA/nBF;;;;;AAGA;;;;;;;;iBA6oBgB,eAAA,CAAgB,OAAA,EAAS,sBAAA,IAchC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAgBP,4BAAA;EAChB,KAAA,GAAQ,sBAAA;EACR,OAAA,EAAS,sBAAA;EACT,IAAA,EAAM,mBAAA;EACN,MAAA,GAAS,sBAAA;EACT,KAAA,EAAO,sBAAA;AAAA;AAAA,UAES,0BAAA;EAChB,OAAA;EACA,SAAA,EAAW,4BAAA;EACX,MAAA;IACC,SAAA,EAAW,WAAA;IACX,cAAA,EAAgB,WAAA;IAChB,gBAAA;EAAA;AAAA;;;;AA3pBF;iBAkqBgB,mBAAA,CAAoB,OAAA,EAAS,0BAAA,IAapC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAgBP,8BAAA;EAChB,KAAA,GAAQ,sBAAA;EACR,OAAA,EAAS,sBAAA;EACT,IAAA,EAAM,mBAAA;EACN,MAAA,GAAS,sBAAA;EACT,KAAA,EAAO,sBAAA;AAAA;AAAA,UAES,4BAAA;EAChB,OAAA;EACA,SAAA,EAAW,8BAAA;EACX,MAAA;IACC,SAAA,EAAW,WAAA;IACX,cAAA,EAAgB,WAAA;IAChB,gBAAA;EAAA;AAAA;AAhsBF;;;;AAAA,iBAusBgB,qBAAA,CAAsB,OAAA,EAAS,4BAAA,IAatC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA"}

package/dist/contracts/deepbook_predict/plp.mjs

@@ -1,6 +1,9 @@
+import { __exportAll } from "../../_virtual/rolldown_runtime.mjs";
 import { MoveStruct, normalizeMoveArguments } from "../utils/index.mjs";
 import { U64 } from "../../bcs/integers.mjs";
 import { Balance } from "./deps/sui/balance.mjs";
+import { VecMap } from "./deps/sui/vec_map.mjs";
+import { FrozenPricer } from "./pricing.mjs";
 import { LpBook } from "./lp_book.mjs";
 import { Ledger } from "./pool_accounting.mjs";
 import { bcs } from "@mysten/sui/bcs";
@@ -12,21 +15,80 @@ import { bcs } from "@mysten/sui/bcs";
 /**
 * PLP token and pool vault.
 *
-* PoolVault owns the PLP treasury cap, idle DUSDC, the protocol reserve,
+* PoolVault owns the PLP treasury cap, idle USDC, 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
+* supply/withdraw requests. It coordinates the full-pool NAV valuation — an atomic
+* oracle snapshot followed by resumable per-market valuation transactions, with
+* trading live throughout (see `PoolValuation`) — 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.
+* through a loaded Account; each flush (`finish_flush`) drains the requests that
+* predate its snapshot at the frozen pool NAV, minting/burning PLP and delivering
+* fills to each account via the balance accumulator.
 */
+var plp_exports = /* @__PURE__ */ __exportAll({
+	PLP: () => PLP,
+	PoolValuation: () => PoolValuation,
+	PoolValuationProof: () => PoolValuationProof,
+	PoolVault: () => PoolVault,
+	SnapshotStage: () => SnapshotStage,
+	activeExpiryMarkets: () => activeExpiryMarkets,
+	activeLiveExpiryCount: () => activeLiveExpiryCount,
+	cancelSupplyRequest: () => cancelSupplyRequest,
+	cancelWithdrawRequest: () => cancelWithdrawRequest,
+	feeIncentiveReserve: () => feeIncentiveReserve,
+	finishFlush: () => finishFlush,
+	id: () => id,
+	idleBalance: () => idleBalance,
+	lockCapital: () => lockCapital,
+	pendingProtocolProfit: () => pendingProtocolProfit,
+	plpTotalSupply: () => plpTotalSupply,
+	profitBasisCredits: () => profitBasisCredits,
+	profitBasisDebits: () => profitBasisDebits,
+	protocolReserveBalance: () => protocolReserveBalance,
+	rebalanceExpiryCash: () => rebalanceExpiryCash,
+	requestSupply: () => requestSupply,
+	requestWithdraw: () => requestWithdraw,
+	sealValuationSnapshot: () => sealValuationSnapshot,
+	snapshotExpiryPricer: () => snapshotExpiryPricer,
+	sponsorFeeIncentives: () => sponsorFeeIncentives,
+	startPoolValuation: () => startPoolValuation,
+	supplyRequestsPending: () => supplyRequestsPending,
+	valueExpiry: () => valueExpiry,
+	withdrawRequestsPending: () => withdrawRequestsPending
+});
 const $moduleName = "@local-pkg/deepbook_predict::plp";
 const PLP = new MoveStruct({
 	name: `${$moduleName}::PLP`,
 	fields: { dummy_field: bcs.bool() }
 });
+const PoolValuationProof = new MoveStruct({
+	name: `${$moduleName}::PoolValuationProof`,
+	fields: { dummy_field: bcs.bool() }
+});
+const SnapshotStage = new MoveStruct({
+	name: `${$moduleName}::SnapshotStage`,
+	fields: { dummy_field: bcs.bool() }
+});
+const PoolValuation = new MoveStruct({
+	name: `${$moduleName}::PoolValuation`,
+	fields: {
+		expected_expiry_markets: bcs.vector(bcs.Address),
+		valued_expiry_markets: bcs.vector(bcs.Address),
+		total_nav: U64,
+		frozen_pricers: VecMap(bcs.Address, bcs.option(FrozenPricer)),
+		sealed: bcs.bool(),
+		started_at_ms: U64,
+		supply_budget: bcs.option(U64),
+		withdraw_budget: bcs.option(U64),
+		supply_request_cutoff: U64,
+		withdraw_request_cutoff: U64,
+		frozen_idle_balance: U64,
+		frozen_profit_basis_credits: U64,
+		frozen_profit_basis_debits: U64,
+		frozen_pending_protocol_profit: U64
+	}
+});
 const PoolVault = new MoveStruct({
 	name: `${$moduleName}::PoolVault`,
 	fields: {
@@ -34,19 +96,26 @@ const PoolVault = new MoveStruct({
 		protocol_reserve_balance: Balance,
 		fee_incentive_reserve: Balance,
 		lp: LpBook,
-		expiry_accounting: Ledger
-	}
-});
-const PoolValuation = new MoveStruct({
-	name: `${$moduleName}::PoolValuation`,
-	fields: {
-		pool_vault_id: bcs.Address,
-		expected_expiry_markets: bcs.vector(bcs.Address),
-		valued_expiry_markets: bcs.vector(bcs.Address),
-		total_nav: U64
+		expiry_accounting: Ledger,
+		valuation: bcs.option(PoolValuation)
 	}
 });
-/** Return idle DUSDC for SDK and devInspect state reads. */
+/** Return the pool vault object ID for external discovery and PTB construction. */
+function id(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["vault"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "plp",
+		function: "id",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			vault: options.arguments?.vault ?? options.config?.poolVault
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Return idle USDC for SDK and devInspect state reads. */
 function idleBalance(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
 	const argumentsTypes = [null];
@@ -61,6 +130,36 @@ function idleBalance(options) {
 		}, argumentsTypes, parameterNames)
 	});
 }
+/** Return protocol-owned USDC for SDK and devInspect state reads. */
+function protocolReserveBalance(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["vault"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "plp",
+		function: "protocol_reserve_balance",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			vault: options.arguments?.vault ?? options.config?.poolVault
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Return sponsor-funded fee reserves for SDK and devInspect state reads. */
+function feeIncentiveReserve(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["vault"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "plp",
+		function: "fee_incentive_reserve",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			vault: options.arguments?.vault ?? options.config?.poolVault
+		}, argumentsTypes, parameterNames)
+	});
+}
 /** Return total PLP supply for SDK and devInspect state reads. */
 function plpTotalSupply(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -121,11 +220,391 @@ function activeExpiryMarkets(options) {
 		}, argumentsTypes, parameterNames)
 	});
 }
+/** Return the pre-expiry active count for SDK and devInspect capacity reads. */
+function activeLiveExpiryCount(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null, "0x2::clock::Clock"];
+	const parameterNames = ["vault"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "plp",
+		function: "active_live_expiry_count",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			vault: options.arguments?.vault ?? options.config?.poolVault
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Return the profit-basis debits for external accounting observability. */
+function profitBasisDebits(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["vault"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "plp",
+		function: "profit_basis_debits",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			vault: options.arguments?.vault ?? options.config?.poolVault
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Return the profit-basis credits for external accounting observability. */
+function profitBasisCredits(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["vault"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "plp",
+		function: "profit_basis_credits",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			vault: options.arguments?.vault ?? options.config?.poolVault
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Return deferred protocol profit for external accounting observability. */
+function pendingProtocolProfit(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["vault"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "plp",
+		function: "pending_protocol_profit",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			vault: options.arguments?.vault ?? options.config?.poolVault
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Begin a full-pool valuation using a registry-issued pool-valuation proof. The
+* proof grants control over when current oracle state is frozen for queued LP
+* fills. Starting engages the cross-transaction valuation flag, snapshots the
+* active expiry set and each LP queue's eligibility cutoff, and opens the atomic
+* snapshot stage: freeze every active market's pricer under the returned
+* `SnapshotStage`, then seal it in the same transaction.
+*/
+function startPoolValuation(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"0x1::option::Option<u64>",
+		"0x1::option::Option<u64>",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"vault",
+		"valuationProof",
+		"supplyBudget",
+		"withdrawBudget"
+	];
+	return (tx) => 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)
+	});
+}
+/**
+* Freeze one snapshotted market's oracle state for this flush and stamp the
+* market, capturing its cash rows and activating its payout-tree snapshot at this
+* instant.
+*
+* Holding `SnapshotStage` is what admits this call, and that potato cannot leave
+* the transaction `start_pool_valuation` minted it in — so every `Pricer` here is
+* loaded at one instant, which is what lets the valuation stage span transactions
+* without mixing marks (audit L10). This stage reads oracles only — it never walks
+* a payout tree — so all markets fit one PTB regardless of book size.
+*
+* The oracle feeding this stage must have been written in an EARLIER transaction:
+* `pricing::resolve_live_pricer` refuses a read stamped with the current
+* transaction digest (RP-24), so a keeper cannot refresh and snapshot in one PTB.
+*
+* A market already settled at snapshot time is recorded with no pricer, gets no
+* stamp (settled flows never touch live NAV), and contributes 0. An
+* expired-but-unsettled market aborts: it has no well-defined mark, and because
+* this stage is atomic the abort reverts the whole snapshot transaction, so the
+* flag is never left engaged. Settle it first, then start the flush; settlement is
+* never blocked by a flush, so that ordering is always available.
+*/
+function snapshotExpiryPricer(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"vault",
+		"Stage",
+		"market",
+		"config",
+		"propbookRegistry",
+		"pyth",
+		"bsValues",
+		"bsSvi"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "plp",
+		function: "snapshot_expiry_pricer",
+		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)
+	});
+}
+/**
+* Close the snapshot stage once every expected market has a frozen pricer, and
+* freeze the vault-side figures — idle, the profit basis, the pending protocol cut
+* — completing the snapshot.
+*
+* Consuming `SnapshotStage` is the simultaneity proof: the potato dies here, so no
+* later transaction can add oracle state to this flush, and every market is marked
+* at the instant the snapshot transaction executed. The vault capture is
+* consistent with the per-market stamps because `rebalance_expiry_cash` refuses to
+* run while the stage is open (`ESnapshotStageOpen`), so no idle↔market move can
+* land between a stamp and this capture. Valuation may then resume across as many
+* transactions as it needs.
+*/
+function sealValuationSnapshot(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"vault",
+		"stage",
+		"config"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "plp",
+		function: "seal_valuation_snapshot",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			vault: options.arguments?.vault ?? options.config?.poolVault,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Fold one snapshotted market's SNAPSHOT-INSTANT NAV into the running total. A
+* market frozen as settled is swept and contributes 0; one frozen with a pricer is
+* valued via `expiry_market::snapshot_nav` over its captured cash and tree
+* shadows, then has its stamp cleared (releasing the tree snapshot), so later
+* trades and the next flush start clean.
+*
+* The resumable stage: any transaction after the seal, one market per transaction
+* (`constants::max_payout_tree_nodes`), reading no oracle and no clock.
+* MEASUREMENT-ONLY for every member — settled members were swept during the
+* snapshot stage and every frozen figure was captured there, so this call moves no
+* cash and `rebalance_expiry_cash` runs at any time. A market that expired
+* mid-window is valued at its frozen pre-expiry mark; its settlement does not wait
+* for this call, because settlement is never blocked by a flush.
+*/
+function valueExpiry(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"vault",
+		"market",
+		"config"
+	];
+	return (tx) => 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
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* 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 USDC for withdrawals), release the valuation flag, retire the in-flight
+* valuation, and return the LP-attributable pool-wide USDC NAV (frozen idle + Σ
+* active NAV, net of the pending-protocol-profit exclusion priced from the frozen
+* profit basis — every term as of the snapshot instant). Each drain fills only
+* requests submitted before the flush's snapshot instant (the recorded queue
+* cutoffs); younger requests wait for the next mark.
+*
+* `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.
+*/
+function finishFlush(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"0x2::clock::Clock"
+	];
+	const parameterNames = ["vault", "config"];
+	return (tx) => 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)
+	});
+}
+/**
+* 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`). Runs at any time, including while
+* a flush is in flight — every figure the mark reads was frozen at the snapshot
+* instant, so no move here can reach it. The one refusal is the still-open
+* snapshot stage (start → seal, a single transaction): a cross-move landing
+* between a market's stamp and the seal's vault capture would skew the frozen
+* figures, so it is structurally rejected rather than corrected for.
+*/
+function rebalanceExpiryCash(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"vault",
+		"market",
+		"config"
+	];
+	return (tx) => 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)
+	});
+}
 /**
-* Queue a supply request: pull `amount` DUSDC from account custody into queue
+* Sponsor taker fee incentives with USDC. 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.
+*/
+function sponsorFeeIncentives(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"vault",
+		"config",
+		"payment"
+	];
+	return (tx) => 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)
+	});
+}
+/**
+* Bootstrap the pool exactly once: permanently lock `payment` USDC 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 USDC 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.
+*/
+function lockCapital(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"vault",
+		"config",
+		"AdminCap",
+		"payment"
+	];
+	return (tx) => 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)
+	});
+}
+/**
+* Queue a supply request: pull `amount` USDC 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
+* auto-settles any flush-delivered USDC first. The flush charges the protocol's
+* supply fee — zero by default — on the USDC 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
@@ -171,15 +650,15 @@ function requestSupply(options) {
 * 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
+* protocol's withdraw fee from the marked payout, so `min_usdc_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.
+* `min_usdc_out` for the whole `amount` — a **price floor**, not a promise of that
+* much USDC: 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.
 */
 function requestWithdraw(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -199,7 +678,7 @@ function requestWithdraw(options) {
 		"auth",
 		"config",
 		"amount",
-		"minDusdcOut"
+		"minUsdcOut"
 	];
 	return (tx) => tx.moveCall({
 		package: packageAddress,
@@ -213,8 +692,8 @@ function requestWithdraw(options) {
 	});
 }
 /**
-* Cancel a still-pending supply request, refunding its escrowed DUSDC straight
-* into the requesting account. `account` must be the request's recorded recipient.
+* Cancel a still-pending supply request, refunding its escrowed USDC straight into
+* the requesting account. `account` must be the request's recorded recipient.
 */
 function cancelSupplyRequest(options) {
 	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
@@ -280,5 +759,5 @@ function cancelWithdrawRequest(options) {
 }
 
 //#endregion
-export { activeExpiryMarkets, cancelSupplyRequest, cancelWithdrawRequest, idleBalance, plpTotalSupply, requestSupply, requestWithdraw, supplyRequestsPending, withdrawRequestsPending };
+export { activeExpiryMarkets, cancelSupplyRequest, cancelWithdrawRequest, idleBalance, plpTotalSupply, plp_exports, requestSupply, requestWithdraw, supplyRequestsPending, withdrawRequestsPending };
 //# sourceMappingURL=plp.mjs.map