@mysten/deepbook-v3 2.6.4 → 2.8.0

package/dist/contracts/deepbook_predict_math/math.mjs

@@ -0,0 +1,364 @@
+import { __exportAll } from "../../_virtual/rolldown_runtime.mjs";
+import { normalizeMoveArguments } from "../utils/index.mjs";
+
+//#region src/contracts/deepbook_predict_math/math.ts
+var math_exports = /* @__PURE__ */ __exportAll({
+	builderFee: () => builderFee,
+	digital: () => digital,
+	inputsOk: () => inputsOk,
+	legFee: () => legFee,
+	maxQty: () => maxQty,
+	needBudget: () => needBudget,
+	needQty: () => needQty,
+	needSell: () => needSell,
+	orderTerms: () => orderTerms,
+	potential: () => potential,
+	rawVarOk: () => rawVarOk,
+	rollDown: () => rollDown,
+	varPositive: () => varPositive
+});
+/**
+* Scale one 1e9-scaled SVI magnitude down by the fraction of anchored time
+* remaining, returning it at 1e18.
+*
+* The roll-down result is kept at 1e18 because the fraction is applied to values
+* that are themselves tiny on short-dated surfaces: a 1e9 floor here costs up to a
+* whole raw unit of `a`, and a short-dated `a` is only about ten raw units, so the
+* truncation alone moves the digital by percent-scale amounts. At 1e18 the same
+* floor is a billionth of that.
+*
+* The `u256` intermediate keeps the product exact for any `expiry_ms` rather than
+* relying on a bound on the anchored horizon. The result is at most
+* `value * 1e9 < 2^64 * 1e9`, so narrowing to `u128` never truncates.
+*/
+function rollDown(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [
+		"u64",
+		"u64",
+		"u64"
+	];
+	const parameterNames = [
+		"value",
+		"remainingMs",
+		"anchorTteMs"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "roll_down",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* The adjusted UP digital for `strike` on a rolled SVI surface (`a` and `b` at
+* 1e18, `rho`, `m`, and `sigma` at 1e9) and `forward`:
+*
+* - k = ln(strike / forward)
+* - w(k) = a + b * (rho * (k - m) + sqrt((k - m)^2 + sigma^2))
+* - d2 = -((k + w(k) / 2) / sqrt(w(k)))
+* - price = N(d2) - phi(d2) * w'(k) / (2 * sqrt(w(k)))
+*
+* Returns the price and `0`, or `none` and the code Predict aborts with where the
+* formula is undefined: a zero forward, a negative inner term, or a non-positive
+* variance.
+*/
+function digital(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [
+		"u128",
+		"bool",
+		"u128",
+		null,
+		null,
+		"u64",
+		"u64",
+		"u64"
+	];
+	const parameterNames = [
+		"aMagnitude",
+		"aIsNegative",
+		"b",
+		"rho",
+		"m",
+		"sigma",
+		"forward",
+		"strike"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "digital",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Whether a rolled surface's minimum total variance over all strikes is positive,
+* at the 1e18 the rolled `a` and `b` are carried in.
+*/
+function varPositive(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [
+		"u128",
+		"bool",
+		"u128",
+		null,
+		"u64"
+	];
+	const parameterNames = [
+		"aMagnitude",
+		"aIsNegative",
+		"b",
+		"rho",
+		"sigma"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "var_positive",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Whether raw Block Scholes inputs fit Predict's pricing-safe envelope: a positive
+* spot and forward, `forward <= max_spot` and `forward <= 100 *  spot`, and SVI
+* `b`, `|rho|`, `|m|`, and `sigma` within their bounds. `a` carries no bound of
+* its own: only total variance has to be positive (`raw_var_ok`), and every
+* downstream use of `a` fits its provider width.
+*/
+function inputsOk(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [
+		"u64",
+		"u64",
+		"u64",
+		null,
+		null,
+		"u64"
+	];
+	const parameterNames = [
+		"spot",
+		"forward",
+		"b",
+		"rho",
+		"m",
+		"sigma"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "inputs_ok",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Whether a raw SVI tuple's minimum total variance
+* `a + b * sigma * sqrt(1 -  rho^2)` is positive, compared rather than summed: `a`
+* reaches `u64::MAX`, where the sum would leave `u64`.
+*/
+function rawVarOk(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [
+		null,
+		"u64",
+		null,
+		"u64"
+	];
+	const parameterNames = [
+		"a",
+		"b",
+		"rho",
+		"sigma"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "raw_var_ok",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* One finite leg's trading fee: `max(bernoulli(p), min_fee) * ramp * quantity`,
+* each product rounded down. `bernoulli(p) = base_fee * sqrt(p * (1 - p))`, zero
+* at `p = 0` or `1`; the caller checks `p <= 1`. The ramp is 1 at or beyond
+* `window_ms` to expiry and rises linearly to `max_multiplier` at expiry, rounded
+* down so the trader keeps the ramp dust.
+*/
+function legFee(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u64",
+		"u64"
+	];
+	const parameterNames = [
+		"baseFee",
+		"minFee",
+		"windowMs",
+		"maxMultiplier",
+		"probability",
+		"quantity",
+		"timeToExpiryMs"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "leg_fee",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* The inventory-impact potential of `liability`: the marginal rate rises linearly
+* from zero to `max_rate` over `scale`, then stays capped:
+*
+* `phi(L) = r_max * L^2 / (2B)` for `L <= B` `phi(L) = phi(B) + r_max * (L - B)`
+* for `L > B`.
+*
+* Defined by this exact sequence of rounded integer operations, so charges and
+* rebates, which always subtract two evaluations, telescope exactly.
+*/
+function potential(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [
+		"u64",
+		"u64",
+		"u64"
+	];
+	const parameterNames = [
+		"maxRate",
+		"scale",
+		"liability"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "potential",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* The largest whole number of `lot`s, at most `max_lots`, whose premium
+* `mul_down(probability, quantity)` fits `max_premium`, as a quantity. The probe
+* is the premium mint admission charges, so the result is exact, and an oversized
+* budget saturates at `max_lots` instead of aborting.
+*/
+function maxQty(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [
+		"u64",
+		"u64",
+		"u64",
+		"u64"
+	];
+	const parameterNames = [
+		"probability",
+		"maxPremium",
+		"lot",
+		"maxLots"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "max_qty",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* The builder fee on a trade with a builder code: `fee_amount * multiplier`,
+* capped at `quantity * max_rate`, each rounded down.
+*/
+function builderFee(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [
+		"u64",
+		"u64",
+		"u64",
+		"u64"
+	];
+	const parameterNames = [
+		"feeAmount",
+		"quantity",
+		"multiplier",
+		"maxRate"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "builder_fee",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Exact-quantity mint cash need: `ceil(quantity * (1 - p)) + 1`, where `p` is the
+* market's minimum entry probability: a fill pays at least `p` per contract into
+* market cash.
+*/
+function needQty(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = ["u64", "u64"];
+	const parameterNames = ["quantity", "p"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "need_qty",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Budget mint cash need: `ceil((budget + 1) * (1 / p - 1)) + 1`. The `budget + 1`
+* covers premiums rounding down, which lets a fill buy up to `1 /  p` raw units
+* more than `budget / p`.
+*/
+function needBudget(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = ["u64", "u64"];
+	const parameterNames = ["budget", "p"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "need_budget",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Sell cash need: `ceil(close_quantity * (1 - lambda)) + 1`. A close lowers payout
+* liability by at least `lambda * close_quantity` and pays at most
+* `close_quantity`.
+*/
+function needSell(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = ["u64", "u64"];
+	const parameterNames = ["closeQuantity", "lambda"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "need_sell",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+/**
+* Decode a packed Predict order ID into `(lower_tick, higher_tick, quantity)`,
+* with the quantity in USDC base units. For the order-flow companion's sell sizing
+* and remainder checks over order IDs Predict issued: it validates nothing. The
+* layout is Predict's frozen order-ID encoding: 30-bit ticks at bits 70 and 40,
+* and a 32-bit count of 10_000-unit lots at bit 100.
+*/
+function orderTerms(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = ["u256"];
+	const parameterNames = ["orderId"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "math",
+		function: "order_terms",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+
+//#endregion
+export { math_exports };
+//# sourceMappingURL=math.mjs.map

package/dist/contracts/deepbook_predict_math/math.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.mjs","names":[],"sources":["../../../src/contracts/deepbook_predict_math/math.ts"],"sourcesContent":["/**************************************************************\n * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *\n **************************************************************/\n\n/**\n * Pure pricing math for Predict, moved out of `deepbook_predict` so the package\n * stays under Sui's object-size limit.\n *\n * Every function takes and returns primitives (and `fixed_math` values) and reads\n * no state, so it cannot move value or see an object. Each body is Predict's own\n * code, moved unchanged: SVI evaluation and the roll-down, the pricing-safe input\n * bounds and minimum-variance checks as booleans, the Bernoulli trading-fee curve\n * with its expiry ramp, the inventory-impact potential, premium sizing, the\n * builder fee, and the order-flow cash-need formulas. Predict keeps every abort:\n * where a check here fails, it returns a boolean or `none`, and Predict asserts\n * with its own error code.\n */\n\nimport { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';\nimport { normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';\nexport interface RollDownArguments {\n\tvalue: RawTransactionArgument<number | bigint>;\n\tremainingMs: RawTransactionArgument<number | bigint>;\n\tanchorTteMs: RawTransactionArgument<number | bigint>;\n}\nexport interface RollDownOptions {\n\tpackage?: string;\n\targuments:\n\t\t| RollDownArguments\n\t\t| [\n\t\t\t\tvalue: RawTransactionArgument<number | bigint>,\n\t\t\t\tremainingMs: RawTransactionArgument<number | bigint>,\n\t\t\t\tanchorTteMs: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * Scale one 1e9-scaled SVI magnitude down by the fraction of anchored time\n * remaining, returning it at 1e18.\n *\n * The roll-down result is kept at 1e18 because the fraction is applied to values\n * that are themselves tiny on short-dated surfaces: a 1e9 floor here costs up to a\n * whole raw unit of `a`, and a short-dated `a` is only about ten raw units, so the\n * truncation alone moves the digital by percent-scale amounts. At 1e18 the same\n * floor is a billionth of that.\n *\n * The `u256` intermediate keeps the product exact for any `expiry_ms` rather than\n * relying on a bound on the anchored horizon. The result is at most\n * `value * 1e9 < 2^64 * 1e9`, so narrowing to `u128` never truncates.\n */\nexport function rollDown(options: RollDownOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u64', 'u64', 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['value', 'remainingMs', 'anchorTteMs'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'roll_down',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface DigitalArguments {\n\taMagnitude: RawTransactionArgument<number | bigint>;\n\taIsNegative: RawTransactionArgument<boolean>;\n\tb: RawTransactionArgument<number | bigint>;\n\trho: TransactionArgument;\n\tm: TransactionArgument;\n\tsigma: RawTransactionArgument<number | bigint>;\n\tforward: RawTransactionArgument<number | bigint>;\n\tstrike: RawTransactionArgument<number | bigint>;\n}\nexport interface DigitalOptions {\n\tpackage?: string;\n\targuments:\n\t\t| DigitalArguments\n\t\t| [\n\t\t\t\taMagnitude: RawTransactionArgument<number | bigint>,\n\t\t\t\taIsNegative: RawTransactionArgument<boolean>,\n\t\t\t\tb: RawTransactionArgument<number | bigint>,\n\t\t\t\trho: TransactionArgument,\n\t\t\t\tm: TransactionArgument,\n\t\t\t\tsigma: RawTransactionArgument<number | bigint>,\n\t\t\t\tforward: RawTransactionArgument<number | bigint>,\n\t\t\t\tstrike: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * The adjusted UP digital for `strike` on a rolled SVI surface (`a` and `b` at\n * 1e18, `rho`, `m`, and `sigma` at 1e9) and `forward`:\n *\n * - k = ln(strike / forward)\n * - w(k) = a + b * (rho * (k - m) + sqrt((k - m)^2 + sigma^2))\n * - d2 = -((k + w(k) / 2) / sqrt(w(k)))\n * - price = N(d2) - phi(d2) * w'(k) / (2 * sqrt(w(k)))\n *\n * Returns the price and `0`, or `none` and the code Predict aborts with where the\n * formula is undefined: a zero forward, a negative inner term, or a non-positive\n * variance.\n */\nexport function digital(options: DigitalOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u128', 'bool', 'u128', null, null, 'u64', 'u64', 'u64'] satisfies (\n\t\tstring | null\n\t)[];\n\tconst parameterNames = [\n\t\t'aMagnitude',\n\t\t'aIsNegative',\n\t\t'b',\n\t\t'rho',\n\t\t'm',\n\t\t'sigma',\n\t\t'forward',\n\t\t'strike',\n\t];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'digital',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface VarPositiveArguments {\n\taMagnitude: RawTransactionArgument<number | bigint>;\n\taIsNegative: RawTransactionArgument<boolean>;\n\tb: RawTransactionArgument<number | bigint>;\n\trho: TransactionArgument;\n\tsigma: RawTransactionArgument<number | bigint>;\n}\nexport interface VarPositiveOptions {\n\tpackage?: string;\n\targuments:\n\t\t| VarPositiveArguments\n\t\t| [\n\t\t\t\taMagnitude: RawTransactionArgument<number | bigint>,\n\t\t\t\taIsNegative: RawTransactionArgument<boolean>,\n\t\t\t\tb: RawTransactionArgument<number | bigint>,\n\t\t\t\trho: TransactionArgument,\n\t\t\t\tsigma: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * Whether a rolled surface's minimum total variance over all strikes is positive,\n * at the 1e18 the rolled `a` and `b` are carried in.\n */\nexport function varPositive(options: VarPositiveOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u128', 'bool', 'u128', null, 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['aMagnitude', 'aIsNegative', 'b', 'rho', 'sigma'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'var_positive',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface InputsOkArguments {\n\tspot: RawTransactionArgument<number | bigint>;\n\tforward: RawTransactionArgument<number | bigint>;\n\tb: RawTransactionArgument<number | bigint>;\n\trho: TransactionArgument;\n\tm: TransactionArgument;\n\tsigma: RawTransactionArgument<number | bigint>;\n}\nexport interface InputsOkOptions {\n\tpackage?: string;\n\targuments:\n\t\t| InputsOkArguments\n\t\t| [\n\t\t\t\tspot: RawTransactionArgument<number | bigint>,\n\t\t\t\tforward: RawTransactionArgument<number | bigint>,\n\t\t\t\tb: RawTransactionArgument<number | bigint>,\n\t\t\t\trho: TransactionArgument,\n\t\t\t\tm: TransactionArgument,\n\t\t\t\tsigma: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * Whether raw Block Scholes inputs fit Predict's pricing-safe envelope: a positive\n * spot and forward, `forward <= max_spot` and `forward <= 100 *  spot`, and SVI\n * `b`, `|rho|`, `|m|`, and `sigma` within their bounds. `a` carries no bound of\n * its own: only total variance has to be positive (`raw_var_ok`), and every\n * downstream use of `a` fits its provider width.\n */\nexport function inputsOk(options: InputsOkOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u64', 'u64', 'u64', null, null, 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['spot', 'forward', 'b', 'rho', 'm', 'sigma'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'inputs_ok',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface RawVarOkArguments {\n\ta: TransactionArgument;\n\tb: RawTransactionArgument<number | bigint>;\n\trho: TransactionArgument;\n\tsigma: RawTransactionArgument<number | bigint>;\n}\nexport interface RawVarOkOptions {\n\tpackage?: string;\n\targuments:\n\t\t| RawVarOkArguments\n\t\t| [\n\t\t\t\ta: TransactionArgument,\n\t\t\t\tb: RawTransactionArgument<number | bigint>,\n\t\t\t\trho: TransactionArgument,\n\t\t\t\tsigma: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * Whether a raw SVI tuple's minimum total variance\n * `a + b * sigma * sqrt(1 -  rho^2)` is positive, compared rather than summed: `a`\n * reaches `u64::MAX`, where the sum would leave `u64`.\n */\nexport function rawVarOk(options: RawVarOkOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = [null, 'u64', null, 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['a', 'b', 'rho', 'sigma'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'raw_var_ok',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface LegFeeArguments {\n\tbaseFee: RawTransactionArgument<number | bigint>;\n\tminFee: RawTransactionArgument<number | bigint>;\n\twindowMs: RawTransactionArgument<number | bigint>;\n\tmaxMultiplier: RawTransactionArgument<number | bigint>;\n\tprobability: RawTransactionArgument<number | bigint>;\n\tquantity: RawTransactionArgument<number | bigint>;\n\ttimeToExpiryMs: RawTransactionArgument<number | bigint>;\n}\nexport interface LegFeeOptions {\n\tpackage?: string;\n\targuments:\n\t\t| LegFeeArguments\n\t\t| [\n\t\t\t\tbaseFee: RawTransactionArgument<number | bigint>,\n\t\t\t\tminFee: RawTransactionArgument<number | bigint>,\n\t\t\t\twindowMs: RawTransactionArgument<number | bigint>,\n\t\t\t\tmaxMultiplier: RawTransactionArgument<number | bigint>,\n\t\t\t\tprobability: RawTransactionArgument<number | bigint>,\n\t\t\t\tquantity: RawTransactionArgument<number | bigint>,\n\t\t\t\ttimeToExpiryMs: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * One finite leg's trading fee: `max(bernoulli(p), min_fee) * ramp * quantity`,\n * each product rounded down. `bernoulli(p) = base_fee * sqrt(p * (1 - p))`, zero\n * at `p = 0` or `1`; the caller checks `p <= 1`. The ramp is 1 at or beyond\n * `window_ms` to expiry and rises linearly to `max_multiplier` at expiry, rounded\n * down so the trader keeps the ramp dust.\n */\nexport function legFee(options: LegFeeOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u64', 'u64', 'u64', 'u64', 'u64', 'u64', 'u64'] satisfies (\n\t\tstring | null\n\t)[];\n\tconst parameterNames = [\n\t\t'baseFee',\n\t\t'minFee',\n\t\t'windowMs',\n\t\t'maxMultiplier',\n\t\t'probability',\n\t\t'quantity',\n\t\t'timeToExpiryMs',\n\t];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'leg_fee',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface PotentialArguments {\n\tmaxRate: RawTransactionArgument<number | bigint>;\n\tscale: RawTransactionArgument<number | bigint>;\n\tliability: RawTransactionArgument<number | bigint>;\n}\nexport interface PotentialOptions {\n\tpackage?: string;\n\targuments:\n\t\t| PotentialArguments\n\t\t| [\n\t\t\t\tmaxRate: RawTransactionArgument<number | bigint>,\n\t\t\t\tscale: RawTransactionArgument<number | bigint>,\n\t\t\t\tliability: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * The inventory-impact potential of `liability`: the marginal rate rises linearly\n * from zero to `max_rate` over `scale`, then stays capped:\n *\n * `phi(L) = r_max * L^2 / (2B)` for `L <= B` `phi(L) = phi(B) + r_max * (L - B)`\n * for `L > B`.\n *\n * Defined by this exact sequence of rounded integer operations, so charges and\n * rebates, which always subtract two evaluations, telescope exactly.\n */\nexport function potential(options: PotentialOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u64', 'u64', 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['maxRate', 'scale', 'liability'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'potential',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface MaxQtyArguments {\n\tprobability: RawTransactionArgument<number | bigint>;\n\tmaxPremium: RawTransactionArgument<number | bigint>;\n\tlot: RawTransactionArgument<number | bigint>;\n\tmaxLots: RawTransactionArgument<number | bigint>;\n}\nexport interface MaxQtyOptions {\n\tpackage?: string;\n\targuments:\n\t\t| MaxQtyArguments\n\t\t| [\n\t\t\t\tprobability: RawTransactionArgument<number | bigint>,\n\t\t\t\tmaxPremium: RawTransactionArgument<number | bigint>,\n\t\t\t\tlot: RawTransactionArgument<number | bigint>,\n\t\t\t\tmaxLots: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * The largest whole number of `lot`s, at most `max_lots`, whose premium\n * `mul_down(probability, quantity)` fits `max_premium`, as a quantity. The probe\n * is the premium mint admission charges, so the result is exact, and an oversized\n * budget saturates at `max_lots` instead of aborting.\n */\nexport function maxQty(options: MaxQtyOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u64', 'u64', 'u64', 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['probability', 'maxPremium', 'lot', 'maxLots'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'max_qty',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface BuilderFeeArguments {\n\tfeeAmount: RawTransactionArgument<number | bigint>;\n\tquantity: RawTransactionArgument<number | bigint>;\n\tmultiplier: RawTransactionArgument<number | bigint>;\n\tmaxRate: RawTransactionArgument<number | bigint>;\n}\nexport interface BuilderFeeOptions {\n\tpackage?: string;\n\targuments:\n\t\t| BuilderFeeArguments\n\t\t| [\n\t\t\t\tfeeAmount: RawTransactionArgument<number | bigint>,\n\t\t\t\tquantity: RawTransactionArgument<number | bigint>,\n\t\t\t\tmultiplier: RawTransactionArgument<number | bigint>,\n\t\t\t\tmaxRate: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * The builder fee on a trade with a builder code: `fee_amount * multiplier`,\n * capped at `quantity * max_rate`, each rounded down.\n */\nexport function builderFee(options: BuilderFeeOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u64', 'u64', 'u64', 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['feeAmount', 'quantity', 'multiplier', 'maxRate'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'builder_fee',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface NeedQtyArguments {\n\tquantity: RawTransactionArgument<number | bigint>;\n\tp: RawTransactionArgument<number | bigint>;\n}\nexport interface NeedQtyOptions {\n\tpackage?: string;\n\targuments:\n\t\t| NeedQtyArguments\n\t\t| [\n\t\t\t\tquantity: RawTransactionArgument<number | bigint>,\n\t\t\t\tp: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * Exact-quantity mint cash need: `ceil(quantity * (1 - p)) + 1`, where `p` is the\n * market's minimum entry probability: a fill pays at least `p` per contract into\n * market cash.\n */\nexport function needQty(options: NeedQtyOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u64', 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['quantity', 'p'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'need_qty',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface NeedBudgetArguments {\n\tbudget: RawTransactionArgument<number | bigint>;\n\tp: RawTransactionArgument<number | bigint>;\n}\nexport interface NeedBudgetOptions {\n\tpackage?: string;\n\targuments:\n\t\t| NeedBudgetArguments\n\t\t| [budget: RawTransactionArgument<number | bigint>, p: RawTransactionArgument<number | bigint>];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * Budget mint cash need: `ceil((budget + 1) * (1 / p - 1)) + 1`. The `budget + 1`\n * covers premiums rounding down, which lets a fill buy up to `1 /  p` raw units\n * more than `budget / p`.\n */\nexport function needBudget(options: NeedBudgetOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u64', 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['budget', 'p'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'need_budget',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface NeedSellArguments {\n\tcloseQuantity: RawTransactionArgument<number | bigint>;\n\tlambda: RawTransactionArgument<number | bigint>;\n}\nexport interface NeedSellOptions {\n\tpackage?: string;\n\targuments:\n\t\t| NeedSellArguments\n\t\t| [\n\t\t\t\tcloseQuantity: RawTransactionArgument<number | bigint>,\n\t\t\t\tlambda: RawTransactionArgument<number | bigint>,\n\t\t  ];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * Sell cash need: `ceil(close_quantity * (1 - lambda)) + 1`. A close lowers payout\n * liability by at least `lambda * close_quantity` and pays at most\n * `close_quantity`.\n */\nexport function needSell(options: NeedSellOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u64', 'u64'] satisfies (string | null)[];\n\tconst parameterNames = ['closeQuantity', 'lambda'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'need_sell',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface OrderTermsArguments {\n\torderId: RawTransactionArgument<number | bigint>;\n}\nexport interface OrderTermsOptions {\n\tpackage?: string;\n\targuments: OrderTermsArguments | [orderId: RawTransactionArgument<number | bigint>];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * Decode a packed Predict order ID into `(lower_tick, higher_tick, quantity)`,\n * with the quantity in USDC base units. For the order-flow companion's sell sizing\n * and remainder checks over order IDs Predict issued: it validates nothing. The\n * layout is Predict's frozen order-ID encoding: 30-bit ticks at bits 70 and 40,\n * and a 32-bit count of 10_000-unit lots at bit 100.\n */\nexport function orderTerms(options: OrderTermsOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = ['u256'] satisfies (string | null)[];\n\tconst parameterNames = ['orderId'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'order_terms',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\n"],"mappings":"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"}

package/dist/contracts/deepbook_predict_orders/config-arguments.d.mts

@@ -0,0 +1,13 @@
+import { ConfigValue } from "../utils/index.mjs";
+
+//#region src/contracts/deepbook_predict_orders/config-arguments.d.ts
+interface DeepbookPredictOrdersConfig {
+  predictOrdersPackageId?: string;
+  orderDesk: ConfigValue;
+  queueRegistry: ConfigValue;
+  protocolConfig: ConfigValue;
+  oracleRegistry: ConfigValue;
+}
+//#endregion
+export { DeepbookPredictOrdersConfig };
+//# sourceMappingURL=config-arguments.d.mts.map

package/dist/contracts/deepbook_predict_orders/config-arguments.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-arguments.d.mts","names":[],"sources":["../../../src/contracts/deepbook_predict_orders/config-arguments.ts"],"mappings":";;;UAIiB,2BAAA;EAChB,sBAAA;EACA,SAAA,EAAW,WAAA;EACX,aAAA,EAAe,WAAA;EACf,cAAA,EAAgB,WAAA;EAChB,cAAA,EAAgB,WAAA;AAAA"}

package/dist/contracts/deepbook_predict_orders/delayed_execution_config.d.mts

@@ -0,0 +1,215 @@
+import { MoveStruct } from "../utils/index.mjs";
+import * as _mysten_sui_bcs476 from "@mysten/sui/bcs";
+import * as _mysten_sui_transactions261 from "@mysten/sui/transactions";
+import { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+
+//#region src/contracts/deepbook_predict_orders/delayed_execution_config.d.ts
+declare namespace delayed_execution_config_d_exports {
+  export { DelayMsArguments, DelayMsOptions, DelayedExecutionPolicy, GapWaitMsArguments, GapWaitMsOptions, MinSellQuantityArguments, MinSellQuantityOptions, MintCapacityArguments, MintCapacityOptions, OrderFeeArguments, OrderFeeOptions, PerAccountCapArguments, PerAccountCapOptions, PythChannelArguments, PythChannelOptions, PythPriceBufferMsArguments, PythPriceBufferMsOptions, SellCapacityArguments, SellCapacityOptions, SettlePayoutBatchArguments, SettlePayoutBatchOptions, SettleRefundBatchArguments, SettleRefundBatchOptions, StallTimeoutMsArguments, StallTimeoutMsOptions, StuckThresholdMsArguments, StuckThresholdMsOptions, SviMaxAgeMsArguments, SviMaxAgeMsOptions, delayMs, gapWaitMs, minSellQuantity, mintCapacity, orderFee, perAccountCap, pythChannel, pythPriceBufferMs, sellCapacity, settlePayoutBatch, settleRefundBatch, stallTimeoutMs, stuckThresholdMs, sviMaxAgeMs };
+}
+declare const DelayedExecutionPolicy: MoveStruct<{
+  /**
+   * Latest τ may fall after placement. τ rounds down to the policy channel's tick at
+   * or before `t₀ + delay_ms`.
+   */
+  delay_ms: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Sets each order's deadline:
+   * `max(min(τ + stall_timeout_ms, expiry), last  deadline)`. At or past it the
+   * order is refunded, never filled.
+   */
+  stall_timeout_ms: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Placement refuses new orders while an uncommitted cohort is this far past its τ
+   * with nothing newer committed, or while two or more uncommitted cohorts are each
+   * this far past their τ.
+   */
+  stuck_threshold_ms: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">; /** Commit accepts a backup tick for a cohort only once now is this far past its τ. */
+  gap_wait_ms: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Switches the backup tick on or off. `0` accepts only the update stamped exactly
+   * τ. Above `0`, once now is `gap_wait_ms` past τ, a cohort also accepts its single
+   * backup: the update stamped one tick of its own stored channel after τ. The value
+   * is not a window: the setter keeps it at `0` or one tick of the policy channel.
+   */
+  pyth_price_buffer_ms: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Pyth Lazer channel new orders are priced on: `2` (`fixed_rate@50ms`) or `3`
+   * (`fixed_rate@200ms`). Its tick period is τ's grid. Each order stores the channel
+   * it was placed under.
+   */
+  pyth_channel: _mysten_sui_bcs476.BcsType<number, number, "u8">;
+  /**
+   * Oldest Block Scholes SVI a placement accepts into an order's volatility
+   * snapshot.
+   */
+  svi_max_age_ms: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">; /** Most unfinished queued mints per market. */
+  mint_capacity: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">; /** Most unfinished queued sells per market. */
+  sell_capacity: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">; /** Most unfinished queued orders per account per market. */
+  per_account_cap: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * Flat fee charged at placement. Kept on a fill and on limit or admission refunds;
+   * returned on every other refund.
+   */
+  order_fee: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">; /** Smallest early-sell close quantity. */
+  min_sell_quantity: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">; /** Most records one `settle_step` call visits while refunding leftover orders. */
+  settle_refund_batch: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">; /** Most records one `settle_step` call visits while paying Open records. */
+  settle_payout_batch: _mysten_sui_bcs476.BcsType<bigint, string | number | bigint, "u64">;
+}, "@local-pkg/deepbook_predict_orders::delayed_execution_config::DelayedExecutionPolicy">;
+interface DelayMsArguments {
+  policy: TransactionArgument;
+}
+interface DelayMsOptions {
+  package?: string;
+  arguments: DelayMsArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function delayMs(options: DelayMsOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface StallTimeoutMsArguments {
+  policy: TransactionArgument;
+}
+interface StallTimeoutMsOptions {
+  package?: string;
+  arguments: StallTimeoutMsArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function stallTimeoutMs(options: StallTimeoutMsOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface StuckThresholdMsArguments {
+  policy: TransactionArgument;
+}
+interface StuckThresholdMsOptions {
+  package?: string;
+  arguments: StuckThresholdMsArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function stuckThresholdMs(options: StuckThresholdMsOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface GapWaitMsArguments {
+  policy: TransactionArgument;
+}
+interface GapWaitMsOptions {
+  package?: string;
+  arguments: GapWaitMsArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function gapWaitMs(options: GapWaitMsOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface PythPriceBufferMsArguments {
+  policy: TransactionArgument;
+}
+interface PythPriceBufferMsOptions {
+  package?: string;
+  arguments: PythPriceBufferMsArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function pythPriceBufferMs(options: PythPriceBufferMsOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface PythChannelArguments {
+  policy: TransactionArgument;
+}
+interface PythChannelOptions {
+  package?: string;
+  arguments: PythChannelArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function pythChannel(options: PythChannelOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface SviMaxAgeMsArguments {
+  policy: TransactionArgument;
+}
+interface SviMaxAgeMsOptions {
+  package?: string;
+  arguments: SviMaxAgeMsArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function sviMaxAgeMs(options: SviMaxAgeMsOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface MintCapacityArguments {
+  policy: TransactionArgument;
+}
+interface MintCapacityOptions {
+  package?: string;
+  arguments: MintCapacityArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function mintCapacity(options: MintCapacityOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface SellCapacityArguments {
+  policy: TransactionArgument;
+}
+interface SellCapacityOptions {
+  package?: string;
+  arguments: SellCapacityArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function sellCapacity(options: SellCapacityOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface PerAccountCapArguments {
+  policy: TransactionArgument;
+}
+interface PerAccountCapOptions {
+  package?: string;
+  arguments: PerAccountCapArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function perAccountCap(options: PerAccountCapOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface OrderFeeArguments {
+  policy: TransactionArgument;
+}
+interface OrderFeeOptions {
+  package?: string;
+  arguments: OrderFeeArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function orderFee(options: OrderFeeOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface MinSellQuantityArguments {
+  policy: TransactionArgument;
+}
+interface MinSellQuantityOptions {
+  package?: string;
+  arguments: MinSellQuantityArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function minSellQuantity(options: MinSellQuantityOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface SettleRefundBatchArguments {
+  policy: TransactionArgument;
+}
+interface SettleRefundBatchOptions {
+  package?: string;
+  arguments: SettleRefundBatchArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function settleRefundBatch(options: SettleRefundBatchOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+interface SettlePayoutBatchArguments {
+  policy: TransactionArgument;
+}
+interface SettlePayoutBatchOptions {
+  package?: string;
+  arguments: SettlePayoutBatchArguments | [policy: TransactionArgument];
+  config?: {
+    predictOrdersPackageId?: string;
+  };
+}
+declare function settlePayoutBatch(options: SettlePayoutBatchOptions): (tx: Transaction) => _mysten_sui_transactions261.TransactionResult;
+//#endregion
+export { DelayedExecutionPolicy, delayed_execution_config_d_exports };
+//# sourceMappingURL=delayed_execution_config.d.mts.map

package/dist/contracts/deepbook_predict_orders/delayed_execution_config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delayed_execution_config.d.mts","names":[],"sources":["../../../src/contracts/deepbook_predict_orders/delayed_execution_config.ts"],"mappings":";;;;;;;;;cAqBa,sBAAA,EAAsB,UAAA;;;;;YA0DjC,kBAAA,CAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA1DF;;;;;;;;;;;4FAAmC;;;UA2DlB,gBAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,cAAA;EAChB,OAAA;EACA,SAAA,EAAW,gBAAA,IAAoB,MAAA,EAAQ,mBAAA;EACvC,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,OAAA,CAAQ,OAAA,EAAS,cAAA,IAOxB,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,uBAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,qBAAA;EAChB,OAAA;EACA,SAAA,EAAW,uBAAA,IAA2B,MAAA,EAAQ,mBAAA;EAC9C,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,cAAA,CAAe,OAAA,EAAS,qBAAA,IAO/B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,yBAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,uBAAA;EAChB,OAAA;EACA,SAAA,EAAW,yBAAA,IAA6B,MAAA,EAAQ,mBAAA;EAChD,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,gBAAA,CAAiB,OAAA,EAAS,uBAAA,IAOjC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,kBAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,gBAAA;EAChB,OAAA;EACA,SAAA,EAAW,kBAAA,IAAsB,MAAA,EAAQ,mBAAA;EACzC,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,SAAA,CAAU,OAAA,EAAS,gBAAA,IAO1B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,0BAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,wBAAA;EAChB,OAAA;EACA,SAAA,EAAW,0BAAA,IAA8B,MAAA,EAAQ,mBAAA;EACjD,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,iBAAA,CAAkB,OAAA,EAAS,wBAAA,IAOlC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,oBAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,kBAAA;EAChB,OAAA;EACA,SAAA,EAAW,oBAAA,IAAwB,MAAA,EAAQ,mBAAA;EAC3C,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,WAAA,CAAY,OAAA,EAAS,kBAAA,IAO5B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,oBAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,kBAAA;EAChB,OAAA;EACA,SAAA,EAAW,oBAAA,IAAwB,MAAA,EAAQ,mBAAA;EAC3C,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,WAAA,CAAY,OAAA,EAAS,kBAAA,IAO5B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,qBAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,mBAAA;EAChB,OAAA;EACA,SAAA,EAAW,qBAAA,IAAyB,MAAA,EAAQ,mBAAA;EAC5C,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,YAAA,CAAa,OAAA,EAAS,mBAAA,IAO7B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,qBAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,mBAAA;EAChB,OAAA;EACA,SAAA,EAAW,qBAAA,IAAyB,MAAA,EAAQ,mBAAA;EAC5C,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,YAAA,CAAa,OAAA,EAAS,mBAAA,IAO7B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,sBAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,oBAAA;EAChB,OAAA;EACA,SAAA,EAAW,sBAAA,IAA0B,MAAA,EAAQ,mBAAA;EAC7C,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,aAAA,CAAc,OAAA,EAAS,oBAAA,IAO9B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,iBAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,eAAA;EAChB,OAAA;EACA,SAAA,EAAW,iBAAA,IAAqB,MAAA,EAAQ,mBAAA;EACxC,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,QAAA,CAAS,OAAA,EAAS,eAAA,IAOzB,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,wBAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,sBAAA;EAChB,OAAA;EACA,SAAA,EAAW,wBAAA,IAA4B,MAAA,EAAQ,mBAAA;EAC/C,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,eAAA,CAAgB,OAAA,EAAS,sBAAA,IAOhC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,0BAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,wBAAA;EAChB,OAAA;EACA,SAAA,EAAW,0BAAA,IAA8B,MAAA,EAAQ,mBAAA;EACjD,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,iBAAA,CAAkB,OAAA,EAAS,wBAAA,IAOlC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,0BAAA;EAChB,MAAA,EAAQ,mBAAA;AAAA;AAAA,UAEQ,wBAAA;EAChB,OAAA;EACA,SAAA,EAAW,0BAAA,IAA8B,MAAA,EAAQ,mBAAA;EACjD,MAAA;IACC,sBAAA;EAAA;AAAA;AAAA,iBAGc,iBAAA,CAAkB,OAAA,EAAS,wBAAA,IAOlC,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA"}