@haneullabs/deepbook-v3 0.1.0

package/dist/cjs/contracts/deepbook/deps/sui/bag.js

@@ -0,0 +1,47 @@
+"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 bag_exports = {};
+__export(bag_exports, {
+  Bag: () => Bag
+});
+module.exports = __toCommonJS(bag_exports);
+var import_utils = require("../../../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+var object = __toESM(require("./object.js"));
+const $moduleName = "0x2::bag";
+const Bag = new import_utils.MoveStruct({
+  name: `${$moduleName}::Bag`,
+  fields: {
+    /** the ID of this bag */
+    id: object.UID,
+    /** the number of key-value pairs in the bag */
+    size: import_bcs.bcs.u64()
+  }
+});
+//# sourceMappingURL=bag.js.map

package/dist/cjs/contracts/deepbook/deps/sui/bag.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/contracts/deepbook/deps/sui/bag.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * A bag is a heterogeneous map-like collection. The collection is similar to\n * `sui::table` in that its keys and values are not stored within the `Bag` value,\n * but instead are stored using Sui's object system. The `Bag` struct acts only as\n * a handle into the object system to retrieve those keys and values. Note that\n * this means that `Bag` values with exactly the same key-value mapping will not be\n * equal, with `==`, at runtime. For example\n *\n * ```\n * let bag1 = bag::new();\n * let bag2 = bag::new();\n * bag::add(&mut bag1, 0, false);\n * bag::add(&mut bag1, 1, true);\n * bag::add(&mut bag2, 0, false);\n * bag::add(&mut bag2, 1, true);\n * // bag1 does not equal bag2, despite having the same entries\n * assert!(&bag1 != &bag2);\n * ```\n *\n * At it's core, `sui::bag` is a wrapper around `UID` that allows for access to\n * `sui::dynamic_field` while preventing accidentally stranding field values. A\n * `UID` can be deleted, even if it has dynamic fields associated with it, but a\n * bag, on the other hand, must be empty to be destroyed.\n */\n\nimport { MoveStruct } from '../../../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport * as object from './object.js';\nconst $moduleName = '0x2::bag';\nexport const Bag = new MoveStruct({\n\tname: `${$moduleName}::Bag`,\n\tfields: {\n\t\t/** the ID of this bag */\n\t\tid: object.UID,\n\t\t/** the number of key-value pairs in the bag */\n\t\tsize: bcs.u64(),\n\t},\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA4BA,mBAA2B;AAC3B,iBAAoB;AACpB,aAAwB;AACxB,MAAM,cAAc;AACb,MAAM,MAAM,IAAI,wBAAW;AAAA,EACjC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA;AAAA,IAEP,IAAI,OAAO;AAAA;AAAA,IAEX,MAAM,eAAI,IAAI;AAAA,EACf;AACD,CAAC;",
+  "names": []
+}

package/dist/cjs/contracts/deepbook/deps/sui/balance.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A storable handler for Balances in general. Is used in the `Coin` module to
+ * allow balance operations and can be used to implement custom coins with `Supply`
+ * and `Balance`s.
+ */
+import { MoveStruct } from '../../../utils/index.js';
+export declare const Balance: MoveStruct<{
+    value: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "0x2::balance::Balance">;

package/dist/cjs/contracts/deepbook/deps/sui/balance.js

@@ -0,0 +1,33 @@
+"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 balance_exports = {};
+__export(balance_exports, {
+  Balance: () => Balance
+});
+module.exports = __toCommonJS(balance_exports);
+var import_utils = require("../../../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+const $moduleName = "0x2::balance";
+const Balance = new import_utils.MoveStruct({
+  name: `${$moduleName}::Balance`,
+  fields: {
+    value: import_bcs.bcs.u64()
+  }
+});
+//# sourceMappingURL=balance.js.map

package/dist/cjs/contracts/deepbook/deps/sui/balance.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/contracts/deepbook/deps/sui/balance.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * A storable handler for Balances in general. Is used in the `Coin` module to\n * allow balance operations and can be used to implement custom coins with `Supply`\n * and `Balance`s.\n */\n\nimport { MoveStruct } from '../../../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nconst $moduleName = '0x2::balance';\nexport const Balance = new MoveStruct({\n\tname: `${$moduleName}::Balance`,\n\tfields: {\n\t\tvalue: bcs.u64(),\n\t},\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,mBAA2B;AAC3B,iBAAoB;AACpB,MAAM,cAAc;AACb,MAAM,UAAU,IAAI,wBAAW;AAAA,EACrC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,OAAO,eAAI,IAAI;AAAA,EAChB;AACD,CAAC;",
+  "names": []
+}

package/dist/cjs/contracts/deepbook/deps/sui/object.d.ts

@@ -0,0 +1,5 @@
+/** Sui object identifiers */
+import { MoveStruct } from '../../../utils/index.js';
+export declare const UID: MoveStruct<{
+    id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "0x2::object::UID">;

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

@@ -0,0 +1,33 @@
+"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 object_exports = {};
+__export(object_exports, {
+  UID: () => UID
+});
+module.exports = __toCommonJS(object_exports);
+var import_utils = require("../../../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+const $moduleName = "0x2::object";
+const UID = new import_utils.MoveStruct({
+  name: `${$moduleName}::UID`,
+  fields: {
+    id: import_bcs.bcs.Address
+  }
+});
+//# sourceMappingURL=object.js.map

package/dist/cjs/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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAA2B;AAC3B,iBAAoB;AACpB,MAAM,cAAc;AACb,MAAM,MAAM,IAAI,wBAAW;AAAA,EACjC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,IAAI,eAAI;AAAA,EACT;AACD,CAAC;",
+  "names": []
+}

package/dist/cjs/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/cjs/contracts/deepbook/deps/sui/table.js

@@ -0,0 +1,47 @@
+"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 table_exports = {};
+__export(table_exports, {
+  Table: () => Table
+});
+module.exports = __toCommonJS(table_exports);
+var import_utils = require("../../../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+var object = __toESM(require("./object.js"));
+const $moduleName = "0x2::table";
+const Table = new import_utils.MoveStruct({
+  name: `${$moduleName}::Table`,
+  fields: {
+    /** the ID of this table */
+    id: object.UID,
+    /** the number of key-value pairs in the table */
+    size: import_bcs.bcs.u64()
+  }
+});
+//# sourceMappingURL=table.js.map

package/dist/cjs/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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,mBAA2B;AAC3B,iBAAoB;AACpB,aAAwB;AACxB,MAAM,cAAc;AACb,MAAM,QAAQ,IAAI,wBAAW;AAAA,EACnC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA;AAAA,IAEP,IAAI,OAAO;AAAA;AAAA,IAEX,MAAM,eAAI,IAAI;AAAA,EACf;AACD,CAAC;",
+  "names": []
+}

package/dist/cjs/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/cjs/contracts/deepbook/deps/sui/vec_map.js

@@ -0,0 +1,45 @@
+"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 vec_map_exports = {};
+__export(vec_map_exports, {
+  Entry: () => Entry,
+  VecMap: () => VecMap
+});
+module.exports = __toCommonJS(vec_map_exports);
+var import_bcs = require("@haneullabs/haneul/bcs");
+var import_utils = require("../../../utils/index.js");
+const $moduleName = "0x2::vec_map";
+function Entry(...typeParameters) {
+  return new import_utils.MoveStruct({
+    name: `${$moduleName}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      key: typeParameters[0],
+      value: typeParameters[1]
+    }
+  });
+}
+function VecMap(...typeParameters) {
+  return new import_utils.MoveStruct({
+    name: `${$moduleName}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      contents: import_bcs.bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+    }
+  });
+}
+//# sourceMappingURL=vec_map.js.map

package/dist/cjs/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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,iBAAoB;AAEpB,mBAA2B;AAC3B,MAAM,cAAc;AAEb,SAAS,SAAyD,gBAAwB;AAChG,SAAO,IAAI,wBAAW;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,wBAAW;AAAA,IACrB,MAAM,GAAG,WAAW,YAAY,eAAe,CAAC,EAAE,IAAiB,KAAK,eAAe,CAAC,EAAE,IAAiB;AAAA,IAC3G,QAAQ;AAAA,MACP,UAAU,eAAI,OAAO,MAAM,eAAe,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC;AAAA,IACjE;AAAA,EACD,CAAC;AACF;",
+  "names": []
+}

package/dist/cjs/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/cjs/contracts/deepbook/deps/sui/vec_set.js

@@ -0,0 +1,35 @@
+"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 vec_set_exports = {};
+__export(vec_set_exports, {
+  VecSet: () => VecSet
+});
+module.exports = __toCommonJS(vec_set_exports);
+var import_bcs = require("@haneullabs/haneul/bcs");
+var import_utils = require("../../../utils/index.js");
+const $moduleName = "0x2::vec_set";
+function VecSet(...typeParameters) {
+  return new import_utils.MoveStruct({
+    name: `${$moduleName}::VecSet<${typeParameters[0].name}>`,
+    fields: {
+      contents: import_bcs.bcs.vector(typeParameters[0])
+    }
+  });
+}
+//# sourceMappingURL=vec_set.js.map

package/dist/cjs/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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,iBAAoB;AAEpB,mBAA2B;AAC3B,MAAM,cAAc;AASb,SAAS,UAAkC,gBAAqB;AACtE,SAAO,IAAI,wBAAW;AAAA,IACrB,MAAM,GAAG,WAAW,YAAY,eAAe,CAAC,EAAE,IAAiB;AAAA,IACnE,QAAQ;AAAA,MACP,UAAU,eAAI,OAAO,eAAe,CAAC,CAAC;AAAA,IACvC;AAAA,EACD,CAAC;AACF;",
+  "names": []
+}

package/dist/cjs/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/cjs/contracts/deepbook/deps/sui/versioned.js

@@ -0,0 +1,45 @@
+"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 versioned_exports = {};
+__export(versioned_exports, {
+  Versioned: () => Versioned
+});
+module.exports = __toCommonJS(versioned_exports);
+var import_utils = require("../../../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+var object = __toESM(require("./object.js"));
+const $moduleName = "0x2::versioned";
+const Versioned = new import_utils.MoveStruct({
+  name: `${$moduleName}::Versioned`,
+  fields: {
+    id: object.UID,
+    version: import_bcs.bcs.u64()
+  }
+});
+//# sourceMappingURL=versioned.js.map

package/dist/cjs/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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,mBAA2B;AAC3B,iBAAoB;AACpB,aAAwB;AACxB,MAAM,cAAc;AACb,MAAM,YAAY,IAAI,wBAAW;AAAA,EACvC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,IAAI,OAAO;AAAA,IACX,SAAS,eAAI,IAAI;AAAA,EAClB;AACD,CAAC;",
+  "names": []
+}

package/dist/cjs/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/cjs/contracts/deepbook/ewma.js

@@ -0,0 +1,39 @@
+"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 ewma_exports = {};
+__export(ewma_exports, {
+  EWMAState: () => EWMAState
+});
+module.exports = __toCommonJS(ewma_exports);
+var import_utils = require("../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+const $moduleName = "@deepbook/core::ewma";
+const EWMAState = new import_utils.MoveStruct({
+  name: `${$moduleName}::EWMAState`,
+  fields: {
+    mean: import_bcs.bcs.u64(),
+    variance: import_bcs.bcs.u64(),
+    alpha: import_bcs.bcs.u64(),
+    z_score_threshold: import_bcs.bcs.u64(),
+    additional_taker_fee: import_bcs.bcs.u64(),
+    last_updated_timestamp: import_bcs.bcs.u64(),
+    enabled: import_bcs.bcs.bool()
+  }
+});
+//# sourceMappingURL=ewma.js.map

package/dist/cjs/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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,mBAA2B;AAC3B,iBAAoB;AACpB,MAAM,cAAc;AACb,MAAM,YAAY,IAAI,wBAAW;AAAA,EACvC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,MAAM,eAAI,IAAI;AAAA,IACd,UAAU,eAAI,IAAI;AAAA,IAClB,OAAO,eAAI,IAAI;AAAA,IACf,mBAAmB,eAAI,IAAI;AAAA,IAC3B,sBAAsB,eAAI,IAAI;AAAA,IAC9B,wBAAwB,eAAI,IAAI;AAAA,IAChC,SAAS,eAAI,KAAK;AAAA,EACnB;AACD,CAAC;",
+  "names": []
+}