@haneullabs/deepbook-v3 0.1.0

package/dist/esm/contracts/deepbook/deps/sui/object.js

@@ -0,0 +1,13 @@
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@haneullabs/haneul/bcs";
+const $moduleName = "0x2::object";
+const UID = new MoveStruct({
+  name: `${$moduleName}::UID`,
+  fields: {
+    id: bcs.Address
+  }
+});
+export {
+  UID
+};
+//# sourceMappingURL=object.js.map

package/dist/esm/contracts/deepbook/deps/sui/object.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/contracts/deepbook/deps/sui/object.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/** Sui object identifiers */\n\nimport { MoveStruct } from '../../../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nconst $moduleName = '0x2::object';\nexport const UID = new MoveStruct({\n\tname: `${$moduleName}::UID`,\n\tfields: {\n\t\tid: bcs.Address,\n\t},\n});\n"],
+  "mappings": "AAKA,SAAS,kBAAkB;AAC3B,SAAS,WAAW;AACpB,MAAM,cAAc;AACb,MAAM,MAAM,IAAI,WAAW;AAAA,EACjC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,IAAI,IAAI;AAAA,EACT;AACD,CAAC;",
+  "names": []
+}

package/dist/esm/contracts/deepbook/deps/sui/table.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A table is a map-like collection. But unlike a traditional collection, it's keys
+ * and values are not stored within the `Table` value, but instead are stored using
+ * Sui's object system. The `Table` struct acts only as a handle into the object
+ * system to retrieve those keys and values. Note that this means that `Table`
+ * values with exactly the same key-value mapping will not be equal, with `==`, at
+ * runtime. For example
+ *
+ * ```
+ * let table1 = table::new<u64, bool>();
+ * let table2 = table::new<u64, bool>();
+ * table::add(&mut table1, 0, false);
+ * table::add(&mut table1, 1, true);
+ * table::add(&mut table2, 0, false);
+ * table::add(&mut table2, 1, true);
+ * // table1 does not equal table2, despite having the same entries
+ * assert!(&table1 != &table2);
+ * ```
+ */
+import { MoveStruct } from '../../../utils/index.js';
+export declare const Table: MoveStruct<{
+    /** the ID of this table */
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    /** the number of key-value pairs in the table */
+    size: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "0x2::table::Table">;

package/dist/esm/contracts/deepbook/deps/sui/table.js

@@ -0,0 +1,17 @@
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@haneullabs/haneul/bcs";
+import * as object from "./object.js";
+const $moduleName = "0x2::table";
+const Table = new MoveStruct({
+  name: `${$moduleName}::Table`,
+  fields: {
+    /** the ID of this table */
+    id: object.UID,
+    /** the number of key-value pairs in the table */
+    size: bcs.u64()
+  }
+});
+export {
+  Table
+};
+//# sourceMappingURL=table.js.map

package/dist/esm/contracts/deepbook/deps/sui/table.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/contracts/deepbook/deps/sui/table.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * A table is a map-like collection. But unlike a traditional collection, it's keys\n * and values are not stored within the `Table` value, but instead are stored using\n * Sui's object system. The `Table` struct acts only as a handle into the object\n * system to retrieve those keys and values. Note that this means that `Table`\n * values with exactly the same key-value mapping will not be equal, with `==`, at\n * runtime. For example\n *\n * ```\n * let table1 = table::new<u64, bool>();\n * let table2 = table::new<u64, bool>();\n * table::add(&mut table1, 0, false);\n * table::add(&mut table1, 1, true);\n * table::add(&mut table2, 0, false);\n * table::add(&mut table2, 1, true);\n * // table1 does not equal table2, despite having the same entries\n * assert!(&table1 != &table2);\n * ```\n */\n\nimport { MoveStruct } from '../../../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport * as object from './object.js';\nconst $moduleName = '0x2::table';\nexport const Table = new MoveStruct({\n\tname: `${$moduleName}::Table`,\n\tfields: {\n\t\t/** the ID of this table */\n\t\tid: object.UID,\n\t\t/** the number of key-value pairs in the table */\n\t\tsize: bcs.u64(),\n\t},\n});\n"],
+  "mappings": "AAuBA,SAAS,kBAAkB;AAC3B,SAAS,WAAW;AACpB,YAAY,YAAY;AACxB,MAAM,cAAc;AACb,MAAM,QAAQ,IAAI,WAAW;AAAA,EACnC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA;AAAA,IAEP,IAAI,OAAO;AAAA;AAAA,IAEX,MAAM,IAAI,IAAI;AAAA,EACf;AACD,CAAC;",
+  "names": []
+}

package/dist/esm/contracts/deepbook/deps/sui/vec_map.d.ts

@@ -0,0 +1,27 @@
+import type { BcsType } from '@haneullabs/haneul/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+/** An entry in the map */
+export declare function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]): MoveStruct<{
+    key: K;
+    value: V;
+}, `0x2::vec_map::Entry<${K["name"]}, ${V["name"]}>`>;
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export declare function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]): MoveStruct<{
+    contents: BcsType<{
+        key: K extends BcsType<infer U, any, string> ? U : never;
+        value: V extends BcsType<infer U, any, string> ? U : never;
+    }[], Iterable<{
+        key: K extends BcsType<any, infer U_1, string> ? U_1 : never;
+        value: V extends BcsType<any, infer U_1, string> ? U_1 : never;
+    }> & {
+        length: number;
+    }, string>;
+}, `0x2::vec_map::VecMap<${K["name"]}, ${V["name"]}>`>;

package/dist/esm/contracts/deepbook/deps/sui/vec_map.js

@@ -0,0 +1,25 @@
+import { bcs } from "@haneullabs/haneul/bcs";
+import { MoveStruct } from "../../../utils/index.js";
+const $moduleName = "0x2::vec_map";
+function Entry(...typeParameters) {
+  return new MoveStruct({
+    name: `${$moduleName}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      key: typeParameters[0],
+      value: typeParameters[1]
+    }
+  });
+}
+function VecMap(...typeParameters) {
+  return new MoveStruct({
+    name: `${$moduleName}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+    }
+  });
+}
+export {
+  Entry,
+  VecMap
+};
+//# sourceMappingURL=vec_map.js.map

package/dist/esm/contracts/deepbook/deps/sui/vec_map.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/contracts/deepbook/deps/sui/vec_map.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport type { BcsType } from '@haneullabs/haneul/bcs';\nimport { MoveStruct } from '../../../utils/index.js';\nconst $moduleName = '0x2::vec_map';\n/** An entry in the map */\nexport function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {\n\treturn new MoveStruct({\n\t\tname: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,\n\t\tfields: {\n\t\t\tkey: typeParameters[0],\n\t\t\tvalue: typeParameters[1],\n\t\t},\n\t});\n}\n/**\n * A map data structure backed by a vector. The map is guaranteed not to contain\n * duplicate keys, but entries are _not_ sorted by key--entries are included in\n * insertion order. All operations are O(N) in the size of the map--the intention\n * of this data structure is only to provide the convenience of programming against\n * a map API. Large maps should use handwritten parent/child relationships instead.\n * Maps that need sorted iteration rather than insertion order iteration should\n * also be handwritten.\n */\nexport function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {\n\treturn new MoveStruct({\n\t\tname: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,\n\t\tfields: {\n\t\t\tcontents: bcs.vector(Entry(typeParameters[0], typeParameters[1])),\n\t\t},\n\t});\n}\n"],
+  "mappings": "AAEA,SAAS,WAAW;AAEpB,SAAS,kBAAkB;AAC3B,MAAM,cAAc;AAEb,SAAS,SAAyD,gBAAwB;AAChG,SAAO,IAAI,WAAW;AAAA,IACrB,MAAM,GAAG,WAAW,WAAW,eAAe,CAAC,EAAE,IAAiB,KAAK,eAAe,CAAC,EAAE,IAAiB;AAAA,IAC1G,QAAQ;AAAA,MACP,KAAK,eAAe,CAAC;AAAA,MACrB,OAAO,eAAe,CAAC;AAAA,IACxB;AAAA,EACD,CAAC;AACF;AAUO,SAAS,UAA0D,gBAAwB;AACjG,SAAO,IAAI,WAAW;AAAA,IACrB,MAAM,GAAG,WAAW,YAAY,eAAe,CAAC,EAAE,IAAiB,KAAK,eAAe,CAAC,EAAE,IAAiB;AAAA,IAC3G,QAAQ;AAAA,MACP,UAAU,IAAI,OAAO,MAAM,eAAe,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC;AAAA,IACjE;AAAA,EACD,CAAC;AACF;",
+  "names": []
+}

package/dist/esm/contracts/deepbook/deps/sui/vec_set.d.ts

@@ -0,0 +1,15 @@
+import type { BcsType } from '@haneullabs/haneul/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+/**
+ * A set data structure backed by a vector. The set is guaranteed not to contain
+ * duplicate keys. All operations are O(N) in the size of the set
+ *
+ * - the intention of this data structure is only to provide the convenience of
+ *   programming against a set API. Sets that need sorted iteration rather than
+ *   insertion order iteration should be handwritten.
+ */
+export declare function VecSet<K extends BcsType<any>>(...typeParameters: [K]): MoveStruct<{
+    contents: BcsType<import("@haneullabs/bcs").InferBcsType<K>[], Iterable<import("@haneullabs/bcs").InferBcsInput<K>> & {
+        length: number;
+    }, string>;
+}, `0x2::vec_set::VecSet<${K["name"]}>`>;

package/dist/esm/contracts/deepbook/deps/sui/vec_set.js

@@ -0,0 +1,15 @@
+import { bcs } from "@haneullabs/haneul/bcs";
+import { MoveStruct } from "../../../utils/index.js";
+const $moduleName = "0x2::vec_set";
+function VecSet(...typeParameters) {
+  return new MoveStruct({
+    name: `${$moduleName}::VecSet<${typeParameters[0].name}>`,
+    fields: {
+      contents: bcs.vector(typeParameters[0])
+    }
+  });
+}
+export {
+  VecSet
+};
+//# sourceMappingURL=vec_set.js.map

package/dist/esm/contracts/deepbook/deps/sui/vec_set.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/contracts/deepbook/deps/sui/vec_set.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport type { BcsType } from '@haneullabs/haneul/bcs';\nimport { MoveStruct } from '../../../utils/index.js';\nconst $moduleName = '0x2::vec_set';\n/**\n * A set data structure backed by a vector. The set is guaranteed not to contain\n * duplicate keys. All operations are O(N) in the size of the set\n *\n * - the intention of this data structure is only to provide the convenience of\n *   programming against a set API. Sets that need sorted iteration rather than\n *   insertion order iteration should be handwritten.\n */\nexport function VecSet<K extends BcsType<any>>(...typeParameters: [K]) {\n\treturn new MoveStruct({\n\t\tname: `${$moduleName}::VecSet<${typeParameters[0].name as K['name']}>`,\n\t\tfields: {\n\t\t\tcontents: bcs.vector(typeParameters[0]),\n\t\t},\n\t});\n}\n"],
+  "mappings": "AAEA,SAAS,WAAW;AAEpB,SAAS,kBAAkB;AAC3B,MAAM,cAAc;AASb,SAAS,UAAkC,gBAAqB;AACtE,SAAO,IAAI,WAAW;AAAA,IACrB,MAAM,GAAG,WAAW,YAAY,eAAe,CAAC,EAAE,IAAiB;AAAA,IACnE,QAAQ;AAAA,MACP,UAAU,IAAI,OAAO,eAAe,CAAC,CAAC;AAAA,IACvC;AAAA,EACD,CAAC;AACF;",
+  "names": []
+}

package/dist/esm/contracts/deepbook/deps/sui/versioned.d.ts

@@ -0,0 +1,7 @@
+import { MoveStruct } from '../../../utils/index.js';
+export declare const Versioned: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    version: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "0x2::versioned::Versioned">;

package/dist/esm/contracts/deepbook/deps/sui/versioned.js

@@ -0,0 +1,15 @@
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@haneullabs/haneul/bcs";
+import * as object from "./object.js";
+const $moduleName = "0x2::versioned";
+const Versioned = new MoveStruct({
+  name: `${$moduleName}::Versioned`,
+  fields: {
+    id: object.UID,
+    version: bcs.u64()
+  }
+});
+export {
+  Versioned
+};
+//# sourceMappingURL=versioned.js.map

package/dist/esm/contracts/deepbook/deps/sui/versioned.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/contracts/deepbook/deps/sui/versioned.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { MoveStruct } from '../../../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport * as object from './object.js';\nconst $moduleName = '0x2::versioned';\nexport const Versioned = new MoveStruct({\n\tname: `${$moduleName}::Versioned`,\n\tfields: {\n\t\tid: object.UID,\n\t\tversion: bcs.u64(),\n\t},\n});\n"],
+  "mappings": "AAEA,SAAS,kBAAkB;AAC3B,SAAS,WAAW;AACpB,YAAY,YAAY;AACxB,MAAM,cAAc;AACb,MAAM,YAAY,IAAI,WAAW;AAAA,EACvC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,IAAI,OAAO;AAAA,IACX,SAAS,IAAI,IAAI;AAAA,EAClB;AACD,CAAC;",
+  "names": []
+}

package/dist/esm/contracts/deepbook/ewma.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The Exponentially Weighted Moving Average (EWMA) state for DeepBook This state
+ * is used to calculate the smoothed mean and variance of gas prices and apply a
+ * penalty to taker fees based on the Z-score of the current gas price relative to
+ * the smoothed mean and variance. The state is enabled by default and can be
+ * configured with different parameters.
+ */
+import { MoveStruct } from '../utils/index.js';
+export declare const EWMAState: MoveStruct<{
+    mean: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    variance: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    alpha: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    z_score_threshold: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    additional_taker_fee: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    last_updated_timestamp: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    enabled: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+}, "@deepbook/core::ewma::EWMAState">;

package/dist/esm/contracts/deepbook/ewma.js

@@ -0,0 +1,19 @@
+import { MoveStruct } from "../utils/index.js";
+import { bcs } from "@haneullabs/haneul/bcs";
+const $moduleName = "@deepbook/core::ewma";
+const EWMAState = new MoveStruct({
+  name: `${$moduleName}::EWMAState`,
+  fields: {
+    mean: bcs.u64(),
+    variance: bcs.u64(),
+    alpha: bcs.u64(),
+    z_score_threshold: bcs.u64(),
+    additional_taker_fee: bcs.u64(),
+    last_updated_timestamp: bcs.u64(),
+    enabled: bcs.bool()
+  }
+});
+export {
+  EWMAState
+};
+//# sourceMappingURL=ewma.js.map

package/dist/esm/contracts/deepbook/ewma.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/contracts/deepbook/ewma.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The Exponentially Weighted Moving Average (EWMA) state for DeepBook This state\n * is used to calculate the smoothed mean and variance of gas prices and apply a\n * penalty to taker fees based on the Z-score of the current gas price relative to\n * the smoothed mean and variance. The state is enabled by default and can be\n * configured with different parameters.\n */\n\nimport { MoveStruct } from '../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nconst $moduleName = '@deepbook/core::ewma';\nexport const EWMAState = new MoveStruct({\n\tname: `${$moduleName}::EWMAState`,\n\tfields: {\n\t\tmean: bcs.u64(),\n\t\tvariance: bcs.u64(),\n\t\talpha: bcs.u64(),\n\t\tz_score_threshold: bcs.u64(),\n\t\tadditional_taker_fee: bcs.u64(),\n\t\tlast_updated_timestamp: bcs.u64(),\n\t\tenabled: bcs.bool(),\n\t},\n});\n"],
+  "mappings": "AAWA,SAAS,kBAAkB;AAC3B,SAAS,WAAW;AACpB,MAAM,cAAc;AACb,MAAM,YAAY,IAAI,WAAW;AAAA,EACvC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,MAAM,IAAI,IAAI;AAAA,IACd,UAAU,IAAI,IAAI;AAAA,IAClB,OAAO,IAAI,IAAI;AAAA,IACf,mBAAmB,IAAI,IAAI;AAAA,IAC3B,sBAAsB,IAAI,IAAI;AAAA,IAC9B,wBAAwB,IAAI,IAAI;AAAA,IAChC,SAAS,IAAI,KAAK;AAAA,EACnB;AACD,CAAC;",
+  "names": []
+}

package/dist/esm/contracts/deepbook/fill.d.ts

@@ -0,0 +1,153 @@
+/** `Fill` struct represents the results of a match between two orders. */
+import { MoveStruct } from '../utils/index.js';
+import type { RawTransactionArgument } from '../utils/index.js';
+import type { Transaction } from '@haneullabs/haneul/transactions';
+export declare const Fill: MoveStruct<{
+    maker_order_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u128">;
+    maker_client_order_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    execution_price: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    balance_manager_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    expired: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+    completed: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+    original_maker_quantity: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    base_quantity: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    quote_quantity: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    taker_is_bid: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+    maker_epoch: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    maker_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">;
+    taker_fee: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    taker_fee_is_deep: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+    maker_fee: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    maker_fee_is_deep: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+}, "@deepbook/core::fill::Fill">;
+export interface MakerOrderIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface MakerOrderIdOptions {
+    package?: string;
+    arguments: MakerOrderIdArguments | [self: RawTransactionArgument<string>];
+}
+export declare function makerOrderId(options: MakerOrderIdOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MakerClientOrderIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface MakerClientOrderIdOptions {
+    package?: string;
+    arguments: MakerClientOrderIdArguments | [self: RawTransactionArgument<string>];
+}
+export declare function makerClientOrderId(options: MakerClientOrderIdOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ExecutionPriceArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ExecutionPriceOptions {
+    package?: string;
+    arguments: ExecutionPriceArguments | [self: RawTransactionArgument<string>];
+}
+export declare function executionPrice(options: ExecutionPriceOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+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 ExpiredArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ExpiredOptions {
+    package?: string;
+    arguments: ExpiredArguments | [self: RawTransactionArgument<string>];
+}
+export declare function expired(options: ExpiredOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface CompletedArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CompletedOptions {
+    package?: string;
+    arguments: CompletedArguments | [self: RawTransactionArgument<string>];
+}
+export declare function completed(options: CompletedOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface OriginalMakerQuantityArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface OriginalMakerQuantityOptions {
+    package?: string;
+    arguments: OriginalMakerQuantityArguments | [self: RawTransactionArgument<string>];
+}
+export declare function originalMakerQuantity(options: OriginalMakerQuantityOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface BaseQuantityArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface BaseQuantityOptions {
+    package?: string;
+    arguments: BaseQuantityArguments | [self: RawTransactionArgument<string>];
+}
+export declare function baseQuantity(options: BaseQuantityOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface TakerIsBidArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface TakerIsBidOptions {
+    package?: string;
+    arguments: TakerIsBidArguments | [self: RawTransactionArgument<string>];
+}
+export declare function takerIsBid(options: TakerIsBidOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface QuoteQuantityArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface QuoteQuantityOptions {
+    package?: string;
+    arguments: QuoteQuantityArguments | [self: RawTransactionArgument<string>];
+}
+export declare function quoteQuantity(options: QuoteQuantityOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MakerEpochArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface MakerEpochOptions {
+    package?: string;
+    arguments: MakerEpochArguments | [self: RawTransactionArgument<string>];
+}
+export declare function makerEpoch(options: MakerEpochOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MakerDeepPriceArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface MakerDeepPriceOptions {
+    package?: string;
+    arguments: MakerDeepPriceArguments | [self: RawTransactionArgument<string>];
+}
+export declare function makerDeepPrice(options: MakerDeepPriceOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface TakerFeeArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface TakerFeeOptions {
+    package?: string;
+    arguments: TakerFeeArguments | [self: RawTransactionArgument<string>];
+}
+export declare function takerFee(options: TakerFeeOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface TakerFeeIsDeepArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface TakerFeeIsDeepOptions {
+    package?: string;
+    arguments: TakerFeeIsDeepArguments | [self: RawTransactionArgument<string>];
+}
+export declare function takerFeeIsDeep(options: TakerFeeIsDeepOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MakerFeeArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface MakerFeeOptions {
+    package?: string;
+    arguments: MakerFeeArguments | [self: RawTransactionArgument<string>];
+}
+export declare function makerFee(options: MakerFeeOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MakerFeeIsDeepArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface MakerFeeIsDeepOptions {
+    package?: string;
+    arguments: MakerFeeIsDeepArguments | [self: RawTransactionArgument<string>];
+}
+export declare function makerFeeIsDeep(options: MakerFeeIsDeepOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;

package/dist/esm/contracts/deepbook/fill.js

@@ -0,0 +1,221 @@
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@haneullabs/haneul/bcs";
+import * as deep_price from "./deep_price.js";
+const $moduleName = "@deepbook/core::fill";
+const Fill = new MoveStruct({
+  name: `${$moduleName}::Fill`,
+  fields: {
+    maker_order_id: bcs.u128(),
+    maker_client_order_id: bcs.u64(),
+    execution_price: bcs.u64(),
+    balance_manager_id: bcs.Address,
+    expired: bcs.bool(),
+    completed: bcs.bool(),
+    original_maker_quantity: bcs.u64(),
+    base_quantity: bcs.u64(),
+    quote_quantity: bcs.u64(),
+    taker_is_bid: bcs.bool(),
+    maker_epoch: bcs.u64(),
+    maker_deep_price: deep_price.OrderDeepPrice,
+    taker_fee: bcs.u64(),
+    taker_fee_is_deep: bcs.bool(),
+    maker_fee: bcs.u64(),
+    maker_fee_is_deep: bcs.bool()
+  }
+});
+function makerOrderId(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "maker_order_id",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function makerClientOrderId(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "maker_client_order_id",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function executionPrice(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "execution_price",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function balanceManagerId(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "balance_manager_id",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function expired(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "expired",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function completed(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "completed",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function originalMakerQuantity(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "original_maker_quantity",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function baseQuantity(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "base_quantity",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function takerIsBid(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "taker_is_bid",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function quoteQuantity(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "quote_quantity",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function makerEpoch(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "maker_epoch",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function makerDeepPrice(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "maker_deep_price",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function takerFee(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "taker_fee",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function takerFeeIsDeep(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "taker_fee_is_deep",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function makerFee(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "maker_fee",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function makerFeeIsDeep(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::fill::Fill`];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "fill",
+    function: "maker_fee_is_deep",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+export {
+  Fill,
+  balanceManagerId,
+  baseQuantity,
+  completed,
+  executionPrice,
+  expired,
+  makerClientOrderId,
+  makerDeepPrice,
+  makerEpoch,
+  makerFee,
+  makerFeeIsDeep,
+  makerOrderId,
+  originalMakerQuantity,
+  quoteQuantity,
+  takerFee,
+  takerFeeIsDeep,
+  takerIsBid
+};
+//# sourceMappingURL=fill.js.map