support AbortSignal param in withRetry

Author: deodad

src/actions/public/waitForTransactionReceipt.ts

@@ -258,6 +258,7 @@ export async function waitForTransactionReceipt<
                 {
                   delay: retryDelay,
                   retryCount,
+                  signal: requestOptions?.signal,
                 },
               )
               retrying = false
@@ -314,6 +315,7 @@ export async function waitForTransactionReceipt<
                     retryCount,
                     shouldRetry: ({ error }) =>
                       error instanceof BlockNotFoundError,
+                    signal: requestOptions?.signal,
                   },
                 )
                 retrying = false

src/actions/wallet/waitForCallsStatus.ts

@@ -4,6 +4,7 @@ import { BaseError } from '../../errors/base.js'
 import { BundleFailedError } from '../../errors/calls.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
+import type { EIP1193RequestOptions } from '../../types/eip1193.js'
 import { getAction } from '../../utils/getAction.js'
 import { type ObserveErrorType, observe } from '../../utils/observe.js'
 import { type PollErrorType, poll } from '../../utils/poll.js'
@@ -30,6 +31,10 @@ export type WaitForCallsStatusParameters = {
    * @default client.pollingInterval
    */
   pollingInterval?: number | undefined
+  /**
+   * Request options.
+   */
+  requestOptions?: EIP1193RequestOptions | undefined
   /**
    * Number of times to retry if the call bundle failed.
    * @default 4 (exponential backoff)
@@ -98,6 +103,7 @@ export async function waitForCallsStatus<chain extends Chain | undefined>(
   const {
     id,
     pollingInterval = client.pollingInterval,
+    requestOptions,
     status = ({ statusCode }) => statusCode === 200 || statusCode >= 300,
     retryCount = 4,
     retryDelay = ({ count }) => ~~(1 << count) * 200, // exponential backoff
@@ -128,14 +134,15 @@ export async function waitForCallsStatus<chain extends Chain | undefined>(
                 client,
                 getCallsStatus,
                 'getCallsStatus',
-              )({ id })
+              )({ id, requestOptions })
               if (throwOnFailure && result.status === 'failure')
                 throw new BundleFailedError(result)
               return result
             },
             {
               retryCount,
               delay: retryDelay,
+              signal: requestOptions?.signal,
             },
           )
           if (!status(result)) return

src/utils/promise/withRetry.test.ts

@@ -154,3 +154,69 @@ test('delay: fn', async () => {
   ).rejects.toThrowError('test')
   expect(end > 1000 && end < 1020).toBe(true)
 })
+
+test('signal: already aborted', async () => {
+  let retryTimes = 0
+  const controller = new AbortController()
+  controller.abort()
+
+  await expect(
+    withRetry(
+      async () => {
+        retryTimes++
+        throw new Error('test')
+      },
+      { signal: controller.signal },
+    ),
+  ).rejects.toThrow('This operation was aborted')
+  expect(retryTimes).toBe(0)
+})
+
+test('signal: aborted during retries', async () => {
+  let retryTimes = 0
+  const controller = new AbortController()
+
+  await expect(
+    withRetry(
+      async () => {
+        retryTimes++
+        if (retryTimes === 1) controller.abort()
+        throw new Error('test')
+      },
+      { signal: controller.signal, delay: 0 },
+    ),
+  ).rejects.toThrow('This operation was aborted')
+  expect(retryTimes).toBe(1)
+})
+
+test('signal: not aborted', async () => {
+  let retryTimes = 0
+  const controller = new AbortController()
+
+  const result = await withRetry(
+    async () => {
+      retryTimes++
+      if (retryTimes < 2) throw new Error('test')
+      return 'success'
+    },
+    { signal: controller.signal, delay: 0 },
+  )
+
+  expect(result).toBe('success')
+  expect(retryTimes).toBe(2)
+})
+
+test('signal: aborted with custom reason', async () => {
+  const controller = new AbortController()
+  const customError = new Error('Custom abort reason')
+  controller.abort(customError)
+
+  await expect(
+    withRetry(
+      async () => {
+        throw new Error('test')
+      },
+      { signal: controller.signal },
+    ),
+  ).rejects.toThrow('Custom abort reason')
+})

src/utils/promise/withRetry.ts

@@ -19,6 +19,8 @@ export type WithRetryParameters = {
         error: Error
       }) => Promise<boolean> | boolean)
     | undefined
+  // AbortSignal to cancel retries.
+  signal?: AbortSignal | undefined
 }
 
 export type WithRetryErrorType = ErrorType
@@ -29,10 +31,25 @@ export function withRetry<data>(
     delay: delay_ = 100,
     retryCount = 2,
     shouldRetry = () => true,
+    signal,
   }: WithRetryParameters = {},
 ) {
   return new Promise<data>((resolve, reject) => {
+    const rejectWithAbort = () => {
+      reject(signal?.reason ?? new Error('Aborted'))
+    }
+
+    if (signal?.aborted) {
+      rejectWithAbort()
+      return
+    }
+
     const attemptRetry = async ({ count = 0 } = {}) => {
+      if (signal?.aborted) {
+        rejectWithAbort()
+        return
+      }
+
       const retry = async ({ error }: { error: Error }) => {
         const delay =
           typeof delay_ === 'function' ? delay_({ count, error }) : delay_