@haneullabs/deepbook-v3 0.1.0

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

@@ -0,0 +1,10 @@
+/**
+ * `Balances` represents the three assets make up a pool: base, quote, and deep.
+ * Whenever funds are moved, they are moved in the form of `Balances`.
+ */
+import { MoveStruct } from '../utils/index.js';
+export declare const Balances: 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">;

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

@@ -0,0 +1,15 @@
+import { MoveStruct } from "../utils/index.js";
+import { bcs } from "@haneullabs/haneul/bcs";
+const $moduleName = "@deepbook/core::balances";
+const Balances = new MoveStruct({
+  name: `${$moduleName}::Balances`,
+  fields: {
+    base: bcs.u64(),
+    quote: bcs.u64(),
+    deep: bcs.u64()
+  }
+});
+export {
+  Balances
+};
+//# sourceMappingURL=balances.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/contracts/deepbook/balances.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `Balances` represents the three assets make up a pool: base, quote, and deep.\n * Whenever funds are moved, they are moved in the form of `Balances`.\n */\n\nimport { MoveStruct } from '../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nconst $moduleName = '@deepbook/core::balances';\nexport const Balances = new MoveStruct({\n\tname: `${$moduleName}::Balances`,\n\tfields: {\n\t\tbase: bcs.u64(),\n\t\tquote: bcs.u64(),\n\t\tdeep: bcs.u64(),\n\t},\n});\n"],
+  "mappings": "AAQA,SAAS,kBAAkB;AAC3B,SAAS,WAAW;AACpB,MAAM,cAAc;AACb,MAAM,WAAW,IAAI,WAAW;AAAA,EACtC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,MAAM,IAAI,IAAI;AAAA,IACd,OAAO,IAAI,IAAI;AAAA,IACf,MAAM,IAAI,IAAI;AAAA,EACf;AACD,CAAC;",
+  "names": []
+}

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

@@ -0,0 +1,62 @@
+/**
+ * BigVector is an arbitrary sized vector-like data structure, implemented using an
+ * on-chain B+ Tree to support almost constant time (log base max_fan_out) random
+ * access, insertion and removal.
+ *
+ * Iteration is supported by exposing access to leaf nodes (slices). Finding the
+ * initial slice can be done in almost constant time, and subsequently finding the
+ * previous or next slice can also be done in constant time.
+ *
+ * Nodes in the B+ Tree are stored as individual dynamic fields hanging off the
+ * `BigVector`.
+ *
+ * Note: The index type is `u128`, but the length is stored as `u64` because the
+ * expectation is that indices are sparsely distributed.
+ */
+import { MoveStruct } from '../utils/index.js';
+import type { BcsType } from '@haneullabs/haneul/bcs';
+export declare const BigVector: MoveStruct<{
+    id: MoveStruct<{
+        id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    /** How deep the tree structure is. */
+    depth: BcsType<number, number, "u8">;
+    /**
+     * Total number of elements that this vector contains, not including gaps in the
+     * vector.
+     */
+    length: BcsType<string, string | number | bigint, "u64">;
+    /** Max size of leaf nodes (counted in number of elements, `E`). */
+    max_slice_size: BcsType<string, string | number | bigint, "u64">;
+    /** Max size of interior nodes (counted in number of children). */
+    max_fan_out: BcsType<string, string | number | bigint, "u64">;
+    /** ID of the tree's root structure. Value of `NO_SLICE` means there's no root. */
+    root_id: BcsType<string, string | number | bigint, "u64">;
+    /** The last node ID that was allocated. */
+    last_id: BcsType<string, string | number | bigint, "u64">;
+}, "@deepbook/core::big_vector::BigVector">;
+/**
+ * A node in the B+ tree.
+ *
+ * If representing a leaf node, there are as many keys as values (such that
+ * `keys[i]` is the key corresponding to `vals[i]`).
+ *
+ * A `Slice<u64>` can also represent an interior node, in which case `vals` contain
+ * the IDs of its children and `keys` represent the partitions between children.
+ * There will be one fewer key than value in this configuration.
+ */
+export declare function Slice<E extends BcsType<any>>(...typeParameters: [E]): MoveStruct<{
+    /** Previous node in the intrusive doubly-linked list data structure. */
+    prev: BcsType<string, string | number | bigint, "u64">;
+    /** Next node in the intrusive doubly-linked list data structure. */
+    next: BcsType<string, string | number | bigint, "u64">;
+    keys: BcsType<string[], Iterable<string | number | bigint> & {
+        length: number;
+    }, string>;
+    vals: BcsType<import("@haneullabs/bcs").InferBcsType<E>[], Iterable<import("@haneullabs/bcs").InferBcsInput<E>> & {
+        length: number;
+    }, string>;
+}, `@deepbook/core::big_vector::Slice<${E["name"]}>`>;
+export declare const SliceRef: MoveStruct<{
+    ix: BcsType<string, string | number | bigint, "u64">;
+}, "@deepbook/core::big_vector::SliceRef">;

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

@@ -0,0 +1,50 @@
+import { MoveStruct } from "../utils/index.js";
+import { bcs } from "@haneullabs/haneul/bcs";
+import * as object from "./deps/sui/object.js";
+const $moduleName = "@deepbook/core::big_vector";
+const BigVector = new MoveStruct({
+  name: `${$moduleName}::BigVector`,
+  fields: {
+    id: object.UID,
+    /** How deep the tree structure is. */
+    depth: bcs.u8(),
+    /**
+     * Total number of elements that this vector contains, not including gaps in the
+     * vector.
+     */
+    length: bcs.u64(),
+    /** Max size of leaf nodes (counted in number of elements, `E`). */
+    max_slice_size: bcs.u64(),
+    /** Max size of interior nodes (counted in number of children). */
+    max_fan_out: bcs.u64(),
+    /** ID of the tree's root structure. Value of `NO_SLICE` means there's no root. */
+    root_id: bcs.u64(),
+    /** The last node ID that was allocated. */
+    last_id: bcs.u64()
+  }
+});
+function Slice(...typeParameters) {
+  return new MoveStruct({
+    name: `${$moduleName}::Slice<${typeParameters[0].name}>`,
+    fields: {
+      /** Previous node in the intrusive doubly-linked list data structure. */
+      prev: bcs.u64(),
+      /** Next node in the intrusive doubly-linked list data structure. */
+      next: bcs.u64(),
+      keys: bcs.vector(bcs.u128()),
+      vals: bcs.vector(typeParameters[0])
+    }
+  });
+}
+const SliceRef = new MoveStruct({
+  name: `${$moduleName}::SliceRef`,
+  fields: {
+    ix: bcs.u64()
+  }
+});
+export {
+  BigVector,
+  Slice,
+  SliceRef
+};
+//# sourceMappingURL=big_vector.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/contracts/deepbook/big_vector.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * BigVector is an arbitrary sized vector-like data structure, implemented using an\n * on-chain B+ Tree to support almost constant time (log base max_fan_out) random\n * access, insertion and removal.\n *\n * Iteration is supported by exposing access to leaf nodes (slices). Finding the\n * initial slice can be done in almost constant time, and subsequently finding the\n * previous or next slice can also be done in constant time.\n *\n * Nodes in the B+ Tree are stored as individual dynamic fields hanging off the\n * `BigVector`.\n *\n * Note: The index type is `u128`, but the length is stored as `u64` because the\n * expectation is that indices are sparsely distributed.\n */\n\nimport { MoveStruct } from '../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport type { BcsType } from '@haneullabs/haneul/bcs';\nimport * as object from './deps/sui/object.js';\nconst $moduleName = '@deepbook/core::big_vector';\nexport const BigVector = new MoveStruct({\n\tname: `${$moduleName}::BigVector`,\n\tfields: {\n\t\tid: object.UID,\n\t\t/** How deep the tree structure is. */\n\t\tdepth: bcs.u8(),\n\t\t/**\n\t\t * Total number of elements that this vector contains, not including gaps in the\n\t\t * vector.\n\t\t */\n\t\tlength: bcs.u64(),\n\t\t/** Max size of leaf nodes (counted in number of elements, `E`). */\n\t\tmax_slice_size: bcs.u64(),\n\t\t/** Max size of interior nodes (counted in number of children). */\n\t\tmax_fan_out: bcs.u64(),\n\t\t/** ID of the tree's root structure. Value of `NO_SLICE` means there's no root. */\n\t\troot_id: bcs.u64(),\n\t\t/** The last node ID that was allocated. */\n\t\tlast_id: bcs.u64(),\n\t},\n});\n/**\n * A node in the B+ tree.\n *\n * If representing a leaf node, there are as many keys as values (such that\n * `keys[i]` is the key corresponding to `vals[i]`).\n *\n * A `Slice<u64>` can also represent an interior node, in which case `vals` contain\n * the IDs of its children and `keys` represent the partitions between children.\n * There will be one fewer key than value in this configuration.\n */\nexport function Slice<E extends BcsType<any>>(...typeParameters: [E]) {\n\treturn new MoveStruct({\n\t\tname: `${$moduleName}::Slice<${typeParameters[0].name as E['name']}>`,\n\t\tfields: {\n\t\t\t/** Previous node in the intrusive doubly-linked list data structure. */\n\t\t\tprev: bcs.u64(),\n\t\t\t/** Next node in the intrusive doubly-linked list data structure. */\n\t\t\tnext: bcs.u64(),\n\t\t\tkeys: bcs.vector(bcs.u128()),\n\t\t\tvals: bcs.vector(typeParameters[0]),\n\t\t},\n\t});\n}\nexport const SliceRef = new MoveStruct({\n\tname: `${$moduleName}::SliceRef`,\n\tfields: {\n\t\tix: bcs.u64(),\n\t},\n});\n"],
+  "mappings": "AAmBA,SAAS,kBAAkB;AAC3B,SAAS,WAAW;AAEpB,YAAY,YAAY;AACxB,MAAM,cAAc;AACb,MAAM,YAAY,IAAI,WAAW;AAAA,EACvC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,IAAI,OAAO;AAAA;AAAA,IAEX,OAAO,IAAI,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA,IAKd,QAAQ,IAAI,IAAI;AAAA;AAAA,IAEhB,gBAAgB,IAAI,IAAI;AAAA;AAAA,IAExB,aAAa,IAAI,IAAI;AAAA;AAAA,IAErB,SAAS,IAAI,IAAI;AAAA;AAAA,IAEjB,SAAS,IAAI,IAAI;AAAA,EAClB;AACD,CAAC;AAWM,SAAS,SAAiC,gBAAqB;AACrE,SAAO,IAAI,WAAW;AAAA,IACrB,MAAM,GAAG,WAAW,WAAW,eAAe,CAAC,EAAE,IAAiB;AAAA,IAClE,QAAQ;AAAA;AAAA,MAEP,MAAM,IAAI,IAAI;AAAA;AAAA,MAEd,MAAM,IAAI,IAAI;AAAA,MACd,MAAM,IAAI,OAAO,IAAI,KAAK,CAAC;AAAA,MAC3B,MAAM,IAAI,OAAO,eAAe,CAAC,CAAC;AAAA,IACnC;AAAA,EACD,CAAC;AACF;AACO,MAAM,WAAW,IAAI,WAAW;AAAA,EACtC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,IAAI,IAAI,IAAI;AAAA,EACb;AACD,CAAC;",
+  "names": []
+}

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

@@ -0,0 +1,34 @@
+/**
+ * The book module contains the `Book` struct which represents the order book. All
+ * order book operations are defined in this module.
+ */
+import { MoveStruct } from '../utils/index.js';
+export declare const Book: MoveStruct<{
+    tick_size: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    lot_size: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    min_size: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    bids: MoveStruct<{
+        id: MoveStruct<{
+            id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        depth: import("@haneullabs/haneul/bcs").BcsType<number, number, "u8">;
+        length: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        max_slice_size: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        max_fan_out: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        root_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        last_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "@deepbook/core::big_vector::BigVector">;
+    asks: MoveStruct<{
+        id: MoveStruct<{
+            id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        depth: import("@haneullabs/haneul/bcs").BcsType<number, number, "u8">;
+        length: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        max_slice_size: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        max_fan_out: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        root_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+        last_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "@deepbook/core::big_vector::BigVector">;
+    next_bid_order_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    next_ask_order_id: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@deepbook/core::book::Book">;

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

@@ -0,0 +1,20 @@
+import { MoveStruct } from "../utils/index.js";
+import { bcs } from "@haneullabs/haneul/bcs";
+import * as big_vector from "./big_vector.js";
+const $moduleName = "@deepbook/core::book";
+const Book = new MoveStruct({
+  name: `${$moduleName}::Book`,
+  fields: {
+    tick_size: bcs.u64(),
+    lot_size: bcs.u64(),
+    min_size: bcs.u64(),
+    bids: big_vector.BigVector,
+    asks: big_vector.BigVector,
+    next_bid_order_id: bcs.u64(),
+    next_ask_order_id: bcs.u64()
+  }
+});
+export {
+  Book
+};
+//# sourceMappingURL=book.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/contracts/deepbook/book.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The book module contains the `Book` struct which represents the order book. All\n * order book operations are defined in this module.\n */\n\nimport { MoveStruct } from '../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport * as big_vector from './big_vector.js';\nconst $moduleName = '@deepbook/core::book';\nexport const Book = new MoveStruct({\n\tname: `${$moduleName}::Book`,\n\tfields: {\n\t\ttick_size: bcs.u64(),\n\t\tlot_size: bcs.u64(),\n\t\tmin_size: bcs.u64(),\n\t\tbids: big_vector.BigVector,\n\t\tasks: big_vector.BigVector,\n\t\tnext_bid_order_id: bcs.u64(),\n\t\tnext_ask_order_id: bcs.u64(),\n\t},\n});\n"],
+  "mappings": "AAQA,SAAS,kBAAkB;AAC3B,SAAS,WAAW;AACpB,YAAY,gBAAgB;AAC5B,MAAM,cAAc;AACb,MAAM,OAAO,IAAI,WAAW;AAAA,EAClC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,WAAW,IAAI,IAAI;AAAA,IACnB,UAAU,IAAI,IAAI;AAAA,IAClB,UAAU,IAAI,IAAI;AAAA,IAClB,MAAM,WAAW;AAAA,IACjB,MAAM,WAAW;AAAA,IACjB,mBAAmB,IAAI,IAAI;AAAA,IAC3B,mBAAmB,IAAI,IAAI;AAAA,EAC5B;AACD,CAAC;",
+  "names": []
+}

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

@@ -0,0 +1,176 @@
+import type { Transaction } from '@haneullabs/haneul/transactions';
+export interface CurrentVersionOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function currentVersion(options?: CurrentVersionOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface PoolCreationFeeOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function poolCreationFee(options?: PoolCreationFeeOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface FloatScalingOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function floatScaling(options?: FloatScalingOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface FloatScalingU128Options {
+    package?: string;
+    arguments?: [];
+}
+export declare function floatScalingU128(options?: FloatScalingU128Options): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MaxU64Options {
+    package?: string;
+    arguments?: [];
+}
+export declare function maxU64(options?: MaxU64Options): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MaxU128Options {
+    package?: string;
+    arguments?: [];
+}
+export declare function maxU128(options?: MaxU128Options): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface NoRestrictionOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function noRestriction(options?: NoRestrictionOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ImmediateOrCancelOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function immediateOrCancel(options?: ImmediateOrCancelOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface FillOrKillOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function fillOrKill(options?: FillOrKillOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface PostOnlyOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function postOnly(options?: PostOnlyOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MaxRestrictionOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function maxRestriction(options?: MaxRestrictionOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface LiveOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function live(options?: LiveOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface PartiallyFilledOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function partiallyFilled(options?: PartiallyFilledOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface FilledOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function filled(options?: FilledOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface CanceledOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function canceled(options?: CanceledOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ExpiredOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function expired(options?: ExpiredOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface SelfMatchingAllowedOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function selfMatchingAllowed(options?: SelfMatchingAllowedOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface CancelTakerOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function cancelTaker(options?: CancelTakerOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface CancelMakerOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function cancelMaker(options?: CancelMakerOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MinPriceOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function minPrice(options?: MinPriceOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MaxPriceOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function maxPrice(options?: MaxPriceOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface PhaseOutEpochsOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function phaseOutEpochs(options?: PhaseOutEpochsOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DefaultStakeRequiredOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function defaultStakeRequired(options?: DefaultStakeRequiredOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface HalfOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function half(options?: HalfOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface FeeIsDeepOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function feeIsDeep(options?: FeeIsDeepOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DeepUnitOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function deepUnit(options?: DeepUnitOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MaxFillsOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function maxFills(options?: MaxFillsOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MaxOpenOrdersOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function maxOpenOrders(options?: MaxOpenOrdersOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MaxSliceSizeOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function maxSliceSize(options?: MaxSliceSizeOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MaxFanOutOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function maxFanOut(options?: MaxFanOutOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface FeePenaltyMultiplierOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function feePenaltyMultiplier(options?: FeePenaltyMultiplierOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DefaultEwmaAlphaOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function defaultEwmaAlpha(options?: DefaultEwmaAlphaOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DefaultZScoreThresholdOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function defaultZScoreThreshold(options?: DefaultZScoreThresholdOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DefaultAdditionalTakerFeeOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function defaultAdditionalTakerFee(options?: DefaultAdditionalTakerFeeOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface EwmaDfKeyOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function ewmaDfKey(options?: EwmaDfKeyOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;