@nadohq/engine-client 0.1.0-alpha.9 → 0.1.0

package/src/types/serverQueryTypes.ts

@@ -1,6 +1,9 @@
 import { HealthStatus } from '@nadohq/shared';
 import {
   EngineServerHealthBreakdown,
+  EngineServerNlpBalance,
+  EngineServerNlpLockedBalance,
+  EngineServerOrder,
   EngineServerPerpBalance,
   EngineServerPerpProduct,
   EngineServerProductType,
@@ -22,6 +25,8 @@ export interface EngineServerSubaccountInfoQueryParams {
       v_quote_delta: string;
     };
   }>;
+  // If not given, engine defaults to 'false'
+  pre_state?: string;
 }
 
 export interface EngineServerIsolatedPositionsQueryParams {
@@ -89,6 +94,10 @@ export interface EngineServerMaxOrderSizeQueryParams {
   // If not given, engine defaults to false. If true, the max order size will be capped to the subaccount's current position size;
   // If no position exists, it will return 0.
   reduce_only: string | null;
+  isolated: string | null;
+  // For isolated, max order size includes available collateral to transfer from parent cross subaccount
+  // If not given, engine defaults to true (borrow enabled)
+  borrow_margin: string | null;
 }
 
 export interface EngineServerLinkedSignerParams {
@@ -101,6 +110,14 @@ export interface EngineServerMaxMintNlpQueryParams {
   spot_leverage: string | null;
 }
 
+export interface EngineServerMaxBurnNlpQueryParams {
+  sender: string;
+}
+
+export interface EngineServerNlpLockedBalancesQueryParams {
+  subaccount: string;
+}
+
 export interface EngineServerQueryRequestByType {
   all_products: Record<string, never>;
   contracts: Record<string, never>;
@@ -113,8 +130,11 @@ export interface EngineServerQueryRequestByType {
   market_liquidity: EngineServerMarketLiquidityQueryParams;
   market_price: EngineServerMarketPriceQueryParams;
   market_prices: EngineServerMarketPricesQueryParams;
+  max_nlp_burnable: EngineServerMaxBurnNlpQueryParams;
   max_nlp_mintable: EngineServerMaxMintNlpQueryParams;
   max_order_size: EngineServerMaxOrderSizeQueryParams;
+  nlp_locked_balances: EngineServerNlpLockedBalancesQueryParams;
+  nlp_pool_info: Record<string, never>;
   max_withdrawable: EngineServerMaxWithdrawableQueryParams;
   nonces: EngineServerNoncesParams;
   order: EngineServerGetOrderQueryParams;
@@ -143,22 +163,36 @@ export interface EngineServerContractsResponse {
 }
 
 // Unless in active state, engine is not fully operational
+export const ENGINE_SERVER_STATUS_VALUES = [
+  'started',
+  'active',
+  'stopping',
+  'syncing',
+  'live_syncing',
+  'failed',
+] as const;
+
 export type EngineServerStatusResponse =
-  | 'started'
-  | 'active'
-  | 'stopping'
-  | 'syncing'
-  | 'live_syncing'
-  | 'failed';
+  (typeof ENGINE_SERVER_STATUS_VALUES)[number];
 
 export interface EngineServerNoncesResponse {
   order_nonce: string;
   tx_nonce: string;
 }
 
-export interface EngineServerSubaccountInfoResponse {
+export interface EngineServerSubaccountInfoResponse extends EngineServerSubaccountInfoState {
   exists: boolean;
   subaccount: string;
+  spot_count: number;
+  perp_count: number;
+  spot_products: EngineServerSpotProduct[];
+  perp_products: EngineServerPerpProduct[];
+
+  /** This is set if request has `pre_state` flag set to 'true' */
+  pre_state: EngineServerSubaccountInfoState | undefined;
+}
+
+export interface EngineServerSubaccountInfoState {
   healths: [
     initial: EngineServerHealthBreakdown,
     maintenance: EngineServerHealthBreakdown,
@@ -166,12 +200,8 @@ export interface EngineServerSubaccountInfoResponse {
   ];
   // First index is product ID, each subarray is of length 3 [initial, maintenance, unweighted]
   health_contributions: string[][];
-  spot_count: number;
-  perp_count: number;
   spot_balances: EngineServerSpotBalance[];
   perp_balances: EngineServerPerpBalance[];
-  spot_products: EngineServerSpotProduct[];
-  perp_products: EngineServerPerpProduct[];
 }
 
 export interface EngineServerIsolatedPosition {
@@ -200,12 +230,13 @@ export interface EngineServerSymbol {
   price_increment_x18: string;
   size_increment: string;
   min_size: string;
-  min_depth_x18: string;
-  max_spread_rate_x18: string;
   maker_fee_rate_x18: string;
   taker_fee_rate_x18: string;
   long_weight_initial_x18: string;
   long_weight_maintenance_x18: string;
+  // undefined when there is no max open interest limit (always undefined for spot products)
+  max_open_interest_x18: string | undefined;
+  isolated_only: boolean;
 }
 
 export interface EngineServerSymbolsResponse {
@@ -268,20 +299,6 @@ export interface EngineServerMarketPricesResponse {
   market_prices: EngineServerMarketPrice[];
 }
 
-export interface EngineServerOrder {
-  product_id: number;
-  sender: string;
-  price_x18: string;
-  amount: string;
-  expiration: string;
-  nonce: string;
-  unfilled_amount: string;
-  digest: string;
-  placed_at: number;
-  order_type: string;
-  appendix: string;
-}
-
 export type EngineServerOrderResponse = EngineServerOrder;
 
 export interface EngineServerValidateOrderResponse {
@@ -318,10 +335,33 @@ export interface EngineServerEdgeAllProductsResponse {
   edge_all_products: Record<number, EngineServerAllProductsResponse>;
 }
 
+export interface EngineServerMaxBurnNlpResponse {
+  max_nlp_amount: string;
+}
+
 export interface EngineServerMaxMintNlpResponse {
   max_quote_amount: string;
 }
 
+export interface EngineServerNlpLockedBalancesResponse {
+  balance_locked: EngineServerNlpBalance;
+  balance_unlocked: EngineServerNlpBalance;
+  locked_balances: EngineServerNlpLockedBalance[];
+}
+
+export interface EngineServerNlpPool {
+  pool_id: number;
+  subaccount: string;
+  owner: string;
+  balance_weight_x18: string;
+  subaccount_info: EngineServerSubaccountInfoResponse;
+  open_orders: EngineServerOrder[];
+}
+
+export interface EngineServerNlpPoolInfoResponse {
+  nlp_pools: EngineServerNlpPool[];
+}
+
 export interface EngineServerQueryResponseByType {
   all_products: EngineServerAllProductsResponse;
   contracts: EngineServerContractsResponse;
@@ -334,8 +374,11 @@ export interface EngineServerQueryResponseByType {
   market_liquidity: EngineServerMarketLiquidityResponse;
   market_price: EngineServerMarketPriceResponse;
   market_prices: EngineServerMarketPricesResponse;
+  max_nlp_burnable: EngineServerMaxBurnNlpResponse;
   max_nlp_mintable: EngineServerMaxMintNlpResponse;
   max_order_size: EngineServerMaxOrderSizeResponse;
+  nlp_locked_balances: EngineServerNlpLockedBalancesResponse;
+  nlp_pool_info: EngineServerNlpPoolInfoResponse;
   max_withdrawable: EngineServerMaxWithdrawableResponse;
   nonces: EngineServerNoncesResponse;
   order: EngineServerOrderResponse;
@@ -348,8 +391,8 @@ export interface EngineServerQueryResponseByType {
 }
 
 export interface EngineServerQuerySuccessResponse<
-  TQueryType extends
-    keyof EngineServerQueryResponseByType = EngineServerQueryRequestType,
+  TQueryType extends keyof EngineServerQueryResponseByType =
+    EngineServerQueryRequestType,
 > {
   status: 'success';
   data: EngineServerQueryResponseByType[TQueryType];
@@ -362,8 +405,8 @@ export interface EngineServerQueryFailureResponse {
 }
 
 export type EngineServerQueryResponse<
-  TQueryType extends
-    keyof EngineServerQueryResponseByType = EngineServerQueryRequestType,
+  TQueryType extends keyof EngineServerQueryResponseByType =
+    EngineServerQueryRequestType,
 > =
   | EngineServerQuerySuccessResponse<TQueryType>
   | EngineServerQueryFailureResponse;

package/src/types/serverSubscriptionEventTypes.ts

@@ -1,7 +1,4 @@
-import {
-  EngineServerOrder,
-  EngineServerPriceTickLiquidity,
-} from './serverQueryTypes';
+import { EngineServerPriceTickLiquidity } from './serverQueryTypes';
 
 /**
  * Reasons that can trigger position change events.
@@ -33,8 +30,8 @@ export type EngineServerSubscriptionEventType =
   | 'funding_payment';
 
 export interface EngineServerSubscriptionBaseEvent<
-  T extends
-    EngineServerSubscriptionEventType = EngineServerSubscriptionEventType,
+  T extends EngineServerSubscriptionEventType =
+    EngineServerSubscriptionEventType,
 > {
   type: T;
   product_id: number;
@@ -43,8 +40,7 @@ export interface EngineServerSubscriptionBaseEvent<
 /**
  * Event from subscribing to a `trade` stream.
  */
-export interface EngineServerSubscriptionTradeEvent
-  extends EngineServerSubscriptionBaseEvent<'trade'> {
+export interface EngineServerSubscriptionTradeEvent extends EngineServerSubscriptionBaseEvent<'trade'> {
   timestamp: string;
   price: string;
   taker_qty: string;
@@ -55,8 +51,7 @@ export interface EngineServerSubscriptionTradeEvent
 /**
  * Event from subscribing to a `best_bid_offer` stream.
  */
-export interface EngineServerSubscriptionBestBidOfferEvent
-  extends EngineServerSubscriptionBaseEvent<'best_bid_offer'> {
+export interface EngineServerSubscriptionBestBidOfferEvent extends EngineServerSubscriptionBaseEvent<'best_bid_offer'> {
   timestamp: string;
   bid_price: string;
   bid_qty: string;
@@ -67,8 +62,7 @@ export interface EngineServerSubscriptionBestBidOfferEvent
 /**
  * Event from subscribing to a `book_depth` stream.
  */
-export interface EngineServerSubscriptionBookDepthEvent
-  extends EngineServerSubscriptionBaseEvent<'book_depth'> {
+export interface EngineServerSubscriptionBookDepthEvent extends EngineServerSubscriptionBaseEvent<'book_depth'> {
   last_max_timestamp: string;
   min_timestamp: string;
   max_timestamp: string;
@@ -79,8 +73,7 @@ export interface EngineServerSubscriptionBookDepthEvent
 /**
  * Event from subscribing to a `fill` stream.
  */
-export interface EngineServerSubscriptionFillEvent
-  extends EngineServerSubscriptionBaseEvent<'fill'> {
+export interface EngineServerSubscriptionFillEvent extends EngineServerSubscriptionBaseEvent<'fill'> {
   // NOTE: `id` is excluded from the response to avoid parsing issues.
   // type of `id` on the backend is `u64` which can overflow until we introduce proper parsing on the SDK.
   timestamp: string;
@@ -100,31 +93,33 @@ export interface EngineServerSubscriptionFillEvent
 /**
  * Event from subscribing to a `position_change` stream.
  */
-export interface EngineServerSubscriptionPositionChangeEvent
-  extends EngineServerSubscriptionBaseEvent<'position_change'> {
+export interface EngineServerSubscriptionPositionChangeEvent extends EngineServerSubscriptionBaseEvent<'position_change'> {
   timestamp: string;
   subaccount: string;
   amount: string;
   /** Zero for everything except perps */
   v_quote_amount: string;
   reason: PositionChangeReason;
+  /**
+   * True if the position change was for an isolated position
+   */
+  isolated: boolean;
 }
 
 /**
  * Event from subscribing to an `order_update` stream.
  */
-export interface EngineServerSubscriptionOrderUpdateEvent
-  extends EngineServerSubscriptionBaseEvent<'order_update'> {
+export interface EngineServerSubscriptionOrderUpdateEvent extends EngineServerSubscriptionBaseEvent<'order_update'> {
   timestamp: string;
-  order: EngineServerOrder;
+  digest: string;
+  amount: string;
   reason: OrderUpdateReason;
 }
 
 /**
  * Event from subscribing to a `liquidation` stream.
  */
-export interface EngineServerSubscriptionLiquidationEvent
-  extends EngineServerSubscriptionBaseEvent<'liquidation'> {
+export interface EngineServerSubscriptionLiquidationEvent extends EngineServerSubscriptionBaseEvent<'liquidation'> {
   timestamp: string;
   /** Single element for regular liquidations, two elements for spread liquidations [spotId, perpId] */
   product_ids: number[];
@@ -139,8 +134,7 @@ export interface EngineServerSubscriptionLiquidationEvent
 /**
  * Event from subscribing to a `latest_candlestick` stream.
  */
-export interface EngineServerSubscriptionLatestCandlestickEvent
-  extends EngineServerSubscriptionBaseEvent<'latest_candlestick'> {
+export interface EngineServerSubscriptionLatestCandlestickEvent extends EngineServerSubscriptionBaseEvent<'latest_candlestick'> {
   timestamp: string;
   granularity: number;
   open_x18: string;
@@ -153,8 +147,7 @@ export interface EngineServerSubscriptionLatestCandlestickEvent
 /**
  * Event from subscribing to a `funding_payment` stream.
  */
-export interface EngineServerSubscriptionFundingPaymentEvent
-  extends EngineServerSubscriptionBaseEvent<'funding_payment'> {
+export interface EngineServerSubscriptionFundingPaymentEvent extends EngineServerSubscriptionBaseEvent<'funding_payment'> {
   timestamp: string;
   /** Funding payment amount (positive = receive, negative = pay) */
   payment_amount: string;

package/src/utils/queryDataMappers.ts

@@ -8,26 +8,33 @@ import {
   removeDecimals,
   SpotMarket,
   subaccountFromHex,
-  toBigDecimal,
+  toBigNumber,
   unpackOrderAppendix,
 } from '@nadohq/shared';
 import {
   EngineMarketPrice,
+  EngineNlpLockedBalance,
   EngineOrder,
   EnginePriceTickLiquidity,
   EngineServerIsolatedPositionsResponse,
   EngineServerMarketPrice,
+  EngineServerNlpLockedBalancesResponse,
+  EngineServerNlpPoolInfoResponse,
   EngineServerOrderResponse,
   EngineServerPerpProduct,
   EngineServerPriceTickLiquidity,
   EngineServerSpotProduct,
   EngineServerSubaccountInfoResponse,
+  EngineServerSubaccountInfoState,
   EngineServerSymbol,
   EngineServerSymbolsResponse,
   EngineSymbol,
   EngineSymbolsResponse,
   GetEngineIsolatedPositionsResponse,
+  GetEngineNlpLockedBalancesResponse,
+  GetEngineNlpPoolInfoResponse,
   GetEngineSubaccountSummaryResponse,
+  SubaccountSummaryState,
 } from '../types';
 import { mapEngineServerProductType } from './productEngineTypeMappers';
 
@@ -36,7 +43,7 @@ export function mapEngineServerTickLiquidity(
 ): EnginePriceTickLiquidity {
   return {
     price: removeDecimals(tick[0]),
-    liquidity: toBigDecimal(tick[1]),
+    liquidity: toBigNumber(tick[1]),
   };
 }
 
@@ -52,8 +59,8 @@ export function mapEngineServerOrder(
     productId: order.product_id,
     subaccountOwner: subaccount.subaccountOwner,
     subaccountName: subaccount.subaccountName,
-    totalAmount: toBigDecimal(order.amount),
-    unfilledAmount: toBigDecimal(order.unfilled_amount),
+    totalAmount: toBigNumber(order.amount),
+    unfilledAmount: toBigNumber(order.unfilled_amount),
     placementTime: order.placed_at,
     appendix: unpackOrderAppendix(order.appendix),
   };
@@ -65,9 +72,9 @@ export function mapEngineServerSpotProduct(
   return {
     type: ProductEngineType.SPOT,
     productId: product.product_id,
-    minSize: toBigDecimal(product.book_info.min_size),
+    minSize: toBigNumber(product.book_info.min_size),
     priceIncrement: removeDecimals(product.book_info.price_increment_x18),
-    sizeIncrement: toBigDecimal(product.book_info.size_increment),
+    sizeIncrement: toBigNumber(product.book_info.size_increment),
     product: {
       productId: product.product_id,
       type: ProductEngineType.SPOT,
@@ -106,9 +113,9 @@ export function mapEngineServerPerpProduct(
   return {
     type: ProductEngineType.PERP,
     productId: product.product_id,
-    minSize: toBigDecimal(product.book_info.min_size),
+    minSize: toBigNumber(product.book_info.min_size),
     priceIncrement: removeDecimals(product.book_info.price_increment_x18),
-    sizeIncrement: toBigDecimal(product.book_info.size_increment),
+    sizeIncrement: toBigNumber(product.book_info.size_increment),
     product: {
       productId: product.product_id,
       type: ProductEngineType.PERP,
@@ -121,7 +128,7 @@ export function mapEngineServerPerpProduct(
       shortWeightMaintenance: removeDecimals(
         product.risk.short_weight_maintenance_x18,
       ),
-      openInterest: toBigDecimal(product.state.open_interest),
+      openInterest: toBigNumber(product.state.open_interest),
       cumulativeFundingLong: removeDecimals(
         product.state.cumulative_funding_long_x18,
       ),
@@ -136,19 +143,41 @@ export function mapEngineServerBalanceHealthContributions(
   healthContributionsForBalance: string[],
 ): BalanceHealthContributions {
   return {
-    initial: toBigDecimal(healthContributionsForBalance[0]),
-    maintenance: toBigDecimal(healthContributionsForBalance[1]),
-    unweighted: toBigDecimal(healthContributionsForBalance[2]),
+    initial: toBigNumber(healthContributionsForBalance[0]),
+    maintenance: toBigNumber(healthContributionsForBalance[1]),
+    unweighted: toBigNumber(healthContributionsForBalance[2]),
   };
 }
 
 export function mapSubaccountSummary(
   baseResponse: EngineServerSubaccountInfoResponse,
 ): GetEngineSubaccountSummaryResponse {
-  const balances: GetEngineSubaccountSummaryResponse['balances'] = [];
+  return {
+    exists: baseResponse.exists,
+    ...mapSubaccountSummaryState(
+      baseResponse,
+      baseResponse.spot_products,
+      baseResponse.perp_products,
+    ),
+    preState: baseResponse.pre_state
+      ? mapSubaccountSummaryState(
+          baseResponse.pre_state,
+          baseResponse.spot_products,
+          baseResponse.perp_products,
+        )
+      : undefined,
+  };
+}
 
-  baseResponse.spot_balances.forEach((spotBalance) => {
-    const product = baseResponse.spot_products.find(
+function mapSubaccountSummaryState(
+  state: EngineServerSubaccountInfoState,
+  spotProducts: EngineServerSubaccountInfoResponse['spot_products'],
+  perpProducts: EngineServerSubaccountInfoResponse['perp_products'],
+): SubaccountSummaryState {
+  const balances: SubaccountSummaryState['balances'] = [];
+
+  state.spot_balances.forEach((spotBalance) => {
+    const product = spotProducts.find(
       (product) => product.product_id === spotBalance.product_id,
     );
     if (!product) {
@@ -156,16 +185,16 @@ export function mapSubaccountSummary(
     }
 
     balances.push({
-      amount: toBigDecimal(spotBalance.balance.amount),
+      amount: toBigNumber(spotBalance.balance.amount),
       healthContributions: mapEngineServerBalanceHealthContributions(
-        baseResponse.health_contributions[spotBalance.product_id],
+        state.health_contributions[spotBalance.product_id],
       ),
       ...mapEngineServerSpotProduct(product).product,
     });
   });
 
-  baseResponse.perp_balances.forEach((perpBalance) => {
-    const product = baseResponse.perp_products.find(
+  state.perp_balances.forEach((perpBalance) => {
+    const product = perpProducts.find(
       (product) => product.product_id === perpBalance.product_id,
     );
     if (!product) {
@@ -173,33 +202,32 @@ export function mapSubaccountSummary(
     }
 
     balances.push({
-      amount: toBigDecimal(perpBalance.balance.amount),
-      vQuoteBalance: toBigDecimal(perpBalance.balance.v_quote_balance),
+      amount: toBigNumber(perpBalance.balance.amount),
+      vQuoteBalance: toBigNumber(perpBalance.balance.v_quote_balance),
       healthContributions: mapEngineServerBalanceHealthContributions(
-        baseResponse.health_contributions[perpBalance.product_id],
+        state.health_contributions[perpBalance.product_id],
       ),
       ...mapEngineServerPerpProduct(product).product,
     });
   });
 
   return {
-    balances: balances,
-    exists: baseResponse.exists,
+    balances,
     health: {
       initial: {
-        health: toBigDecimal(baseResponse.healths[0].health),
-        assets: toBigDecimal(baseResponse.healths[0].assets),
-        liabilities: toBigDecimal(baseResponse.healths[0].liabilities),
+        health: toBigNumber(state.healths[0].health),
+        assets: toBigNumber(state.healths[0].assets),
+        liabilities: toBigNumber(state.healths[0].liabilities),
       },
       maintenance: {
-        health: toBigDecimal(baseResponse.healths[1].health),
-        assets: toBigDecimal(baseResponse.healths[1].assets),
-        liabilities: toBigDecimal(baseResponse.healths[1].liabilities),
+        health: toBigNumber(state.healths[1].health),
+        assets: toBigNumber(state.healths[1].assets),
+        liabilities: toBigNumber(state.healths[1].liabilities),
       },
       unweighted: {
-        health: toBigDecimal(baseResponse.healths[2].health),
-        assets: toBigDecimal(baseResponse.healths[2].assets),
-        liabilities: toBigDecimal(baseResponse.healths[2].liabilities),
+        health: toBigNumber(state.healths[2].health),
+        assets: toBigNumber(state.healths[2].assets),
+        liabilities: toBigNumber(state.healths[2].liabilities),
       },
     },
   };
@@ -215,27 +243,27 @@ export function mapEngineServerIsolatedPositions(
     return {
       subaccount: subaccountFromHex(position.subaccount),
       healths: {
-        initial: toBigDecimal(position.healths[0].health),
-        maintenance: toBigDecimal(position.healths[1].health),
-        unweighted: toBigDecimal(position.healths[2].health),
+        initial: toBigNumber(position.healths[0].health),
+        maintenance: toBigNumber(position.healths[1].health),
+        unweighted: toBigNumber(position.healths[2].health),
       },
       baseBalance: {
-        amount: toBigDecimal(perpBalance.balance.amount),
-        vQuoteBalance: toBigDecimal(perpBalance.balance.v_quote_balance),
+        amount: toBigNumber(perpBalance.balance.amount),
+        vQuoteBalance: toBigNumber(perpBalance.balance.v_quote_balance),
         // Health contributions === healths for an isolated position
         healthContributions: {
-          initial: toBigDecimal(position.base_healths[0]),
-          maintenance: toBigDecimal(position.base_healths[1]),
-          unweighted: toBigDecimal(position.base_healths[2]),
+          initial: toBigNumber(position.base_healths[0]),
+          maintenance: toBigNumber(position.base_healths[1]),
+          unweighted: toBigNumber(position.base_healths[2]),
         },
         ...mapEngineServerPerpProduct(position.base_product).product,
       },
       quoteBalance: {
-        amount: toBigDecimal(quoteBalance.balance.amount),
+        amount: toBigNumber(quoteBalance.balance.amount),
         healthContributions: {
-          initial: toBigDecimal(position.quote_healths[0]),
-          maintenance: toBigDecimal(position.quote_healths[1]),
-          unweighted: toBigDecimal(position.quote_healths[2]),
+          initial: toBigNumber(position.quote_healths[0]),
+          maintenance: toBigNumber(position.quote_healths[1]),
+          unweighted: toBigNumber(position.quote_healths[2]),
         },
         ...mapEngineServerSpotProduct(position.quote_product).product,
       },
@@ -264,10 +292,8 @@ export function mapEngineServerSymbol(
     productId: engineServerSymbol.product_id,
     symbol: engineServerSymbol.symbol,
     priceIncrement: removeDecimals(engineServerSymbol.price_increment_x18),
-    sizeIncrement: toBigDecimal(engineServerSymbol.size_increment),
-    minSize: toBigDecimal(engineServerSymbol.min_size),
-    minDepth: removeDecimals(engineServerSymbol.min_depth_x18),
-    maxSpreadRate: removeDecimals(engineServerSymbol.max_spread_rate_x18),
+    sizeIncrement: toBigNumber(engineServerSymbol.size_increment),
+    minSize: toBigNumber(engineServerSymbol.min_size),
     makerFeeRate: removeDecimals(engineServerSymbol.maker_fee_rate_x18),
     takerFeeRate: removeDecimals(engineServerSymbol.taker_fee_rate_x18),
     longWeightInitial: removeDecimals(
@@ -276,6 +302,8 @@ export function mapEngineServerSymbol(
     longWeightMaintenance: removeDecimals(
       engineServerSymbol.long_weight_maintenance_x18,
     ),
+    maxOpenInterest: removeDecimals(engineServerSymbol.max_open_interest_x18),
+    isolatedOnly: engineServerSymbol.isolated_only,
   };
 }
 
@@ -288,3 +316,41 @@ export function mapEngineMarketPrice(
     productId: baseResponse.product_id,
   };
 }
+
+export function mapEngineServerNlpLockedBalances(
+  baseResponse: EngineServerNlpLockedBalancesResponse,
+): GetEngineNlpLockedBalancesResponse {
+  const lockedBalances: EngineNlpLockedBalance[] =
+    baseResponse.locked_balances.map((lockedBalance) => ({
+      productId: lockedBalance.balance.product_id,
+      balance: toBigNumber(lockedBalance.balance.balance.amount),
+      unlockedAt: lockedBalance.unlocked_at,
+    }));
+
+  return {
+    lockedBalances,
+    balanceLocked: {
+      productId: baseResponse.balance_locked.product_id,
+      balance: toBigNumber(baseResponse.balance_locked.balance.amount),
+    },
+    balanceUnlocked: {
+      productId: baseResponse.balance_unlocked.product_id,
+      balance: toBigNumber(baseResponse.balance_unlocked.balance.amount),
+    },
+  };
+}
+
+export function mapEngineServerNlpPoolInfo(
+  baseResponse: EngineServerNlpPoolInfoResponse,
+): GetEngineNlpPoolInfoResponse {
+  return {
+    nlpPools: baseResponse.nlp_pools.map((pool) => ({
+      poolId: pool.pool_id,
+      subaccountHex: pool.subaccount,
+      ownerAddress: pool.owner,
+      balanceWeight: removeDecimals(pool.balance_weight_x18),
+      subaccountInfo: mapSubaccountSummary(pool.subaccount_info),
+      openOrders: pool.open_orders.map(mapEngineServerOrder),
+    })),
+  };
+}