@mysten/deepbook-v3 2.6.4 → 2.8.0

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

@@ -0,0 +1,10 @@
+//#region src/contracts/deepbook_predict_math/config-arguments.d.ts
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+interface DeepbookPredictMathConfig {
+  predictMathPackageId?: string;
+}
+//#endregion
+export { DeepbookPredictMathConfig };
+//# sourceMappingURL=config-arguments.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config-arguments.d.mts","names":[],"sources":["../../../src/contracts/deepbook_predict_math/config-arguments.ts"],"mappings":";;AAGA;;UAAiB,yBAAA;EAChB,oBAAA;AAAA"}

package/dist/contracts/deepbook_predict_math/lazer_price.d.mts

@@ -0,0 +1,106 @@
+import { MoveStruct, RawTransactionArgument } from "../utils/index.mjs";
+import * as _mysten_sui_bcs752 from "@mysten/sui/bcs";
+import * as _mysten_sui_transactions350 from "@mysten/sui/transactions";
+import { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+
+//#region src/contracts/deepbook_predict_math/lazer_price.d.ts
+declare namespace lazer_price_d_exports {
+  export { ChannelArguments, ChannelOptions, EnvelopeUsArguments, EnvelopeUsOptions, FeedIdArguments, FeedIdOptions, FromUpdateArguments, FromUpdateOptions, GenerationUsArguments, GenerationUsOptions, LazerPrice, SpotArguments, SpotOptions, channel, envelopeUs, feedId, fromUpdate, generationUs, spot };
+}
+declare const LazerPrice: MoveStruct<{
+  feed_id: _mysten_sui_bcs752.BcsType<number, number, "u32">;
+  /**
+   * A Lazer channel id: `channel_fixed_rate_50ms!()`, `channel_fixed_rate_200ms!()`,
+   * or `1` for real-time.
+   */
+  channel: _mysten_sui_bcs752.BcsType<number, number, "u8">; /** The update's timestamp, in µs. */
+  envelope_us: _mysten_sui_bcs752.BcsType<bigint, string | number | bigint, "u64">; /** The feed's own update time, in µs. Never after the envelope. */
+  generation_us: _mysten_sui_bcs752.BcsType<bigint, string | number | bigint, "u64">;
+  /**
+   * The price normalized to 1e9, rounded down when the source is finer; positive and
+   * at most `u64::MAX / 100`.
+   */
+  spot: _mysten_sui_bcs752.BcsType<bigint, string | number | bigint, "u64">;
+}, "@local-pkg/deepbook_predict_math::lazer_price::LazerPrice">;
+interface FromUpdateArguments {
+  update: TransactionArgument;
+  feedId: RawTransactionArgument<number>;
+}
+interface FromUpdateOptions {
+  package?: string;
+  arguments: FromUpdateArguments | [update: TransactionArgument, feedId: RawTransactionArgument<number>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * Decode `feed_id` from a verified Lazer update. `none` when the feed's price or
+ * update time is empty at this tick, or its price does not normalize to a
+ * pricing-safe spot. Aborts `EFeedMissing` when the update does not carry the feed
+ * and `EPropertyNotRequested` when the feed lacks the price, exponent, or
+ * update-time property, because the caller then passed the wrong update, and
+ * `EGenerationAfterEnvelope` when the feed claims an update time after the
+ * envelope that carries it.
+ *
+ * Uses Lazer's v1 `Update`, which Pyth marked deprecated on Mainnet but still
+ * serves; a later library upgrade adds a constructor for v2.
+ */
+declare function fromUpdate(options: FromUpdateOptions): (tx: Transaction) => _mysten_sui_transactions350.TransactionResult;
+interface FeedIdArguments {
+  price: TransactionArgument;
+}
+interface FeedIdOptions {
+  package?: string;
+  arguments: FeedIdArguments | [price: TransactionArgument];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+declare function feedId(options: FeedIdOptions): (tx: Transaction) => _mysten_sui_transactions350.TransactionResult;
+interface ChannelArguments {
+  price: TransactionArgument;
+}
+interface ChannelOptions {
+  package?: string;
+  arguments: ChannelArguments | [price: TransactionArgument];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+declare function channel(options: ChannelOptions): (tx: Transaction) => _mysten_sui_transactions350.TransactionResult;
+interface EnvelopeUsArguments {
+  price: TransactionArgument;
+}
+interface EnvelopeUsOptions {
+  package?: string;
+  arguments: EnvelopeUsArguments | [price: TransactionArgument];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+declare function envelopeUs(options: EnvelopeUsOptions): (tx: Transaction) => _mysten_sui_transactions350.TransactionResult;
+interface GenerationUsArguments {
+  price: TransactionArgument;
+}
+interface GenerationUsOptions {
+  package?: string;
+  arguments: GenerationUsArguments | [price: TransactionArgument];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+declare function generationUs(options: GenerationUsOptions): (tx: Transaction) => _mysten_sui_transactions350.TransactionResult;
+interface SpotArguments {
+  price: TransactionArgument;
+}
+interface SpotOptions {
+  package?: string;
+  arguments: SpotArguments | [price: TransactionArgument];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+declare function spot(options: SpotOptions): (tx: Transaction) => _mysten_sui_transactions350.TransactionResult;
+//#endregion
+export { lazer_price_d_exports };
+//# sourceMappingURL=lazer_price.d.mts.map

package/dist/contracts/deepbook_predict_math/lazer_price.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazer_price.d.mts","names":[],"sources":["../../../src/contracts/deepbook_predict_math/lazer_price.ts"],"mappings":";;;;;;;;;cAwBa,UAAA,EAAU,UAAA;WAmBrB,kBAAA,CAAA,OAAA;;;;;;oFAnBW;;;;;;;;UAoBI,mBAAA;EAChB,MAAA,EAAQ,mBAAA;EACR,MAAA,EAAQ,sBAAA;AAAA;AAAA,UAEQ,iBAAA;EAChB,OAAA;EACA,SAAA,EACC,mBAAA,IAAuB,MAAA,EAAQ,mBAAA,EAAqB,MAAA,EAAQ,sBAAA;EAC7D,MAAA;IACC,oBAAA;EAAA;AAAA;;;;;;AATF;;;;;;;iBAwBgB,UAAA,CAAW,OAAA,EAAS,iBAAA,IAK3B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,eAAA;EAChB,KAAA,EAAO,mBAAA;AAAA;AAAA,UAES,aAAA;EAChB,OAAA;EACA,SAAA,EAAW,eAAA,IAAmB,KAAA,EAAO,mBAAA;EACrC,MAAA;IACC,oBAAA;EAAA;AAAA;AAAA,iBAGc,MAAA,CAAO,OAAA,EAAS,aAAA,IAKvB,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,gBAAA;EAChB,KAAA,EAAO,mBAAA;AAAA;AAAA,UAES,cAAA;EAChB,OAAA;EACA,SAAA,EAAW,gBAAA,IAAoB,KAAA,EAAO,mBAAA;EACtC,MAAA;IACC,oBAAA;EAAA;AAAA;AAAA,iBAGc,OAAA,CAAQ,OAAA,EAAS,cAAA,IAKxB,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,mBAAA;EAChB,KAAA,EAAO,mBAAA;AAAA;AAAA,UAES,iBAAA;EAChB,OAAA;EACA,SAAA,EAAW,mBAAA,IAAuB,KAAA,EAAO,mBAAA;EACzC,MAAA;IACC,oBAAA;EAAA;AAAA;AAAA,iBAGc,UAAA,CAAW,OAAA,EAAS,iBAAA,IAK3B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,qBAAA;EAChB,KAAA,EAAO,mBAAA;AAAA;AAAA,UAES,mBAAA;EAChB,OAAA;EACA,SAAA,EAAW,qBAAA,IAAyB,KAAA,EAAO,mBAAA;EAC3C,MAAA;IACC,oBAAA;EAAA;AAAA;AAAA,iBAGc,YAAA,CAAa,OAAA,EAAS,mBAAA,IAK7B,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA;AAAA,UAQP,aAAA;EAChB,KAAA,EAAO,mBAAA;AAAA;AAAA,UAES,WAAA;EAChB,OAAA;EACA,SAAA,EAAW,aAAA,IAAiB,KAAA,EAAO,mBAAA;EACnC,MAAA;IACC,oBAAA;EAAA;AAAA;AAAA,iBAGc,IAAA,CAAK,OAAA,EAAS,WAAA,IAKrB,EAAA,EAAI,WAAA,KAAW,2BAAA,CAAA,iBAAA"}

package/dist/contracts/deepbook_predict_math/lazer_price.mjs

@@ -0,0 +1,125 @@
+import { __exportAll } from "../../_virtual/rolldown_runtime.mjs";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.mjs";
+import { U64 } from "../../bcs/integers.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/deepbook_predict_math/lazer_price.ts
+/**************************************************************
+* THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+**************************************************************/
+/**
+* A Pyth Lazer price decoded from a verified update, for Predict's order-flow
+* commit.
+*
+* A `LazerPrice` is built only from a `pyth_lazer::update::Update`, which only
+* Pyth's verifier produces, so holding one proves a Pyth signature over its feed,
+* channel, timestamps, and price. It has `copy` and `drop` but not `store`, so it
+* lives within one transaction. The decode is Predict v4's queue commit decode: it
+* aborts on an update that does not carry the requested feed or lacks its price,
+* exponent, or feed-update-time property, because the caller then passed the wrong
+* update, and it returns `none` only when the feed has no usable price at that
+* tick: an empty price or update time, or a price that does not normalize to
+* Predict's pricing-safe 1e9 spot.
+*/
+var lazer_price_exports = /* @__PURE__ */ __exportAll({
+	LazerPrice: () => LazerPrice,
+	channel: () => channel,
+	envelopeUs: () => envelopeUs,
+	feedId: () => feedId,
+	fromUpdate: () => fromUpdate,
+	generationUs: () => generationUs,
+	spot: () => spot
+});
+const $moduleName = "@local-pkg/deepbook_predict_math::lazer_price";
+const LazerPrice = new MoveStruct({
+	name: `${$moduleName}::LazerPrice`,
+	fields: {
+		feed_id: bcs.u32(),
+		channel: bcs.u8(),
+		envelope_us: U64,
+		generation_us: U64,
+		spot: U64
+	}
+});
+/**
+* Decode `feed_id` from a verified Lazer update. `none` when the feed's price or
+* update time is empty at this tick, or its price does not normalize to a
+* pricing-safe spot. Aborts `EFeedMissing` when the update does not carry the feed
+* and `EPropertyNotRequested` when the feed lacks the price, exponent, or
+* update-time property, because the caller then passed the wrong update, and
+* `EGenerationAfterEnvelope` when the feed claims an update time after the
+* envelope that carries it.
+*
+* Uses Lazer's v1 `Update`, which Pyth marked deprecated on Mainnet but still
+* serves; a later library upgrade adds a constructor for v2.
+*/
+function fromUpdate(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [null, "u32"];
+	const parameterNames = ["update", "feedId"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "lazer_price",
+		function: "from_update",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function feedId(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [null];
+	const parameterNames = ["price"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "lazer_price",
+		function: "feed_id",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function channel(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [null];
+	const parameterNames = ["price"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "lazer_price",
+		function: "channel",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function envelopeUs(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [null];
+	const parameterNames = ["price"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "lazer_price",
+		function: "envelope_us",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function generationUs(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [null];
+	const parameterNames = ["price"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "lazer_price",
+		function: "generation_us",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+function spot(options) {
+	const packageAddress = options.package ?? options.config?.predictMathPackageId ?? "@local-pkg/deepbook_predict_math";
+	const argumentsTypes = [null];
+	const parameterNames = ["price"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "lazer_price",
+		function: "spot",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+	});
+}
+
+//#endregion
+export { lazer_price_exports };
+//# sourceMappingURL=lazer_price.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazer_price.mjs","names":[],"sources":["../../../src/contracts/deepbook_predict_math/lazer_price.ts"],"sourcesContent":["/**************************************************************\n * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *\n **************************************************************/\n\n/**\n * A Pyth Lazer price decoded from a verified update, for Predict's order-flow\n * commit.\n *\n * A `LazerPrice` is built only from a `pyth_lazer::update::Update`, which only\n * Pyth's verifier produces, so holding one proves a Pyth signature over its feed,\n * channel, timestamps, and price. It has `copy` and `drop` but not `store`, so it\n * lives within one transaction. The decode is Predict v4's queue commit decode: it\n * aborts on an update that does not carry the requested feed or lacks its price,\n * exponent, or feed-update-time property, because the caller then passed the wrong\n * update, and it returns `none` only when the feed has no usable price at that\n * tick: an empty price or update time, or a price that does not normalize to\n * Predict's pricing-safe 1e9 spot.\n */\n\nimport { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';\nimport { bcs } from '@mysten/sui/bcs';\nimport { U64 } from '../../bcs/integers.js';\nimport { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';\nconst $moduleName = '@local-pkg/deepbook_predict_math::lazer_price';\nexport const LazerPrice = new MoveStruct({\n\tname: `${$moduleName}::LazerPrice`,\n\tfields: {\n\t\tfeed_id: bcs.u32(),\n\t\t/**\n\t\t * A Lazer channel id: `channel_fixed_rate_50ms!()`, `channel_fixed_rate_200ms!()`,\n\t\t * or `1` for real-time.\n\t\t */\n\t\tchannel: bcs.u8(),\n\t\t/** The update's timestamp, in µs. */\n\t\tenvelope_us: U64,\n\t\t/** The feed's own update time, in µs. Never after the envelope. */\n\t\tgeneration_us: U64,\n\t\t/**\n\t\t * The price normalized to 1e9, rounded down when the source is finer; positive and\n\t\t * at most `u64::MAX / 100`.\n\t\t */\n\t\tspot: U64,\n\t},\n});\nexport interface FromUpdateArguments {\n\tupdate: TransactionArgument;\n\tfeedId: RawTransactionArgument<number>;\n}\nexport interface FromUpdateOptions {\n\tpackage?: string;\n\targuments:\n\t\tFromUpdateArguments | [update: TransactionArgument, feedId: RawTransactionArgument<number>];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\n/**\n * Decode `feed_id` from a verified Lazer update. `none` when the feed's price or\n * update time is empty at this tick, or its price does not normalize to a\n * pricing-safe spot. Aborts `EFeedMissing` when the update does not carry the feed\n * and `EPropertyNotRequested` when the feed lacks the price, exponent, or\n * update-time property, because the caller then passed the wrong update, and\n * `EGenerationAfterEnvelope` when the feed claims an update time after the\n * envelope that carries it.\n *\n * Uses Lazer's v1 `Update`, which Pyth marked deprecated on Mainnet but still\n * serves; a later library upgrade adds a constructor for v2.\n */\nexport function fromUpdate(options: FromUpdateOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = [null, 'u32'] satisfies (string | null)[];\n\tconst parameterNames = ['update', 'feedId'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'lazer_price',\n\t\t\tfunction: 'from_update',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface FeedIdArguments {\n\tprice: TransactionArgument;\n}\nexport interface FeedIdOptions {\n\tpackage?: string;\n\targuments: FeedIdArguments | [price: TransactionArgument];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\nexport function feedId(options: FeedIdOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['price'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'lazer_price',\n\t\t\tfunction: 'feed_id',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface ChannelArguments {\n\tprice: TransactionArgument;\n}\nexport interface ChannelOptions {\n\tpackage?: string;\n\targuments: ChannelArguments | [price: TransactionArgument];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\nexport function channel(options: ChannelOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['price'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'lazer_price',\n\t\t\tfunction: 'channel',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface EnvelopeUsArguments {\n\tprice: TransactionArgument;\n}\nexport interface EnvelopeUsOptions {\n\tpackage?: string;\n\targuments: EnvelopeUsArguments | [price: TransactionArgument];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\nexport function envelopeUs(options: EnvelopeUsOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['price'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'lazer_price',\n\t\t\tfunction: 'envelope_us',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface GenerationUsArguments {\n\tprice: TransactionArgument;\n}\nexport interface GenerationUsOptions {\n\tpackage?: string;\n\targuments: GenerationUsArguments | [price: TransactionArgument];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\nexport function generationUs(options: GenerationUsOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['price'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'lazer_price',\n\t\t\tfunction: 'generation_us',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface SpotArguments {\n\tprice: TransactionArgument;\n}\nexport interface SpotOptions {\n\tpackage?: string;\n\targuments: SpotArguments | [price: TransactionArgument];\n\tconfig?: {\n\t\tpredictMathPackageId?: string;\n\t};\n}\nexport function spot(options: SpotOptions) {\n\tconst packageAddress =\n\t\toptions.package ?? options.config?.predictMathPackageId ?? '@local-pkg/deepbook_predict_math';\n\tconst argumentsTypes = [null] satisfies (string | null)[];\n\tconst parameterNames = ['price'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'lazer_price',\n\t\t\tfunction: 'spot',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,cAAc;AACpB,MAAa,aAAa,IAAI,WAAW;CACxC,MAAM,GAAG,YAAY;CACrB,QAAQ;EACP,SAAS,IAAI,KAAK;EAKlB,SAAS,IAAI,IAAI;EAEjB,aAAa;EAEb,eAAe;EAKf,MAAM;EACN;CACD,CAAC;;;;;;;;;;;;;AAyBF,SAAgB,WAAW,SAA4B;CACtD,MAAM,iBACL,QAAQ,WAAW,QAAQ,QAAQ,wBAAwB;CAC5D,MAAM,iBAAiB,CAAC,MAAM,MAAM;CACpC,MAAM,iBAAiB,CAAC,UAAU,SAAS;AAC3C,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,CAAC;;AAYJ,SAAgB,OAAO,SAAwB;CAC9C,MAAM,iBACL,QAAQ,WAAW,QAAQ,QAAQ,wBAAwB;CAC5D,MAAM,iBAAiB,CAAC,KAAK;CAC7B,MAAM,iBAAiB,CAAC,QAAQ;AAChC,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,CAAC;;AAYJ,SAAgB,QAAQ,SAAyB;CAChD,MAAM,iBACL,QAAQ,WAAW,QAAQ,QAAQ,wBAAwB;CAC5D,MAAM,iBAAiB,CAAC,KAAK;CAC7B,MAAM,iBAAiB,CAAC,QAAQ;AAChC,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,CAAC;;AAYJ,SAAgB,WAAW,SAA4B;CACtD,MAAM,iBACL,QAAQ,WAAW,QAAQ,QAAQ,wBAAwB;CAC5D,MAAM,iBAAiB,CAAC,KAAK;CAC7B,MAAM,iBAAiB,CAAC,QAAQ;AAChC,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,CAAC;;AAYJ,SAAgB,aAAa,SAA8B;CAC1D,MAAM,iBACL,QAAQ,WAAW,QAAQ,QAAQ,wBAAwB;CAC5D,MAAM,iBAAiB,CAAC,KAAK;CAC7B,MAAM,iBAAiB,CAAC,QAAQ;AAChC,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,CAAC;;AAYJ,SAAgB,KAAK,SAAsB;CAC1C,MAAM,iBACL,QAAQ,WAAW,QAAQ,QAAQ,wBAAwB;CAC5D,MAAM,iBAAiB,CAAC,KAAK;CAC7B,MAAM,iBAAiB,CAAC,QAAQ;AAChC,SAAQ,OACP,GAAG,SAAS;EACX,SAAS;EACT,QAAQ;EACR,UAAU;EACV,WAAW,uBAAuB,QAAQ,WAAW,gBAAgB,eAAe;EACpF,CAAC"}

package/dist/contracts/deepbook_predict_math/math.d.mts

@@ -0,0 +1,284 @@
+import { RawTransactionArgument } from "../utils/index.mjs";
+import * as _mysten_sui_transactions337 from "@mysten/sui/transactions";
+import { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+
+//#region src/contracts/deepbook_predict_math/math.d.ts
+declare namespace math_d_exports {
+  export { BuilderFeeArguments, BuilderFeeOptions, DigitalArguments, DigitalOptions, InputsOkArguments, InputsOkOptions, LegFeeArguments, LegFeeOptions, MaxQtyArguments, MaxQtyOptions, NeedBudgetArguments, NeedBudgetOptions, NeedQtyArguments, NeedQtyOptions, NeedSellArguments, NeedSellOptions, OrderTermsArguments, OrderTermsOptions, PotentialArguments, PotentialOptions, RawVarOkArguments, RawVarOkOptions, RollDownArguments, RollDownOptions, VarPositiveArguments, VarPositiveOptions, builderFee, digital, inputsOk, legFee, maxQty, needBudget, needQty, needSell, orderTerms, potential, rawVarOk, rollDown, varPositive };
+}
+interface RollDownArguments {
+  value: RawTransactionArgument<number | bigint>;
+  remainingMs: RawTransactionArgument<number | bigint>;
+  anchorTteMs: RawTransactionArgument<number | bigint>;
+}
+interface RollDownOptions {
+  package?: string;
+  arguments: RollDownArguments | [value: RawTransactionArgument<number | bigint>, remainingMs: RawTransactionArgument<number | bigint>, anchorTteMs: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function rollDown(options: RollDownOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface DigitalArguments {
+  aMagnitude: RawTransactionArgument<number | bigint>;
+  aIsNegative: RawTransactionArgument<boolean>;
+  b: RawTransactionArgument<number | bigint>;
+  rho: TransactionArgument;
+  m: TransactionArgument;
+  sigma: RawTransactionArgument<number | bigint>;
+  forward: RawTransactionArgument<number | bigint>;
+  strike: RawTransactionArgument<number | bigint>;
+}
+interface DigitalOptions {
+  package?: string;
+  arguments: DigitalArguments | [aMagnitude: RawTransactionArgument<number | bigint>, aIsNegative: RawTransactionArgument<boolean>, b: RawTransactionArgument<number | bigint>, rho: TransactionArgument, m: TransactionArgument, sigma: RawTransactionArgument<number | bigint>, forward: RawTransactionArgument<number | bigint>, strike: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function digital(options: DigitalOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface VarPositiveArguments {
+  aMagnitude: RawTransactionArgument<number | bigint>;
+  aIsNegative: RawTransactionArgument<boolean>;
+  b: RawTransactionArgument<number | bigint>;
+  rho: TransactionArgument;
+  sigma: RawTransactionArgument<number | bigint>;
+}
+interface VarPositiveOptions {
+  package?: string;
+  arguments: VarPositiveArguments | [aMagnitude: RawTransactionArgument<number | bigint>, aIsNegative: RawTransactionArgument<boolean>, b: RawTransactionArgument<number | bigint>, rho: TransactionArgument, sigma: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * Whether a rolled surface's minimum total variance over all strikes is positive,
+ * at the 1e18 the rolled `a` and `b` are carried in.
+ */
+declare function varPositive(options: VarPositiveOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface InputsOkArguments {
+  spot: RawTransactionArgument<number | bigint>;
+  forward: RawTransactionArgument<number | bigint>;
+  b: RawTransactionArgument<number | bigint>;
+  rho: TransactionArgument;
+  m: TransactionArgument;
+  sigma: RawTransactionArgument<number | bigint>;
+}
+interface InputsOkOptions {
+  package?: string;
+  arguments: InputsOkArguments | [spot: RawTransactionArgument<number | bigint>, forward: RawTransactionArgument<number | bigint>, b: RawTransactionArgument<number | bigint>, rho: TransactionArgument, m: TransactionArgument, sigma: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function inputsOk(options: InputsOkOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface RawVarOkArguments {
+  a: TransactionArgument;
+  b: RawTransactionArgument<number | bigint>;
+  rho: TransactionArgument;
+  sigma: RawTransactionArgument<number | bigint>;
+}
+interface RawVarOkOptions {
+  package?: string;
+  arguments: RawVarOkArguments | [a: TransactionArgument, b: RawTransactionArgument<number | bigint>, rho: TransactionArgument, sigma: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * 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`.
+ */
+declare function rawVarOk(options: RawVarOkOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface LegFeeArguments {
+  baseFee: RawTransactionArgument<number | bigint>;
+  minFee: RawTransactionArgument<number | bigint>;
+  windowMs: RawTransactionArgument<number | bigint>;
+  maxMultiplier: RawTransactionArgument<number | bigint>;
+  probability: RawTransactionArgument<number | bigint>;
+  quantity: RawTransactionArgument<number | bigint>;
+  timeToExpiryMs: RawTransactionArgument<number | bigint>;
+}
+interface LegFeeOptions {
+  package?: string;
+  arguments: LegFeeArguments | [baseFee: RawTransactionArgument<number | bigint>, minFee: RawTransactionArgument<number | bigint>, windowMs: RawTransactionArgument<number | bigint>, maxMultiplier: RawTransactionArgument<number | bigint>, probability: RawTransactionArgument<number | bigint>, quantity: RawTransactionArgument<number | bigint>, timeToExpiryMs: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function legFee(options: LegFeeOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface PotentialArguments {
+  maxRate: RawTransactionArgument<number | bigint>;
+  scale: RawTransactionArgument<number | bigint>;
+  liability: RawTransactionArgument<number | bigint>;
+}
+interface PotentialOptions {
+  package?: string;
+  arguments: PotentialArguments | [maxRate: RawTransactionArgument<number | bigint>, scale: RawTransactionArgument<number | bigint>, liability: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function potential(options: PotentialOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface MaxQtyArguments {
+  probability: RawTransactionArgument<number | bigint>;
+  maxPremium: RawTransactionArgument<number | bigint>;
+  lot: RawTransactionArgument<number | bigint>;
+  maxLots: RawTransactionArgument<number | bigint>;
+}
+interface MaxQtyOptions {
+  package?: string;
+  arguments: MaxQtyArguments | [probability: RawTransactionArgument<number | bigint>, maxPremium: RawTransactionArgument<number | bigint>, lot: RawTransactionArgument<number | bigint>, maxLots: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function maxQty(options: MaxQtyOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface BuilderFeeArguments {
+  feeAmount: RawTransactionArgument<number | bigint>;
+  quantity: RawTransactionArgument<number | bigint>;
+  multiplier: RawTransactionArgument<number | bigint>;
+  maxRate: RawTransactionArgument<number | bigint>;
+}
+interface BuilderFeeOptions {
+  package?: string;
+  arguments: BuilderFeeArguments | [feeAmount: RawTransactionArgument<number | bigint>, quantity: RawTransactionArgument<number | bigint>, multiplier: RawTransactionArgument<number | bigint>, maxRate: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * The builder fee on a trade with a builder code: `fee_amount * multiplier`,
+ * capped at `quantity * max_rate`, each rounded down.
+ */
+declare function builderFee(options: BuilderFeeOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface NeedQtyArguments {
+  quantity: RawTransactionArgument<number | bigint>;
+  p: RawTransactionArgument<number | bigint>;
+}
+interface NeedQtyOptions {
+  package?: string;
+  arguments: NeedQtyArguments | [quantity: RawTransactionArgument<number | bigint>, p: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function needQty(options: NeedQtyOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface NeedBudgetArguments {
+  budget: RawTransactionArgument<number | bigint>;
+  p: RawTransactionArgument<number | bigint>;
+}
+interface NeedBudgetOptions {
+  package?: string;
+  arguments: NeedBudgetArguments | [budget: RawTransactionArgument<number | bigint>, p: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * 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`.
+ */
+declare function needBudget(options: NeedBudgetOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface NeedSellArguments {
+  closeQuantity: RawTransactionArgument<number | bigint>;
+  lambda: RawTransactionArgument<number | bigint>;
+}
+interface NeedSellOptions {
+  package?: string;
+  arguments: NeedSellArguments | [closeQuantity: RawTransactionArgument<number | bigint>, lambda: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * 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`.
+ */
+declare function needSell(options: NeedSellOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+interface OrderTermsArguments {
+  orderId: RawTransactionArgument<number | bigint>;
+}
+interface OrderTermsOptions {
+  package?: string;
+  arguments: OrderTermsArguments | [orderId: RawTransactionArgument<number | bigint>];
+  config?: {
+    predictMathPackageId?: string;
+  };
+}
+/**
+ * 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.
+ */
+declare function orderTerms(options: OrderTermsOptions): (tx: Transaction) => _mysten_sui_transactions337.TransactionResult;
+//#endregion
+export { math_d_exports };
+//# sourceMappingURL=math.d.mts.map

package/dist/contracts/deepbook_predict_math/math.d.mts.map

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