@mysten/deepbook-v3 2.1.4 → 2.4.0

package/dist/contracts/deepbook_predict/protocol_config.mjs

@@ -0,0 +1,841 @@
+import { __exportAll } from "../../_virtual/rolldown_runtime.mjs";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.mjs";
+import { U64 } from "../../bcs/integers.mjs";
+import { StrikeExposureConfig } from "./strike_exposure_config.mjs";
+import { PricingConfig } from "./pricing_config.mjs";
+import { EwmaConfig } from "./ewma_config.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/deepbook_predict/protocol_config.ts
+/**************************************************************
+* THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+**************************************************************/
+/**
+* Protocol-wide configuration and flow gates for Predict.
+*
+* This shared object owns the admin-tunable config structs, the trading pause
+* gate, the protocol-wide emergency freeze, and the full-pool valuation in-flight
+* state (flag + flush ordinal, held across the transactions a flush spans;
+* keeper/config flows gate on it, trading flows read it only to discard stale
+* stamps lazily). Flow modules decide which gates apply before they mutate expiry,
+* oracle, pool, or account state.
+*/
+var protocol_config_exports = /* @__PURE__ */ __exportAll({
+	ProtocolConfig: () => ProtocolConfig,
+	bumpVersionWatermark: () => bumpVersionWatermark,
+	frozen: () => frozen,
+	id: () => id,
+	noTradeWindowMs: () => noTradeWindowMs,
+	referralFeeRate: () => referralFeeRate,
+	setBlockScholesPriceFreshnessMs: () => setBlockScholesPriceFreshnessMs,
+	setBlockScholesSviFreshnessMs: () => setBlockScholesSviFreshnessMs,
+	setEwmaEnabled: () => setEwmaEnabled,
+	setEwmaParams: () => setEwmaParams,
+	setFrozen: () => setFrozen,
+	setLpRequestLimitFlushAttempts: () => setLpRequestLimitFlushAttempts,
+	setMaxLpPoolValue: () => setMaxLpPoolValue,
+	setMaxValuationWindowMs: () => setMaxValuationWindowMs,
+	setNoTradeWindowMs: () => setNoTradeWindowMs,
+	setPlpSupplyFeeRate: () => setPlpSupplyFeeRate,
+	setPlpWithdrawFeeRate: () => setPlpWithdrawFeeRate,
+	setProtocolReserveProfitShare: () => setProtocolReserveProfitShare,
+	setPythSpotFreshnessMs: () => setPythSpotFreshnessMs,
+	setReferralFeeRate: () => setReferralFeeRate,
+	setTemplateBackingBufferLambda: () => setTemplateBackingBufferLambda,
+	setTemplateBaseFee: () => setTemplateBaseFee,
+	setTemplateExpiryFeeMaxMultiplier: () => setTemplateExpiryFeeMaxMultiplier,
+	setTemplateExpiryFeeWindowMs: () => setTemplateExpiryFeeWindowMs,
+	setTemplateInventoryImpactMaxRate: () => setTemplateInventoryImpactMaxRate,
+	setTemplateMaxEntryProbability: () => setTemplateMaxEntryProbability,
+	setTemplateMinEntryProbability: () => setTemplateMinEntryProbability,
+	setTemplateMinFee: () => setTemplateMinFee,
+	setTradingPaused: () => setTradingPaused,
+	setUsePythSpotForForward: () => setUsePythSpotForForward,
+	tradingPaused: () => tradingPaused,
+	valuationInProgress: () => valuationInProgress
+});
+const $moduleName = "@local-pkg/deepbook_predict::protocol_config";
+const ProtocolConfig = new MoveStruct({
+	name: `${$moduleName}::ProtocolConfig`,
+	fields: {
+		id: bcs.Address,
+		pricing_config: PricingConfig,
+		protocol_reserve_profit_share: U64,
+		referral_fee_rate: U64,
+		plp_supply_fee_rate: U64,
+		plp_withdraw_fee_rate: U64,
+		lp_request_limit_flush_attempts: U64,
+		max_lp_pool_value: U64,
+		max_valuation_window_ms: U64,
+		no_trade_window_ms: U64,
+		strike_exposure_template_config: StrikeExposureConfig,
+		ewma_config: EwmaConfig,
+		version_watermark: U64,
+		trading_paused: bcs.bool(),
+		frozen: bcs.bool(),
+		valuation_in_progress: bcs.bool(),
+		snapshot_in_progress: bcs.bool(),
+		flush_seq: U64
+	}
+});
+/**
+* Return the protocol config 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 = ["config"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "id",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Return the global trading-pause state for SDK and devInspect reads. */
+function tradingPaused(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["config"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "trading_paused",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Return the global protocol-freeze state for SDK and devInspect reads. */
+function frozen(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["config"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "frozen",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Return whether a full-pool valuation is in flight, for SDK and devInspect reads.
+* The flush spans transactions, so "in flight" is an observable state: a keeper
+* reads it to notice a flush it must finish or discard, and an integrator reads it
+* to explain a gated keeper/config transaction. Trading is not gated on it.
+*/
+function valuationInProgress(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["config"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "valuation_in_progress",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Return the live referral fee rate for SDK and devInspect reads. */
+function referralFeeRate(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["config"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "referral_fee_rate",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Window before expiry in which live quotes, mints, and live redeems abort.
+* `public` for SDK and devInspect reads: a client that cannot see this value can
+* only learn the window closed by decoding `ETradeWindowClosed` from a failed
+* quote.
+*/
+function noTradeWindowMs(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null];
+	const parameterNames = ["config"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "no_trade_window_ms",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Set the base fee multiplier snapshotted by newly created expiry markets. */
+function setTemplateBaseFee(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"fee"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_template_base_fee",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Set the minimum fee floor snapshotted by newly created expiry markets. */
+function setTemplateMinFee(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"fee"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_template_min_fee",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Set the expiry-fee ramp window snapshotted by newly created expiry markets. */
+function setTemplateExpiryFeeWindowMs(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"value"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_template_expiry_fee_window_ms",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Set the expiry-fee max multiplier snapshotted by newly created expiry markets. */
+function setTemplateExpiryFeeMaxMultiplier(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"value"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_template_expiry_fee_max_multiplier",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Set the backing-buffer lambda snapshotted by newly created expiry markets. */
+function setTemplateBackingBufferLambda(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"value"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_template_backing_buffer_lambda",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set the maximum marginal inventory-impact rate snapshotted by newly created
+* expiry markets. `0` (the default) disables both charges and rebates.
+*/
+function setTemplateInventoryImpactMaxRate(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"value"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_template_inventory_impact_max_rate",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set the minimum raw entry probability snapshotted by newly created expiry
+* markets.
+*/
+function setTemplateMinEntryProbability(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"value"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_template_min_entry_probability",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set the maximum raw entry probability snapshotted by newly created expiry
+* markets.
+*/
+function setTemplateMaxEntryProbability(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"value"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_template_max_entry_probability",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Select which source the live forward is built from: `true` carries the Block
+* Scholes basis on a fresh Pyth spot, `false` uses the Block Scholes forward
+* directly. Locked during valuation so one flush marks every market on one
+* formula.
+*/
+function setUsePythSpotForForward(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"bool",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"enabled"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_use_pyth_spot_for_forward",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Set the live Pyth spot freshness threshold. */
+function setPythSpotFreshnessMs(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"value"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_pyth_spot_freshness_ms",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Set the live Block Scholes spot/forward freshness threshold. */
+function setBlockScholesPriceFreshnessMs(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"value"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_block_scholes_price_freshness_ms",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Set the live Block Scholes SVI freshness threshold. */
+function setBlockScholesSviFreshnessMs(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"value"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_block_scholes_svi_freshness_ms",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set how many frozen-mark attempts a queued LP request gets before it is
+* cancelled and refunded. `1` is fill-or-kill. Raising it lets a request rest at
+* the head across flushes, which stops that queue each time it misses — see RP-12
+* for the liveness cost that buys.
+*/
+function setLpRequestLimitFlushAttempts(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"attempts"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_lp_request_limit_flush_attempts",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set how long a started full-pool valuation may stay in flight before anyone may
+* discard it. A stalled flush costs LP-fill latency (and settlement latency for
+* its own market set), not a trading pause, so this is an operator liveness knob:
+* too short and a legitimate long flush can be discarded from under the keeper,
+* too long and an abandoned one delays queued LP fills for that duration. See
+* RP-29.
+*/
+function setMaxValuationWindowMs(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"windowMs"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_max_valuation_window_ms",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set the ceiling on LP-attributable pool value that queued supplies may raise the
+* pool to. A supply that would carry the pool past it is filled up to the cap at
+* the flush and its remainder stays queued; withdrawals and already-issued PLP are
+* unaffected, so lowering this below current pool value closes the pool to new
+* capital rather than forcing anyone out.
+*/
+function setMaxLpPoolValue(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"maxPoolValue"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_max_lp_pool_value",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Set the EWMA gas-price penalty parameters. */
+function setEwmaParams(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"u64",
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"alpha",
+		"zScoreThreshold",
+		"penaltyRate"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_ewma_params",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Enable or disable the EWMA gas-price penalty. */
+function setEwmaEnabled(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"bool",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"enabled"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_ewma_enabled",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set the window before expiry in which live quotes, mints, and live redeems
+* abort. `0` disables the block. Read live at trade time, so a change applies to
+* markets already trading and stays available as an incident control.
+*
+* Deliberately not gated on `assert_not_valuation_in_progress`, matching
+* `set_trading_paused`: a stalled flush must not be able to trap a safety control.
+* Nothing in the flush reads this value, so a mid-valuation change cannot skew a
+* frozen mark.
+*/
+function setNoTradeWindowMs(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"value"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_no_trade_window_ms",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/** Set whether trading is paused. */
+function setTradingPaused(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"bool"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"paused"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_trading_paused",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set the protocol-wide emergency freeze.
+*
+* Intentionally NOT version-gated, unlike every other admin setter: the freeze
+* gate lives inside `assert_version`, so routing this through it would make an
+* engaged freeze unclearable without a package upgrade — defeating the point.
+*/
+function setFrozen(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"bool"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"frozen"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_frozen",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Advance the version floor to this package's compiled-in `current_version!()`.
+*
+* The floor cannot be set above the executing package's version. This function is
+* ungated so an upgraded package can retire older versions; it aborts unless the
+* executing version is strictly greater than the existing floor.
+*/
+function bumpVersionWatermark(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["config", "AdminCap"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "bump_version_watermark",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set the protocol reserve profit share used when materializing aggregate expiry
+* profit. Admin-gated; validated against its config-constants envelope.
+*/
+function setProtocolReserveProfitShare(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"protocolReserveProfitShare"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_protocol_reserve_profit_share",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set the portion of referred mint fees routed to the referrer. The new rate
+* applies to subsequent mints without changing their all-in account withdrawal.
+*/
+function setReferralFeeRate(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"rate"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_referral_fee_rate",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set the fee charged on executed PLP supply fills. Admin-gated and validated
+* against its config-constants envelope. Locked during valuation so the rate a
+* flush froze into its mark cannot change midway through that flush.
+*/
+function setPlpSupplyFeeRate(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"rate"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_plp_supply_fee_rate",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Set the fee charged on executed PLP withdraw fills. Same gating as the supply
+* leg; the two are independent so the exit charge can move without taxing entry.
+*/
+function setPlpWithdrawFeeRate(options) {
+	const packageAddress = options.package ?? options.config?.predictPackageId ?? "@local-pkg/deepbook_predict";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"config",
+		"AdminCap",
+		"rate"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "protocol_config",
+		function: "set_plp_withdraw_fee_rate",
+		arguments: normalizeMoveArguments({
+			...options.arguments,
+			config: options.arguments?.config ?? options.config?.protocolConfig
+		}, argumentsTypes, parameterNames)
+	});
+}
+
+//#endregion
+export { protocol_config_exports };
+//# sourceMappingURL=protocol_config.mjs.map