@haneullabs/deepbook-v3 0.1.0

package/dist/cjs/transactions/deepbook.js

@@ -0,0 +1,1335 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var deepbook_exports = {};
+__export(deepbook_exports, {
+  DeepBookContract: () => DeepBookContract
+});
+module.exports = __toCommonJS(deepbook_exports);
+var import_transactions = require("@haneullabs/haneul/transactions");
+var import_types = require("../types/index.js");
+var import_config = require("../utils/config.js");
+var _config;
+class DeepBookContract {
+  /**
+   * @param {DeepBookConfig} config Configuration for DeepBookContract
+   */
+  constructor(config) {
+    __privateAdd(this, _config);
+    /**
+     * @description Place a limit order
+     * @param {PlaceLimitOrderParams} params Parameters for placing a limit order
+     * @returns A function that takes a Transaction object
+     */
+    this.placeLimitOrder = (params) => (tx) => {
+      const {
+        poolKey,
+        balanceManagerKey,
+        clientOrderId,
+        price,
+        quantity,
+        isBid,
+        expiration = import_config.MAX_TIMESTAMP,
+        orderType = import_types.OrderType.NO_RESTRICTION,
+        selfMatchingOption = import_types.SelfMatchingOptions.SELF_MATCHING_ALLOWED,
+        payWithDeep = true
+      } = params;
+      tx.setGasBudgetIfNotSet(import_config.GAS_BUDGET);
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const inputPrice = Math.round(price * import_config.FLOAT_SCALAR * quoteCoin.scalar / baseCoin.scalar);
+      const inputQuantity = Math.round(quantity * baseCoin.scalar);
+      const tradeProof = tx.add(__privateGet(this, _config).balanceManager.generateProof(balanceManagerKey));
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::place_limit_order`,
+        arguments: [
+          tx.object(pool.address),
+          tx.object(balanceManager.address),
+          tradeProof,
+          tx.pure.u64(clientOrderId),
+          tx.pure.u8(orderType),
+          tx.pure.u8(selfMatchingOption),
+          tx.pure.u64(inputPrice),
+          tx.pure.u64(inputQuantity),
+          tx.pure.bool(isBid),
+          tx.pure.bool(payWithDeep),
+          tx.pure.u64(expiration),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Place a market order
+     * @param {PlaceMarketOrderParams} params Parameters for placing a market order
+     * @returns A function that takes a Transaction object
+     */
+    this.placeMarketOrder = (params) => (tx) => {
+      const {
+        poolKey,
+        balanceManagerKey,
+        clientOrderId,
+        quantity,
+        isBid,
+        selfMatchingOption = import_types.SelfMatchingOptions.SELF_MATCHING_ALLOWED,
+        payWithDeep = true
+      } = params;
+      tx.setGasBudgetIfNotSet(import_config.GAS_BUDGET);
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const tradeProof = tx.add(__privateGet(this, _config).balanceManager.generateProof(balanceManagerKey));
+      const inputQuantity = Math.round(quantity * baseCoin.scalar);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::place_market_order`,
+        arguments: [
+          tx.object(pool.address),
+          tx.object(balanceManager.address),
+          tradeProof,
+          tx.pure.u64(clientOrderId),
+          tx.pure.u8(selfMatchingOption),
+          tx.pure.u64(inputQuantity),
+          tx.pure.bool(isBid),
+          tx.pure.bool(payWithDeep),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Modify an existing order
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} balanceManagerKey The key to identify the BalanceManager
+     * @param {string} orderId Order ID to modify
+     * @param {number} newQuantity New quantity for the order
+     * @returns A function that takes a Transaction object
+     */
+    this.modifyOrder = (poolKey, balanceManagerKey, orderId, newQuantity) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const tradeProof = tx.add(__privateGet(this, _config).balanceManager.generateProof(balanceManagerKey));
+      const inputQuantity = Math.round(newQuantity * baseCoin.scalar);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::modify_order`,
+        arguments: [
+          tx.object(pool.address),
+          tx.object(balanceManager.address),
+          tradeProof,
+          tx.pure.u128(orderId),
+          tx.pure.u64(inputQuantity),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Cancel an existing order
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} balanceManagerKey The key to identify the BalanceManager
+     * @param {string} orderId Order ID to cancel
+     * @returns A function that takes a Transaction object
+     */
+    this.cancelOrder = (poolKey, balanceManagerKey, orderId) => (tx) => {
+      tx.setGasBudgetIfNotSet(import_config.GAS_BUDGET);
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const tradeProof = tx.add(__privateGet(this, _config).balanceManager.generateProof(balanceManagerKey));
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::cancel_order`,
+        arguments: [
+          tx.object(pool.address),
+          tx.object(balanceManager.address),
+          tradeProof,
+          tx.pure.u128(orderId),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Cancel multiple orders
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} balanceManagerKey The key to identify the BalanceManager
+     * @param {string[]} orderIds Array of order IDs to cancel
+     * @returns A function that takes a Transaction object
+     */
+    this.cancelOrders = (poolKey, balanceManagerKey, orderIds) => (tx) => {
+      tx.setGasBudgetIfNotSet(import_config.GAS_BUDGET);
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const tradeProof = tx.add(__privateGet(this, _config).balanceManager.generateProof(balanceManagerKey));
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::cancel_orders`,
+        arguments: [
+          tx.object(pool.address),
+          tx.object(balanceManager.address),
+          tradeProof,
+          tx.pure.vector("u128", orderIds),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Cancel all open orders for a balance manager
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} balanceManagerKey The key to identify the BalanceManager
+     * @returns A function that takes a Transaction object
+     */
+    this.cancelAllOrders = (poolKey, balanceManagerKey) => (tx) => {
+      tx.setGasBudgetIfNotSet(import_config.GAS_BUDGET);
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const tradeProof = tx.add(__privateGet(this, _config).balanceManager.generateProof(balanceManagerKey));
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::cancel_all_orders`,
+        arguments: [
+          tx.object(pool.address),
+          tx.object(balanceManager.address),
+          tradeProof,
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Withdraw settled amounts for a balance manager
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} balanceManagerKey The key to identify the BalanceManager
+     * @returns A function that takes a Transaction object
+     */
+    this.withdrawSettledAmounts = (poolKey, balanceManagerKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const tradeProof = tx.add(__privateGet(this, _config).balanceManager.generateProof(balanceManagerKey));
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::withdraw_settled_amounts`,
+        arguments: [tx.object(pool.address), tx.object(balanceManager.address), tradeProof],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Withdraw settled amounts permissionlessly for a balance manager
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} balanceManagerKey The key to identify the BalanceManager
+     * @returns A function that takes a Transaction object
+     */
+    this.withdrawSettledAmountsPermissionless = (poolKey, balanceManagerKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::withdraw_settled_amounts_permissionless`,
+        arguments: [tx.object(pool.address), tx.object(balanceManager.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Add a deep price point for a target pool using a reference pool
+     * @param {string} targetPoolKey The key to identify the target pool
+     * @param {string} referencePoolKey The key to identify the reference pool
+     * @returns A function that takes a Transaction object
+     */
+    this.addDeepPricePoint = (targetPoolKey, referencePoolKey) => (tx) => {
+      const targetPool = __privateGet(this, _config).getPool(targetPoolKey);
+      const referencePool = __privateGet(this, _config).getPool(referencePoolKey);
+      const targetBaseCoin = __privateGet(this, _config).getCoin(targetPool.baseCoin);
+      const targetQuoteCoin = __privateGet(this, _config).getCoin(targetPool.quoteCoin);
+      const referenceBaseCoin = __privateGet(this, _config).getCoin(referencePool.baseCoin);
+      const referenceQuoteCoin = __privateGet(this, _config).getCoin(referencePool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::add_deep_price_point`,
+        arguments: [
+          tx.object(targetPool.address),
+          tx.object(referencePool.address),
+          tx.object.clock()
+        ],
+        typeArguments: [
+          targetBaseCoin.type,
+          targetQuoteCoin.type,
+          referenceBaseCoin.type,
+          referenceQuoteCoin.type
+        ]
+      });
+    };
+    /**
+     * @description Claim rebates for a balance manager
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} balanceManagerKey The key to identify the BalanceManager
+     * @returns A function that takes a Transaction object
+     */
+    this.claimRebates = (poolKey, balanceManagerKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const tradeProof = tx.add(__privateGet(this, _config).balanceManager.generateProof(balanceManagerKey));
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::claim_rebates`,
+        arguments: [tx.object(pool.address), tx.object(balanceManager.address), tradeProof],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Mint a referral for a pool
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} multiplier The multiplier for the referral
+     * @returns A function that takes a Transaction object
+     */
+    this.mintReferral = (poolKey, multiplier) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const adjustedNumber = Math.round(multiplier * import_config.FLOAT_SCALAR);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::mint_referral`,
+        arguments: [tx.object(pool.address), tx.pure.u64(adjustedNumber)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Update the referral multiplier for a pool (DeepBookPoolReferral)
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} referral The referral (DeepBookPoolReferral) to update
+     * @param {number} multiplier The multiplier for the referral
+     * @returns A function that takes a Transaction object
+     */
+    this.updatePoolReferralMultiplier = (poolKey, referral, multiplier) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const adjustedNumber = Math.round(multiplier * import_config.FLOAT_SCALAR);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::update_pool_referral_multiplier`,
+        arguments: [tx.object(pool.address), tx.object(referral), tx.pure.u64(adjustedNumber)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Claim the rewards for a referral (DeepBookPoolReferral)
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} referral The referral (DeepBookPoolReferral) to claim the rewards for
+     * @returns A function that takes a Transaction object
+     */
+    this.claimPoolReferralRewards = (poolKey, referral) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const [baseRewards, quoteRewards, deepRewards] = tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::claim_pool_referral_rewards`,
+        arguments: [tx.object(pool.address), tx.object(referral)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+      return { baseRewards, quoteRewards, deepRewards };
+    };
+    /**
+     * @description Update the allowed versions for a pool
+     * @param {string} poolKey The key of the pool to be updated
+     * @returns A function that takes a Transaction object
+     */
+    this.updatePoolAllowedVersions = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::update_pool_allowed_versions`,
+        arguments: [tx.object(pool.address), tx.object(__privateGet(this, _config).REGISTRY_ID)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Gets an order
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} orderId Order ID to get
+     * @returns A function that takes a Transaction object
+     */
+    this.getOrder = (poolKey, orderId) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_order`,
+        arguments: [tx.object(pool.address), tx.pure.u128(orderId)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Prepares a transaction to retrieve multiple orders from a specified pool.
+     * @param {string} poolKey - The identifier key for the pool to retrieve orders from.
+     * @param {string[]} orderIds - Array of order IDs to retrieve.
+     * @returns {Function} A function that takes a Transaction object
+     */
+    this.getOrders = (poolKey, orderIds) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_orders`,
+        arguments: [tx.object(pool.address), tx.pure.vector("u128", orderIds)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Burn DEEP tokens from the pool
+     * @param {string} poolKey The key to identify the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.burnDeep = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::burn_deep`,
+        arguments: [tx.object(pool.address), tx.object(__privateGet(this, _config).DEEP_TREASURY_ID)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the mid price for a pool
+     * @param {string} poolKey The key to identify the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.midPrice = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::mid_price`,
+        arguments: [tx.object(pool.address), tx.object.clock()],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Check if a pool is whitelisted
+     * @param {string} poolKey The key to identify the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.whitelisted = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::whitelisted`,
+        arguments: [tx.object(pool.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the quote quantity out for a given base quantity in
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} baseQuantity Base quantity to convert
+     * @returns A function that takes a Transaction object
+     */
+    this.getQuoteQuantityOut = (poolKey, baseQuantity) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_quote_quantity_out`,
+        arguments: [
+          tx.object(pool.address),
+          tx.pure.u64(baseQuantity * baseCoin.scalar),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the base quantity out for a given quote quantity in
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} quoteQuantity Quote quantity to convert
+     * @returns A function that takes a Transaction object
+     */
+    this.getBaseQuantityOut = (poolKey, quoteQuantity) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const quoteScalar = quoteCoin.scalar;
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_base_quantity_out`,
+        arguments: [
+          tx.object(pool.address),
+          tx.pure.u64(quoteQuantity * quoteScalar),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the quantity out for a given base or quote quantity
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} baseQuantity Base quantity to convert
+     * @param {number} quoteQuantity Quote quantity to convert
+     * @returns A function that takes a Transaction object
+     */
+    this.getQuantityOut = (poolKey, baseQuantity, quoteQuantity) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const quoteScalar = quoteCoin.scalar;
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_quantity_out`,
+        arguments: [
+          tx.object(pool.address),
+          tx.pure.u64(baseQuantity * baseCoin.scalar),
+          tx.pure.u64(quoteQuantity * quoteScalar),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get open orders for a balance manager in a pool
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} managerKey Key of the balance manager
+     * @returns A function that takes a Transaction object
+     */
+    this.accountOpenOrders = (poolKey, managerKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const manager = __privateGet(this, _config).getBalanceManager(managerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::account_open_orders`,
+        arguments: [tx.object(pool.address), tx.object(manager.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get level 2 order book specifying range of price
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} priceLow Lower bound of the price range
+     * @param {number} priceHigh Upper bound of the price range
+     * @param {boolean} isBid Whether to get bid or ask orders
+     * @returns A function that takes a Transaction object
+     */
+    this.getLevel2Range = (poolKey, priceLow, priceHigh, isBid) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_level2_range`,
+        arguments: [
+          tx.object(pool.address),
+          tx.pure.u64(priceLow * import_config.FLOAT_SCALAR * quoteCoin.scalar / baseCoin.scalar),
+          tx.pure.u64(priceHigh * import_config.FLOAT_SCALAR * quoteCoin.scalar / baseCoin.scalar),
+          tx.pure.bool(isBid),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get level 2 order book ticks from mid-price for a pool
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} tickFromMid Number of ticks from mid-price
+     * @returns A function that takes a Transaction object
+     */
+    this.getLevel2TicksFromMid = (poolKey, tickFromMid) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_level2_ticks_from_mid`,
+        arguments: [tx.object(pool.address), tx.pure.u64(tickFromMid), tx.object.clock()],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the vault balances for a pool
+     * @param {string} poolKey The key to identify the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.vaultBalances = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::vault_balances`,
+        arguments: [tx.object(pool.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the pool ID by asset types
+     * @param {string} baseType Type of the base asset
+     * @param {string} quoteType Type of the quote asset
+     * @returns A function that takes a Transaction object
+     */
+    this.getPoolIdByAssets = (baseType, quoteType) => (tx) => {
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_pool_id_by_asset`,
+        arguments: [tx.object(__privateGet(this, _config).REGISTRY_ID)],
+        typeArguments: [baseType, quoteType]
+      });
+    };
+    /**
+     * @description Swap exact base amount for quote amount
+     * @param {SwapParams} params Parameters for the swap
+     * @returns A function that takes a Transaction object
+     */
+    this.swapExactBaseForQuote = (params) => (tx) => {
+      tx.setGasBudgetIfNotSet(import_config.GAS_BUDGET);
+      tx.setSenderIfNotSet(__privateGet(this, _config).address);
+      if (params.quoteCoin) {
+        throw new Error("quoteCoin is not accepted for swapping base asset");
+      }
+      const { poolKey, amount: baseAmount, deepAmount, minOut: minQuote } = params;
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const deepCoinType = __privateGet(this, _config).getCoin("DEEP").type;
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const baseCoinInput = params.baseCoin ?? (0, import_transactions.coinWithBalance)({ type: baseCoin.type, balance: Math.round(baseAmount * baseCoin.scalar) });
+      const deepCoin = params.deepCoin ?? (0, import_transactions.coinWithBalance)({ type: deepCoinType, balance: Math.round(deepAmount * import_config.DEEP_SCALAR) });
+      const minQuoteInput = Math.round(minQuote * quoteCoin.scalar);
+      const [baseCoinResult, quoteCoinResult, deepCoinResult] = tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::swap_exact_base_for_quote`,
+        arguments: [
+          tx.object(pool.address),
+          baseCoinInput,
+          deepCoin,
+          tx.pure.u64(minQuoteInput),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+      return [baseCoinResult, quoteCoinResult, deepCoinResult];
+    };
+    /**
+     * @description Swap exact quote amount for base amount
+     * @param {SwapParams} params Parameters for the swap
+     * @returns A function that takes a Transaction object
+     */
+    this.swapExactQuoteForBase = (params) => (tx) => {
+      tx.setGasBudgetIfNotSet(import_config.GAS_BUDGET);
+      tx.setSenderIfNotSet(__privateGet(this, _config).address);
+      if (params.baseCoin) {
+        throw new Error("baseCoin is not accepted for swapping quote asset");
+      }
+      const { poolKey, amount: quoteAmount, deepAmount, minOut: minBase } = params;
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const deepCoinType = __privateGet(this, _config).getCoin("DEEP").type;
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const quoteCoinInput = params.quoteCoin ?? (0, import_transactions.coinWithBalance)({
+        type: quoteCoin.type,
+        balance: Math.round(quoteAmount * quoteCoin.scalar)
+      });
+      const deepCoin = params.deepCoin ?? (0, import_transactions.coinWithBalance)({ type: deepCoinType, balance: Math.round(deepAmount * import_config.DEEP_SCALAR) });
+      const minBaseInput = Math.round(minBase * baseCoin.scalar);
+      const [baseCoinResult, quoteCoinResult, deepCoinResult] = tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::swap_exact_quote_for_base`,
+        arguments: [
+          tx.object(pool.address),
+          quoteCoinInput,
+          deepCoin,
+          tx.pure.u64(minBaseInput),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+      return [baseCoinResult, quoteCoinResult, deepCoinResult];
+    };
+    /**
+     * @description Swap exact quantity without a balance manager
+     * @param {SwapParams & {isBaseToCoin: boolean}} params Parameters for the swap
+     * @returns A function that takes a Transaction object
+     */
+    this.swapExactQuantity = (params) => (tx) => {
+      tx.setGasBudgetIfNotSet(import_config.GAS_BUDGET);
+      tx.setSenderIfNotSet(__privateGet(this, _config).address);
+      const { poolKey, amount, deepAmount, minOut, baseCoin, quoteCoin, deepCoin, isBaseToCoin } = params;
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const deepCoinType = __privateGet(this, _config).getCoin("DEEP").type;
+      const baseCoinType = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoinType = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const baseCoinInput = isBaseToCoin ? baseCoin ?? (0, import_transactions.coinWithBalance)({
+        type: baseCoinType.type,
+        balance: Math.round(amount * baseCoinType.scalar)
+      }) : (0, import_transactions.coinWithBalance)({ type: baseCoinType.type, balance: 0 });
+      const quoteCoinInput = isBaseToCoin ? (0, import_transactions.coinWithBalance)({ type: quoteCoinType.type, balance: 0 }) : quoteCoin ?? (0, import_transactions.coinWithBalance)({
+        type: quoteCoinType.type,
+        balance: Math.round(amount * quoteCoinType.scalar)
+      });
+      const deepCoinInput = deepCoin ?? (0, import_transactions.coinWithBalance)({ type: deepCoinType, balance: Math.round(deepAmount * import_config.DEEP_SCALAR) });
+      const minOutInput = Math.round(
+        minOut * (isBaseToCoin ? quoteCoinType.scalar : baseCoinType.scalar)
+      );
+      const [baseCoinResult, quoteCoinResult, deepCoinResult] = tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::swap_exact_quantity`,
+        arguments: [
+          tx.object(pool.address),
+          baseCoinInput,
+          quoteCoinInput,
+          deepCoinInput,
+          tx.pure.u64(minOutInput),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoinType.type, quoteCoinType.type]
+      });
+      return [baseCoinResult, quoteCoinResult, deepCoinResult];
+    };
+    /**
+     * @description Swap exact base for quote with a balance manager
+     * @param {SwapWithManagerParams} params Parameters for the swap
+     * @returns A function that takes a Transaction object
+     */
+    this.swapExactBaseForQuoteWithManager = (params) => (tx) => {
+      tx.setGasBudgetIfNotSet(import_config.GAS_BUDGET);
+      const {
+        poolKey,
+        balanceManagerKey,
+        tradeCap,
+        depositCap,
+        withdrawCap,
+        amount: baseAmount,
+        minOut: minQuote,
+        baseCoin
+      } = params;
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoinType = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoinType = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const baseCoinInput = baseCoin ?? (0, import_transactions.coinWithBalance)({
+        type: baseCoinType.type,
+        balance: Math.round(baseAmount * baseCoinType.scalar)
+      });
+      const minQuoteInput = Math.round(minQuote * quoteCoinType.scalar);
+      const [baseCoinResult, quoteCoinResult] = tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::swap_exact_base_for_quote_with_manager`,
+        arguments: [
+          tx.object(pool.address),
+          tx.object(balanceManager.address),
+          tx.object(tradeCap),
+          tx.object(depositCap),
+          tx.object(withdrawCap),
+          baseCoinInput,
+          tx.pure.u64(minQuoteInput),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoinType.type, quoteCoinType.type]
+      });
+      return [baseCoinResult, quoteCoinResult];
+    };
+    /**
+     * @description Swap exact quote for base with a balance manager
+     * @param {SwapWithManagerParams} params Parameters for the swap
+     * @returns A function that takes a Transaction object
+     */
+    this.swapExactQuoteForBaseWithManager = (params) => (tx) => {
+      tx.setGasBudgetIfNotSet(import_config.GAS_BUDGET);
+      const {
+        poolKey,
+        balanceManagerKey,
+        tradeCap,
+        depositCap,
+        withdrawCap,
+        amount: quoteAmount,
+        minOut: minBase,
+        quoteCoin
+      } = params;
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoinType = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoinType = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const quoteCoinInput = quoteCoin ?? (0, import_transactions.coinWithBalance)({
+        type: quoteCoinType.type,
+        balance: Math.round(quoteAmount * quoteCoinType.scalar)
+      });
+      const minBaseInput = Math.round(minBase * baseCoinType.scalar);
+      const [baseCoinResult, quoteCoinResult] = tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::swap_exact_quote_for_base_with_manager`,
+        arguments: [
+          tx.object(pool.address),
+          tx.object(balanceManager.address),
+          tx.object(tradeCap),
+          tx.object(depositCap),
+          tx.object(withdrawCap),
+          quoteCoinInput,
+          tx.pure.u64(minBaseInput),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoinType.type, quoteCoinType.type]
+      });
+      return [baseCoinResult, quoteCoinResult];
+    };
+    /**
+     * @description Swap exact quantity (base or quote) with a balance manager
+     * @param {SwapWithManagerParams & {isBaseToCoin: boolean}} params Parameters for the swap
+     * @returns A function that takes a Transaction object
+     */
+    this.swapExactQuantityWithManager = (params) => (tx) => {
+      tx.setGasBudgetIfNotSet(import_config.GAS_BUDGET);
+      const {
+        poolKey,
+        balanceManagerKey,
+        tradeCap,
+        depositCap,
+        withdrawCap,
+        amount,
+        minOut,
+        baseCoin,
+        quoteCoin,
+        isBaseToCoin
+      } = params;
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const balanceManager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoinType = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoinType = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const baseCoinInput = isBaseToCoin ? baseCoin ?? (0, import_transactions.coinWithBalance)({
+        type: baseCoinType.type,
+        balance: Math.round(amount * baseCoinType.scalar)
+      }) : (0, import_transactions.coinWithBalance)({ type: baseCoinType.type, balance: 0 });
+      const quoteCoinInput = isBaseToCoin ? (0, import_transactions.coinWithBalance)({ type: quoteCoinType.type, balance: 0 }) : quoteCoin ?? (0, import_transactions.coinWithBalance)({
+        type: quoteCoinType.type,
+        balance: Math.round(amount * quoteCoinType.scalar)
+      });
+      const minOutInput = Math.round(
+        minOut * (isBaseToCoin ? quoteCoinType.scalar : baseCoinType.scalar)
+      );
+      const [baseCoinResult, quoteCoinResult] = tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::swap_exact_quantity_with_manager`,
+        arguments: [
+          tx.object(pool.address),
+          tx.object(balanceManager.address),
+          tx.object(tradeCap),
+          tx.object(depositCap),
+          tx.object(withdrawCap),
+          baseCoinInput,
+          quoteCoinInput,
+          tx.pure.u64(minOutInput),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoinType.type, quoteCoinType.type]
+      });
+      return [baseCoinResult, quoteCoinResult];
+    };
+    /**
+     * @description Create a new pool permissionlessly
+     * @param {CreatePermissionlessPoolParams} params Parameters for creating permissionless pool
+     * @returns A function that takes a Transaction object
+     */
+    this.createPermissionlessPool = (params) => (tx) => {
+      tx.setSenderIfNotSet(__privateGet(this, _config).address);
+      const { baseCoinKey, quoteCoinKey, tickSize, lotSize, minSize, deepCoin } = params;
+      const baseCoin = __privateGet(this, _config).getCoin(baseCoinKey);
+      const quoteCoin = __privateGet(this, _config).getCoin(quoteCoinKey);
+      const deepCoinType = __privateGet(this, _config).getCoin("DEEP").type;
+      const baseScalar = baseCoin.scalar;
+      const quoteScalar = quoteCoin.scalar;
+      const adjustedTickSize = Math.round(tickSize * import_config.FLOAT_SCALAR * quoteScalar / baseScalar);
+      const adjustedLotSize = Math.round(lotSize * baseScalar);
+      const adjustedMinSize = Math.round(minSize * baseScalar);
+      const deepCoinInput = deepCoin ?? (0, import_transactions.coinWithBalance)({
+        type: deepCoinType,
+        balance: import_config.POOL_CREATION_FEE_DEEP
+      });
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::create_permissionless_pool`,
+        arguments: [
+          tx.object(__privateGet(this, _config).REGISTRY_ID),
+          // registry_id
+          tx.pure.u64(adjustedTickSize),
+          // adjusted tick_size
+          tx.pure.u64(adjustedLotSize),
+          // adjusted lot_size
+          tx.pure.u64(adjustedMinSize),
+          // adjusted min_size
+          deepCoinInput
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the trade parameters for a given pool, including taker fee, maker fee, and stake required.
+     * @param {string} poolKey Key of the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.poolTradeParams = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::pool_trade_params`,
+        arguments: [tx.object(pool.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the book parameters for a given pool, including tick size, lot size, and min size.
+     * @param {string} poolKey Key of the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.poolBookParams = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::pool_book_params`,
+        arguments: [tx.object(pool.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the account information for a given pool and balance manager
+     * @param {string} poolKey Key of the pool
+     * @param {string} managerKey The key of the BalanceManager
+     * @returns A function that takes a Transaction object
+     */
+    this.account = (poolKey, managerKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const managerId = __privateGet(this, _config).getBalanceManager(managerKey).address;
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::account`,
+        arguments: [tx.object(pool.address), tx.object(managerId)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the locked balance for a given pool and balance manager
+     * @param {string} poolKey Key of the pool
+     * @param {string} managerKey The key of the BalanceManager
+     * @returns A function that takes a Transaction object
+     */
+    this.lockedBalance = (poolKey, managerKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const managerId = __privateGet(this, _config).getBalanceManager(managerKey).address;
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::locked_balance`,
+        arguments: [tx.object(pool.address), tx.object(managerId)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the DEEP price conversion for a pool
+     * @param {string} poolKey The key to identify the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.getPoolDeepPrice = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_order_deep_price`,
+        arguments: [tx.object(pool.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the balance manager IDs for a given owner
+     * @param {string} owner The owner address to get balance manager IDs for
+     * @returns A function that takes a Transaction object
+     */
+    this.getBalanceManagerIds = (owner) => (tx) => {
+      tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::registry::get_balance_manager_ids`,
+        arguments: [tx.object(__privateGet(this, _config).REGISTRY_ID), tx.pure.address(owner)]
+      });
+    };
+    /**
+     * @description Get the balances for a referral (DeepBookPoolReferral)
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} referral The referral (DeepBookPoolReferral) to get the balances for
+     * @returns A function that takes a Transaction object
+     */
+    this.getPoolReferralBalances = (poolKey, referral) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_pool_referral_balances`,
+        arguments: [tx.object(pool.address), tx.object(referral)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the multiplier for a referral (DeepBookPoolReferral)
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} referral The referral (DeepBookPoolReferral) to get the multiplier for
+     * @returns A function that takes a Transaction object
+     */
+    this.poolReferralMultiplier = (poolKey, referral) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::pool_referral_multiplier`,
+        arguments: [tx.object(pool.address), tx.object(referral)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Check if a pool is a stable pool
+     * @param {string} poolKey The key to identify the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.stablePool = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::stable_pool`,
+        arguments: [tx.object(pool.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Check if a pool is registered
+     * @param {string} poolKey The key to identify the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.registeredPool = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::registered_pool`,
+        arguments: [tx.object(pool.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the quote quantity out for a given base quantity using input token as fee
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} baseQuantity Base quantity to convert
+     * @returns A function that takes a Transaction object
+     */
+    this.getQuoteQuantityOutInputFee = (poolKey, baseQuantity) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_quote_quantity_out_input_fee`,
+        arguments: [
+          tx.object(pool.address),
+          tx.pure.u64(baseQuantity * baseCoin.scalar),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the base quantity out for a given quote quantity using input token as fee
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} quoteQuantity Quote quantity to convert
+     * @returns A function that takes a Transaction object
+     */
+    this.getBaseQuantityOutInputFee = (poolKey, quoteQuantity) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_base_quantity_out_input_fee`,
+        arguments: [
+          tx.object(pool.address),
+          tx.pure.u64(quoteQuantity * quoteCoin.scalar),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the quantity out for a given base or quote quantity using input token as fee
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} baseQuantity Base quantity to convert
+     * @param {number} quoteQuantity Quote quantity to convert
+     * @returns A function that takes a Transaction object
+     */
+    this.getQuantityOutInputFee = (poolKey, baseQuantity, quoteQuantity) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_quantity_out_input_fee`,
+        arguments: [
+          tx.object(pool.address),
+          tx.pure.u64(baseQuantity * baseCoin.scalar),
+          tx.pure.u64(quoteQuantity * quoteCoin.scalar),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the base quantity needed to receive a target quote quantity
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} targetQuoteQuantity Target quote quantity
+     * @param {boolean} payWithDeep Whether to pay fees with DEEP
+     * @returns A function that takes a Transaction object
+     */
+    this.getBaseQuantityIn = (poolKey, targetQuoteQuantity, payWithDeep) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_base_quantity_in`,
+        arguments: [
+          tx.object(pool.address),
+          tx.pure.u64(targetQuoteQuantity * quoteCoin.scalar),
+          tx.pure.bool(payWithDeep),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the quote quantity needed to receive a target base quantity
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} targetBaseQuantity Target base quantity
+     * @param {boolean} payWithDeep Whether to pay fees with DEEP
+     * @returns A function that takes a Transaction object
+     */
+    this.getQuoteQuantityIn = (poolKey, targetBaseQuantity, payWithDeep) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_quote_quantity_in`,
+        arguments: [
+          tx.object(pool.address),
+          tx.pure.u64(targetBaseQuantity * baseCoin.scalar),
+          tx.pure.bool(payWithDeep),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get account order details for a balance manager
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} managerKey Key of the balance manager
+     * @returns A function that takes a Transaction object
+     */
+    this.getAccountOrderDetails = (poolKey, managerKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const manager = __privateGet(this, _config).getBalanceManager(managerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_account_order_details`,
+        arguments: [tx.object(pool.address), tx.object(manager.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the DEEP required for an order
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} baseQuantity Base quantity
+     * @param {number} price Price
+     * @returns A function that takes a Transaction object
+     */
+    this.getOrderDeepRequired = (poolKey, baseQuantity, price) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const inputPrice = Math.round(price * import_config.FLOAT_SCALAR * quoteCoin.scalar / baseCoin.scalar);
+      const inputQuantity = Math.round(baseQuantity * baseCoin.scalar);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::get_order_deep_required`,
+        arguments: [tx.object(pool.address), tx.pure.u64(inputQuantity), tx.pure.u64(inputPrice)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Check if account exists for a balance manager
+     * @param {string} poolKey The key to identify the pool
+     * @param {string} managerKey Key of the balance manager
+     * @returns A function that takes a Transaction object
+     */
+    this.accountExists = (poolKey, managerKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const manager = __privateGet(this, _config).getBalanceManager(managerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::account_exists`,
+        arguments: [tx.object(pool.address), tx.object(manager.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the next epoch trade parameters for a pool
+     * @param {string} poolKey The key to identify the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.poolTradeParamsNext = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::pool_trade_params_next`,
+        arguments: [tx.object(pool.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the quorum for a pool
+     * @param {string} poolKey The key to identify the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.quorum = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::quorum`,
+        arguments: [tx.object(pool.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Get the pool ID
+     * @param {string} poolKey The key to identify the pool
+     * @returns A function that takes a Transaction object
+     */
+    this.poolId = (poolKey) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::id`,
+        arguments: [tx.object(pool.address)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Check if a limit order can be placed
+     * @param {CanPlaceLimitOrderParams} params Parameters for checking limit order validity
+     * @returns A function that takes a Transaction object
+     */
+    this.canPlaceLimitOrder = (params) => (tx) => {
+      const { poolKey, balanceManagerKey, price, quantity, isBid, payWithDeep, expireTimestamp } = params;
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const manager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const inputPrice = Math.round(price * import_config.FLOAT_SCALAR * quoteCoin.scalar / baseCoin.scalar);
+      const inputQuantity = Math.round(quantity * baseCoin.scalar);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::can_place_limit_order`,
+        arguments: [
+          tx.object(pool.address),
+          tx.object(manager.address),
+          tx.pure.u64(inputPrice),
+          tx.pure.u64(inputQuantity),
+          tx.pure.bool(isBid),
+          tx.pure.bool(payWithDeep),
+          tx.pure.u64(expireTimestamp),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Check if a market order can be placed
+     * @param {CanPlaceMarketOrderParams} params Parameters for checking market order validity
+     * @returns A function that takes a Transaction object
+     */
+    this.canPlaceMarketOrder = (params) => (tx) => {
+      const { poolKey, balanceManagerKey, quantity, isBid, payWithDeep } = params;
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const manager = __privateGet(this, _config).getBalanceManager(balanceManagerKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const inputQuantity = Math.round(quantity * baseCoin.scalar);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::can_place_market_order`,
+        arguments: [
+          tx.object(pool.address),
+          tx.object(manager.address),
+          tx.pure.u64(inputQuantity),
+          tx.pure.bool(isBid),
+          tx.pure.bool(payWithDeep),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Check if market order params are valid
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} quantity Quantity
+     * @returns A function that takes a Transaction object
+     */
+    this.checkMarketOrderParams = (poolKey, quantity) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const inputQuantity = Math.round(quantity * baseCoin.scalar);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::check_market_order_params`,
+        arguments: [tx.object(pool.address), tx.pure.u64(inputQuantity)],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    /**
+     * @description Check if limit order params are valid
+     * @param {string} poolKey The key to identify the pool
+     * @param {number} price Price
+     * @param {number} quantity Quantity
+     * @param {number} expireTimestamp Expiration timestamp
+     * @returns A function that takes a Transaction object
+     */
+    this.checkLimitOrderParams = (poolKey, price, quantity, expireTimestamp) => (tx) => {
+      const pool = __privateGet(this, _config).getPool(poolKey);
+      const baseCoin = __privateGet(this, _config).getCoin(pool.baseCoin);
+      const quoteCoin = __privateGet(this, _config).getCoin(pool.quoteCoin);
+      const inputPrice = Math.round(price * import_config.FLOAT_SCALAR * quoteCoin.scalar / baseCoin.scalar);
+      const inputQuantity = Math.round(quantity * baseCoin.scalar);
+      return tx.moveCall({
+        target: `${__privateGet(this, _config).DEEPBOOK_PACKAGE_ID}::pool::check_limit_order_params`,
+        arguments: [
+          tx.object(pool.address),
+          tx.pure.u64(inputPrice),
+          tx.pure.u64(inputQuantity),
+          tx.pure.u64(expireTimestamp),
+          tx.object.clock()
+        ],
+        typeArguments: [baseCoin.type, quoteCoin.type]
+      });
+    };
+    __privateSet(this, _config, config);
+  }
+}
+_config = new WeakMap();
+//# sourceMappingURL=deepbook.js.map