@across-protocol/sdk 4.3.145-alpha.1 → 4.3.145-alpha.4

package/src/utils/common.ts

@@ -221,55 +221,20 @@ export function delay(seconds: number) {
 }
 
 /**
- * Discriminated union for operations that can fail. Callers narrow on `.ok`: success
- * carries `value`, failure carries the original `error` for inspection. Avoids the
- * control-flow cost of try/catch at call sites that want to handle failure as data.
- */
-export type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
-
-/**
- * Configures {@link retry}. Retries always use exponential backoff
- * (`delaySeconds * 2 ** attempt + random()` seconds) to play nicely with upstream
- * rate-limits; callers that want tighter spacing should lower {@link delaySeconds}.
- */
-export type RetryOptions = {
-  /** Maximum number of retry attempts after the initial call (total attempts = retries + 1). Defaults to 2 (3 total tries). */
-  retries?: number;
-  /** Base delay in seconds for the exponential backoff. Defaults to 1. */
-  delaySeconds?: number;
-  /** Predicate evaluated against the thrown error to decide whether to retry. Defaults to retrying every error. */
-  isRetryable?: (err: unknown) => boolean;
-};
-
-const DEFAULT_RETRY_OPTIONS: Required<RetryOptions> = {
-  retries: 2,
-  delaySeconds: 1,
-  isRetryable: () => true,
-};
-
-/**
- * Attempt a function call with exponential backoff and a retryability predicate, returning a
- * {@link Result} that encodes success or the terminal failure. Exhausted retries and errors
- * rejected by `isRetryable` both surface as `{ ok: false, error }` — the caller decides how
- * to react instead of catching a throw.
- * @param call The function to call.
- * @param options Retry configuration — see {@link RetryOptions}. All fields are optional.
- * @returns A `Result<T>` wrapping the terminal outcome.
- */
-export async function retry<T>(call: () => Promise<T>, options: RetryOptions = {}): Promise<Result<T>> {
-  const resolved: Required<RetryOptions> = { ...DEFAULT_RETRY_OPTIONS, ...options };
-  const backoffSeconds = (attempt: number): number => resolved.delaySeconds * 2 ** attempt + Math.random();
-
-  for (let nAttempts = 0; ; ++nAttempts) {
-    try {
-      return { ok: true, value: await call() };
-    } catch (err) {
-      if (nAttempts >= resolved.retries || !resolved.isRetryable(err)) {
-        return { ok: false, error: err instanceof Error ? err : new Error(String(err)) };
-      }
-      await delay(backoffSeconds(nAttempts));
-    }
-  }
+ * Attempt to retry a function call a number of times with a delay between each attempt
+ * @param call The function to call
+ * @param times The number of times to retry
+ * @param delayS The number of seconds to delay between each attempt
+ * @returns The result of the function call.
+ */
+export function retry<T>(call: () => Promise<T>, times: number, delayS: number): Promise<T> {
+  let promiseChain = call();
+  for (let i = 0; i < times; i++)
+    promiseChain = promiseChain.catch(async () => {
+      await delay(delayS);
+      return await call();
+    });
+  return promiseChain;
 }
 
 export type TransactionCostEstimate = {