@lifi/perps-sdk 19.0.0 → 20.1.0

package/src/utils/math.ts

@@ -0,0 +1,7 @@
+import type Big from 'big.js'
+
+/** The larger of two Big values, as `Math.max` for numbers. */
+export const maxOf = (a: Big, b: Big): Big => (a.gt(b) ? a : b)
+
+/** The smaller of two Big values, as `Math.min` for numbers. */
+export const minOf = (a: Big, b: Big): Big => (a.lt(b) ? a : b)

package/src/utils/orderEntry.ts

@@ -0,0 +1,38 @@
+import type Big from 'big.js'
+import { TruncBig } from './decimal.js'
+
+/**
+ * Base size the given margin buys at `leverage`: size = margin × leverage ÷ price.
+ * Truncates, so `size × price` never exceeds `margin × leverage`.
+ * @public
+ */
+export function sizeFromMargin(margin: Big, leverage: number, price: Big): Big {
+  return new TruncBig(margin).times(leverage).div(price)
+}
+
+/**
+ * Margin that holds the given base size at `leverage`: margin = size × price ÷ leverage.
+ * Truncates, so `margin × leverage` never exceeds `size × price`.
+ * @public
+ */
+export function marginFromSize(size: Big, leverage: number, price: Big): Big {
+  return new TruncBig(size).times(price).div(leverage)
+}
+
+/**
+ * Base size for a notional: size = notional ÷ price.
+ * Truncates, so `size × price` never exceeds the notional.
+ * @public
+ */
+export function sizeFromNotional(notionalUsd: Big, price: Big): Big {
+  return new TruncBig(notionalUsd).div(price)
+}
+
+/**
+ * Margin for a notional at `leverage`: margin = notional ÷ leverage.
+ * Truncates, so `margin × leverage` never exceeds the notional.
+ * @public
+ */
+export function marginFromNotional(notionalUsd: Big, leverage: number): Big {
+  return new TruncBig(notionalUsd).div(leverage)
+}

package/src/utils/parse.ts

@@ -27,3 +27,28 @@ export function stringToFloat(value: string): number {
   }
   return parseFloat(cleaned)
 }
+
+const FORMATTED_NUMBER =
+  /^(?:[+-]\s*)?(?:\$\s*)?(?:(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:\s*(?:%|USD))?$/i
+
+/**
+ * Parse an optional decimal field, with the same formatting tolerance as {@link stringToFloat}.
+ * Gives back `undefined` for a missing, malformed or non-finite value, and `0` for an empty string.
+ *
+ * @public
+ */
+export function parseDecimal(
+  value: string | null | undefined
+): number | undefined {
+  if (value == null) {
+    return undefined
+  }
+  if (value.trim() === '') {
+    return stringToFloat(value)
+  }
+  if (!FORMATTED_NUMBER.test(value.trim())) {
+    return undefined
+  }
+  const parsed = stringToFloat(value)
+  return Number.isFinite(parsed) ? parsed : undefined
+}

package/src/utils/positionMath.ts

@@ -6,6 +6,8 @@
  * always non-negative magnitudes; direction is carried by `isLong`.
  */
 
+import { areFinite, DivBig } from './decimal.js'
+
 /**
  * Direction sign for a position.
  *
@@ -50,8 +52,39 @@ export function estimateIsolatedLiquidationPrice(params: {
   if (denominator === 0) {
     return undefined
   }
-  const marginAvailable = entryPrice * (1 / leverage - maintenanceMarginRate)
-  return entryPrice - (side * marginAvailable) / denominator
+  if (!areFinite(entryPrice, leverage, maintenanceMarginRate)) {
+    return Number.NaN
+  }
+  const mmr = new DivBig(maintenanceMarginRate)
+  const marginAvailable = new DivBig(1)
+    .div(leverage)
+    .minus(mmr)
+    .times(entryPrice)
+  return new DivBig(entryPrice)
+    .minus(marginAvailable.times(side).div(mmr.times(-side).plus(1)))
+    .toNumber()
+}
+
+/**
+ * Whether an isolated position with this liquidation price is already past
+ * liquidation at `currentPrice`: a long liquidates when the price falls to its
+ * liquidation level, a short when it rises to it. A non-positive price on
+ * either side counts as unknown, so the result is `false`.
+ *
+ * @public
+ */
+export function wouldImmediatelyLiquidate(params: {
+  liquidationPrice: number
+  currentPrice: number
+  isLong: boolean
+}): boolean {
+  const { liquidationPrice, currentPrice, isLong } = params
+  if (currentPrice <= 0 || liquidationPrice <= 0) {
+    return false
+  }
+  return isLong
+    ? liquidationPrice >= currentPrice
+    : liquidationPrice <= currentPrice
 }
 
 /**
@@ -84,7 +117,14 @@ export function predictAverageEntryPrice(params: {
   if (!Number.isFinite(currentEntry) || !Number.isFinite(fillPrice)) {
     return undefined
   }
-  return (currentSize * currentEntry + addSize * fillPrice) / totalSize
+  if (!areFinite(currentSize, addSize)) {
+    return Number.NaN
+  }
+  return new DivBig(currentSize)
+    .times(currentEntry)
+    .plus(new DivBig(addSize).times(fillPrice))
+    .div(new DivBig(currentSize).plus(addSize))
+    .toNumber()
 }
 
 /**
@@ -109,7 +149,13 @@ export function predictNewLeverage(params: {
   if (totalMargin <= 0) {
     return undefined
   }
-  return (currentNotional + addNotional) / totalMargin
+  if (!areFinite(currentNotional, currentMargin, addNotional, addMargin)) {
+    return Number.NaN
+  }
+  return new DivBig(currentNotional)
+    .plus(addNotional)
+    .div(new DivBig(currentMargin).plus(addMargin))
+    .toNumber()
 }
 
 /**
@@ -127,7 +173,14 @@ export function predictUnrealizedPnl(params: {
   isLong: boolean
 }): number {
   const { entryPrice, markPrice, size, isLong } = params
-  return (markPrice - entryPrice) * size * directionSign(isLong)
+  if (!areFinite(entryPrice, markPrice, size)) {
+    return Number.NaN
+  }
+  return new DivBig(markPrice)
+    .minus(entryPrice)
+    .times(size)
+    .times(directionSign(isLong))
+    .toNumber()
 }
 
 /**
@@ -145,5 +198,12 @@ export function realizedPnlOnClose(params: {
   isLong: boolean
 }): number {
   const { entryPrice, closePrice, closeSize, isLong } = params
-  return (closePrice - entryPrice) * closeSize * directionSign(isLong)
+  if (!areFinite(entryPrice, closePrice, closeSize)) {
+    return Number.NaN
+  }
+  return new DivBig(closePrice)
+    .minus(entryPrice)
+    .times(closeSize)
+    .times(directionSign(isLong))
+    .toNumber()
 }

package/src/version.ts

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

package/src/websocket/PerpsWsClient.ts

@@ -20,13 +20,6 @@ export interface WsProviderFactoryParams {
   provider: string
   /** WS URL discovered from `/providers`. */
   wsUrl: string
-  /**
-   * Markets visible to this provider via `/providers`, optionally filtered
-   * by the consumer's `createPerpsClient({ providers: { [key]: { markets } } })`
-   * config. Each provider interprets these its own way — Hyperliquid uses
-   * them to decide which sub-DEXes to subscribe to; Lighter ignores them.
-   */
-  markets: string[]
   /**
    * The SDK client. WS providers use it to call core services (e.g.
    * `getAssets` to source the wire-id ↔ display-symbol map) without
@@ -235,21 +228,9 @@ export class PerpsWsClient {
       throw new Error(`No WebSocket URL found for provider: ${provider}`)
     }
 
-    const allMarkets = (providerInfo.categories ?? []) as Array<{
-      id: string
-    }>
-    const providerConfig = this.client.config.providers?.[provider]
-    const configuredMarkets = providerConfig?.markets
-    const markets = (
-      configuredMarkets
-        ? allMarkets.filter((m) => configuredMarkets.includes(m.id))
-        : allMarkets
-    ).map((m) => m.id)
-
     const wsProvider = factory({
       provider,
       wsUrl: providerInfo.wsUrl,
-      markets,
       client: this.client,
     })
     this.providers.set(provider, wsProvider)

package/src/websocket/WsProviderBase.ts

@@ -199,7 +199,9 @@ export abstract class WsProviderBase<TSub = unknown> implements WsProvider {
     try {
       await this.sendSubscribe(state)
     } catch (err) {
-      this.wireSubs.delete(key)
+      if (this.wireSubs.get(key) === state) {
+        this.wireSubs.delete(key)
+      }
       throw err
     }
   }
@@ -304,7 +306,11 @@ export abstract class WsProviderBase<TSub = unknown> implements WsProvider {
     try {
       const teardown = await opening
       const current = this.channels.get(key)
-      if (current === undefined || current.listeners.size === 0) {
+      if (current !== entry) {
+        teardown()
+        return
+      }
+      if (current.listeners.size === 0) {
         // Every listener released while opening — unwind immediately.
         teardown()
         this.channels.delete(key)
@@ -315,7 +321,9 @@ export abstract class WsProviderBase<TSub = unknown> implements WsProvider {
     } catch (err) {
       // Open failed: drop the channel so all (concurrent) subscribers reject
       // cleanly and a later subscribe re-opens.
-      this.channels.delete(key)
+      if (this.channels.get(key) === entry) {
+        this.channels.delete(key)
+      }
       throw err
     }
   }