viem 2.48.11 → 2.49.0

package/utils/promise/withRetry.ts

@@ -1,4 +1,8 @@
-import type { ErrorType } from '../../errors/utils.js'
+import {
+  type ErrorType,
+  getAbortError,
+  isAbortError,
+} from '../../errors/utils.js'
 import { wait } from '../wait.js'
 
 export type WithRetryParameters = {
@@ -19,6 +23,8 @@ export type WithRetryParameters = {
         error: Error
       }) => Promise<boolean> | boolean)
     | undefined
+  // AbortSignal to cancel retries.
+  signal?: AbortSignal | undefined
 }
 
 export type WithRetryErrorType = ErrorType
@@ -29,14 +35,27 @@ export function withRetry<data>(
     delay: delay_ = 100,
     retryCount = 2,
     shouldRetry = () => true,
+    signal,
   }: WithRetryParameters = {},
 ) {
   return new Promise<data>((resolve, reject) => {
     const attemptRetry = async ({ count = 0 } = {}) => {
+      if (signal?.aborted) {
+        reject(getAbortError(signal))
+        return
+      }
+
       const retry = async ({ error }: { error: Error }) => {
         const delay =
           typeof delay_ === 'function' ? delay_({ count, error }) : delay_
-        if (delay) await wait(delay)
+        if (delay) {
+          try {
+            await wait(delay, { signal })
+          } catch (err) {
+            reject(err)
+            return
+          }
+        }
         attemptRetry({ count: count + 1 })
       }
 
@@ -44,6 +63,14 @@ export function withRetry<data>(
         const data = await fn()
         resolve(data)
       } catch (err) {
+        if (signal?.aborted) {
+          reject(getAbortError(signal))
+          return
+        }
+        if (isAbortError(err)) {
+          reject(err)
+          return
+        }
         if (
           count < retryCount &&
           (await shouldRetry({ count, error: err as Error }))

package/utils/promise/withTimeout.ts

@@ -1,4 +1,4 @@
-import type { ErrorType } from '../../errors/utils.js'
+import { type ErrorType, isAbortError } from '../../errors/utils.js'
 
 export type WithTimeoutErrorType = ErrorType
 
@@ -24,8 +24,8 @@ export function withTimeout<data>(
   return new Promise((resolve, reject) => {
     ;(async () => {
       let timeoutId!: NodeJS.Timeout
+      const controller = new AbortController()
       try {
-        const controller = new AbortController()
         if (timeout > 0) {
           timeoutId = setTimeout(() => {
             if (signal) {
@@ -37,7 +37,10 @@ export function withTimeout<data>(
         }
         resolve(await fn({ signal: controller?.signal || null }))
       } catch (err) {
-        if ((err as Error)?.name === 'AbortError') reject(errorInstance)
+        if (controller?.signal.aborted && isAbortError(err)) {
+          reject(errorInstance)
+          return
+        }
         reject(err)
       } finally {
         clearTimeout(timeoutId)

package/utils/rpc/http.ts

@@ -4,7 +4,11 @@ import {
   TimeoutError,
   type TimeoutErrorType,
 } from '../../errors/request.js'
-import type { ErrorType } from '../../errors/utils.js'
+import {
+  type ErrorType,
+  getAbortError,
+  isAbortError,
+} from '../../errors/utils.js'
 import type { RpcRequest, RpcResponse } from '../../types/rpc.js'
 import type { MaybePromise } from '../../types/utils.js'
 import {
@@ -174,6 +178,8 @@ export function getHttpRpcClient(
 
         return data
       } catch (err) {
+        if (signal_?.aborted) throw getAbortError(signal_)
+        if (isAbortError(err)) throw err
         if (err instanceof HttpRequestError) throw err
         if (err instanceof TimeoutError) throw err
         throw new HttpRequestError({

package/utils/wait.ts

@@ -1,3 +1,25 @@
-export async function wait(time: number) {
-  return new Promise((res) => setTimeout(res, time))
+import { getAbortError } from '../errors/utils.js'
+
+export async function wait(
+  time: number,
+  { signal }: { signal?: AbortSignal | undefined } = {},
+) {
+  return new Promise<void>((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(getAbortError(signal))
+      return
+    }
+
+    const cleanup = () => signal?.removeEventListener('abort', onAbort)
+    const timeout = setTimeout(() => {
+      cleanup()
+      resolve()
+    }, time)
+    const onAbort = () => {
+      clearTimeout(timeout)
+      cleanup()
+      reject(getAbortError(signal))
+    }
+    signal?.addEventListener('abort', onAbort, { once: true })
+  })
 }