@lifi/perps-sdk 12.1.0 → 14.0.0

package/src/utils/orderMath.ts

@@ -1,10 +1,12 @@
 import {
-  type OpenOrder,
   OrderSide,
+  OrderStatus,
   type Position,
   PositionSide,
+  type RegularOrder,
   type TriggerOrder,
 } from '@lifi/perps-types'
+import { isActiveOrderStatus } from './orderClassification.js'
 import { realizedPnlOnClose } from './positionMath.js'
 
 /**
@@ -55,10 +57,10 @@ export function resolveCloseSize(
  * @public
  */
 export function expectedRealizedPnlForOpenOrder(
-  order: OpenOrder,
+  order: RegularOrder,
   position: Position | undefined
 ): number | null {
-  if (!position) {
+  if (!position || !isActiveOrderStatus(order.status)) {
     return null
   }
 
@@ -70,7 +72,7 @@ export function expectedRealizedPnlForOpenOrder(
     return null
   }
 
-  const limitPrice = Number.parseFloat(order.price)
+  const limitPrice = Number.parseFloat(order.price ?? '')
   const entryPrice = Number.parseFloat(position.entryPrice)
   const orderSize = Math.abs(Number.parseFloat(order.remainingSize))
   const positionSize = Math.abs(Number.parseFloat(position.size))
@@ -100,29 +102,29 @@ export function expectedRealizedPnlForOpenOrder(
   })
 }
 
-/**
- * Expected rPnL for a TP/SL trigger order against a matching position.
- *
- * A trigger order is by construction a closing leg — its direction is the
- * opposite of the position's. With no matching position there is nothing to
- * close, so rPnL is `null`. The trigger price (always present on the SDK
- * `TriggerOrder` shape) is used as the rPnL price; the optional `limitPrice`
- * for STOP_LIMIT / TAKE_PROFIT_LIMIT is the post-trigger limit, not the rPnL
- * price.
- * @public
- */
+/** Project the unfilled closing quantity of an active trigger at its trigger price. */
 export function expectedRealizedPnlForTriggerOrder(
   order: TriggerOrder,
   position: Position | undefined
 ): number | null {
-  if (!position) {
+  if (
+    !position ||
+    !isActiveOrderStatus(order.status) ||
+    order.status === OrderStatus.PENDING
+  ) {
     return null
   }
 
   const isLong = position.side === PositionSide.LONG
+  if (
+    (isLong && order.side !== OrderSide.SELL) ||
+    (!isLong && order.side !== OrderSide.BUY)
+  ) {
+    return null
+  }
   const triggerPrice = Number.parseFloat(order.triggerPrice)
   const entryPrice = Number.parseFloat(position.entryPrice)
-  const orderSize = Math.abs(Number.parseFloat(order.size))
+  const orderSize = Math.abs(Number.parseFloat(order.remainingSize))
   const positionSize = Math.abs(Number.parseFloat(position.size))
   if (
     !Number.isFinite(triggerPrice) ||
@@ -133,6 +135,12 @@ export function expectedRealizedPnlForTriggerOrder(
   ) {
     return null
   }
+  if (
+    orderSize === 0 &&
+    (Number.parseFloat(order.originalSize) !== 0 || !order.reduceOnly)
+  ) {
+    return null
+  }
 
   const closeSize = resolveCloseSize(orderSize, positionSize)
   return realizedPnlOnClose({

package/src/utils/warnOnce.ts

@@ -0,0 +1,29 @@
+/**
+ * The number of keys one warner remembers. Venue wire data supplies the keys,
+ * so the memory must not grow for as long as the process runs.
+ */
+const KEY_MEMORY_LIMIT = 256
+
+/**
+ * Build a warner that writes each distinct key once. The warner forgets the
+ * oldest key when its memory is full, so a key it saw long ago can warn a
+ * second time.
+ *
+ * @internal
+ */
+export const createWarnOnce = (): ((key: string, message: string) => void) => {
+  const seen = new Set<string>()
+  return (key, message) => {
+    if (seen.has(key)) {
+      return
+    }
+    if (seen.size >= KEY_MEMORY_LIMIT) {
+      const oldest = seen.values().next().value
+      if (oldest !== undefined) {
+        seen.delete(oldest)
+      }
+    }
+    seen.add(key)
+    console.warn(message)
+  }
+}

package/src/version.ts

@@ -10,4 +10,4 @@ export const name = '@lifi/perps-sdk'
  *
  * @public
  */
-export const version = '12.1.0'
+export const version = '14.0.0'

package/src/websocket/PerpsWsClient.ts

@@ -12,12 +12,11 @@ import type {
 } from './types.js'
 
 /**
- * Factory for a per-provider WS plugin. Invoked once per provider key the
- * first time `subscribe(...)` is called against it.
+ * Call parameters of a {@link WsProviderFactory}.
  *
  * @public
  */
-export type WsProviderFactory = (params: {
+export interface WsProviderFactoryParams {
   provider: string
   /** WS URL discovered from `/providers`. */
   wsUrl: string
@@ -34,7 +33,19 @@ export type WsProviderFactory = (params: {
    * duplicating backend orchestration in the WS layer.
    */
   client: PerpsSDKClient
-}) => WsProvider
+}
+
+/**
+ * Factory for a per-provider WS plugin. Invoked once per provider key the
+ * first time `subscribe(...)` is called against it.
+ *
+ * @public
+ */
+export interface WsProviderFactory {
+  (params: WsProviderFactoryParams): WsProvider
+  /** `true` when the venue socket serves the `candle` channel. */
+  readonly streamsCandles: boolean
+}
 
 /**
  * Options for {@link PerpsWsClient}.
@@ -54,7 +65,7 @@ export interface PerpsWsClientOptions {
 }
 
 /**
- * Realtime client: lazily instantiates a per-provider {@link WsProvider} on
+ * WebSocket client: lazily instantiates a per-provider {@link WsProvider} on
  * first subscription and fans subscriptions out to it.
  *
  * @public
@@ -72,7 +83,19 @@ export class PerpsWsClient {
   }
 
   /**
-   * Subscribe to a realtime channel, lazily creating the provider's WS
+   * Whether `provider`'s socket serves the `candle` channel, as reported by
+   * its registered factory. Returns `false` when no factory is registered.
+   * Synchronous: it reads the factory without instantiating the provider and
+   * makes no network call, so a caller can branch before the first subscribe.
+   *
+   * @public
+   */
+  streamsCandles(provider: string): boolean {
+    return this.options.wsProviders?.[provider]?.streamsCandles ?? false
+  }
+
+  /**
+   * Subscribe to a WebSocket channel, lazily creating the provider's WS
    * connection. Returns an unsubscribe function.
    *
    * @param onStatus - Optional listener for the underlying connection's