@lifi/perps-sdk 0.1.1-alpha.9 → 1.0.0

package/src/errors/PerpsSDKError.ts

@@ -1,79 +0,0 @@
-import { PerpsErrorCode } from '@lifi/perps-types'
-import { version } from '../version.js'
-import { PerpsError } from './PerpsError.js'
-
-const PERPS_SDK_ERROR_NAME = 'PerpsSDKError'
-
-/**
- * Top-level SDK error that wraps all other error types.
- * This is the public-facing error type for the SDK.
- *
- * PerpsSDKError always includes:
- * - A consistent error message format with SDK version
- * - Access to the root cause error via the `cause` property
- * - Stack trace preservation
- *
- * @example
- * ```ts
- * try {
- *   await getDexes(client)
- * } catch (error) {
- *   if (error instanceof PerpsSDKError) {
- *     console.log(error.message) // [PerpsSDKError] message\nSDK version: X
- *     console.log(error.cause)   // Original error
- *     console.log(error.code)    // Numeric error code
- *   }
- * }
- * ```
- */
-export class PerpsSDKError extends Error {
-  override name = PERPS_SDK_ERROR_NAME
-
-  /** Numeric error code from PerpsErrorCode enum */
-  code: PerpsErrorCode
-
-  /** Original cause of the error */
-  override cause?: Error
-
-  constructor(error: Error, message?: string) {
-    // Determine the code
-    const code =
-      error instanceof PerpsError ? error.code : PerpsErrorCode.DefaultError
-
-    // Build the message
-    const errorMessage = message ?? error.message
-    const formattedMessage = `[${PERPS_SDK_ERROR_NAME}] ${errorMessage}\nLI.FI Perps SDK version: ${version}`
-
-    super(formattedMessage)
-
-    this.name = PERPS_SDK_ERROR_NAME
-    this.code = code
-    this.cause = error
-
-    // Preserve the original stack trace if available
-    if (error.stack) {
-      this.stack = `${this.stack}\nCaused by: ${error.stack}`
-    }
-  }
-
-  /**
-   * Wrap any error in a PerpsSDKError.
-   *
-   * @param error - The error to wrap
-   * @param message - Optional custom message
-   * @returns PerpsSDKError instance
-   */
-  static wrap(error: unknown, message?: string): PerpsSDKError {
-    if (error instanceof PerpsSDKError) {
-      return error
-    }
-
-    if (error instanceof Error) {
-      return new PerpsSDKError(error, message)
-    }
-
-    // Convert non-Error to Error
-    const wrappedError = new Error(String(error))
-    return new PerpsSDKError(wrappedError, message)
-  }
-}

package/src/errors/ServerError.ts

@@ -1,41 +0,0 @@
-import { PerpsErrorCode } from '@lifi/perps-types'
-import { version } from '../version.js'
-import { PerpsErrorName } from './constants.js'
-import { PerpsError } from './PerpsError.js'
-
-/**
- * Error thrown when server-side operations fail (network errors, timeouts, etc.)
- */
-export class ServerError extends PerpsError {
-  override name = PerpsErrorName.ServerError
-
-  constructor(message: string, code = PerpsErrorCode.ServerError) {
-    super(code, message)
-    this.name = PerpsErrorName.ServerError
-
-    // Override message format
-    this.message = `[${PerpsErrorName.ServerError}] ${message}\nLI.FI Perps SDK version: ${version}`
-  }
-
-  /**
-   * Create a ServerError for a network failure.
-   *
-   * @param cause - The original error
-   */
-  static networkError(cause?: Error): ServerError {
-    const message = cause?.message ?? 'Network request failed'
-    return new ServerError(message)
-  }
-
-  /**
-   * Create a ServerError for a timeout.
-   *
-   * @param operation - The operation that timed out
-   */
-  static timeout(operation: string): ServerError {
-    return new ServerError(
-      `${operation} timed out`,
-      PerpsErrorCode.TimeoutError
-    )
-  }
-}

package/src/errors/ValidationError.ts

@@ -1,38 +0,0 @@
-import { PerpsErrorCode } from '@lifi/perps-types'
-import { version } from '../version.js'
-import { PerpsErrorName } from './constants.js'
-import { PerpsError } from './PerpsError.js'
-
-/**
- * Error thrown when validation fails (invalid parameters, missing required fields, etc.)
- */
-export class ValidationError extends PerpsError {
-  override name = PerpsErrorName.ValidationError
-
-  constructor(message: string) {
-    super(PerpsErrorCode.ValidationError, message)
-    this.name = PerpsErrorName.ValidationError
-
-    // Override message format
-    this.message = `[${PerpsErrorName.ValidationError}] ${message}\nLI.FI Perps SDK version: ${version}`
-  }
-
-  /**
-   * Create a ValidationError from a validation failure.
-   *
-   * @param field - The field that failed validation
-   * @param reason - The reason for validation failure
-   */
-  static field(field: string, reason: string): ValidationError {
-    return new ValidationError(`Invalid ${field}: ${reason}`)
-  }
-
-  /**
-   * Create a ValidationError for a missing required field.
-   *
-   * @param field - The name of the missing field
-   */
-  static required(field: string): ValidationError {
-    return new ValidationError(`${field} is required`)
-  }
-}

package/src/errors/utils/rootCause.ts

@@ -1,112 +0,0 @@
-/**
- * Get the root cause of an error by following the cause chain.
- *
- * @param error - The error to get the root cause of
- * @returns The root cause error, or the original error if no cause chain
- *
- * @example
- * ```ts
- * const wrapper = new PerpsSDKError(new HTTPError(response, url))
- * const root = getRootCause(wrapper) // Returns the HTTPError
- * ```
- */
-export function getRootCause(error: Error): Error {
-  let current: Error = error
-  let iterations = 0
-  const maxIterations = 100 // Prevent infinite loops
-
-  while (current.cause instanceof Error && iterations < maxIterations) {
-    current = current.cause
-    iterations++
-  }
-
-  return current
-}
-
-/**
- * Get the message from the root cause of an error.
- *
- * @param error - The error to get the root cause message from
- * @returns The root cause message
- *
- * @example
- * ```ts
- * const wrapper = new PerpsSDKError(new HTTPError(response, url))
- * const message = getRootCauseMessage(wrapper) // Returns the HTTPError's message
- * ```
- */
-export function getRootCauseMessage(error: Error): string {
-  return getRootCause(error).message
-}
-
-/**
- * Get the full error chain as an array.
- *
- * @param error - The error to get the chain from
- * @returns Array of errors from outermost to root cause
- *
- * @example
- * ```ts
- * const chain = getErrorChain(sdkError)
- * // [PerpsSDKError, HTTPError, ...]
- * ```
- */
-export function getErrorChain(error: Error): Error[] {
-  const chain: Error[] = [error]
-  let current = error
-  let iterations = 0
-  const maxIterations = 100
-
-  while (current.cause instanceof Error && iterations < maxIterations) {
-    chain.push(current.cause)
-    current = current.cause
-    iterations++
-  }
-
-  return chain
-}
-
-/**
- * Check if an error chain contains an error of a specific type.
- *
- * @param error - The error to check
- * @param ErrorClass - The error class to look for
- * @returns True if the chain contains an error of the specified type
- *
- * @example
- * ```ts
- * if (hasErrorType(error, HTTPError)) {
- *   // Handle HTTP error specifically
- * }
- * ```
- */
-export function hasErrorType<T extends Error>(
-  error: Error,
-  ErrorClass: new (...args: any[]) => T
-): boolean {
-  const chain = getErrorChain(error)
-  return chain.some((e) => e instanceof ErrorClass)
-}
-
-/**
- * Find the first error of a specific type in the error chain.
- *
- * @param error - The error to search
- * @param ErrorClass - The error class to find
- * @returns The first matching error, or undefined if not found
- *
- * @example
- * ```ts
- * const httpError = findErrorType(error, HTTPError)
- * if (httpError) {
- *   console.log(httpError.status)
- * }
- * ```
- */
-export function findErrorType<T extends Error>(
-  error: Error,
-  ErrorClass: new (...args: any[]) => T
-): T | undefined {
-  const chain = getErrorChain(error)
-  return chain.find((e): e is T => e instanceof ErrorClass)
-}

package/src/realtime/PerpsWsClient.ts

@@ -1,73 +0,0 @@
-import type { Subscription } from '@lifi/perps-types'
-import type { PerpsSDKClient } from '../client/createPerpsClient.js'
-import { getDexes } from '../services/getDexes.js'
-import { getMarkets } from '../services/getMarkets.js'
-import { HyperliquidWsProvider } from './hyperliquid/HyperliquidWsProvider.js'
-import type { EventForSubscription, SubscriptionListener } from './types.js'
-
-export class PerpsWsClient {
-  private readonly client: PerpsSDKClient
-  private providers = new Map<string, HyperliquidWsProvider>()
-  private initPromises = new Map<string, Promise<HyperliquidWsProvider>>()
-
-  constructor(client: PerpsSDKClient) {
-    this.client = client
-  }
-
-  async subscribe<S extends Subscription>(
-    sub: S,
-    listener: (event: EventForSubscription<S>) => void
-  ): Promise<() => void> {
-    const provider = await this.getOrCreateProvider(sub.dex)
-    return provider.subscribe(sub, listener as SubscriptionListener)
-  }
-
-  close() {
-    for (const p of this.providers.values()) {
-      p.close()
-    }
-    this.providers.clear()
-    this.initPromises.clear()
-  }
-
-  private async getOrCreateProvider(
-    dex: string
-  ): Promise<HyperliquidWsProvider> {
-    const existing = this.providers.get(dex)
-    if (existing) {
-      return existing
-    }
-
-    let initPromise = this.initPromises.get(dex)
-    if (!initPromise) {
-      initPromise = this.initProvider(dex)
-      this.initPromises.set(dex, initPromise)
-    }
-    return initPromise
-  }
-
-  private async initProvider(dex: string): Promise<HyperliquidWsProvider> {
-    const [{ dexes }, { markets }] = await Promise.all([
-      getDexes(this.client),
-      getMarkets(this.client, { dex }),
-    ])
-
-    const dexInfo = dexes.find((d) => d.key === dex)
-    if (!dexInfo?.wsUrl) {
-      throw new Error(`No WebSocket URL found for dex: ${dex}`)
-    }
-
-    const assetIdLookup = new Map<string, number>()
-    for (const m of markets) {
-      assetIdLookup.set(m.symbol, m.assetId)
-    }
-
-    const provider = new HyperliquidWsProvider(
-      dexInfo.wsUrl,
-      dex,
-      assetIdLookup
-    )
-    this.providers.set(dex, provider)
-    return provider
-  }
-}

package/src/realtime/ReconnectingWebSocket.ts

@@ -1,156 +0,0 @@
-type WsEventMap = {
-  open: () => void
-  close: (code: number, reason: string) => void
-  error: (error: Event) => void
-  message: (data: string) => void
-}
-
-type WsEvent = keyof WsEventMap
-
-export interface ReconnectingWebSocketOptions {
-  maxRetries?: number
-  pingIntervalMs?: number
-}
-
-export class ReconnectingWebSocket {
-  private ws: WebSocket | null = null
-  private readonly url: string
-  private readonly maxRetries: number
-  private readonly pingIntervalMs: number
-  private attempt = 0
-  private closed = false
-  private buffer: string[] = []
-  private pingTimer: ReturnType<typeof setInterval> | null = null
-  private listeners = {
-    open: new Set<WsEventMap['open']>(),
-    close: new Set<WsEventMap['close']>(),
-    error: new Set<WsEventMap['error']>(),
-    message: new Set<WsEventMap['message']>(),
-  }
-  private readyResolvers: Array<{
-    resolve: () => void
-    reject: (e: Error) => void
-  }> = []
-
-  constructor(url: string, options?: ReconnectingWebSocketOptions) {
-    this.url = url
-    this.maxRetries = options?.maxRetries ?? 3
-    this.pingIntervalMs = options?.pingIntervalMs ?? 30_000
-    this.connect()
-  }
-
-  private connect() {
-    this.ws = new WebSocket(this.url)
-
-    this.ws.onopen = () => {
-      this.attempt = 0
-      this.flush()
-      this.startPing()
-      for (const fn of this.listeners.open) {
-        fn()
-      }
-      for (const { resolve } of this.readyResolvers) {
-        resolve()
-      }
-      this.readyResolvers = []
-    }
-
-    this.ws.onclose = (e) => {
-      this.stopPing()
-      for (const fn of this.listeners.close) {
-        fn(e.code, e.reason)
-      }
-      if (!this.closed) {
-        this.reconnect()
-      }
-    }
-
-    this.ws.onerror = (e) => {
-      for (const fn of this.listeners.error) {
-        fn(e)
-      }
-    }
-
-    this.ws.onmessage = (e) => {
-      const data = typeof e.data === 'string' ? e.data : String(e.data)
-      for (const fn of this.listeners.message) {
-        fn(data)
-      }
-    }
-  }
-
-  private reconnect() {
-    if (this.attempt >= this.maxRetries) {
-      for (const { reject } of this.readyResolvers) {
-        reject(new Error('WebSocket max reconnect attempts reached'))
-      }
-      this.readyResolvers = []
-      return
-    }
-    const delay = Math.min((1 << this.attempt) * 150, 10_000)
-    this.attempt++
-    setTimeout(() => {
-      if (!this.closed) {
-        this.connect()
-      }
-    }, delay)
-  }
-
-  private flush() {
-    for (const msg of this.buffer) {
-      this.ws?.send(msg)
-    }
-    this.buffer = []
-  }
-
-  private startPing() {
-    this.pingTimer = setInterval(() => {
-      if (this.ws?.readyState === WebSocket.OPEN) {
-        this.ws.send('{"method":"ping"}')
-      }
-    }, this.pingIntervalMs)
-  }
-
-  private stopPing() {
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer)
-      this.pingTimer = null
-    }
-  }
-
-  send(data: string) {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(data)
-    } else {
-      this.buffer.push(data)
-    }
-  }
-
-  close() {
-    this.closed = true
-    this.stopPing()
-    this.ws?.close()
-    this.ws = null
-    for (const { reject } of this.readyResolvers) {
-      reject(new Error('WebSocket closed'))
-    }
-    this.readyResolvers = []
-  }
-
-  on<E extends WsEvent>(event: E, fn: WsEventMap[E]) {
-    ;(this.listeners[event] as Set<WsEventMap[E]>).add(fn)
-  }
-
-  off<E extends WsEvent>(event: E, fn: WsEventMap[E]) {
-    ;(this.listeners[event] as Set<WsEventMap[E]>).delete(fn)
-  }
-
-  ready(): Promise<void> {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      return Promise.resolve()
-    }
-    return new Promise((resolve, reject) => {
-      this.readyResolvers.push({ resolve, reject })
-    })
-  }
-}