@mysten/deepbook-v3 0.22.2 → 0.23.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @mysten/deepbook-v3
 
+## 0.23.0
+
+### Minor Changes
+
+- 3fff516: DeepBook Core Package Upgrade (V4)
+
 ## 0.22.2
 
 ### Patch Changes

package/dist/cjs/client.d.ts

@@ -5,7 +5,7 @@ import { DeepBookContract } from './transactions/deepbook.js';
 import { DeepBookAdminContract } from './transactions/deepbookAdmin.js';
 import { FlashLoanContract } from './transactions/flashLoans.js';
 import { GovernanceContract } from './transactions/governance.js';
-import type { BalanceManager, Environment, MarginManager } from './types/index.js';
+import type { BalanceManager, Environment, MarginManager, CanPlaceLimitOrderParams, CanPlaceMarketOrderParams } from './types/index.js';
 import type { CoinMap, PoolMap } from './utils/constants.js';
 import { MarginAdminContract } from './transactions/marginAdmin.js';
 import { MarginMaintainerContract } from './transactions/marginMaintainer.js';
@@ -556,6 +556,9 @@ export declare class DeepBookClient {
         basePythDecimals: number;
         quotePythPrice: string;
         quotePythDecimals: number;
+        currentPrice: bigint;
+        lowestTriggerAbovePrice: bigint;
+        highestTriggerBelowPrice: bigint;
     }>;
     /**
      * @description Get the base asset balance of a margin manager
@@ -648,4 +651,167 @@ export declare class DeepBookClient {
      * @returns {Promise<string[]>} Array of allowed pause cap IDs
      */
     getAllowedPauseCaps(): Promise<string[]>;
+    /**
+     * @description Check if a pool is a stable pool
+     * @param {string} poolKey Key of the pool
+     * @returns {Promise<boolean>} Whether the pool is a stable pool
+     */
+    stablePool(poolKey: string): Promise<boolean>;
+    /**
+     * @description Check if a pool is registered
+     * @param {string} poolKey Key of the pool
+     * @returns {Promise<boolean>} Whether the pool is registered
+     */
+    registeredPool(poolKey: string): Promise<boolean>;
+    /**
+     * @description Get the quote quantity out using input token as fee
+     * @param {string} poolKey Key of the pool
+     * @param {number} baseQuantity Base quantity
+     * @returns {Promise<{baseQuantity: number, baseOut: number, quoteOut: number, deepRequired: number}>}
+     */
+    getQuoteQuantityOutInputFee(poolKey: string, baseQuantity: number): Promise<{
+        baseQuantity: number;
+        baseOut: number;
+        quoteOut: number;
+        deepRequired: number;
+    }>;
+    /**
+     * @description Get the base quantity out using input token as fee
+     * @param {string} poolKey Key of the pool
+     * @param {number} quoteQuantity Quote quantity
+     * @returns {Promise<{quoteQuantity: number, baseOut: number, quoteOut: number, deepRequired: number}>}
+     */
+    getBaseQuantityOutInputFee(poolKey: string, quoteQuantity: number): Promise<{
+        quoteQuantity: number;
+        baseOut: number;
+        quoteOut: number;
+        deepRequired: number;
+    }>;
+    /**
+     * @description Get the quantity out using input token as fee
+     * @param {string} poolKey Key of the pool
+     * @param {number} baseQuantity Base quantity
+     * @param {number} quoteQuantity Quote quantity
+     * @returns {Promise<{baseQuantity: number, quoteQuantity: number, baseOut: number, quoteOut: number, deepRequired: number}>}
+     */
+    getQuantityOutInputFee(poolKey: string, baseQuantity: number, quoteQuantity: number): Promise<{
+        baseQuantity: number;
+        quoteQuantity: number;
+        baseOut: number;
+        quoteOut: number;
+        deepRequired: number;
+    }>;
+    /**
+     * @description Get the base quantity needed to receive target quote quantity
+     * @param {string} poolKey Key of the pool
+     * @param {number} targetQuoteQuantity Target quote quantity
+     * @param {boolean} payWithDeep Whether to pay fees with DEEP
+     * @returns {Promise<{baseIn: number, quoteOut: number, deepRequired: number}>}
+     */
+    getBaseQuantityIn(poolKey: string, targetQuoteQuantity: number, payWithDeep: boolean): Promise<{
+        baseIn: number;
+        quoteOut: number;
+        deepRequired: number;
+    }>;
+    /**
+     * @description Get the quote quantity needed to receive target base quantity
+     * @param {string} poolKey Key of the pool
+     * @param {number} targetBaseQuantity Target base quantity
+     * @param {boolean} payWithDeep Whether to pay fees with DEEP
+     * @returns {Promise<{baseOut: number, quoteIn: number, deepRequired: number}>}
+     */
+    getQuoteQuantityIn(poolKey: string, targetBaseQuantity: number, payWithDeep: boolean): Promise<{
+        baseOut: number;
+        quoteIn: number;
+        deepRequired: number;
+    }>;
+    /**
+     * @description Get account order details for a balance manager
+     * @param {string} poolKey Key of the pool
+     * @param {string} managerKey Key of the balance manager
+     * @returns {Promise<Array>} Array of order details
+     */
+    getAccountOrderDetails(poolKey: string, managerKey: string): Promise<{
+        balance_manager_id: string;
+        order_id: string;
+        client_order_id: string;
+        quantity: string;
+        filled_quantity: string;
+        fee_is_deep: boolean;
+        order_deep_price: {
+            asset_is_base: boolean;
+            deep_per_asset: string;
+        };
+        epoch: string;
+        status: number;
+        expire_timestamp: string;
+    }[]>;
+    /**
+     * @description Get the DEEP required for an order
+     * @param {string} poolKey Key of the pool
+     * @param {number} baseQuantity Base quantity
+     * @param {number} price Price
+     * @returns {Promise<{deepRequiredTaker: number, deepRequiredMaker: number}>}
+     */
+    getOrderDeepRequired(poolKey: string, baseQuantity: number, price: number): Promise<{
+        deepRequiredTaker: number;
+        deepRequiredMaker: number;
+    }>;
+    /**
+     * @description Check if account exists for a balance manager
+     * @param {string} poolKey Key of the pool
+     * @param {string} managerKey Key of the balance manager
+     * @returns {Promise<boolean>} Whether account exists
+     */
+    accountExists(poolKey: string, managerKey: string): Promise<boolean>;
+    /**
+     * @description Get the next epoch trade parameters
+     * @param {string} poolKey Key of the pool
+     * @returns {Promise<{takerFee: number, makerFee: number, stakeRequired: number}>}
+     */
+    poolTradeParamsNext(poolKey: string): Promise<{
+        takerFee: number;
+        makerFee: number;
+        stakeRequired: number;
+    }>;
+    /**
+     * @description Get the quorum for a pool
+     * @param {string} poolKey Key of the pool
+     * @returns {Promise<number>} The quorum amount in DEEP
+     */
+    quorum(poolKey: string): Promise<number>;
+    /**
+     * @description Get the pool ID
+     * @param {string} poolKey Key of the pool
+     * @returns {Promise<string>} The pool ID
+     */
+    poolId(poolKey: string): Promise<string>;
+    /**
+     * @description Check if a limit order can be placed
+     * @param {CanPlaceLimitOrderParams} params Parameters for checking limit order placement
+     * @returns {Promise<boolean>} Whether order can be placed
+     */
+    canPlaceLimitOrder(params: CanPlaceLimitOrderParams): Promise<boolean>;
+    /**
+     * @description Check if a market order can be placed
+     * @param {CanPlaceMarketOrderParams} params Parameters for checking market order placement
+     * @returns {Promise<boolean>} Whether order can be placed
+     */
+    canPlaceMarketOrder(params: CanPlaceMarketOrderParams): Promise<boolean>;
+    /**
+     * @description Check if market order params are valid
+     * @param {string} poolKey Key of the pool
+     * @param {number} quantity Quantity
+     * @returns {Promise<boolean>} Whether params are valid
+     */
+    checkMarketOrderParams(poolKey: string, quantity: number): Promise<boolean>;
+    /**
+     * @description Check if limit order params are valid
+     * @param {string} poolKey Key of the pool
+     * @param {number} price Price
+     * @param {number} quantity Quantity
+     * @param {number} expireTimestamp Expiration timestamp
+     * @returns {Promise<boolean>} Whether params are valid
+     */
+    checkLimitOrderParams(poolKey: string, price: number, quantity: number, expireTimestamp: number): Promise<boolean>;
 }

package/dist/cjs/client.js

@@ -675,8 +675,8 @@ class DeepBookClient {
   }
   async getPriceInfoObject(tx, coinKey) {
     const currentTime = Date.now();
-    const dbusdcPriceInfoObjectAge = await this.getPriceInfoObjectAge(coinKey) * 1e3;
-    if (currentTime - dbusdcPriceInfoObjectAge < import_config.PRICE_INFO_OBJECT_MAX_AGE) {
+    const priceInfoObjectAge = await this.getPriceInfoObjectAge(coinKey) * 1e3;
+    if (currentTime - priceInfoObjectAge < import_config.PRICE_INFO_OBJECT_MAX_AGE_MS) {
       return await __privateGet(this, _config).getCoin(coinKey).priceInfoObjectId;
     }
     const endpoint = __privateGet(this, _config).env === "testnet" ? "https://hermes-beta.pyth.network" : "https://hermes.pyth.network";
@@ -1195,6 +1195,13 @@ class DeepBookClient {
     const quotePythDecimals = Number(
       import_bcs.bcs.u8().parse(new Uint8Array(res.results[0].returnValues[10][0]))
     );
+    const currentPrice = BigInt(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[11][0])));
+    const lowestTriggerAbovePrice = BigInt(
+      import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[12][0]))
+    );
+    const highestTriggerBelowPrice = BigInt(
+      import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[13][0]))
+    );
     return {
       managerId,
       deepbookPoolId,
@@ -1206,7 +1213,10 @@ class DeepBookClient {
       basePythPrice: basePythPrice.toString(),
       basePythDecimals,
       quotePythPrice: quotePythPrice.toString(),
-      quotePythDecimals
+      quotePythDecimals,
+      currentPrice,
+      lowestTriggerAbovePrice,
+      highestTriggerBelowPrice
     };
   }
   /**
@@ -1470,6 +1480,347 @@ class DeepBookClient {
     const vecSet = (0, import_bcs2.VecSet)(import_bcs.bcs.Address).parse(new Uint8Array(bytes));
     return vecSet.contents.map((id) => (0, import_utils.normalizeSuiAddress)(id));
   }
+  /**
+   * @description Check if a pool is a stable pool
+   * @param {string} poolKey Key of the pool
+   * @returns {Promise<boolean>} Whether the pool is a stable pool
+   */
+  async stablePool(poolKey) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.stablePool(poolKey));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const bytes = res.results[0].returnValues[0][0];
+    return import_bcs.bcs.bool().parse(new Uint8Array(bytes));
+  }
+  /**
+   * @description Check if a pool is registered
+   * @param {string} poolKey Key of the pool
+   * @returns {Promise<boolean>} Whether the pool is registered
+   */
+  async registeredPool(poolKey) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.registeredPool(poolKey));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const bytes = res.results[0].returnValues[0][0];
+    return import_bcs.bcs.bool().parse(new Uint8Array(bytes));
+  }
+  /**
+   * @description Get the quote quantity out using input token as fee
+   * @param {string} poolKey Key of the pool
+   * @param {number} baseQuantity Base quantity
+   * @returns {Promise<{baseQuantity: number, baseOut: number, quoteOut: number, deepRequired: number}>}
+   */
+  async getQuoteQuantityOutInputFee(poolKey, baseQuantity) {
+    const tx = new import_transactions.Transaction();
+    const pool = __privateGet(this, _config).getPool(poolKey);
+    const baseScalar = __privateGet(this, _config).getCoin(pool.baseCoin).scalar;
+    const quoteScalar = __privateGet(this, _config).getCoin(pool.quoteCoin).scalar;
+    tx.add(this.deepBook.getQuoteQuantityOutInputFee(poolKey, baseQuantity));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const baseOut = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[0][0])));
+    const quoteOut = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[1][0])));
+    const deepRequired = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[2][0])));
+    return {
+      baseQuantity,
+      baseOut: Number((baseOut / baseScalar).toFixed(9)),
+      quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+      deepRequired: Number((deepRequired / import_config.DEEP_SCALAR).toFixed(9))
+    };
+  }
+  /**
+   * @description Get the base quantity out using input token as fee
+   * @param {string} poolKey Key of the pool
+   * @param {number} quoteQuantity Quote quantity
+   * @returns {Promise<{quoteQuantity: number, baseOut: number, quoteOut: number, deepRequired: number}>}
+   */
+  async getBaseQuantityOutInputFee(poolKey, quoteQuantity) {
+    const tx = new import_transactions.Transaction();
+    const pool = __privateGet(this, _config).getPool(poolKey);
+    const baseScalar = __privateGet(this, _config).getCoin(pool.baseCoin).scalar;
+    const quoteScalar = __privateGet(this, _config).getCoin(pool.quoteCoin).scalar;
+    tx.add(this.deepBook.getBaseQuantityOutInputFee(poolKey, quoteQuantity));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const baseOut = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[0][0])));
+    const quoteOut = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[1][0])));
+    const deepRequired = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[2][0])));
+    return {
+      quoteQuantity,
+      baseOut: Number((baseOut / baseScalar).toFixed(9)),
+      quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+      deepRequired: Number((deepRequired / import_config.DEEP_SCALAR).toFixed(9))
+    };
+  }
+  /**
+   * @description Get the quantity out using input token as fee
+   * @param {string} poolKey Key of the pool
+   * @param {number} baseQuantity Base quantity
+   * @param {number} quoteQuantity Quote quantity
+   * @returns {Promise<{baseQuantity: number, quoteQuantity: number, baseOut: number, quoteOut: number, deepRequired: number}>}
+   */
+  async getQuantityOutInputFee(poolKey, baseQuantity, quoteQuantity) {
+    const tx = new import_transactions.Transaction();
+    const pool = __privateGet(this, _config).getPool(poolKey);
+    const baseScalar = __privateGet(this, _config).getCoin(pool.baseCoin).scalar;
+    const quoteScalar = __privateGet(this, _config).getCoin(pool.quoteCoin).scalar;
+    tx.add(this.deepBook.getQuantityOutInputFee(poolKey, baseQuantity, quoteQuantity));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const baseOut = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[0][0])));
+    const quoteOut = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[1][0])));
+    const deepRequired = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[2][0])));
+    return {
+      baseQuantity,
+      quoteQuantity,
+      baseOut: Number((baseOut / baseScalar).toFixed(9)),
+      quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+      deepRequired: Number((deepRequired / import_config.DEEP_SCALAR).toFixed(9))
+    };
+  }
+  /**
+   * @description Get the base quantity needed to receive target quote quantity
+   * @param {string} poolKey Key of the pool
+   * @param {number} targetQuoteQuantity Target quote quantity
+   * @param {boolean} payWithDeep Whether to pay fees with DEEP
+   * @returns {Promise<{baseIn: number, quoteOut: number, deepRequired: number}>}
+   */
+  async getBaseQuantityIn(poolKey, targetQuoteQuantity, payWithDeep) {
+    const tx = new import_transactions.Transaction();
+    const pool = __privateGet(this, _config).getPool(poolKey);
+    const baseScalar = __privateGet(this, _config).getCoin(pool.baseCoin).scalar;
+    const quoteScalar = __privateGet(this, _config).getCoin(pool.quoteCoin).scalar;
+    tx.add(this.deepBook.getBaseQuantityIn(poolKey, targetQuoteQuantity, payWithDeep));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const baseIn = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[0][0])));
+    const quoteOut = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[1][0])));
+    const deepRequired = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[2][0])));
+    return {
+      baseIn: Number((baseIn / baseScalar).toFixed(9)),
+      quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+      deepRequired: Number((deepRequired / import_config.DEEP_SCALAR).toFixed(9))
+    };
+  }
+  /**
+   * @description Get the quote quantity needed to receive target base quantity
+   * @param {string} poolKey Key of the pool
+   * @param {number} targetBaseQuantity Target base quantity
+   * @param {boolean} payWithDeep Whether to pay fees with DEEP
+   * @returns {Promise<{baseOut: number, quoteIn: number, deepRequired: number}>}
+   */
+  async getQuoteQuantityIn(poolKey, targetBaseQuantity, payWithDeep) {
+    const tx = new import_transactions.Transaction();
+    const pool = __privateGet(this, _config).getPool(poolKey);
+    const baseScalar = __privateGet(this, _config).getCoin(pool.baseCoin).scalar;
+    const quoteScalar = __privateGet(this, _config).getCoin(pool.quoteCoin).scalar;
+    tx.add(this.deepBook.getQuoteQuantityIn(poolKey, targetBaseQuantity, payWithDeep));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const baseOut = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[0][0])));
+    const quoteIn = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[1][0])));
+    const deepRequired = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[2][0])));
+    return {
+      baseOut: Number((baseOut / baseScalar).toFixed(9)),
+      quoteIn: Number((quoteIn / quoteScalar).toFixed(9)),
+      deepRequired: Number((deepRequired / import_config.DEEP_SCALAR).toFixed(9))
+    };
+  }
+  /**
+   * @description Get account order details for a balance manager
+   * @param {string} poolKey Key of the pool
+   * @param {string} managerKey Key of the balance manager
+   * @returns {Promise<Array>} Array of order details
+   */
+  async getAccountOrderDetails(poolKey, managerKey) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.getAccountOrderDetails(poolKey, managerKey));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    try {
+      const orderInformation = res.results[0].returnValues[0][0];
+      return import_bcs.bcs.vector(import_bcs2.Order).parse(new Uint8Array(orderInformation));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * @description Get the DEEP required for an order
+   * @param {string} poolKey Key of the pool
+   * @param {number} baseQuantity Base quantity
+   * @param {number} price Price
+   * @returns {Promise<{deepRequiredTaker: number, deepRequiredMaker: number}>}
+   */
+  async getOrderDeepRequired(poolKey, baseQuantity, price) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.getOrderDeepRequired(poolKey, baseQuantity, price));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const deepRequiredTaker = Number(
+      import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[0][0]))
+    );
+    const deepRequiredMaker = Number(
+      import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[1][0]))
+    );
+    return {
+      deepRequiredTaker: Number((deepRequiredTaker / import_config.DEEP_SCALAR).toFixed(9)),
+      deepRequiredMaker: Number((deepRequiredMaker / import_config.DEEP_SCALAR).toFixed(9))
+    };
+  }
+  /**
+   * @description Check if account exists for a balance manager
+   * @param {string} poolKey Key of the pool
+   * @param {string} managerKey Key of the balance manager
+   * @returns {Promise<boolean>} Whether account exists
+   */
+  async accountExists(poolKey, managerKey) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.accountExists(poolKey, managerKey));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const bytes = res.results[0].returnValues[0][0];
+    return import_bcs.bcs.bool().parse(new Uint8Array(bytes));
+  }
+  /**
+   * @description Get the next epoch trade parameters
+   * @param {string} poolKey Key of the pool
+   * @returns {Promise<{takerFee: number, makerFee: number, stakeRequired: number}>}
+   */
+  async poolTradeParamsNext(poolKey) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.poolTradeParamsNext(poolKey));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const takerFee = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[0][0])));
+    const makerFee = Number(import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[1][0])));
+    const stakeRequired = Number(
+      import_bcs.bcs.U64.parse(new Uint8Array(res.results[0].returnValues[2][0]))
+    );
+    return {
+      takerFee: takerFee / import_config.FLOAT_SCALAR,
+      makerFee: makerFee / import_config.FLOAT_SCALAR,
+      stakeRequired: stakeRequired / import_config.DEEP_SCALAR
+    };
+  }
+  /**
+   * @description Get the quorum for a pool
+   * @param {string} poolKey Key of the pool
+   * @returns {Promise<number>} The quorum amount in DEEP
+   */
+  async quorum(poolKey) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.quorum(poolKey));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const bytes = res.results[0].returnValues[0][0];
+    const quorum = Number(import_bcs.bcs.U64.parse(new Uint8Array(bytes)));
+    return quorum / import_config.DEEP_SCALAR;
+  }
+  /**
+   * @description Get the pool ID
+   * @param {string} poolKey Key of the pool
+   * @returns {Promise<string>} The pool ID
+   */
+  async poolId(poolKey) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.poolId(poolKey));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const bytes = res.results[0].returnValues[0][0];
+    return (0, import_utils.normalizeSuiAddress)(import_bcs.bcs.Address.parse(new Uint8Array(bytes)));
+  }
+  /**
+   * @description Check if a limit order can be placed
+   * @param {CanPlaceLimitOrderParams} params Parameters for checking limit order placement
+   * @returns {Promise<boolean>} Whether order can be placed
+   */
+  async canPlaceLimitOrder(params) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.canPlaceLimitOrder(params));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const bytes = res.results[0].returnValues[0][0];
+    return import_bcs.bcs.bool().parse(new Uint8Array(bytes));
+  }
+  /**
+   * @description Check if a market order can be placed
+   * @param {CanPlaceMarketOrderParams} params Parameters for checking market order placement
+   * @returns {Promise<boolean>} Whether order can be placed
+   */
+  async canPlaceMarketOrder(params) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.canPlaceMarketOrder(params));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const bytes = res.results[0].returnValues[0][0];
+    return import_bcs.bcs.bool().parse(new Uint8Array(bytes));
+  }
+  /**
+   * @description Check if market order params are valid
+   * @param {string} poolKey Key of the pool
+   * @param {number} quantity Quantity
+   * @returns {Promise<boolean>} Whether params are valid
+   */
+  async checkMarketOrderParams(poolKey, quantity) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.checkMarketOrderParams(poolKey, quantity));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const bytes = res.results[0].returnValues[0][0];
+    return import_bcs.bcs.bool().parse(new Uint8Array(bytes));
+  }
+  /**
+   * @description Check if limit order params are valid
+   * @param {string} poolKey Key of the pool
+   * @param {number} price Price
+   * @param {number} quantity Quantity
+   * @param {number} expireTimestamp Expiration timestamp
+   * @returns {Promise<boolean>} Whether params are valid
+   */
+  async checkLimitOrderParams(poolKey, price, quantity, expireTimestamp) {
+    const tx = new import_transactions.Transaction();
+    tx.add(this.deepBook.checkLimitOrderParams(poolKey, price, quantity, expireTimestamp));
+    const res = await this.client.devInspectTransactionBlock({
+      sender: (0, import_utils.normalizeSuiAddress)(__privateGet(this, _address)),
+      transactionBlock: tx
+    });
+    const bytes = res.results[0].returnValues[0][0];
+    return import_bcs.bcs.bool().parse(new Uint8Array(bytes));
+  }
 }
 _config = new WeakMap();
 _address = new WeakMap();