@lifi/perps-sdk 0.0.0-preview-2edcdb1 → 0.0.0-preview-5111896

package/src/transport/fetchWithRetry.ts

@@ -12,25 +12,12 @@ export interface FetchWithRetryOptions {
   signal?: AbortSignal
 }
 
-/**
- * True when `error` is an `AbortSignal` cancellation (the native `fetch` abort
- * rejection) rather than a genuine network failure. An abort is a deliberate
- * caller action, so it is rethrown untouched instead of being retried.
- *
- * @internal
- */
-export function isAbortError(error: unknown): boolean {
-  return error instanceof Error && error.name === 'AbortError'
-}
-
 /**
  * Wrap `fetch` with policy-driven retry. Honors `Retry-After` (when present
  * and `respectRetryAfter` is true), otherwise falls back to exponential
  * backoff with full jitter, capped by `maxDelayMs`. Network errors (thrown
  * `fetch` rejections) are treated as `retry-network` — same retry budget as
- * 5xx. Aborts (a pre-aborted signal, a mid-flight abort rejection, or a signal
- * that fires during a between-retries backoff) reject with the abort reason
- * without any further attempt.
+ * 5xx. An aborted signal short-circuits without further attempts.
  *
  * @public
  */
@@ -53,9 +40,6 @@ export async function fetchWithRetry(
     try {
       response = await fetchImpl(input, mergedInit)
     } catch (error) {
-      if (isAbortError(error)) {
-        throw error
-      }
       networkError = error
     }
 
@@ -94,7 +78,7 @@ export async function fetchWithRetry(
 
     const delayMs = computeDelay(policy, attempt, response)
     if (delayMs > 0) {
-      await sleep(delayMs, signal)
+      await sleep(delayMs)
     }
     attempt++
   }

package/src/transport/request.ts

@@ -3,7 +3,7 @@ import { PerpsErrorCode } from '@lifi/perps-types'
 import { PerpsError } from '../errors/PerpsError.js'
 import type { PerpsBaseConfig, SDKRequestOptions } from '../types/config.js'
 import { version } from '../version.js'
-import { fetchWithRetry, isAbortError } from './fetchWithRetry.js'
+import { fetchWithRetry } from './fetchWithRetry.js'
 import {
   LIFI_REQUEST_KEY,
   LIFI_RETRY_DEFAULTS,
@@ -94,10 +94,6 @@ export async function request<T>(
       throw error
     }
 
-    if (isAbortError(error)) {
-      throw error
-    }
-
     throw new PerpsError(
       PerpsErrorCode.ServerError,
       error instanceof Error ? error.message : 'Request failed'

package/src/utils/sleep.ts

@@ -1,23 +1,7 @@
 /**
- * Resolve after `ms` milliseconds, or reject with the signal's abort reason if
- * `signal` aborts first. Without a `signal` it always resolves.
+ * Resolve after `ms` milliseconds.
  *
  * @internal
  */
-export const sleep = (ms: number, signal?: AbortSignal): Promise<void> =>
-  new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(signal.reason ?? new DOMException('Aborted', 'AbortError'))
-      return
-    }
-    let timer: ReturnType<typeof setTimeout>
-    const onAbort = () => {
-      clearTimeout(timer)
-      reject(signal?.reason ?? new DOMException('Aborted', 'AbortError'))
-    }
-    timer = setTimeout(() => {
-      signal?.removeEventListener('abort', onAbort)
-      resolve()
-    }, ms)
-    signal?.addEventListener('abort', onAbort, { once: true })
-  })
+export const sleep = (ms: number): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms))

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/perps-sdk'
-export const version = '0.0.0-preview-2edcdb1'
+export const version = '0.0.0-preview-5111896'

package/src/websocket/PerpsWsClient.ts

@@ -65,6 +65,7 @@ export class PerpsWsClient {
   private readonly options: PerpsWsClientOptions
   private providers = new Map<string, WsProvider>()
   private initPromises = new Map<string, Promise<WsProvider>>()
+  private closed = false
 
   constructor(client: PerpsSDKClient, options: PerpsWsClientOptions = {}) {
     this.client = client
@@ -124,10 +125,14 @@ export class PerpsWsClient {
 
   /**
    * Close every open provider WS connection and drop all cached providers.
+   * Terminal: after `close()` the client is dead — `subscribe` and
+   * `subscribeQuote` reject, and any provider init still suspended mid-flight
+   * aborts without opening a socket. Create a new instance to subscribe again.
    *
    * @public
    */
   close() {
+    this.closed = true
     for (const p of this.providers.values()) {
       p.close()
     }
@@ -145,7 +150,18 @@ export class PerpsWsClient {
     this.providers.get(provider)?.reconnect()
   }
 
+  private assertOpen(): void {
+    if (this.closed) {
+      throw new PerpsError(
+        PerpsErrorCode.SDKError,
+        'PerpsWsClient is closed. Create a new instance to subscribe again.'
+      )
+    }
+  }
+
   private async getOrCreateProvider(provider: string): Promise<WsProvider> {
+    this.assertOpen()
+
     const existing = this.providers.get(provider)
     if (existing) {
       return existing
@@ -175,6 +191,7 @@ export class PerpsWsClient {
     }
 
     const { providers } = await getProviders(this.client)
+    this.assertOpen()
 
     const providerInfo = providers.find((d) => d.key === provider)
     if (!providerInfo?.wsUrl) {

package/src/websocket/WsProviderBase.ts

@@ -188,7 +188,15 @@ export abstract class WsProviderBase<TSub = unknown> implements WsProvider {
   }
 
   private async replaySubs(): Promise<void> {
-    for (const [key, state] of this.wireSubs) {
+    // Snapshot at replay start, and re-check the live registry before each
+    // send. An async sendSubscribe (e.g. Lighter's auth-token fetch) suspends
+    // the loop; status is already 'connected' while open listeners run, so a
+    // subscribe landing mid-replay is sent inline by registerSub — it must not
+    // be revisited here, and an entry unregistered mid-replay must be skipped.
+    for (const [key, state] of [...this.wireSubs]) {
+      if (this.wireSubs.get(key) !== state) {
+        continue
+      }
       // Isolate each resubscribe: a send can reject (e.g. an auth-token fetch
       // after reconnect), and one sub's failure must not abort the rest of
       // the loop or escape as an unhandled rejection.