@haneullabs/deepbook-v3 0.1.0

package/dist/cjs/contracts/deepbook/history.d.ts

@@ -0,0 +1,60 @@
+/**
+ * History module tracks the volume data for the current epoch and past epochs. It
+ * also tracks past trade params. Past maker fees are used to calculate fills for
+ * old orders. The historic median is used to calculate rebates and burns.
+ */
+import { MoveStruct } from '../utils/index.js';
+export declare const Volumes: MoveStruct<{
+    total_volume: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+    total_staked_volume: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+    total_fees_collected: MoveStruct<{
+        base: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        quote: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        deep: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "@deepbook/core::balances::Balances">;
+    historic_median: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+    trade_params: MoveStruct<{
+        taker_fee: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        maker_fee: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        stake_required: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "@deepbook/core::trade_params::TradeParams">;
+}, "@deepbook/core::history::Volumes">;
+export declare const History: MoveStruct<{
+    epoch: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    epoch_created: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    volumes: MoveStruct<{
+        total_volume: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+        total_staked_volume: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+        total_fees_collected: MoveStruct<{
+            base: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+            quote: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+            deep: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        }, "@deepbook/core::balances::Balances">;
+        historic_median: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+        trade_params: MoveStruct<{
+            taker_fee: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+            maker_fee: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+            stake_required: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        }, "@deepbook/core::trade_params::TradeParams">;
+    }, "@deepbook/core::history::Volumes">;
+    historic_volumes: MoveStruct<{
+        id: MoveStruct<{
+            id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        size: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table">;
+    balance_to_burn: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@deepbook/core::history::History">;
+export declare const EpochData: MoveStruct<{
+    epoch: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    pool_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    total_volume: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+    total_staked_volume: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+    base_fees_collected: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    quote_fees_collected: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    deep_fees_collected: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    historic_median: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+    taker_fee: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    maker_fee: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    stake_required: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@deepbook/core::history::EpochData">;

package/dist/cjs/contracts/deepbook/history.js

@@ -0,0 +1,78 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var history_exports = {};
+__export(history_exports, {
+  EpochData: () => EpochData,
+  History: () => History,
+  Volumes: () => Volumes
+});
+module.exports = __toCommonJS(history_exports);
+var import_utils = require("../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+var balances = __toESM(require("./balances.js"));
+var trade_params = __toESM(require("./trade_params.js"));
+var table = __toESM(require("./deps/sui/table.js"));
+const $moduleName = "@deepbook/core::history";
+const Volumes = new import_utils.MoveStruct({
+  name: `${$moduleName}::Volumes`,
+  fields: {
+    total_volume: import_bcs.bcs.u128(),
+    total_staked_volume: import_bcs.bcs.u128(),
+    total_fees_collected: balances.Balances,
+    historic_median: import_bcs.bcs.u128(),
+    trade_params: trade_params.TradeParams
+  }
+});
+const History = new import_utils.MoveStruct({
+  name: `${$moduleName}::History`,
+  fields: {
+    epoch: import_bcs.bcs.u64(),
+    epoch_created: import_bcs.bcs.u64(),
+    volumes: Volumes,
+    historic_volumes: table.Table,
+    balance_to_burn: import_bcs.bcs.u64()
+  }
+});
+const EpochData = new import_utils.MoveStruct({
+  name: `${$moduleName}::EpochData`,
+  fields: {
+    epoch: import_bcs.bcs.u64(),
+    pool_id: import_bcs.bcs.Address,
+    total_volume: import_bcs.bcs.u128(),
+    total_staked_volume: import_bcs.bcs.u128(),
+    base_fees_collected: import_bcs.bcs.u64(),
+    quote_fees_collected: import_bcs.bcs.u64(),
+    deep_fees_collected: import_bcs.bcs.u64(),
+    historic_median: import_bcs.bcs.u128(),
+    taker_fee: import_bcs.bcs.u64(),
+    maker_fee: import_bcs.bcs.u64(),
+    stake_required: import_bcs.bcs.u64()
+  }
+});
+//# sourceMappingURL=history.js.map

package/dist/cjs/contracts/deepbook/history.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/contracts/deepbook/history.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * History module tracks the volume data for the current epoch and past epochs. It\n * also tracks past trade params. Past maker fees are used to calculate fills for\n * old orders. The historic median is used to calculate rebates and burns.\n */\n\nimport { MoveStruct } from '../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport * as balances from './balances.js';\nimport * as trade_params from './trade_params.js';\nimport * as table from './deps/sui/table.js';\nconst $moduleName = '@deepbook/core::history';\nexport const Volumes = new MoveStruct({\n\tname: `${$moduleName}::Volumes`,\n\tfields: {\n\t\ttotal_volume: bcs.u128(),\n\t\ttotal_staked_volume: bcs.u128(),\n\t\ttotal_fees_collected: balances.Balances,\n\t\thistoric_median: bcs.u128(),\n\t\ttrade_params: trade_params.TradeParams,\n\t},\n});\nexport const History = new MoveStruct({\n\tname: `${$moduleName}::History`,\n\tfields: {\n\t\tepoch: bcs.u64(),\n\t\tepoch_created: bcs.u64(),\n\t\tvolumes: Volumes,\n\t\thistoric_volumes: table.Table,\n\t\tbalance_to_burn: bcs.u64(),\n\t},\n});\nexport const EpochData = new MoveStruct({\n\tname: `${$moduleName}::EpochData`,\n\tfields: {\n\t\tepoch: bcs.u64(),\n\t\tpool_id: bcs.Address,\n\t\ttotal_volume: bcs.u128(),\n\t\ttotal_staked_volume: bcs.u128(),\n\t\tbase_fees_collected: bcs.u64(),\n\t\tquote_fees_collected: bcs.u64(),\n\t\tdeep_fees_collected: bcs.u64(),\n\t\thistoric_median: bcs.u128(),\n\t\ttaker_fee: bcs.u64(),\n\t\tmaker_fee: bcs.u64(),\n\t\tstake_required: bcs.u64(),\n\t},\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,mBAA2B;AAC3B,iBAAoB;AACpB,eAA0B;AAC1B,mBAA8B;AAC9B,YAAuB;AACvB,MAAM,cAAc;AACb,MAAM,UAAU,IAAI,wBAAW;AAAA,EACrC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,cAAc,eAAI,KAAK;AAAA,IACvB,qBAAqB,eAAI,KAAK;AAAA,IAC9B,sBAAsB,SAAS;AAAA,IAC/B,iBAAiB,eAAI,KAAK;AAAA,IAC1B,cAAc,aAAa;AAAA,EAC5B;AACD,CAAC;AACM,MAAM,UAAU,IAAI,wBAAW;AAAA,EACrC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,OAAO,eAAI,IAAI;AAAA,IACf,eAAe,eAAI,IAAI;AAAA,IACvB,SAAS;AAAA,IACT,kBAAkB,MAAM;AAAA,IACxB,iBAAiB,eAAI,IAAI;AAAA,EAC1B;AACD,CAAC;AACM,MAAM,YAAY,IAAI,wBAAW;AAAA,EACvC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,OAAO,eAAI,IAAI;AAAA,IACf,SAAS,eAAI;AAAA,IACb,cAAc,eAAI,KAAK;AAAA,IACvB,qBAAqB,eAAI,KAAK;AAAA,IAC9B,qBAAqB,eAAI,IAAI;AAAA,IAC7B,sBAAsB,eAAI,IAAI;AAAA,IAC9B,qBAAqB,eAAI,IAAI;AAAA,IAC7B,iBAAiB,eAAI,KAAK;AAAA,IAC1B,WAAW,eAAI,IAAI;AAAA,IACnB,WAAW,eAAI,IAAI;AAAA,IACnB,gBAAgB,eAAI,IAAI;AAAA,EACzB;AACD,CAAC;",
+  "names": []
+}

package/dist/cjs/contracts/deepbook/math.d.ts

@@ -0,0 +1,94 @@
+import type { Transaction } from '@haneullabs/haneul/transactions';
+import type { RawTransactionArgument } from '../utils/index.js';
+export interface MulArguments {
+    x: RawTransactionArgument<number | bigint>;
+    y: RawTransactionArgument<number | bigint>;
+}
+export interface MulOptions {
+    package?: string;
+    arguments: MulArguments | [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];
+}
+/** Multiply two floating numbers. This function will round down the result. */
+export declare function mul(options: MulOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MulU128Arguments {
+    x: RawTransactionArgument<number | bigint>;
+    y: RawTransactionArgument<number | bigint>;
+}
+export interface MulU128Options {
+    package?: string;
+    arguments: MulU128Arguments | [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];
+}
+export declare function mulU128(options: MulU128Options): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MulRoundUpArguments {
+    x: RawTransactionArgument<number | bigint>;
+    y: RawTransactionArgument<number | bigint>;
+}
+export interface MulRoundUpOptions {
+    package?: string;
+    arguments: MulRoundUpArguments | [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];
+}
+/** Multiply two floating numbers. This function will round up the result. */
+export declare function mulRoundUp(options: MulRoundUpOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DivArguments {
+    x: RawTransactionArgument<number | bigint>;
+    y: RawTransactionArgument<number | bigint>;
+}
+export interface DivOptions {
+    package?: string;
+    arguments: DivArguments | [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];
+}
+/** Divide two floating numbers. This function will round down the result. */
+export declare function div(options: DivOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DivU128Arguments {
+    x: RawTransactionArgument<number | bigint>;
+    y: RawTransactionArgument<number | bigint>;
+}
+export interface DivU128Options {
+    package?: string;
+    arguments: DivU128Arguments | [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];
+}
+export declare function divU128(options: DivU128Options): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DivRoundUpArguments {
+    x: RawTransactionArgument<number | bigint>;
+    y: RawTransactionArgument<number | bigint>;
+}
+export interface DivRoundUpOptions {
+    package?: string;
+    arguments: DivRoundUpArguments | [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];
+}
+/** Divide two floating numbers. This function will round up the result. */
+export declare function divRoundUp(options: DivRoundUpOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MedianArguments {
+    v: RawTransactionArgument<number | bigint[]>;
+}
+export interface MedianOptions {
+    package?: string;
+    arguments: MedianArguments | [v: RawTransactionArgument<number | bigint[]>];
+}
+/** given a vector of u64, return the median */
+export declare function median(options: MedianOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface SqrtArguments {
+    x: RawTransactionArgument<number | bigint>;
+    precision: RawTransactionArgument<number | bigint>;
+}
+export interface SqrtOptions {
+    package?: string;
+    arguments: SqrtArguments | [
+        x: RawTransactionArgument<number | bigint>,
+        precision: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Computes the integer square root of a scaled u64 value, assuming the original
+ * value is scaled by precision. The result will be in the same floating-point
+ * representation.
+ */
+export declare function sqrt(options: SqrtOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface IsPowerOfTenArguments {
+    n: RawTransactionArgument<number | bigint>;
+}
+export interface IsPowerOfTenOptions {
+    package?: string;
+    arguments: IsPowerOfTenArguments | [n: RawTransactionArgument<number | bigint>];
+}
+export declare function isPowerOfTen(options: IsPowerOfTenOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;

package/dist/cjs/contracts/deepbook/math.js

@@ -0,0 +1,132 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var math_exports = {};
+__export(math_exports, {
+  div: () => div,
+  divRoundUp: () => divRoundUp,
+  divU128: () => divU128,
+  isPowerOfTen: () => isPowerOfTen,
+  median: () => median,
+  mul: () => mul,
+  mulRoundUp: () => mulRoundUp,
+  mulU128: () => mulU128,
+  sqrt: () => sqrt
+});
+module.exports = __toCommonJS(math_exports);
+var import_utils = require("../utils/index.js");
+function mul(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["u64", "u64"];
+  const parameterNames = ["x", "y"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "math",
+    function: "mul",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function mulU128(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["u128", "u128"];
+  const parameterNames = ["x", "y"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "math",
+    function: "mul_u128",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function mulRoundUp(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["u64", "u64"];
+  const parameterNames = ["x", "y"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "math",
+    function: "mul_round_up",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function div(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["u64", "u64"];
+  const parameterNames = ["x", "y"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "math",
+    function: "div",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function divU128(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["u128", "u128"];
+  const parameterNames = ["x", "y"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "math",
+    function: "div_u128",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function divRoundUp(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["u64", "u64"];
+  const parameterNames = ["x", "y"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "math",
+    function: "div_round_up",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function median(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["vector<u128>"];
+  const parameterNames = ["v"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "math",
+    function: "median",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function sqrt(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["u64", "u64"];
+  const parameterNames = ["x", "precision"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "math",
+    function: "sqrt",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function isPowerOfTen(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["u64"];
+  const parameterNames = ["n"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "math",
+    function: "is_power_of_ten",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+//# sourceMappingURL=math.js.map

package/dist/cjs/contracts/deepbook/math.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/contracts/deepbook/math.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport type { Transaction } from '@haneullabs/haneul/transactions';\nimport { normalizeMoveArguments } from '../utils/index.js';\nimport type { RawTransactionArgument } from '../utils/index.js';\nexport interface MulArguments {\n\tx: RawTransactionArgument<number | bigint>;\n\ty: RawTransactionArgument<number | bigint>;\n}\nexport interface MulOptions {\n\tpackage?: string;\n\targuments:\n\t\t| MulArguments\n\t\t| [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];\n}\n/** Multiply two floating numbers. This function will round down the result. */\nexport function mul(options: MulOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = ['u64', 'u64'] satisfies string[];\n\tconst parameterNames = ['x', 'y'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'mul',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface MulU128Arguments {\n\tx: RawTransactionArgument<number | bigint>;\n\ty: RawTransactionArgument<number | bigint>;\n}\nexport interface MulU128Options {\n\tpackage?: string;\n\targuments:\n\t\t| MulU128Arguments\n\t\t| [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];\n}\nexport function mulU128(options: MulU128Options) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = ['u128', 'u128'] satisfies string[];\n\tconst parameterNames = ['x', 'y'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'mul_u128',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface MulRoundUpArguments {\n\tx: RawTransactionArgument<number | bigint>;\n\ty: RawTransactionArgument<number | bigint>;\n}\nexport interface MulRoundUpOptions {\n\tpackage?: string;\n\targuments:\n\t\t| MulRoundUpArguments\n\t\t| [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];\n}\n/** Multiply two floating numbers. This function will round up the result. */\nexport function mulRoundUp(options: MulRoundUpOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = ['u64', 'u64'] satisfies string[];\n\tconst parameterNames = ['x', 'y'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'mul_round_up',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface DivArguments {\n\tx: RawTransactionArgument<number | bigint>;\n\ty: RawTransactionArgument<number | bigint>;\n}\nexport interface DivOptions {\n\tpackage?: string;\n\targuments:\n\t\t| DivArguments\n\t\t| [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];\n}\n/** Divide two floating numbers. This function will round down the result. */\nexport function div(options: DivOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = ['u64', 'u64'] satisfies string[];\n\tconst parameterNames = ['x', 'y'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'div',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface DivU128Arguments {\n\tx: RawTransactionArgument<number | bigint>;\n\ty: RawTransactionArgument<number | bigint>;\n}\nexport interface DivU128Options {\n\tpackage?: string;\n\targuments:\n\t\t| DivU128Arguments\n\t\t| [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];\n}\nexport function divU128(options: DivU128Options) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = ['u128', 'u128'] satisfies string[];\n\tconst parameterNames = ['x', 'y'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'div_u128',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface DivRoundUpArguments {\n\tx: RawTransactionArgument<number | bigint>;\n\ty: RawTransactionArgument<number | bigint>;\n}\nexport interface DivRoundUpOptions {\n\tpackage?: string;\n\targuments:\n\t\t| DivRoundUpArguments\n\t\t| [x: RawTransactionArgument<number | bigint>, y: RawTransactionArgument<number | bigint>];\n}\n/** Divide two floating numbers. This function will round up the result. */\nexport function divRoundUp(options: DivRoundUpOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = ['u64', 'u64'] satisfies string[];\n\tconst parameterNames = ['x', 'y'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'div_round_up',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface MedianArguments {\n\tv: RawTransactionArgument<number | bigint[]>;\n}\nexport interface MedianOptions {\n\tpackage?: string;\n\targuments: MedianArguments | [v: RawTransactionArgument<number | bigint[]>];\n}\n/** given a vector of u64, return the median */\nexport function median(options: MedianOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = ['vector<u128>'] satisfies string[];\n\tconst parameterNames = ['v'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'median',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface SqrtArguments {\n\tx: RawTransactionArgument<number | bigint>;\n\tprecision: RawTransactionArgument<number | bigint>;\n}\nexport interface SqrtOptions {\n\tpackage?: string;\n\targuments:\n\t\t| SqrtArguments\n\t\t| [\n\t\t\t\tx: RawTransactionArgument<number | bigint>,\n\t\t\t\tprecision: RawTransactionArgument<number | bigint>,\n\t\t  ];\n}\n/**\n * Computes the integer square root of a scaled u64 value, assuming the original\n * value is scaled by precision. The result will be in the same floating-point\n * representation.\n */\nexport function sqrt(options: SqrtOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = ['u64', 'u64'] satisfies string[];\n\tconst parameterNames = ['x', 'precision'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'sqrt',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface IsPowerOfTenArguments {\n\tn: RawTransactionArgument<number | bigint>;\n}\nexport interface IsPowerOfTenOptions {\n\tpackage?: string;\n\targuments: IsPowerOfTenArguments | [n: RawTransactionArgument<number | bigint>];\n}\nexport function isPowerOfTen(options: IsPowerOfTenOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = ['u64'] satisfies string[];\n\tconst parameterNames = ['n'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'math',\n\t\t\tfunction: 'is_power_of_ten',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/contracts/deepbook/order.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Order module defines the order struct and its methods. All order matching
+ * happens in this module.
+ */
+import { MoveStruct } from '../utils/index.js';
+import type { RawTransactionArgument } from '../utils/index.js';
+import type { Transaction } from '@haneullabs/haneul/transactions';
+export declare const Order: MoveStruct<{
+    balance_manager_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    order_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+    client_order_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    quantity: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    filled_quantity: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    fee_is_deep: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+    order_deep_price: MoveStruct<{
+        asset_is_base: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+        deep_per_asset: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "@deepbook/core::deep_price::OrderDeepPrice">;
+    epoch: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    status: import("@haneullabs/haneul/bcs").BcsType<number, number, "u8">;
+    expire_timestamp: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@deepbook/core::order::Order">;
+export declare const OrderCanceled: MoveStruct<{
+    balance_manager_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    pool_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    order_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+    client_order_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    trader: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    price: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    is_bid: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+    original_quantity: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    base_asset_quantity_canceled: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    timestamp: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@deepbook/core::order::OrderCanceled">;
+export declare const OrderModified: MoveStruct<{
+    balance_manager_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    pool_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    order_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+    client_order_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    trader: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    price: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    is_bid: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+    previous_quantity: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    filled_quantity: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    new_quantity: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    timestamp: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@deepbook/core::order::OrderModified">;
+export interface BalanceManagerIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface BalanceManagerIdOptions {
+    package?: string;
+    arguments: BalanceManagerIdArguments | [self: RawTransactionArgument<string>];
+}
+export declare function balanceManagerId(options: BalanceManagerIdOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface OrderIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface OrderIdOptions {
+    package?: string;
+    arguments: OrderIdArguments | [self: RawTransactionArgument<string>];
+}
+export declare function orderId(options: OrderIdOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ClientOrderIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ClientOrderIdOptions {
+    package?: string;
+    arguments: ClientOrderIdArguments | [self: RawTransactionArgument<string>];
+}
+export declare function clientOrderId(options: ClientOrderIdOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface QuantityArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface QuantityOptions {
+    package?: string;
+    arguments: QuantityArguments | [self: RawTransactionArgument<string>];
+}
+export declare function quantity(options: QuantityOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface FilledQuantityArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface FilledQuantityOptions {
+    package?: string;
+    arguments: FilledQuantityArguments | [self: RawTransactionArgument<string>];
+}
+export declare function filledQuantity(options: FilledQuantityOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface FeeIsDeepArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface FeeIsDeepOptions {
+    package?: string;
+    arguments: FeeIsDeepArguments | [self: RawTransactionArgument<string>];
+}
+export declare function feeIsDeep(options: FeeIsDeepOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface OrderDeepPriceArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface OrderDeepPriceOptions {
+    package?: string;
+    arguments: OrderDeepPriceArguments | [self: RawTransactionArgument<string>];
+}
+export declare function orderDeepPrice(options: OrderDeepPriceOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface EpochArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface EpochOptions {
+    package?: string;
+    arguments: EpochArguments | [self: RawTransactionArgument<string>];
+}
+export declare function epoch(options: EpochOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface StatusArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface StatusOptions {
+    package?: string;
+    arguments: StatusArguments | [self: RawTransactionArgument<string>];
+}
+export declare function status(options: StatusOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ExpireTimestampArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ExpireTimestampOptions {
+    package?: string;
+    arguments: ExpireTimestampArguments | [self: RawTransactionArgument<string>];
+}
+export declare function expireTimestamp(options: ExpireTimestampOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface PriceArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface PriceOptions {
+    package?: string;
+    arguments: PriceArguments | [self: RawTransactionArgument<string>];
+}
+export declare function price(options: PriceOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;