@haneullabs/deepbook 0.1.0

package/dist/cjs/client.js

@@ -0,0 +1,630 @@
+"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 __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var client_exports = {};
+__export(client_exports, {
+  DeepBookClient: () => DeepBookClient
+});
+module.exports = __toCommonJS(client_exports);
+var import_bcs = require("@haneullabs/haneul/bcs");
+var import_client = require("@haneullabs/haneul/client");
+var import_transactions = require("@haneullabs/haneul/transactions");
+var import_utils = require("@haneullabs/haneul/utils");
+var import_bcs2 = require("./types/bcs.js");
+var import_types = require("./types/index.js");
+var import_utils2 = require("./utils/index.js");
+var _poolTypeArgsCache, _DeepBookClient_instances, checkAccountCap_fn, checkAddress_fn, nextClientOrderId_fn;
+const DUMMY_ADDRESS = (0, import_utils.normalizeHaneulAddress)("0x0");
+class DeepBookClient {
+  /**
+   *
+   * @param haneulClient connection to fullnode
+   * @param accountCap (optional) only required for wrting operations
+   * @param currentAddress (optional) address of the current user (default: DUMMY_ADDRESS)
+   */
+  constructor(haneulClient = new import_client.HaneulClient({ url: (0, import_client.getFullnodeUrl)("testnet") }), accountCap = void 0, currentAddress = DUMMY_ADDRESS, clientOrderId = 0) {
+    this.haneulClient = haneulClient;
+    this.accountCap = accountCap;
+    this.currentAddress = currentAddress;
+    this.clientOrderId = clientOrderId;
+    __privateAdd(this, _DeepBookClient_instances);
+    __privateAdd(this, _poolTypeArgsCache, /* @__PURE__ */ new Map());
+  }
+  /**
+   * @param cap set the account cap for interacting with DeepBook
+   */
+  async setAccountCap(cap) {
+    this.accountCap = cap;
+  }
+  /**
+   * @description Create pool for trading pair
+   * @param baseAssetType Full coin type of the base asset, eg: "0x3d0d0ce17dcd3b40c2d839d96ce66871ffb40e1154a8dd99af72292b3d10d7fc::wbtc::WBTC"
+   * @param quoteAssetType Full coin type of quote asset, eg: "0x3d0d0ce17dcd3b40c2d839d96ce66871ffb40e1154a8dd99af72292b3d10d7fc::usdt::USDT"
+   * @param tickSize Minimal Price Change Accuracy of this pool, eg: 10000000. The number must be an integer float scaled by `FLOAT_SCALING_FACTOR`.
+   * @param lotSize Minimal Lot Change Accuracy of this pool, eg: 10000.
+   */
+  createPool(baseAssetType, quoteAssetType, tickSize, lotSize) {
+    const tx = new import_transactions.Transaction();
+    const [coin] = tx.splitCoins(tx.gas, [import_utils2.CREATION_FEE]);
+    tx.moveCall({
+      typeArguments: [baseAssetType, quoteAssetType],
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::create_pool`,
+      arguments: [tx.pure.u64(tickSize), tx.pure.u64(lotSize), coin]
+    });
+    return tx;
+  }
+  /**
+   * @description Create pool for trading pair
+   * @param baseAssetType Full coin type of the base asset, eg: "0x3d0d0ce17dcd3b40c2d839d96ce66871ffb40e1154a8dd99af72292b3d10d7fc::wbtc::WBTC"
+   * @param quoteAssetType Full coin type of quote asset, eg: "0x3d0d0ce17dcd3b40c2d839d96ce66871ffb40e1154a8dd99af72292b3d10d7fc::usdt::USDT"
+   * @param tickSize Minimal Price Change Accuracy of this pool, eg: 10000000. The number must be an interger float scaled by `FLOAT_SCALING_FACTOR`.
+   * @param lotSize Minimal Lot Change Accuracy of this pool, eg: 10000.
+   * @param takerFeeRate Customized taker fee rate, float scaled by `FLOAT_SCALING_FACTOR`, Taker_fee_rate of 0.25% should be 2_500_000 for example
+   * @param makerRebateRate Customized maker rebate rate, float scaled by `FLOAT_SCALING_FACTOR`,  should be less than or equal to the taker_rebate_rate
+   */
+  createCustomizedPool(baseAssetType, quoteAssetType, tickSize, lotSize, takerFeeRate, makerRebateRate) {
+    const tx = new import_transactions.Transaction();
+    const [coin] = tx.splitCoins(tx.gas, [import_utils2.CREATION_FEE]);
+    tx.moveCall({
+      typeArguments: [baseAssetType, quoteAssetType],
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::create_customized_pool`,
+      arguments: [
+        tx.pure.u64(tickSize),
+        tx.pure.u64(lotSize),
+        tx.pure.u64(takerFeeRate),
+        tx.pure.u64(makerRebateRate),
+        coin
+      ]
+    });
+    return tx;
+  }
+  /**
+   * @description Create Account Cap
+   * @param tx
+   */
+  createAccountCap(tx) {
+    const [cap] = tx.moveCall({
+      typeArguments: [],
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::create_account`,
+      arguments: []
+    });
+    return cap;
+  }
+  /**
+   * @description Create and Transfer custodian account to user
+   * @param currentAddress current address of the user
+   * @param tx
+   */
+  createAccount(currentAddress = this.currentAddress, tx = new import_transactions.Transaction()) {
+    const cap = this.createAccountCap(tx);
+    tx.transferObjects([cap], __privateMethod(this, _DeepBookClient_instances, checkAddress_fn).call(this, currentAddress));
+    return tx;
+  }
+  /**
+   * @description Create and Transfer custodian account to user
+   * @param currentAddress: current user address, eg: "0xbddc9d4961b46a130c2e1f38585bbc6fa8077ce54bcb206b26874ac08d607966"
+   * @param accountCap: Object id of Account Capacity under user address, created after invoking createAccount, eg: "0x6f699fef193723277559c8f499ca3706121a65ac96d273151b8e52deb29135d3"
+   */
+  createChildAccountCap(currentAddress = this.currentAddress, accountCap = this.accountCap) {
+    const tx = new import_transactions.Transaction();
+    const [childCap] = tx.moveCall({
+      typeArguments: [],
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CUSTODIAN}::create_child_account_cap`,
+      arguments: [tx.object(__privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this, accountCap))]
+    });
+    tx.transferObjects([childCap], __privateMethod(this, _DeepBookClient_instances, checkAddress_fn).call(this, currentAddress));
+    return tx;
+  }
+  /**
+   * @description construct transaction for depositing asset into a pool.
+   * @param poolId the pool id for the deposit
+   * @param coinId the coin used for the deposit. You can omit this argument if you are depositing SUI, in which case
+   * gas coin will be used
+   * @param amount the amount of coin to deposit. If omitted, the entire balance of the coin will be deposited
+   */
+  async deposit(poolId, coinId = void 0, quantity = void 0) {
+    const tx = new import_transactions.Transaction();
+    const [baseAsset, quoteAsset] = await this.getPoolTypeArgs(poolId);
+    const hasSui = baseAsset === import_utils2.NORMALIZED_HANEUL_COIN_TYPE || quoteAsset === import_utils2.NORMALIZED_HANEUL_COIN_TYPE;
+    if (coinId === void 0 && !hasSui) {
+      throw new Error("coinId must be specified if neither baseAsset nor quoteAsset is SUI");
+    }
+    const inputCoin = coinId ? tx.object(coinId) : tx.gas;
+    const [coin] = quantity ? tx.splitCoins(inputCoin, [quantity]) : [inputCoin];
+    const coinType = coinId ? await this.getCoinType(coinId) : import_utils2.NORMALIZED_HANEUL_COIN_TYPE;
+    if (coinType !== baseAsset && coinType !== quoteAsset) {
+      throw new Error(
+        `coin ${coinId} of ${coinType} type is not a valid asset for pool ${poolId}, which supports ${baseAsset} and ${quoteAsset}`
+      );
+    }
+    const functionName = coinType === baseAsset ? "deposit_base" : "deposit_quote";
+    tx.moveCall({
+      typeArguments: [baseAsset, quoteAsset],
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::${functionName}`,
+      arguments: [tx.object(poolId), coin, tx.object(__privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this))]
+    });
+    return tx;
+  }
+  /**
+   * @description construct transaction for withdrawing asset from a pool.
+   * @param poolId the pool id for the withdraw
+   * @param amount the amount of coin to withdraw
+   * @param assetType Base or Quote
+   * @param recipientAddress the address to receive the withdrawn asset. If omitted, `this.currentAddress` will be used. The function
+   * will throw if the `recipientAddress === DUMMY_ADDRESS`
+   */
+  async withdraw(poolId, quantity, assetType, recipientAddress = this.currentAddress) {
+    const tx = new import_transactions.Transaction();
+    const functionName = assetType === "base" ? "withdraw_base" : "withdraw_quote";
+    const [withdraw] = tx.moveCall({
+      typeArguments: await this.getPoolTypeArgs(poolId),
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::${functionName}`,
+      arguments: [tx.object(poolId), tx.pure.u64(quantity), tx.object(__privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this))]
+    });
+    tx.transferObjects([withdraw], __privateMethod(this, _DeepBookClient_instances, checkAddress_fn).call(this, recipientAddress));
+    return tx;
+  }
+  /**
+   * @description place a limit order
+   * @param poolId Object id of pool, created after invoking createPool, eg: "0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4"
+   * @param price: price of the limit order. The number must be an interger float scaled by `FLOAT_SCALING_FACTOR`.
+   * @param quantity: quantity of the limit order in BASE ASSET, eg: 100000000.
+   * @param orderType: bid for buying base with quote, ask for selling base for quote
+   * @param expirationTimestamp: expiration timestamp of the limit order in ms, eg: 1620000000000. If omitted, the order will expire in 1 day
+   * from the time this function is called(not the time the transaction is executed)
+   * @param restriction restrictions on limit orders, explain in doc for more details, eg: 0
+   * @param clientOrderId a client side defined order number for bookkeeping purpose, e.g., "1", "2", etc. If omitted, the sdk will
+   * assign a increasing number starting from 0. But this number might be duplicated if you are using multiple sdk instances
+   * @param selfMatchingPrevention: Options for self-match prevention. Right now only support `CANCEL_OLDEST`
+   */
+  async placeLimitOrder(poolId, price, quantity, orderType, expirationTimestamp = Date.now() + import_utils2.ORDER_DEFAULT_EXPIRATION_IN_MS, restriction = import_types.LimitOrderType.NO_RESTRICTION, clientOrderId = void 0, selfMatchingPrevention = import_types.SelfMatchingPreventionStyle.CANCEL_OLDEST) {
+    const tx = new import_transactions.Transaction();
+    const args = [
+      tx.object(poolId),
+      tx.pure.u64(clientOrderId ?? __privateMethod(this, _DeepBookClient_instances, nextClientOrderId_fn).call(this)),
+      tx.pure.u64(price),
+      tx.pure.u64(quantity),
+      tx.pure.u8(selfMatchingPrevention),
+      tx.pure.bool(orderType === "bid"),
+      tx.pure.u64(expirationTimestamp),
+      tx.pure.u8(restriction),
+      tx.object(import_utils.HANEUL_CLOCK_OBJECT_ID),
+      tx.object(__privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this))
+    ];
+    tx.moveCall({
+      typeArguments: await this.getPoolTypeArgs(poolId),
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::place_limit_order`,
+      arguments: args
+    });
+    return tx;
+  }
+  /**
+   * @description place a market order
+   * @param poolId Object id of pool, created after invoking createPool, eg: "0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4"
+   * @param quantity Amount of quote asset to swap in base asset
+   * @param orderType bid for buying base with quote, ask for selling base for quote
+   * @param baseCoin the objectId or the coin object of the base coin
+   * @param quoteCoin the objectId or the coin object of the quote coin
+   * @param clientOrderId a client side defined order id for bookkeeping purpose. eg: "1" , "2", ... If omitted, the sdk will
+   * assign an increasing number starting from 0. But this number might be duplicated if you are using multiple sdk instances
+   * @param accountCap
+   * @param recipientAddress the address to receive the swapped asset. If omitted, `this.currentAddress` will be used. The function
+   * @param tx
+   */
+  async placeMarketOrder(accountCap, poolId, quantity, orderType, baseCoin = void 0, quoteCoin = void 0, clientOrderId = void 0, recipientAddress = this.currentAddress, tx = new import_transactions.Transaction()) {
+    const [baseAssetType, quoteAssetType] = await this.getPoolTypeArgs(poolId);
+    if (!baseCoin && orderType === "ask") {
+      throw new Error("Must specify a valid base coin for an ask order");
+    } else if (!quoteCoin && orderType === "bid") {
+      throw new Error("Must specify a valid quote coin for a bid order");
+    }
+    const emptyCoin = tx.moveCall({
+      typeArguments: [baseCoin ? quoteAssetType : baseAssetType],
+      target: `0x2::coin::zero`,
+      arguments: []
+    });
+    const [base_coin_ret, quote_coin_ret] = tx.moveCall({
+      typeArguments: [baseAssetType, quoteAssetType],
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::place_market_order`,
+      arguments: [
+        tx.object(poolId),
+        typeof accountCap === "string" ? tx.object(__privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this, accountCap)) : accountCap,
+        tx.pure.u64(clientOrderId ?? __privateMethod(this, _DeepBookClient_instances, nextClientOrderId_fn).call(this)),
+        tx.pure.u64(quantity),
+        tx.pure.bool(orderType === "bid"),
+        baseCoin ? tx.object(baseCoin) : emptyCoin,
+        quoteCoin ? tx.object(quoteCoin) : emptyCoin,
+        tx.object(import_utils.HANEUL_CLOCK_OBJECT_ID)
+      ]
+    });
+    const recipient = __privateMethod(this, _DeepBookClient_instances, checkAddress_fn).call(this, recipientAddress);
+    tx.transferObjects([base_coin_ret], recipient);
+    tx.transferObjects([quote_coin_ret], recipient);
+    return tx;
+  }
+  /**
+   * @description swap exact quote for base
+   * @param poolId Object id of pool, created after invoking createPool, eg: "0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4"
+   * @param tokenObjectIn Object id of the token to swap: eg: "0x6e566fec4c388eeb78a7dab832c9f0212eb2ac7e8699500e203def5b41b9c70d"
+   * @param amountIn amount of token to buy or sell, eg: 10000000.
+   * @param currentAddress current user address, eg: "0xbddc9d4961b46a130c2e1f38585bbc6fa8077ce54bcb206b26874ac08d607966"
+   * @param clientOrderId a client side defined order id for bookkeeping purpose, eg: "1" , "2", ... If omitted, the sdk will
+   * assign an increasing number starting from 0. But this number might be duplicated if you are using multiple sdk instances
+   * @param tx
+   */
+  async swapExactQuoteForBase(poolId, tokenObjectIn, amountIn, currentAddress, clientOrderId, tx = new import_transactions.Transaction()) {
+    const [base_coin_ret, quote_coin_ret, _amount] = tx.moveCall({
+      typeArguments: await this.getPoolTypeArgs(poolId),
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::swap_exact_quote_for_base`,
+      arguments: [
+        tx.object(poolId),
+        tx.pure.u64(clientOrderId ?? __privateMethod(this, _DeepBookClient_instances, nextClientOrderId_fn).call(this)),
+        tx.object(__privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this)),
+        tx.pure.u64(String(amountIn)),
+        tx.object(import_utils.HANEUL_CLOCK_OBJECT_ID),
+        tx.object(tokenObjectIn)
+      ]
+    });
+    tx.transferObjects([base_coin_ret], currentAddress);
+    tx.transferObjects([quote_coin_ret], currentAddress);
+    return tx;
+  }
+  /**
+   * @description swap exact base for quote
+   * @param poolId Object id of pool, created after invoking createPool, eg: "0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4"
+   * @param tokenObjectIn Object id of the token to swap: eg: "0x6e566fec4c388eeb78a7dab832c9f0212eb2ac7e8699500e203def5b41b9c70d"
+   * @param amountIn amount of token to buy or sell, eg: 10000000
+   * @param currentAddress current user address, eg: "0xbddc9d4961b46a130c2e1f38585bbc6fa8077ce54bcb206b26874ac08d607966"
+   * @param clientOrderId a client side defined order number for bookkeeping purpose. eg: "1" , "2", ...
+   */
+  async swapExactBaseForQuote(poolId, tokenObjectIn, amountIn, currentAddress, clientOrderId = void 0) {
+    const tx = new import_transactions.Transaction();
+    const [baseAsset, quoteAsset] = await this.getPoolTypeArgs(poolId);
+    const [base_coin_ret, quote_coin_ret, _amount] = tx.moveCall({
+      typeArguments: [baseAsset, quoteAsset],
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::swap_exact_base_for_quote`,
+      arguments: [
+        tx.object(poolId),
+        tx.pure.u64(clientOrderId ?? __privateMethod(this, _DeepBookClient_instances, nextClientOrderId_fn).call(this)),
+        tx.object(__privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this)),
+        tx.object(String(amountIn)),
+        tx.object(tokenObjectIn),
+        tx.moveCall({
+          typeArguments: [quoteAsset],
+          target: `0x2::coin::zero`,
+          arguments: []
+        }),
+        tx.object(import_utils.HANEUL_CLOCK_OBJECT_ID)
+      ]
+    });
+    tx.transferObjects([base_coin_ret], currentAddress);
+    tx.transferObjects([quote_coin_ret], currentAddress);
+    return tx;
+  }
+  /**
+   * @description cancel an order
+   * @param poolId Object id of pool, created after invoking createPool, eg: "0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4"
+   * @param orderId orderId of a limit order, you can find them through function query.list_open_orders eg: "0"
+   */
+  async cancelOrder(poolId, orderId) {
+    const tx = new import_transactions.Transaction();
+    tx.moveCall({
+      typeArguments: await this.getPoolTypeArgs(poolId),
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::cancel_order`,
+      arguments: [tx.object(poolId), tx.pure.u64(orderId), tx.object(__privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this))]
+    });
+    return tx;
+  }
+  /**
+   * @description Cancel all limit orders under a certain account capacity
+   * @param poolId Object id of pool, created after invoking createPool, eg: "0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4"
+   */
+  async cancelAllOrders(poolId) {
+    const tx = new import_transactions.Transaction();
+    tx.moveCall({
+      typeArguments: await this.getPoolTypeArgs(poolId),
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::cancel_all_orders`,
+      arguments: [tx.object(poolId), tx.object(__privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this))]
+    });
+    return tx;
+  }
+  /**
+   * @description batch cancel order
+   * @param poolId Object id of pool, created after invoking createPool, eg: "0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4"
+   * @param orderIds array of order ids you want to cancel, you can find your open orders by query.list_open_orders eg: ["0", "1", "2"]
+   */
+  async batchCancelOrder(poolId, orderIds) {
+    const tx = new import_transactions.Transaction();
+    tx.moveCall({
+      typeArguments: await this.getPoolTypeArgs(poolId),
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::batch_cancel_order`,
+      arguments: [
+        tx.object(poolId),
+        import_bcs.bcs.vector(import_bcs.bcs.U64).serialize(orderIds),
+        tx.object(__privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this))
+      ]
+    });
+    return tx;
+  }
+  /**
+   * @param poolId Object id of pool, created after invoking createPool, eg: "0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4"
+   * @param orderIds array of expired order ids to clean, eg: ["0", "1", "2"]
+   * @param orderOwners array of Order owners, should be the owner addresses from the account capacities which placed the orders
+   */
+  async cleanUpExpiredOrders(poolId, orderIds, orderOwners) {
+    const tx = new import_transactions.Transaction();
+    tx.moveCall({
+      typeArguments: await this.getPoolTypeArgs(poolId),
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::clean_up_expired_orders`,
+      arguments: [
+        tx.object(poolId),
+        tx.object(import_utils.HANEUL_CLOCK_OBJECT_ID),
+        import_bcs.bcs.vector(import_bcs.bcs.U64).serialize(orderIds),
+        import_bcs.bcs.vector(import_bcs.bcs.Address).serialize(orderOwners)
+      ]
+    });
+    return tx;
+  }
+  /**
+   * @description returns paginated list of pools created in DeepBook by querying for the
+   * `PoolCreated` event. Warning: this method can return incomplete results if the upstream data source
+   * is pruned.
+   */
+  async getAllPools(input) {
+    const resp = await this.haneulClient.queryEvents({
+      query: { MoveEventType: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::PoolCreated` },
+      ...input
+    });
+    const pools = resp.data.map((event) => {
+      const rawEvent = event.parsedJson;
+      return {
+        poolId: rawEvent.pool_id,
+        baseAsset: (0, import_utils.normalizeStructTag)(rawEvent.base_asset.name),
+        quoteAsset: (0, import_utils.normalizeStructTag)(rawEvent.quote_asset.name)
+      };
+    });
+    return {
+      data: pools,
+      nextCursor: resp.nextCursor,
+      hasNextPage: resp.hasNextPage
+    };
+  }
+  /**
+   * @description Fetch metadata for a pool
+   * @param poolId object id of the pool
+   * @returns Metadata for the Pool
+   */
+  async getPoolInfo(poolId) {
+    const resp = await this.haneulClient.getObject({
+      id: poolId,
+      options: { showContent: true }
+    });
+    if (resp?.data?.content?.dataType !== "moveObject") {
+      throw new Error(`pool ${poolId} does not exist`);
+    }
+    const [baseAsset, quoteAsset] = (0, import_utils.parseStructTag)(resp.data.content.type).typeParams.map(
+      (t) => (0, import_utils.normalizeStructTag)(t)
+    );
+    return {
+      poolId,
+      baseAsset,
+      quoteAsset
+    };
+  }
+  async getPoolTypeArgs(poolId) {
+    if (!__privateGet(this, _poolTypeArgsCache).has(poolId)) {
+      const { baseAsset, quoteAsset } = await this.getPoolInfo(poolId);
+      const typeArgs = [baseAsset, quoteAsset];
+      __privateGet(this, _poolTypeArgsCache).set(poolId, typeArgs);
+    }
+    return __privateGet(this, _poolTypeArgsCache).get(poolId);
+  }
+  /**
+   * @description get the order status
+   * @param poolId: the pool id, eg: 0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4
+   * @param orderId the order id, eg: "1"
+   */
+  async getOrderStatus(poolId, orderId, accountCap = this.accountCap) {
+    const tx = new import_transactions.Transaction();
+    const cap = __privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this, accountCap);
+    tx.moveCall({
+      typeArguments: await this.getPoolTypeArgs(poolId),
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::get_order_status`,
+      arguments: [tx.object(poolId), tx.pure.u64(orderId), tx.object(cap)]
+    });
+    const results = (await this.haneulClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: this.currentAddress
+    })).results;
+    if (!results) {
+      return void 0;
+    }
+    return import_bcs2.BcsOrder.parse(Uint8Array.from(results[0].returnValues[0][0]));
+  }
+  /**
+   * @description get the base and quote token in custodian account
+   * @param poolId the pool id, eg: 0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4
+   * @param accountCap your accountCap, eg: 0x6f699fef193723277559c8f499ca3706121a65ac96d273151b8e52deb29135d3. If not provided, `this.accountCap` will be used.
+   */
+  async getUserPosition(poolId, accountCap = void 0) {
+    const tx = new import_transactions.Transaction();
+    const cap = __privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this, accountCap);
+    tx.moveCall({
+      typeArguments: await this.getPoolTypeArgs(poolId),
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::account_balance`,
+      arguments: [tx.object((0, import_utils.normalizeHaneulObjectId)(poolId)), tx.object(cap)]
+    });
+    const [availableBaseAmount, lockedBaseAmount, availableQuoteAmount, lockedQuoteAmount] = (await this.haneulClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: this.currentAddress
+    })).results[0].returnValues.map(([bytes, _]) => BigInt(import_bcs.bcs.U64.parse(Uint8Array.from(bytes))));
+    return {
+      availableBaseAmount,
+      lockedBaseAmount,
+      availableQuoteAmount,
+      lockedQuoteAmount
+    };
+  }
+  /**
+   * @description get the open orders of the current user
+   * @param poolId the pool id, eg: 0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4
+   * @param accountCap your accountCap, eg: 0x6f699fef193723277559c8f499ca3706121a65ac96d273151b8e52deb29135d3. If not provided, `this.accountCap` will be used.
+   */
+  async listOpenOrders(poolId, accountCap = void 0) {
+    const tx = new import_transactions.Transaction();
+    const cap = __privateMethod(this, _DeepBookClient_instances, checkAccountCap_fn).call(this, accountCap);
+    tx.moveCall({
+      typeArguments: await this.getPoolTypeArgs(poolId),
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::list_open_orders`,
+      arguments: [tx.object(poolId), tx.object(cap)]
+    });
+    const results = (await this.haneulClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: this.currentAddress
+    })).results;
+    if (!results) {
+      return [];
+    }
+    return import_bcs.bcs.vector(import_bcs2.BcsOrder).parse(Uint8Array.from(results[0].returnValues[0][0]));
+  }
+  /**
+   * @description get the market price {bestBidPrice, bestAskPrice}
+   * @param poolId the pool id, eg: 0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4
+   */
+  async getMarketPrice(poolId) {
+    const tx = new import_transactions.Transaction();
+    tx.moveCall({
+      typeArguments: await this.getPoolTypeArgs(poolId),
+      target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::get_market_price`,
+      arguments: [tx.object(poolId)]
+    });
+    const resp = (await this.haneulClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: this.currentAddress
+    })).results[0].returnValues.map(([bytes, _]) => {
+      const opt = import_bcs.bcs.option(import_bcs.bcs.U64).parse(Uint8Array.from(bytes));
+      return opt == null ? void 0 : BigInt(opt);
+    });
+    return { bestBidPrice: resp[0], bestAskPrice: resp[1] };
+  }
+  /**
+   * @description get level2 book status
+   * @param poolId the pool id, eg: 0xcaee8e1c046b58e55196105f1436a2337dcaa0c340a7a8c8baf65e4afb8823a4
+   * @param lowerPrice lower price you want to query in the level2 book, eg: 18000000000. The number must be an integer float scaled by `FLOAT_SCALING_FACTOR`.
+   * @param higherPrice higher price you want to query in the level2 book, eg: 20000000000. The number must be an integer float scaled by `FLOAT_SCALING_FACTOR`.
+   * @param side { 'bid' | 'ask' | 'both' } bid or ask or both sides.
+   */
+  async getLevel2BookStatus(poolId, lowerPrice, higherPrice, side) {
+    const tx = new import_transactions.Transaction();
+    if (side === "both") {
+      tx.moveCall({
+        typeArguments: await this.getPoolTypeArgs(poolId),
+        target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::get_level2_book_status_bid_side`,
+        arguments: [
+          tx.object(poolId),
+          tx.pure.u64(lowerPrice),
+          tx.pure.u64(higherPrice),
+          tx.object(import_utils.HANEUL_CLOCK_OBJECT_ID)
+        ]
+      });
+      tx.moveCall({
+        typeArguments: await this.getPoolTypeArgs(poolId),
+        target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::get_level2_book_status_ask_side`,
+        arguments: [
+          tx.object(poolId),
+          tx.pure.u64(lowerPrice),
+          tx.pure.u64(higherPrice),
+          tx.object(import_utils.HANEUL_CLOCK_OBJECT_ID)
+        ]
+      });
+    } else {
+      tx.moveCall({
+        typeArguments: await this.getPoolTypeArgs(poolId),
+        target: `${import_utils2.PACKAGE_ID}::${import_utils2.MODULE_CLOB}::get_level2_book_status_${side}_side`,
+        arguments: [
+          tx.object(poolId),
+          tx.pure.u64(lowerPrice),
+          tx.pure.u64(higherPrice),
+          tx.object(import_utils.HANEUL_CLOCK_OBJECT_ID)
+        ]
+      });
+    }
+    const results = await this.haneulClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: this.currentAddress
+    });
+    if (side === "both") {
+      const bidSide = results.results[0].returnValues.map(
+        ([bytes, _]) => import_bcs.bcs.vector(import_bcs.bcs.U64).parse(Uint8Array.from(bytes)).map((s) => BigInt(s))
+      );
+      const askSide = results.results[1].returnValues.map(
+        ([bytes, _]) => import_bcs.bcs.vector(import_bcs.bcs.U64).parse(Uint8Array.from(bytes)).map((s) => BigInt(s))
+      );
+      return [
+        bidSide[0].map((price, i) => ({ price, depth: bidSide[1][i] })),
+        askSide[0].map((price, i) => ({ price, depth: askSide[1][i] }))
+      ];
+    } else {
+      const result = results.results[0].returnValues.map(
+        ([bytes, _]) => import_bcs.bcs.vector(import_bcs.bcs.U64).parse(Uint8Array.from(bytes)).map((s) => BigInt(s))
+      );
+      return result[0].map((price, i) => ({ price, depth: result[1][i] }));
+    }
+  }
+  async getCoinType(coinId) {
+    const resp = await this.haneulClient.getObject({
+      id: coinId,
+      options: { showType: true }
+    });
+    const parsed = resp.data?.type != null ? (0, import_utils.parseStructTag)(resp.data.type) : null;
+    if (parsed?.address === import_utils2.NORMALIZED_HANEUL_COIN_TYPE.split("::")[0] && parsed.module === "coin" && parsed.name === "Coin" && parsed.typeParams.length > 0) {
+      const firstTypeParam = parsed.typeParams[0];
+      return typeof firstTypeParam === "object" ? firstTypeParam.address + "::" + firstTypeParam.module + "::" + firstTypeParam.name : null;
+    } else {
+      return null;
+    }
+  }
+}
+_poolTypeArgsCache = new WeakMap();
+_DeepBookClient_instances = new WeakSet();
+checkAccountCap_fn = function(accountCap = void 0) {
+  const cap = accountCap ?? this.accountCap;
+  if (cap === void 0) {
+    throw new Error("accountCap is undefined, please call setAccountCap() first");
+  }
+  return (0, import_utils.normalizeHaneulObjectId)(cap);
+};
+checkAddress_fn = function(recipientAddress) {
+  if (recipientAddress === DUMMY_ADDRESS) {
+    throw new Error("Current address cannot be DUMMY_ADDRESS");
+  }
+  return (0, import_utils.normalizeHaneulAddress)(recipientAddress);
+};
+nextClientOrderId_fn = function() {
+  const id = this.clientOrderId;
+  this.clientOrderId += 1;
+  return id;
+};
+//# sourceMappingURL=client.js.map