@nadohq/engine-client 0.14.0 → 0.17.0

package/dist/EngineQueryClient.cjs

@@ -1,450 +1,357 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_EngineBaseClient = require("./EngineBaseClient-Uc1D8ftx.cjs");
+const require_utils_productEngineTypeMappers = require("./utils/productEngineTypeMappers.cjs");
+const require_utils_queryDataMappers = require("./utils/queryDataMappers.cjs");
+let _nadohq_shared = require("@nadohq/shared");
+//#region src/EngineQueryClient.ts
+var EngineQueryClient = class extends require_EngineBaseClient.EngineBaseClient {
+	/**
+	* Retrieves the set of contracts that the engine is interfacing with
+	*/
+	async getContracts() {
+		const baseResponse = await this.query("contracts", {});
+		return {
+			chainId: Number(baseResponse.chain_id),
+			endpointAddr: baseResponse.endpoint_addr
+		};
+	}
+	/**
+	* Retrieves current engine status
+	*/
+	async getStatus() {
+		return this.query("status", {});
+	}
+	/**
+	* Retrieves a subaccount summary reflective of the state within the offchain engine. This adheres to the
+	* same return interface as the contract version
+	*
+	* @param params
+	*/
+	async getSubaccountSummary(params) {
+		const subaccount = (0, _nadohq_shared.subaccountToHex)({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		});
+		return require_utils_queryDataMappers.mapSubaccountSummary(await this.query("subaccount_info", { subaccount }));
+	}
+	/**
+	* Retrieves a list of isolated positions
+	*
+	* @param params
+	*/
+	async getIsolatedPositions(params) {
+		const subaccount = (0, _nadohq_shared.subaccountToHex)({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		});
+		return require_utils_queryDataMappers.mapEngineServerIsolatedPositions(await this.query("isolated_positions", { subaccount }));
+	}
+	/**
+	* Retrieves an estimated subaccount summary with the applied transactions
+	*
+	* @param params
+	*/
+	async getEstimatedSubaccountSummary(params) {
+		const subaccount = (0, _nadohq_shared.subaccountToHex)({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		});
+		const queryParams = {
+			subaccount,
+			txns: params.txs.map((tx) => {
+				switch (tx.type) {
+					case "apply_delta": return { apply_delta: {
+						product_id: tx.tx.productId,
+						subaccount,
+						amount_delta: (0, _nadohq_shared.toIntegerString)(tx.tx.amountDelta),
+						v_quote_delta: (0, _nadohq_shared.toIntegerString)(tx.tx.vQuoteDelta)
+					} };
+				}
+			})
+		};
+		return require_utils_queryDataMappers.mapSubaccountSummary(await this.query("subaccount_info", {
+			subaccount: queryParams.subaccount,
+			txns: JSON.stringify(queryParams.txns),
+			pre_state: params.preState !== void 0 ? String(params.preState) : void 0
+		}));
+	}
+	/**
+	* Retrieves symbols and product info
+	*
+	* @param params
+	*/
+	async getSymbols(params) {
+		return require_utils_queryDataMappers.mapEngineServerSymbols(await this.query("symbols", {
+			product_ids: params.productIds,
+			product_type: params.productType != null ? require_utils_productEngineTypeMappers.mapProductEngineType(params.productType) : void 0
+		}));
+	}
+	/**
+	* Retrieves all market states as per the offchain engine. Same return interface as contracts
+	*/
+	async getAllMarkets() {
+		const markets = [];
+		const baseResponse = await this.query("all_products", {});
+		baseResponse.spot_products.forEach((spotProduct) => {
+			markets.push(require_utils_queryDataMappers.mapEngineServerSpotProduct(spotProduct));
+		});
+		baseResponse.perp_products.forEach((perpProduct) => {
+			markets.push(require_utils_queryDataMappers.mapEngineServerPerpProduct(perpProduct));
+		});
+		return markets;
+	}
+	/**
+	* Retrieves all markets by chain id.
+	*/
+	async getEdgeAllMarkets() {
+		return (0, _nadohq_shared.mapValues)((await this.query("edge_all_products", {})).edge_all_products, (allProducts) => {
+			const markets = [];
+			allProducts.spot_products.forEach((spotProduct) => {
+				markets.push(require_utils_queryDataMappers.mapEngineServerSpotProduct(spotProduct));
+			});
+			allProducts.perp_products.forEach((perpProduct) => {
+				markets.push(require_utils_queryDataMappers.mapEngineServerPerpProduct(perpProduct));
+			});
+			return markets;
+		});
+	}
+	/**
+	* Retrieves all health groups (linked spot & perp products) from the engine
+	*/
+	async getHealthGroups() {
+		return { healthGroups: (await this.query("health_groups", {})).health_groups.map(([spotProductId, perpProductId]) => {
+			return {
+				spotProductId,
+				perpProductId
+			};
+		}) };
+	}
+	/**
+	* Retrieves an order from the offchain engine
+	*
+	* @param params
+	*/
+	async getOrder(params) {
+		return require_utils_queryDataMappers.mapEngineServerOrder(await this.query("order", {
+			digest: params.digest,
+			product_id: params.productId
+		}));
+	}
+	/**
+	* Signs and validates with the engine that the order is valid to be submitted (i.e. does not violate health reqs)
+	*
+	* @param params
+	*/
+	async validateOrderParams(params) {
+		const signedOrder = {
+			order: params.order,
+			signature: await this.sign("place_order", (0, _nadohq_shared.getOrderVerifyingAddress)(params.productId), params.chainId, params.order)
+		};
+		return this.validateSignedOrderParams({
+			signedOrder,
+			productId: params.productId
+		});
+	}
+	/**
+	* Validates an existing signed order with the engine as a pre-check for health
+	*
+	* @param params
+	*/
+	async validateSignedOrderParams(params) {
+		const baseResponse = await this.query("validate_order", {
+			product_id: params.productId,
+			order: (0, _nadohq_shared.encodeSignedOrder)(params.signedOrder)
+		});
+		return {
+			productId: baseResponse.product_id,
+			valid: baseResponse.valid
+		};
+	}
+	/**
+	* Get all subaccount orders from the engine, per product ID
+	* @param params
+	*/
+	async getSubaccountOrders(params) {
+		return {
+			orders: (await this.query("subaccount_orders", {
+				sender: (0, _nadohq_shared.subaccountToHex)({
+					subaccountOwner: params.subaccountOwner,
+					subaccountName: params.subaccountName
+				}),
+				product_id: params.productId
+			})).orders.map(require_utils_queryDataMappers.mapEngineServerOrder),
+			productId: params.productId
+		};
+	}
+	/**
+	* Get all subaccount orders from the engine, for multiple products
+	* @param params
+	*/
+	async getSubaccountMultiProductOrders(params) {
+		return { productOrders: (await this.query("orders", {
+			sender: (0, _nadohq_shared.subaccountToHex)({
+				subaccountOwner: params.subaccountOwner,
+				subaccountName: params.subaccountName
+			}),
+			product_ids: params.productIds
+		})).product_orders.map((orders) => {
+			return {
+				orders: orders.orders.map(require_utils_queryDataMappers.mapEngineServerOrder),
+				productId: orders.product_id
+			};
+		}) };
+	}
+	/**
+	* Gets maker & taker fee rates for order fees
+	* @param params
+	*/
+	async getSubaccountFeeRates(params) {
+		const baseResponse = await this.query("fee_rates", { sender: (0, _nadohq_shared.subaccountToHex)({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		}) });
+		return {
+			healthCheckSequencerFee: (0, _nadohq_shared.toBigNumber)(baseResponse.health_check_sequencer_fee),
+			liquidationSequencerFee: (0, _nadohq_shared.toBigNumber)(baseResponse.liquidation_sequencer_fee),
+			takerSequencerFee: (0, _nadohq_shared.toBigNumber)(baseResponse.taker_sequencer_fee),
+			orders: baseResponse.taker_fee_rates_x18.reduce((acc, takerRateX18, currIndex) => {
+				acc[currIndex] = {
+					taker: (0, _nadohq_shared.removeDecimals)(takerRateX18),
+					maker: (0, _nadohq_shared.removeDecimals)(baseResponse.maker_fee_rates_x18[currIndex])
+				};
+				return acc;
+			}, {}),
+			withdrawal: baseResponse.withdraw_sequencer_fees.reduce((acc, productFee, currIndex) => {
+				acc[currIndex] = (0, _nadohq_shared.toBigNumber)(productFee);
+				return acc;
+			}, {}),
+			feeTier: baseResponse.fee_tier
+		};
+	}
+	/**
+	* Gets "price ticks" for a given market, useful for constructing liquidity levels at each price
+	* @param params
+	*/
+	async getMarketLiquidity(params) {
+		const baseResponse = await this.query("market_liquidity", {
+			product_id: params.productId,
+			depth: params.depth
+		});
+		return {
+			asks: baseResponse.asks.map(require_utils_queryDataMappers.mapEngineServerTickLiquidity),
+			bids: baseResponse.bids.map(require_utils_queryDataMappers.mapEngineServerTickLiquidity)
+		};
+	}
+	/**
+	* Retrieves the latest price for a given market
+	* @param params
+	*/
+	async getMarketPrice(params) {
+		return require_utils_queryDataMappers.mapEngineMarketPrice(await this.query("market_price", { product_id: params.productId }));
+	}
+	/**
+	* Retrieves the latest prices for provided markets
+	* @param params
+	*/
+	async getMarketPrices(params) {
+		return { marketPrices: (await this.query("market_prices", { product_ids: params.productIds })).market_prices.map(require_utils_queryDataMappers.mapEngineMarketPrice) };
+	}
+	/**
+	* Retrieves the estimated max order size for a product
+	* @param params
+	*/
+	async getMaxOrderSize(params) {
+		return (0, _nadohq_shared.toBigNumber)((await this.query("max_order_size", {
+			direction: params.side,
+			price_x18: (0, _nadohq_shared.toIntegerString)((0, _nadohq_shared.addDecimals)(params.price)),
+			avg_price_x18: params.avgPrice != null ? (0, _nadohq_shared.toIntegerString)((0, _nadohq_shared.addDecimals)(params.avgPrice)) : null,
+			product_id: params.productId,
+			sender: (0, _nadohq_shared.subaccountToHex)({
+				subaccountOwner: params.subaccountOwner,
+				subaccountName: params.subaccountName
+			}),
+			spot_leverage: params.spotLeverage != null ? String(params.spotLeverage) : null,
+			reduce_only: params.reduceOnly != null ? String(params.reduceOnly) : null,
+			isolated: params.isolated != null ? String(params.isolated) : null,
+			borrow_margin: params.isolated && params.isoBorrowMargin != null ? String(params.isoBorrowMargin) : null
+		})).max_order_size);
+	}
+	/**
+	* Retrieves the estimated max withdrawal size for a product
+	* @param params
+	*/
+	async getMaxWithdrawable(params) {
+		return (0, _nadohq_shared.toBigNumber)((await this.query("max_withdrawable", {
+			product_id: params.productId,
+			sender: (0, _nadohq_shared.subaccountToHex)({
+				subaccountOwner: params.subaccountOwner,
+				subaccountName: params.subaccountName
+			}),
+			spot_leverage: params.spotLeverage != null ? String(params.spotLeverage) : null
+		})).max_withdrawable);
+	}
+	/**
+	* Retrieves the estimated max quote amount for minting NLP.
+	*
+	* @param params
+	*/
+	async getMaxMintNlpAmount(params) {
+		return (0, _nadohq_shared.toBigNumber)((await this.query("max_nlp_mintable", {
+			sender: (0, _nadohq_shared.subaccountToHex)({
+				subaccountOwner: params.subaccountOwner,
+				subaccountName: params.subaccountName
+			}),
+			spot_leverage: params.spotLeverage != null ? String(params.spotLeverage) : null
+		})).max_quote_amount);
+	}
+	/**
+	* Retrieves the max amount of NLP that can be burned.
+	*
+	* @param params
+	*/
+	async getMaxBurnNlpAmount(params) {
+		return (0, _nadohq_shared.toBigNumber)((await this.query("max_nlp_burnable", { sender: (0, _nadohq_shared.subaccountToHex)({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		}) })).max_nlp_amount);
+	}
+	/**
+	* Gets the currently linked signer for the subaccount
+	* @param params
+	* @returns
+	*/
+	async getLinkedSigner(params) {
+		return { signer: (await this.query("linked_signer", { subaccount: (0, _nadohq_shared.subaccountToHex)({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		}) })).linked_signer };
+	}
+	/**
+	* Gets the insurance funds in USDT.
+	* @returns
+	*/
+	async getInsurance() {
+		return (0, _nadohq_shared.toBigNumber)((await this.query("insurance", {})).insurance);
+	}
+	/**
+	* Retrieves the NLP locked and unlocked balances for a subaccount.
+	*
+	* @param params
+	*/
+	async getNlpLockedBalances(params) {
+		return require_utils_queryDataMappers.mapEngineServerNlpLockedBalances(await this.query("nlp_locked_balances", { subaccount: (0, _nadohq_shared.subaccountToHex)({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		}) }));
+	}
+	/**
+	* Retrieves information about all NLP sub-pools
+	*/
+	async getNlpPoolInfo() {
+		return require_utils_queryDataMappers.mapEngineServerNlpPoolInfo(await this.query("nlp_pool_info", {}));
+	}
 };
-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);
+//#endregion
+exports.EngineQueryClient = EngineQueryClient;
 
-// src/EngineQueryClient.ts
-var EngineQueryClient_exports = {};
-__export(EngineQueryClient_exports, {
-  EngineQueryClient: () => EngineQueryClient
-});
-module.exports = __toCommonJS(EngineQueryClient_exports);
-var import_shared = require("@nadohq/shared");
-var import_EngineBaseClient = require("./EngineBaseClient.cjs");
-var import_productEngineTypeMappers = require("./utils/productEngineTypeMappers.cjs");
-var import_queryDataMappers = require("./utils/queryDataMappers.cjs");
-var EngineQueryClient = class extends import_EngineBaseClient.EngineBaseClient {
-  /**
-   * Retrieves the set of contracts that the engine is interfacing with
-   */
-  async getContracts() {
-    const baseResponse = await this.query("contracts", {});
-    return {
-      chainId: Number(baseResponse.chain_id),
-      endpointAddr: baseResponse.endpoint_addr
-    };
-  }
-  /**
-   * Retrieves current engine status
-   */
-  async getStatus() {
-    return this.query("status", {});
-  }
-  /**
-   * Retrieves a subaccount summary reflective of the state within the offchain engine. This adheres to the
-   * same return interface as the contract version
-   *
-   * @param params
-   */
-  async getSubaccountSummary(params) {
-    const subaccount = (0, import_shared.subaccountToHex)({
-      subaccountOwner: params.subaccountOwner,
-      subaccountName: params.subaccountName
-    });
-    const baseResponse = await this.query("subaccount_info", {
-      subaccount
-    });
-    return (0, import_queryDataMappers.mapSubaccountSummary)(baseResponse);
-  }
-  /**
-   * Retrieves a list of isolated positions
-   *
-   * @param params
-   */
-  async getIsolatedPositions(params) {
-    const subaccount = (0, import_shared.subaccountToHex)({
-      subaccountOwner: params.subaccountOwner,
-      subaccountName: params.subaccountName
-    });
-    const baseResponse = await this.query("isolated_positions", {
-      subaccount
-    });
-    return (0, import_queryDataMappers.mapEngineServerIsolatedPositions)(baseResponse);
-  }
-  /**
-   * Retrieves an estimated subaccount summary with the applied transactions
-   *
-   * @param params
-   */
-  async getEstimatedSubaccountSummary(params) {
-    const subaccount = (0, import_shared.subaccountToHex)({
-      subaccountOwner: params.subaccountOwner,
-      subaccountName: params.subaccountName
-    });
-    const queryParams = {
-      subaccount,
-      txns: params.txs.map(
-        (tx) => {
-          switch (tx.type) {
-            case "apply_delta":
-              return {
-                apply_delta: {
-                  product_id: tx.tx.productId,
-                  subaccount,
-                  amount_delta: (0, import_shared.toIntegerString)(tx.tx.amountDelta),
-                  v_quote_delta: (0, import_shared.toIntegerString)(tx.tx.vQuoteDelta)
-                }
-              };
-          }
-        }
-      )
-    };
-    const baseResponse = await this.query("subaccount_info", {
-      subaccount: queryParams.subaccount,
-      txns: JSON.stringify(queryParams.txns),
-      // Backend expects string variants of booleans
-      pre_state: params.preState !== void 0 ? String(params.preState) : void 0
-    });
-    return (0, import_queryDataMappers.mapSubaccountSummary)(baseResponse);
-  }
-  /**
-   * Retrieves symbols and product info
-   *
-   * @param params
-   */
-  async getSymbols(params) {
-    const baseResponse = await this.query("symbols", {
-      product_ids: params.productIds,
-      product_type: params.productType != null ? (0, import_productEngineTypeMappers.mapProductEngineType)(params.productType) : void 0
-    });
-    return (0, import_queryDataMappers.mapEngineServerSymbols)(baseResponse);
-  }
-  /**
-   * Retrieves all market states as per the offchain engine. Same return interface as contracts
-   */
-  async getAllMarkets() {
-    const markets = [];
-    const baseResponse = await this.query("all_products", {});
-    baseResponse.spot_products.forEach((spotProduct) => {
-      markets.push((0, import_queryDataMappers.mapEngineServerSpotProduct)(spotProduct));
-    });
-    baseResponse.perp_products.forEach((perpProduct) => {
-      markets.push((0, import_queryDataMappers.mapEngineServerPerpProduct)(perpProduct));
-    });
-    return markets;
-  }
-  /**
-   * Retrieves all markets by chain id.
-   */
-  async getEdgeAllMarkets() {
-    const baseResponse = await this.query("edge_all_products", {});
-    return (0, import_shared.mapValues)(baseResponse.edge_all_products, (allProducts) => {
-      const markets = [];
-      allProducts.spot_products.forEach((spotProduct) => {
-        markets.push((0, import_queryDataMappers.mapEngineServerSpotProduct)(spotProduct));
-      });
-      allProducts.perp_products.forEach((perpProduct) => {
-        markets.push((0, import_queryDataMappers.mapEngineServerPerpProduct)(perpProduct));
-      });
-      return markets;
-    });
-  }
-  /**
-   * Retrieves all health groups (linked spot & perp products) from the engine
-   */
-  async getHealthGroups() {
-    const baseResponse = await this.query("health_groups", {});
-    return {
-      healthGroups: baseResponse.health_groups.map(
-        ([spotProductId, perpProductId]) => {
-          return {
-            spotProductId,
-            perpProductId
-          };
-        }
-      )
-    };
-  }
-  /**
-   * Retrieves an order from the offchain engine
-   *
-   * @param params
-   */
-  async getOrder(params) {
-    const baseResponse = await this.query("order", {
-      digest: params.digest,
-      product_id: params.productId
-    });
-    return (0, import_queryDataMappers.mapEngineServerOrder)(baseResponse);
-  }
-  /**
-   * Signs and validates with the engine that the order is valid to be submitted (i.e. does not violate health reqs)
-   *
-   * @param params
-   */
-  async validateOrderParams(params) {
-    const signedOrder = {
-      order: params.order,
-      signature: await this.sign(
-        "place_order",
-        (0, import_shared.getOrderVerifyingAddress)(params.productId),
-        params.chainId,
-        params.order
-      )
-    };
-    return this.validateSignedOrderParams({
-      signedOrder,
-      productId: params.productId
-    });
-  }
-  /**
-   * Validates an existing signed order with the engine as a pre-check for health
-   *
-   * @param params
-   */
-  async validateSignedOrderParams(params) {
-    const baseResponse = await this.query("validate_order", {
-      product_id: params.productId,
-      order: (0, import_shared.encodeSignedOrder)(params.signedOrder)
-    });
-    return {
-      productId: baseResponse.product_id,
-      valid: baseResponse.valid
-    };
-  }
-  /**
-   * Get all subaccount orders from the engine, per product ID
-   * @param params
-   */
-  async getSubaccountOrders(params) {
-    const baseResponse = await this.query("subaccount_orders", {
-      sender: (0, import_shared.subaccountToHex)({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      }),
-      product_id: params.productId
-    });
-    return {
-      orders: baseResponse.orders.map(import_queryDataMappers.mapEngineServerOrder),
-      productId: params.productId
-    };
-  }
-  /**
-   * Get all subaccount orders from the engine, for multiple products
-   * @param params
-   */
-  async getSubaccountMultiProductOrders(params) {
-    const baseResponse = await this.query("orders", {
-      sender: (0, import_shared.subaccountToHex)({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      }),
-      product_ids: params.productIds
-    });
-    return {
-      productOrders: baseResponse.product_orders.map((orders) => {
-        return {
-          orders: orders.orders.map(import_queryDataMappers.mapEngineServerOrder),
-          productId: orders.product_id
-        };
-      })
-    };
-  }
-  /**
-   * Gets maker & taker fee rates for order fees
-   * @param params
-   */
-  async getSubaccountFeeRates(params) {
-    const baseResponse = await this.query("fee_rates", {
-      sender: (0, import_shared.subaccountToHex)({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      })
-    });
-    return {
-      healthCheckSequencerFee: (0, import_shared.toBigNumber)(
-        baseResponse.health_check_sequencer_fee
-      ),
-      liquidationSequencerFee: (0, import_shared.toBigNumber)(
-        baseResponse.liquidation_sequencer_fee
-      ),
-      takerSequencerFee: (0, import_shared.toBigNumber)(baseResponse.taker_sequencer_fee),
-      orders: baseResponse.taker_fee_rates_x18.reduce(
-        (acc, takerRateX18, currIndex) => {
-          acc[currIndex] = {
-            taker: (0, import_shared.removeDecimals)(takerRateX18),
-            maker: (0, import_shared.removeDecimals)(baseResponse.maker_fee_rates_x18[currIndex])
-          };
-          return acc;
-        },
-        {}
-      ),
-      withdrawal: baseResponse.withdraw_sequencer_fees.reduce(
-        (acc, productFee, currIndex) => {
-          acc[currIndex] = (0, import_shared.toBigNumber)(productFee);
-          return acc;
-        },
-        {}
-      ),
-      feeTier: baseResponse.fee_tier
-    };
-  }
-  /**
-   * Gets "price ticks" for a given market, useful for constructing liquidity levels at each price
-   * @param params
-   */
-  async getMarketLiquidity(params) {
-    const baseResponse = await this.query("market_liquidity", {
-      product_id: params.productId,
-      depth: params.depth
-    });
-    return {
-      asks: baseResponse.asks.map(import_queryDataMappers.mapEngineServerTickLiquidity),
-      bids: baseResponse.bids.map(import_queryDataMappers.mapEngineServerTickLiquidity)
-    };
-  }
-  /**
-   * Retrieves the latest price for a given market
-   * @param params
-   */
-  async getMarketPrice(params) {
-    const baseResponse = await this.query("market_price", {
-      product_id: params.productId
-    });
-    return (0, import_queryDataMappers.mapEngineMarketPrice)(baseResponse);
-  }
-  /**
-   * Retrieves the latest prices for provided markets
-   * @param params
-   */
-  async getMarketPrices(params) {
-    const baseResponse = await this.query("market_prices", {
-      product_ids: params.productIds
-    });
-    return {
-      marketPrices: baseResponse.market_prices.map(import_queryDataMappers.mapEngineMarketPrice)
-    };
-  }
-  /**
-   * Retrieves the estimated max order size for a product
-   * @param params
-   */
-  async getMaxOrderSize(params) {
-    const baseResponse = await this.query("max_order_size", {
-      direction: params.side,
-      price_x18: (0, import_shared.toIntegerString)((0, import_shared.addDecimals)(params.price)),
-      product_id: params.productId,
-      sender: (0, import_shared.subaccountToHex)({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      }),
-      // Backend expects string variants of booleans
-      spot_leverage: params.spotLeverage != null ? String(params.spotLeverage) : null,
-      reduce_only: params.reduceOnly != null ? String(params.reduceOnly) : null,
-      isolated: params.isolated != null ? String(params.isolated) : null,
-      borrow_margin: (
-        // This field is only relevant for isolated orders
-        params.isolated && params.isoBorrowMargin != null ? String(params.isoBorrowMargin) : null
-      )
-    });
-    return (0, import_shared.toBigNumber)(baseResponse.max_order_size);
-  }
-  /**
-   * Retrieves the estimated max withdrawal size for a product
-   * @param params
-   */
-  async getMaxWithdrawable(params) {
-    const baseResponse = await this.query("max_withdrawable", {
-      product_id: params.productId,
-      sender: (0, import_shared.subaccountToHex)({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      }),
-      spot_leverage: params.spotLeverage != null ? String(params.spotLeverage) : null
-    });
-    return (0, import_shared.toBigNumber)(baseResponse.max_withdrawable);
-  }
-  /**
-   * Retrieves the estimated max quote amount for minting NLP.
-   *
-   * @param params
-   */
-  async getMaxMintNlpAmount(params) {
-    const baseResponse = await this.query("max_nlp_mintable", {
-      sender: (0, import_shared.subaccountToHex)({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      }),
-      spot_leverage: params.spotLeverage != null ? String(params.spotLeverage) : null
-    });
-    return (0, import_shared.toBigNumber)(baseResponse.max_quote_amount);
-  }
-  /**
-   * Retrieves the max amount of NLP that can be burned.
-   *
-   * @param params
-   */
-  async getMaxBurnNlpAmount(params) {
-    const baseResponse = await this.query("max_nlp_burnable", {
-      sender: (0, import_shared.subaccountToHex)({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      })
-    });
-    return (0, import_shared.toBigNumber)(baseResponse.max_nlp_amount);
-  }
-  /**
-   * Gets the currently linked signer for the subaccount
-   * @param params
-   * @returns
-   */
-  async getLinkedSigner(params) {
-    const baseResponse = await this.query("linked_signer", {
-      subaccount: (0, import_shared.subaccountToHex)({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      })
-    });
-    return {
-      signer: baseResponse.linked_signer
-    };
-  }
-  /**
-   * Gets the insurance funds in USDT.
-   * @returns
-   */
-  async getInsurance() {
-    const baseResponse = await this.query("insurance", {});
-    return (0, import_shared.toBigNumber)(baseResponse.insurance);
-  }
-  /**
-   * Retrieves the NLP locked and unlocked balances for a subaccount.
-   *
-   * @param params
-   */
-  async getNlpLockedBalances(params) {
-    const baseResponse = await this.query("nlp_locked_balances", {
-      subaccount: (0, import_shared.subaccountToHex)({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      })
-    });
-    return (0, import_queryDataMappers.mapEngineServerNlpLockedBalances)(baseResponse);
-  }
-  /**
-   * Retrieves information about all NLP sub-pools
-   */
-  async getNlpPoolInfo() {
-    const baseResponse = await this.query("nlp_pool_info", {});
-    return (0, import_queryDataMappers.mapEngineServerNlpPoolInfo)(baseResponse);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  EngineQueryClient
-});
 //# sourceMappingURL=EngineQueryClient.cjs.map