@mysten/deepbook-v3 2.3.0 → 2.4.1

package/dist/contracts/deepbook_predict/protocol_config.d.mts

@@ -0,0 +1,665 @@
+import { ConfigValue, MoveStruct, RawTransactionArgument } from "../utils/index.mjs";
+import * as _mysten_sui_bcs217 from "@mysten/sui/bcs";
+import * as _mysten_sui_transactions248 from "@mysten/sui/transactions";
+import { Transaction } from "@mysten/sui/transactions";
+
+//#region src/contracts/deepbook_predict/protocol_config.d.ts
+declare namespace protocol_config_d_exports {
+  export { BumpVersionWatermarkArguments, BumpVersionWatermarkOptions, FrozenArguments, FrozenOptions, IdArguments, IdOptions, NoTradeWindowMsArguments, NoTradeWindowMsOptions, ProtocolConfig, ReferralFeeRateArguments, ReferralFeeRateOptions, SetBlockScholesPriceFreshnessMsArguments, SetBlockScholesPriceFreshnessMsOptions, SetBlockScholesSviFreshnessMsArguments, SetBlockScholesSviFreshnessMsOptions, SetEwmaEnabledArguments, SetEwmaEnabledOptions, SetEwmaParamsArguments, SetEwmaParamsOptions, SetFrozenArguments, SetFrozenOptions, SetLpRequestLimitFlushAttemptsArguments, SetLpRequestLimitFlushAttemptsOptions, SetMaxLpPoolValueArguments, SetMaxLpPoolValueOptions, SetMaxValuationWindowMsArguments, SetMaxValuationWindowMsOptions, SetNoTradeWindowMsArguments, SetNoTradeWindowMsOptions, SetPlpSupplyFeeRateArguments, SetPlpSupplyFeeRateOptions, SetPlpWithdrawFeeRateArguments, SetPlpWithdrawFeeRateOptions, SetProtocolReserveProfitShareArguments, SetProtocolReserveProfitShareOptions, SetPythSpotFreshnessMsArguments, SetPythSpotFreshnessMsOptions, SetReferralFeeRateArguments, SetReferralFeeRateOptions, SetTemplateBackingBufferLambdaArguments, SetTemplateBackingBufferLambdaOptions, SetTemplateBaseFeeArguments, SetTemplateBaseFeeOptions, SetTemplateExpiryFeeMaxMultiplierArguments, SetTemplateExpiryFeeMaxMultiplierOptions, SetTemplateExpiryFeeWindowMsArguments, SetTemplateExpiryFeeWindowMsOptions, SetTemplateInventoryImpactMaxRateArguments, SetTemplateInventoryImpactMaxRateOptions, SetTemplateMaxEntryProbabilityArguments, SetTemplateMaxEntryProbabilityOptions, SetTemplateMinEntryProbabilityArguments, SetTemplateMinEntryProbabilityOptions, SetTemplateMinFeeArguments, SetTemplateMinFeeOptions, SetTradingPausedArguments, SetTradingPausedOptions, SetUsePythSpotForForwardArguments, SetUsePythSpotForForwardOptions, TradingPausedArguments, TradingPausedOptions, ValuationInProgressArguments, ValuationInProgressOptions, bumpVersionWatermark, frozen, id, noTradeWindowMs, referralFeeRate, setBlockScholesPriceFreshnessMs, setBlockScholesSviFreshnessMs, setEwmaEnabled, setEwmaParams, setFrozen, setLpRequestLimitFlushAttempts, setMaxLpPoolValue, setMaxValuationWindowMs, setNoTradeWindowMs, setPlpSupplyFeeRate, setPlpWithdrawFeeRate, setProtocolReserveProfitShare, setPythSpotFreshnessMs, setReferralFeeRate, setTemplateBackingBufferLambda, setTemplateBaseFee, setTemplateExpiryFeeMaxMultiplier, setTemplateExpiryFeeWindowMs, setTemplateInventoryImpactMaxRate, setTemplateMaxEntryProbability, setTemplateMinEntryProbability, setTemplateMinFee, setTradingPaused, setUsePythSpotForForward, tradingPaused, valuationInProgress };
+}
+declare const ProtocolConfig: MoveStruct<{
+  id: _mysten_sui_bcs217.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  pricing_config: MoveStruct<{
+    use_pyth_spot_for_forward: _mysten_sui_bcs217.BcsType<boolean, boolean, "bool">;
+    pyth_spot_freshness_ms: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    block_scholes_price_freshness_ms: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    block_scholes_svi_freshness_ms: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+  }, "@local-pkg/deepbook_predict::pricing_config::PricingConfig">;
+  /**
+   * Merged protocol + insurance reserve share of materialized terminal profit, in
+   * FLOAT_SCALING. The complement accrues to LPs.
+   */
+  protocol_reserve_profit_share: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Portion of a referred mint's trader-paid trading fee and congestion surcharge
+   * routed to the referrer, in FLOAT_SCALING.
+   */
+  referral_fee_rate: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Fee charged on an executed PLP supply fill, in FLOAT_SCALING, deducted from the
+   * USDC taken in before shares are priced. Ships at zero — a deposit dilutes the
+   * pool's risk per dollar rather than concentrating it, so it is not taxed; the
+   * knob exists to keep that reversible.
+   */
+  plp_supply_fee_rate: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Fee charged on an executed PLP withdraw fill, in FLOAT_SCALING, withheld from
+   * the marked payout. Retained by the pool, so it accrues to the holders who stay.
+   * Both rates are read once per flush into the frozen mark, so every fill in one
+   * flush is charged the same pair.
+   */
+  plp_withdraw_fee_rate: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Frozen-mark attempts a queued LP supply/withdraw request gets before the
+   * protocol cancels and refunds it. `1` (the default) is fill-or-kill; above that a
+   * missing request rests at the queue head and stops that queue for the flush, so
+   * this is an LP-queue liveness knob (RP-12).
+   */
+  lp_request_limit_flush_attempts: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Ceiling on LP-attributable pool value that queued supplies may raise the pool
+   * to, enforced at the flush against the frozen mark. Defaults to 500,000 USDC
+   * (RP-23).
+   */
+  max_lp_pool_value: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Hard staleness bound: `finish_flush` refuses to complete a flush in flight
+   * longer than this, so no LP request fills at a mark older than the window; past
+   * it the operator starts a fresh flush (which discards the stale one). A stalled
+   * flush blocks only LP queue fills and the flush-set markets' settlement — trading
+   * continues — so this also bounds LP-fill latency and is tuned alongside flush
+   * cadence (RP-29).
+   */
+  max_valuation_window_ms: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Window before a market's expiry in which live quotes, mints, and live redeems
+   * abort. Read live at trade time rather than snapshotted per market, so it can be
+   * widened on markets already trading. `0` disables.
+   */
+  no_trade_window_ms: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+  strike_exposure_template_config: MoveStruct<{
+    backing_buffer_lambda: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    base_fee: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    min_fee: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    min_entry_probability: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    max_entry_probability: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    expiry_fee_window_ms: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    expiry_fee_max_multiplier: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    inventory_impact_max_rate: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+  }, "@local-pkg/deepbook_predict::strike_exposure_config::StrikeExposureConfig">;
+  ewma_config: MoveStruct<{
+    alpha: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    z_score_threshold: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    penalty_rate: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+    enabled: _mysten_sui_bcs217.BcsType<boolean, boolean, "bool">;
+  }, "@local-pkg/deepbook_predict::ewma_config::EwmaConfig">;
+  /**
+   * Minimum package version permitted to run version-gated flows. Monotonic;
+   * `bump_version_watermark` advances it to the running `current_version!()`,
+   * retiring older versions. A running version below this floor is dead
+   * (`assert_version`). `current_version!()` stays the upgrade-required code
+   * constant; this is the runtime floor.
+   */
+  version_watermark: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">; /** Blocks new risk creation while true. */
+  trading_paused: _mysten_sui_bcs217.BcsType<boolean, boolean, "bool">;
+  /**
+   * Emergency hard stop. While true, `assert_version` aborts, halting every
+   * version-gated flow (mint, redeem, settlement, valuation, LP supply/withdraw,
+   * admin config) — the same blast radius as a version-disable, but reversible
+   * without a package upgrade. Force-on via `PauseCap`; cleared by `AdminCap`.
+   * Account-package custody withdrawals and builder-fee claims are ungated and stay
+   * available (already-earned funds).
+   */
+  frozen: _mysten_sui_bcs217.BcsType<boolean, boolean, "bool">;
+  /**
+   * True for the whole duration of a full-pool valuation, across every transaction
+   * it spans. Keeper cash flows, market lifecycle, and config mutations gate on it;
+   * trading flows do NOT — they read it (with `flush_seq`) only to discard a stale
+   * valuation stamp lazily; a pending market's snapshot state is captured, never
+   * recorded per trade (see `plp`).
+   */
+  valuation_in_progress: _mysten_sui_bcs217.BcsType<boolean, boolean, "bool">;
+  /**
+   * True ONLY while the atomic snapshot stage is open — set by `begin_snapshot` at
+   * `start_pool_valuation` and cleared by `end_snapshot` at
+   * `seal_valuation_snapshot`. Both live in one PTB (the `SnapshotStage` hot potato
+   * forces it), so this can never be observed across transactions: it blocks only a
+   * trade the keeper composes INTO its own snapshot PTB, where a mid-stamp cash move
+   * would skew the figures the seal freezes. The resumable valuation stage after the
+   * seal leaves it false, so trading stays live.
+   */
+  snapshot_in_progress: _mysten_sui_bcs217.BcsType<boolean, boolean, "bool">;
+  /**
+   * Monotonic flush ordinal, bumped by `begin_valuation`. A market's valuation stamp
+   * names the flush that made it; a stamp whose ordinal is not the current one — or
+   * held while no valuation is in flight — is stale and is lazily discarded by the
+   * next trade, so aborting a flush never has to visit its stamped markets.
+   */
+  flush_seq: _mysten_sui_bcs217.BcsType<bigint, string | number | bigint, "u64">;
+}, "@local-pkg/deepbook_predict::protocol_config::ProtocolConfig">;
+interface IdArguments {
+  config?: RawTransactionArgument<string>;
+}
+interface IdOptions {
+  package?: string;
+  arguments?: IdArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * Return the protocol config object ID for external discovery and PTB
+ * construction.
+ */
+declare function id(options: IdOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface TradingPausedArguments {
+  config?: RawTransactionArgument<string>;
+}
+interface TradingPausedOptions {
+  package?: string;
+  arguments?: TradingPausedArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Return the global trading-pause state for SDK and devInspect reads. */
+declare function tradingPaused(options: TradingPausedOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface FrozenArguments {
+  config?: RawTransactionArgument<string>;
+}
+interface FrozenOptions {
+  package?: string;
+  arguments?: FrozenArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Return the global protocol-freeze state for SDK and devInspect reads. */
+declare function frozen(options: FrozenOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface ValuationInProgressArguments {
+  config?: RawTransactionArgument<string>;
+}
+interface ValuationInProgressOptions {
+  package?: string;
+  arguments?: ValuationInProgressArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function valuationInProgress(options: ValuationInProgressOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface ReferralFeeRateArguments {
+  config?: RawTransactionArgument<string>;
+}
+interface ReferralFeeRateOptions {
+  package?: string;
+  arguments?: ReferralFeeRateArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Return the live referral fee rate for SDK and devInspect reads. */
+declare function referralFeeRate(options: ReferralFeeRateOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface NoTradeWindowMsArguments {
+  config?: RawTransactionArgument<string>;
+}
+interface NoTradeWindowMsOptions {
+  package?: string;
+  arguments?: NoTradeWindowMsArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function noTradeWindowMs(options: NoTradeWindowMsOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetTemplateBaseFeeArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  fee: RawTransactionArgument<number | bigint>;
+}
+interface SetTemplateBaseFeeOptions {
+  package?: string;
+  arguments: SetTemplateBaseFeeArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Set the base fee multiplier snapshotted by newly created expiry markets. */
+declare function setTemplateBaseFee(options: SetTemplateBaseFeeOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetTemplateMinFeeArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  fee: RawTransactionArgument<number | bigint>;
+}
+interface SetTemplateMinFeeOptions {
+  package?: string;
+  arguments: SetTemplateMinFeeArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Set the minimum fee floor snapshotted by newly created expiry markets. */
+declare function setTemplateMinFee(options: SetTemplateMinFeeOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetTemplateExpiryFeeWindowMsArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  value: RawTransactionArgument<number | bigint>;
+}
+interface SetTemplateExpiryFeeWindowMsOptions {
+  package?: string;
+  arguments: SetTemplateExpiryFeeWindowMsArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Set the expiry-fee ramp window snapshotted by newly created expiry markets. */
+declare function setTemplateExpiryFeeWindowMs(options: SetTemplateExpiryFeeWindowMsOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetTemplateExpiryFeeMaxMultiplierArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  value: RawTransactionArgument<number | bigint>;
+}
+interface SetTemplateExpiryFeeMaxMultiplierOptions {
+  package?: string;
+  arguments: SetTemplateExpiryFeeMaxMultiplierArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Set the expiry-fee max multiplier snapshotted by newly created expiry markets. */
+declare function setTemplateExpiryFeeMaxMultiplier(options: SetTemplateExpiryFeeMaxMultiplierOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetTemplateBackingBufferLambdaArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  value: RawTransactionArgument<number | bigint>;
+}
+interface SetTemplateBackingBufferLambdaOptions {
+  package?: string;
+  arguments: SetTemplateBackingBufferLambdaArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Set the backing-buffer lambda snapshotted by newly created expiry markets. */
+declare function setTemplateBackingBufferLambda(options: SetTemplateBackingBufferLambdaOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetTemplateInventoryImpactMaxRateArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  value: RawTransactionArgument<number | bigint>;
+}
+interface SetTemplateInventoryImpactMaxRateOptions {
+  package?: string;
+  arguments: SetTemplateInventoryImpactMaxRateArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * Set the maximum marginal inventory-impact rate snapshotted by newly created
+ * expiry markets. `0` (the default) disables both charges and rebates.
+ */
+declare function setTemplateInventoryImpactMaxRate(options: SetTemplateInventoryImpactMaxRateOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetTemplateMinEntryProbabilityArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  value: RawTransactionArgument<number | bigint>;
+}
+interface SetTemplateMinEntryProbabilityOptions {
+  package?: string;
+  arguments: SetTemplateMinEntryProbabilityArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * Set the minimum raw entry probability snapshotted by newly created expiry
+ * markets.
+ */
+declare function setTemplateMinEntryProbability(options: SetTemplateMinEntryProbabilityOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetTemplateMaxEntryProbabilityArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  value: RawTransactionArgument<number | bigint>;
+}
+interface SetTemplateMaxEntryProbabilityOptions {
+  package?: string;
+  arguments: SetTemplateMaxEntryProbabilityArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * Set the maximum raw entry probability snapshotted by newly created expiry
+ * markets.
+ */
+declare function setTemplateMaxEntryProbability(options: SetTemplateMaxEntryProbabilityOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetUsePythSpotForForwardArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  enabled: RawTransactionArgument<boolean>;
+}
+interface SetUsePythSpotForForwardOptions {
+  package?: string;
+  arguments: SetUsePythSpotForForwardArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function setUsePythSpotForForward(options: SetUsePythSpotForForwardOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetPythSpotFreshnessMsArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  value: RawTransactionArgument<number | bigint>;
+}
+interface SetPythSpotFreshnessMsOptions {
+  package?: string;
+  arguments: SetPythSpotFreshnessMsArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Set the live Pyth spot freshness threshold. */
+declare function setPythSpotFreshnessMs(options: SetPythSpotFreshnessMsOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetBlockScholesPriceFreshnessMsArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  value: RawTransactionArgument<number | bigint>;
+}
+interface SetBlockScholesPriceFreshnessMsOptions {
+  package?: string;
+  arguments: SetBlockScholesPriceFreshnessMsArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Set the live Block Scholes spot/forward freshness threshold. */
+declare function setBlockScholesPriceFreshnessMs(options: SetBlockScholesPriceFreshnessMsOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetBlockScholesSviFreshnessMsArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  value: RawTransactionArgument<number | bigint>;
+}
+interface SetBlockScholesSviFreshnessMsOptions {
+  package?: string;
+  arguments: SetBlockScholesSviFreshnessMsArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Set the live Block Scholes SVI freshness threshold. */
+declare function setBlockScholesSviFreshnessMs(options: SetBlockScholesSviFreshnessMsOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetLpRequestLimitFlushAttemptsArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  attempts: RawTransactionArgument<number | bigint>;
+}
+interface SetLpRequestLimitFlushAttemptsOptions {
+  package?: string;
+  arguments: SetLpRequestLimitFlushAttemptsArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function setLpRequestLimitFlushAttempts(options: SetLpRequestLimitFlushAttemptsOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetMaxValuationWindowMsArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  windowMs: RawTransactionArgument<number | bigint>;
+}
+interface SetMaxValuationWindowMsOptions {
+  package?: string;
+  arguments: SetMaxValuationWindowMsArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function setMaxValuationWindowMs(options: SetMaxValuationWindowMsOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetMaxLpPoolValueArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  maxPoolValue: RawTransactionArgument<number | bigint>;
+}
+interface SetMaxLpPoolValueOptions {
+  package?: string;
+  arguments: SetMaxLpPoolValueArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function setMaxLpPoolValue(options: SetMaxLpPoolValueOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetEwmaParamsArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  alpha: RawTransactionArgument<number | bigint>;
+  zScoreThreshold: RawTransactionArgument<number | bigint>;
+  penaltyRate: RawTransactionArgument<number | bigint>;
+}
+interface SetEwmaParamsOptions {
+  package?: string;
+  arguments: SetEwmaParamsArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Set the EWMA gas-price penalty parameters. */
+declare function setEwmaParams(options: SetEwmaParamsOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetEwmaEnabledArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  enabled: RawTransactionArgument<boolean>;
+}
+interface SetEwmaEnabledOptions {
+  package?: string;
+  arguments: SetEwmaEnabledArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Enable or disable the EWMA gas-price penalty. */
+declare function setEwmaEnabled(options: SetEwmaEnabledOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetNoTradeWindowMsArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  value: RawTransactionArgument<number | bigint>;
+}
+interface SetNoTradeWindowMsOptions {
+  package?: string;
+  arguments: SetNoTradeWindowMsArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function setNoTradeWindowMs(options: SetNoTradeWindowMsOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetTradingPausedArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  paused: RawTransactionArgument<boolean>;
+}
+interface SetTradingPausedOptions {
+  package?: string;
+  arguments: SetTradingPausedArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/** Set whether trading is paused. */
+declare function setTradingPaused(options: SetTradingPausedOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetFrozenArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  frozen: RawTransactionArgument<boolean>;
+}
+interface SetFrozenOptions {
+  package?: string;
+  arguments: SetFrozenArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function setFrozen(options: SetFrozenOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface BumpVersionWatermarkArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+}
+interface BumpVersionWatermarkOptions {
+  package?: string;
+  arguments: BumpVersionWatermarkArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function bumpVersionWatermark(options: BumpVersionWatermarkOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetProtocolReserveProfitShareArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  protocolReserveProfitShare: RawTransactionArgument<number | bigint>;
+}
+interface SetProtocolReserveProfitShareOptions {
+  package?: string;
+  arguments: SetProtocolReserveProfitShareArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * Set the protocol reserve profit share used when materializing aggregate expiry
+ * profit. Admin-gated; validated against its config-constants envelope.
+ */
+declare function setProtocolReserveProfitShare(options: SetProtocolReserveProfitShareOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetReferralFeeRateArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  rate: RawTransactionArgument<number | bigint>;
+}
+interface SetReferralFeeRateOptions {
+  package?: string;
+  arguments: SetReferralFeeRateArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function setReferralFeeRate(options: SetReferralFeeRateOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetPlpSupplyFeeRateArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  rate: RawTransactionArgument<number | bigint>;
+}
+interface SetPlpSupplyFeeRateOptions {
+  package?: string;
+  arguments: SetPlpSupplyFeeRateArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function setPlpSupplyFeeRate(options: SetPlpSupplyFeeRateOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+interface SetPlpWithdrawFeeRateArguments {
+  config?: RawTransactionArgument<string>;
+  AdminCap: RawTransactionArgument<string>;
+  rate: RawTransactionArgument<number | bigint>;
+}
+interface SetPlpWithdrawFeeRateOptions {
+  package?: string;
+  arguments: SetPlpWithdrawFeeRateArguments;
+  config?: {
+    protocolConfig: ConfigValue;
+    predictPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function setPlpWithdrawFeeRate(options: SetPlpWithdrawFeeRateOptions): (tx: Transaction) => _mysten_sui_transactions248.TransactionResult;
+//#endregion
+export { protocol_config_d_exports };
+//# sourceMappingURL=protocol_config.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocol_config.d.mts","names":[],"sources":["../../../src/contracts/deepbook_predict/protocol_config.ts"],"mappings":"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"}