@nadohq/engine-client 0.14.0 → 0.17.0

package/dist/EngineQueryClient.js

@@ -1,445 +1,356 @@
-// src/EngineQueryClient.ts
-import {
-  addDecimals,
-  encodeSignedOrder,
-  getOrderVerifyingAddress,
-  mapValues,
-  removeDecimals,
-  subaccountToHex,
-  toBigNumber,
-  toIntegerString
-} from "@nadohq/shared";
 import { EngineBaseClient } from "./EngineBaseClient.js";
 import { mapProductEngineType } from "./utils/productEngineTypeMappers.js";
-import {
-  mapEngineMarketPrice,
-  mapEngineServerIsolatedPositions,
-  mapEngineServerNlpLockedBalances,
-  mapEngineServerNlpPoolInfo,
-  mapEngineServerOrder,
-  mapEngineServerPerpProduct,
-  mapEngineServerSpotProduct,
-  mapEngineServerSymbols,
-  mapEngineServerTickLiquidity,
-  mapSubaccountSummary
-} from "./utils/queryDataMappers.js";
+import { mapEngineMarketPrice, mapEngineServerIsolatedPositions, mapEngineServerNlpLockedBalances, mapEngineServerNlpPoolInfo, mapEngineServerOrder, mapEngineServerPerpProduct, mapEngineServerSpotProduct, mapEngineServerSymbols, mapEngineServerTickLiquidity, mapSubaccountSummary } from "./utils/queryDataMappers.js";
+import { addDecimals, encodeSignedOrder, getOrderVerifyingAddress, mapValues, removeDecimals, subaccountToHex, toBigNumber, toIntegerString } from "@nadohq/shared";
+//#region src/EngineQueryClient.ts
 var EngineQueryClient = class extends 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 = subaccountToHex({
-      subaccountOwner: params.subaccountOwner,
-      subaccountName: params.subaccountName
-    });
-    const baseResponse = await this.query("subaccount_info", {
-      subaccount
-    });
-    return mapSubaccountSummary(baseResponse);
-  }
-  /**
-   * Retrieves a list of isolated positions
-   *
-   * @param params
-   */
-  async getIsolatedPositions(params) {
-    const subaccount = subaccountToHex({
-      subaccountOwner: params.subaccountOwner,
-      subaccountName: params.subaccountName
-    });
-    const baseResponse = await this.query("isolated_positions", {
-      subaccount
-    });
-    return mapEngineServerIsolatedPositions(baseResponse);
-  }
-  /**
-   * Retrieves an estimated subaccount summary with the applied transactions
-   *
-   * @param params
-   */
-  async getEstimatedSubaccountSummary(params) {
-    const subaccount = 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: toIntegerString(tx.tx.amountDelta),
-                  v_quote_delta: 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 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 ? mapProductEngineType(params.productType) : void 0
-    });
-    return 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(mapEngineServerSpotProduct(spotProduct));
-    });
-    baseResponse.perp_products.forEach((perpProduct) => {
-      markets.push(mapEngineServerPerpProduct(perpProduct));
-    });
-    return markets;
-  }
-  /**
-   * Retrieves all markets by chain id.
-   */
-  async getEdgeAllMarkets() {
-    const baseResponse = await this.query("edge_all_products", {});
-    return mapValues(baseResponse.edge_all_products, (allProducts) => {
-      const markets = [];
-      allProducts.spot_products.forEach((spotProduct) => {
-        markets.push(mapEngineServerSpotProduct(spotProduct));
-      });
-      allProducts.perp_products.forEach((perpProduct) => {
-        markets.push(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 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",
-        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: 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: subaccountToHex({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      }),
-      product_id: params.productId
-    });
-    return {
-      orders: baseResponse.orders.map(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: subaccountToHex({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      }),
-      product_ids: params.productIds
-    });
-    return {
-      productOrders: baseResponse.product_orders.map((orders) => {
-        return {
-          orders: orders.orders.map(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: subaccountToHex({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      })
-    });
-    return {
-      healthCheckSequencerFee: toBigNumber(
-        baseResponse.health_check_sequencer_fee
-      ),
-      liquidationSequencerFee: toBigNumber(
-        baseResponse.liquidation_sequencer_fee
-      ),
-      takerSequencerFee: toBigNumber(baseResponse.taker_sequencer_fee),
-      orders: baseResponse.taker_fee_rates_x18.reduce(
-        (acc, takerRateX18, currIndex) => {
-          acc[currIndex] = {
-            taker: removeDecimals(takerRateX18),
-            maker: removeDecimals(baseResponse.maker_fee_rates_x18[currIndex])
-          };
-          return acc;
-        },
-        {}
-      ),
-      withdrawal: baseResponse.withdraw_sequencer_fees.reduce(
-        (acc, productFee, currIndex) => {
-          acc[currIndex] = 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(mapEngineServerTickLiquidity),
-      bids: baseResponse.bids.map(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 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(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: toIntegerString(addDecimals(params.price)),
-      product_id: params.productId,
-      sender: 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 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: subaccountToHex({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      }),
-      spot_leverage: params.spotLeverage != null ? String(params.spotLeverage) : null
-    });
-    return 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: subaccountToHex({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      }),
-      spot_leverage: params.spotLeverage != null ? String(params.spotLeverage) : null
-    });
-    return 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: subaccountToHex({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      })
-    });
-    return 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: 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 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: subaccountToHex({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName
-      })
-    });
-    return mapEngineServerNlpLockedBalances(baseResponse);
-  }
-  /**
-   * Retrieves information about all NLP sub-pools
-   */
-  async getNlpPoolInfo() {
-    const baseResponse = await this.query("nlp_pool_info", {});
-    return mapEngineServerNlpPoolInfo(baseResponse);
-  }
-};
-export {
-  EngineQueryClient
+	/**
+	* 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 = subaccountToHex({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		});
+		return mapSubaccountSummary(await this.query("subaccount_info", { subaccount }));
+	}
+	/**
+	* Retrieves a list of isolated positions
+	*
+	* @param params
+	*/
+	async getIsolatedPositions(params) {
+		const subaccount = subaccountToHex({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		});
+		return mapEngineServerIsolatedPositions(await this.query("isolated_positions", { subaccount }));
+	}
+	/**
+	* Retrieves an estimated subaccount summary with the applied transactions
+	*
+	* @param params
+	*/
+	async getEstimatedSubaccountSummary(params) {
+		const subaccount = 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: toIntegerString(tx.tx.amountDelta),
+						v_quote_delta: toIntegerString(tx.tx.vQuoteDelta)
+					} };
+				}
+			})
+		};
+		return 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 mapEngineServerSymbols(await this.query("symbols", {
+			product_ids: params.productIds,
+			product_type: params.productType != null ? 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(mapEngineServerSpotProduct(spotProduct));
+		});
+		baseResponse.perp_products.forEach((perpProduct) => {
+			markets.push(mapEngineServerPerpProduct(perpProduct));
+		});
+		return markets;
+	}
+	/**
+	* Retrieves all markets by chain id.
+	*/
+	async getEdgeAllMarkets() {
+		return mapValues((await this.query("edge_all_products", {})).edge_all_products, (allProducts) => {
+			const markets = [];
+			allProducts.spot_products.forEach((spotProduct) => {
+				markets.push(mapEngineServerSpotProduct(spotProduct));
+			});
+			allProducts.perp_products.forEach((perpProduct) => {
+				markets.push(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 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", 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: 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: subaccountToHex({
+					subaccountOwner: params.subaccountOwner,
+					subaccountName: params.subaccountName
+				}),
+				product_id: params.productId
+			})).orders.map(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: subaccountToHex({
+				subaccountOwner: params.subaccountOwner,
+				subaccountName: params.subaccountName
+			}),
+			product_ids: params.productIds
+		})).product_orders.map((orders) => {
+			return {
+				orders: orders.orders.map(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: subaccountToHex({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		}) });
+		return {
+			healthCheckSequencerFee: toBigNumber(baseResponse.health_check_sequencer_fee),
+			liquidationSequencerFee: toBigNumber(baseResponse.liquidation_sequencer_fee),
+			takerSequencerFee: toBigNumber(baseResponse.taker_sequencer_fee),
+			orders: baseResponse.taker_fee_rates_x18.reduce((acc, takerRateX18, currIndex) => {
+				acc[currIndex] = {
+					taker: removeDecimals(takerRateX18),
+					maker: removeDecimals(baseResponse.maker_fee_rates_x18[currIndex])
+				};
+				return acc;
+			}, {}),
+			withdrawal: baseResponse.withdraw_sequencer_fees.reduce((acc, productFee, currIndex) => {
+				acc[currIndex] = 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(mapEngineServerTickLiquidity),
+			bids: baseResponse.bids.map(mapEngineServerTickLiquidity)
+		};
+	}
+	/**
+	* Retrieves the latest price for a given market
+	* @param params
+	*/
+	async getMarketPrice(params) {
+		return 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(mapEngineMarketPrice) };
+	}
+	/**
+	* Retrieves the estimated max order size for a product
+	* @param params
+	*/
+	async getMaxOrderSize(params) {
+		return toBigNumber((await this.query("max_order_size", {
+			direction: params.side,
+			price_x18: toIntegerString(addDecimals(params.price)),
+			avg_price_x18: params.avgPrice != null ? toIntegerString(addDecimals(params.avgPrice)) : null,
+			product_id: params.productId,
+			sender: 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 toBigNumber((await this.query("max_withdrawable", {
+			product_id: params.productId,
+			sender: 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 toBigNumber((await this.query("max_nlp_mintable", {
+			sender: 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 toBigNumber((await this.query("max_nlp_burnable", { sender: 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: subaccountToHex({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		}) })).linked_signer };
+	}
+	/**
+	* Gets the insurance funds in USDT.
+	* @returns
+	*/
+	async getInsurance() {
+		return toBigNumber((await this.query("insurance", {})).insurance);
+	}
+	/**
+	* Retrieves the NLP locked and unlocked balances for a subaccount.
+	*
+	* @param params
+	*/
+	async getNlpLockedBalances(params) {
+		return mapEngineServerNlpLockedBalances(await this.query("nlp_locked_balances", { subaccount: subaccountToHex({
+			subaccountOwner: params.subaccountOwner,
+			subaccountName: params.subaccountName
+		}) }));
+	}
+	/**
+	* Retrieves information about all NLP sub-pools
+	*/
+	async getNlpPoolInfo() {
+		return mapEngineServerNlpPoolInfo(await this.query("nlp_pool_info", {}));
+	}
 };
+//#endregion
+export { EngineQueryClient };
+
 //# sourceMappingURL=EngineQueryClient.js.map