@nadohq/engine-client 0.1.0-alpha.4 → 0.1.0-alpha.40

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;
@@ -156,9 +176,20 @@ export interface EngineServerNoncesResponse {
   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 +197,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 +227,12 @@ 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;
 }
 
 export interface EngineServerSymbolsResponse {
@@ -253,6 +280,7 @@ export interface EngineServerFeeRatesResponse {
   withdraw_sequencer_fees: string[];
   taker_fee_rates_x18: string[];
   maker_fee_rates_x18: string[];
+  fee_tier: number;
 }
 
 export interface EngineServerMarketPrice {
@@ -267,20 +295,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 {
@@ -317,10 +331,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;
@@ -333,8 +370,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;

package/src/types/serverSubscriptionEventTypes.ts

@@ -1,22 +1,48 @@
 import { EngineServerPriceTickLiquidity } from './serverQueryTypes';
 
 /**
- * Event from subscribing to a `order_update` stream.
+ * Reasons that can trigger position change events.
  */
-export interface EngineServerSubscriptionOrderUpdateEvent {
-  timestamp: string;
+export type PositionChangeReason =
+  | 'deposit_collateral'
+  | 'match_orders'
+  | 'withdraw_collateral'
+  | 'transfer_quote'
+  | 'settle_pnl'
+  | 'mint_nlp'
+  | 'burn_nlp'
+  | 'liquidate_subaccount';
+
+/**
+ * Possible reasons for order updates.
+ */
+export type OrderUpdateReason = 'cancelled' | 'filled' | 'placed';
+
+export type EngineServerSubscriptionEventType =
+  | 'trade'
+  | 'best_bid_offer'
+  | 'book_depth'
+  | 'fill'
+  | 'position_change'
+  | 'order_update'
+  | 'liquidation'
+  | 'latest_candlestick'
+  | 'funding_payment';
+
+export interface EngineServerSubscriptionBaseEvent<
+  T extends
+    EngineServerSubscriptionEventType = EngineServerSubscriptionEventType,
+> {
+  type: T;
   product_id: number;
-  digest: string;
-  amount: string;
-  reason: string;
 }
 
 /**
  * Event from subscribing to a `trade` stream.
  */
-export interface EngineServerSubscriptionTradeEvent {
+export interface EngineServerSubscriptionTradeEvent
+  extends EngineServerSubscriptionBaseEvent<'trade'> {
   timestamp: string;
-  product_id: number;
   price: string;
   taker_qty: string;
   maker_qty: string;
@@ -26,49 +52,133 @@ export interface EngineServerSubscriptionTradeEvent {
 /**
  * Event from subscribing to a `best_bid_offer` stream.
  */
-export interface EngineServerSubscriptionBestBidOfferEvent {
+export interface EngineServerSubscriptionBestBidOfferEvent
+  extends EngineServerSubscriptionBaseEvent<'best_bid_offer'> {
   timestamp: string;
-  product_id: number;
   bid_price: string;
   bid_qty: string;
   ask_price: string;
   ask_qty: string;
 }
 
+/**
+ * Event from subscribing to a `book_depth` stream.
+ */
+export interface EngineServerSubscriptionBookDepthEvent
+  extends EngineServerSubscriptionBaseEvent<'book_depth'> {
+  last_max_timestamp: string;
+  min_timestamp: string;
+  max_timestamp: string;
+  bids: EngineServerPriceTickLiquidity[];
+  asks: EngineServerPriceTickLiquidity[];
+}
+
 /**
  * Event from subscribing to a `fill` stream.
  */
-export interface EngineServerSubscriptionFillEvent {
+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;
-  product_id: number;
   subaccount: string;
   order_digest: string;
   filled_qty: string;
   remaining_qty: string;
+  original_qty: string;
   price: string;
   is_taker: boolean;
+  is_bid: boolean;
+  fee: string;
+  submission_idx: string;
+  appendix: string;
 }
 
 /**
  * Event from subscribing to a `position_change` stream.
  */
-export interface EngineServerSubscriptionPositionChangeEvent {
+export interface EngineServerSubscriptionPositionChangeEvent
+  extends EngineServerSubscriptionBaseEvent<'position_change'> {
   timestamp: string;
-  product_id: number;
   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 a `book_depth` stream.
+ * Event from subscribing to an `order_update` stream.
  */
-export interface EngineServerSubscriptionBookDepthEvent {
-  min_timestamp: string;
-  max_timestamp: string;
-  product_id: number;
-  bids: EngineServerPriceTickLiquidity[];
-  asks: EngineServerPriceTickLiquidity[];
+export interface EngineServerSubscriptionOrderUpdateEvent
+  extends EngineServerSubscriptionBaseEvent<'order_update'> {
+  timestamp: string;
+  digest: string;
+  amount: string;
+  reason: OrderUpdateReason;
 }
+
+/**
+ * Event from subscribing to a `liquidation` stream.
+ */
+export interface EngineServerSubscriptionLiquidationEvent
+  extends EngineServerSubscriptionBaseEvent<'liquidation'> {
+  timestamp: string;
+  /** Single element for regular liquidations, two elements for spread liquidations [spotId, perpId] */
+  product_ids: number[];
+  liquidator: string;
+  liquidatee: string;
+  /** Amount liquidated (positive for long, negative for short) */
+  amount: string;
+  /** Price at which liquidation occurred */
+  price: string;
+}
+
+/**
+ * Event from subscribing to a `latest_candlestick` stream.
+ */
+export interface EngineServerSubscriptionLatestCandlestickEvent
+  extends EngineServerSubscriptionBaseEvent<'latest_candlestick'> {
+  timestamp: string;
+  granularity: number;
+  open_x18: string;
+  high_x18: string;
+  low_x18: string;
+  close_x18: string;
+  volume: string;
+}
+
+/**
+ * Event from subscribing to a `funding_payment` stream.
+ */
+export interface EngineServerSubscriptionFundingPaymentEvent
+  extends EngineServerSubscriptionBaseEvent<'funding_payment'> {
+  timestamp: string;
+  /** Funding payment amount (positive = receive, negative = pay) */
+  payment_amount: string;
+  /** Open interest at time of funding */
+  open_interest: string;
+  /** Current cumulative funding values */
+  cumulative_funding_long_x18: string;
+  cumulative_funding_short_x18: string;
+  /** Time delta over which the funding payment was calculated */
+  dt: string;
+}
+
+/**
+ * Union type for all engine server subscription events.
+ */
+export type EngineServerSubscriptionEvent =
+  | EngineServerSubscriptionTradeEvent
+  | EngineServerSubscriptionBestBidOfferEvent
+  | EngineServerSubscriptionBookDepthEvent
+  | EngineServerSubscriptionFillEvent
+  | EngineServerSubscriptionPositionChangeEvent
+  | EngineServerSubscriptionOrderUpdateEvent
+  | EngineServerSubscriptionLiquidationEvent
+  | EngineServerSubscriptionLatestCandlestickEvent
+  | EngineServerSubscriptionFundingPaymentEvent;

package/src/types/serverSubscriptionTypes.ts

@@ -1,5 +1,6 @@
 export interface EngineServerOrderUpdateStreamParams {
-  product_id: number;
+  /** when not provided, subscribes to all products */
+  product_id?: number;
   subaccount: string;
 }
 
@@ -12,12 +13,14 @@ export interface EngineServerBestBidOfferStreamParams {
 }
 
 export interface EngineServerFillStreamParams {
-  product_id: number;
+  /** when not provided, subscribes to all products */
+  product_id?: number;
   subaccount: string;
 }
 
 export interface EngineServerPositionChangeStreamParams {
-  product_id: number;
+  /** when not provided, subscribes to all products */
+  product_id?: number;
   subaccount: string;
 }
 
@@ -25,6 +28,20 @@ export interface EngineServerBookDepthStreamParams {
   product_id: number;
 }
 
+export interface EngineServerLatestCandlestickStreamParams {
+  product_id: number;
+  granularity: number;
+}
+
+export interface EngineServerLiquidationStreamParams {
+  /** when not provided, subscribes to all products */
+  product_id?: number;
+}
+
+export interface EngineServerFundingPaymentStreamParams {
+  product_id: number;
+}
+
 /**
  * Available subscription streams
  */
@@ -35,6 +52,9 @@ export interface EngineServerSubscriptionStreamParamsByType {
   fill: EngineServerFillStreamParams;
   position_change: EngineServerPositionChangeStreamParams;
   book_depth: EngineServerBookDepthStreamParams;
+  liquidation: EngineServerLiquidationStreamParams;
+  latest_candlestick: EngineServerLatestCandlestickStreamParams;
+  funding_payment: EngineServerFundingPaymentStreamParams;
 }
 
 export type EngineServerSubscriptionStreamParamsType =

package/src/utils/queryDataMappers.ts

@@ -13,21 +13,28 @@ import {
 } 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';
 
@@ -145,10 +152,32 @@ export function mapEngineServerBalanceHealthContributions(
 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) {
@@ -158,14 +187,14 @@ export function mapSubaccountSummary(
     balances.push({
       amount: toBigDecimal(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) {
@@ -176,30 +205,29 @@ export function mapSubaccountSummary(
       amount: toBigDecimal(perpBalance.balance.amount),
       vQuoteBalance: toBigDecimal(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: toBigDecimal(state.healths[0].health),
+        assets: toBigDecimal(state.healths[0].assets),
+        liabilities: toBigDecimal(state.healths[0].liabilities),
       },
       maintenance: {
-        health: toBigDecimal(baseResponse.healths[1].health),
-        assets: toBigDecimal(baseResponse.healths[1].assets),
-        liabilities: toBigDecimal(baseResponse.healths[1].liabilities),
+        health: toBigDecimal(state.healths[1].health),
+        assets: toBigDecimal(state.healths[1].assets),
+        liabilities: toBigDecimal(state.healths[1].liabilities),
       },
       unweighted: {
-        health: toBigDecimal(baseResponse.healths[2].health),
-        assets: toBigDecimal(baseResponse.healths[2].assets),
-        liabilities: toBigDecimal(baseResponse.healths[2].liabilities),
+        health: toBigDecimal(state.healths[2].health),
+        assets: toBigDecimal(state.healths[2].assets),
+        liabilities: toBigDecimal(state.healths[2].liabilities),
       },
     },
   };
@@ -266,8 +294,6 @@ export function mapEngineServerSymbol(
     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),
     makerFeeRate: removeDecimals(engineServerSymbol.maker_fee_rate_x18),
     takerFeeRate: removeDecimals(engineServerSymbol.taker_fee_rate_x18),
     longWeightInitial: removeDecimals(
@@ -276,6 +302,7 @@ export function mapEngineServerSymbol(
     longWeightMaintenance: removeDecimals(
       engineServerSymbol.long_weight_maintenance_x18,
     ),
+    maxOpenInterest: removeDecimals(engineServerSymbol.max_open_interest_x18),
   };
 }
 
@@ -288,3 +315,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: toBigDecimal(lockedBalance.balance.balance.amount),
+      unlockedAt: lockedBalance.unlocked_at,
+    }));
+
+  return {
+    lockedBalances,
+    balanceLocked: {
+      productId: baseResponse.balance_locked.product_id,
+      balance: toBigDecimal(baseResponse.balance_locked.balance.amount),
+    },
+    balanceUnlocked: {
+      productId: baseResponse.balance_unlocked.product_id,
+      balance: toBigDecimal(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),
+    })),
+  };
+}