opticedge-cloud-utils 1.1.8 → 1.1.9

package/dist/retry.d.ts

@@ -7,5 +7,7 @@ export type RetryOptions = {
     isRetryable?: (err: any) => boolean;
     onRetry?: (err: any, attempt: number, nextDelayMs: number) => void;
 };
+export declare function sleep(ms: number, signal?: AbortSignal | null): Promise<void>;
 export declare function isRetryableDefault(err: any): boolean;
+export declare function isRetryableAxios(err: any): boolean;
 export declare function retry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;

package/dist/retry.js

@@ -1,20 +1,29 @@
 "use strict";
+// src/retry.ts
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = sleep;
 exports.isRetryableDefault = isRetryableDefault;
+exports.isRetryableAxios = isRetryableAxios;
 exports.retry = retry;
-function sleep(ms, signal) {
+const axios_1 = __importDefault(require("axios"));
+async function sleep(ms, signal) {
     return new Promise((resolve, reject) => {
         if (signal?.aborted)
             return reject(new Error('Aborted'));
         const t = setTimeout(() => {
-            signal?.removeEventListener('abort', onAbort);
+            signal?.removeEventListener?.('abort', onAbort);
             resolve();
         }, ms);
         function onAbort() {
             clearTimeout(t);
+            signal?.removeEventListener?.('abort', onAbort);
             reject(new Error('Aborted'));
         }
-        signal?.addEventListener('abort', onAbort);
+        signal?.addEventListener?.('abort', onAbort);
     });
 }
 function isRetryableDefault(err) {
@@ -55,6 +64,24 @@ function isRetryableDefault(err) {
         return true;
     return false;
 }
+function isRetryableAxios(err) {
+    if (!err)
+        return false;
+    // If axios knows about it:
+    if (axios_1.default.isAxiosError(err)) {
+        // No response -> network error / timeout -> retry
+        if (!err.response)
+            return true;
+        const status = err.response.status;
+        // retry on 429 or 5xx
+        if (status === 429 || (status >= 500 && status < 600))
+            return true;
+        // 4xx client errors -> do not retry
+        return false;
+    }
+    // Fallback to your existing heuristics (gRPC codes, node syscodes, etc.)
+    return isRetryableDefault(err);
+}
 async function retry(fn, opts = {}) {
     const retries = opts.retries ?? 4;
     const base = opts.baseDelayMs ?? 200;
@@ -66,8 +93,8 @@ async function retry(fn, opts = {}) {
     const start = Date.now();
     let attempt = 0;
     let lastErr;
-    /* eslint-disable no-constant-condition */
-    while (true) {
+    // attempt = number of retries already performed; initial try is attempt==0
+    while (attempt <= retries) {
         if (signal?.aborted)
             throw new Error('Aborted');
         try {
@@ -78,11 +105,11 @@ async function retry(fn, opts = {}) {
             if (!isRetryable(err)) {
                 throw err;
             }
-            if (attempt >= retries) {
+            if (attempt >= retries)
                 break;
-            }
-            attempt++;
-            const exp = Math.min(max, base * Math.pow(2, attempt - 1));
+            // compute next retry (1-based)
+            const nextAttempt = attempt + 1;
+            const exp = Math.min(max, base * Math.pow(2, nextAttempt - 1));
             const delay = Math.floor(Math.random() * exp);
             if (typeof timeoutMs === 'number') {
                 const elapsed = Date.now() - start;
@@ -91,13 +118,14 @@ async function retry(fn, opts = {}) {
                 }
             }
             try {
-                onRetry?.(err, attempt, delay);
-                /* eslint-disable @typescript-eslint/no-unused-vars */
+                // pass 1-based attempt to onRetry to mean "this is the upcoming retry number"
+                onRetry?.(err, nextAttempt, delay);
             }
-            catch (e) {
-                // ignore errors from onRetry
+            catch {
+                /* ignore onRetry errors */
             }
             await sleep(delay, signal);
+            attempt = nextAttempt;
         }
     }
     const finalErr = new Error(`Retry failed after ${attempt} retries: ${String(lastErr?.message ?? lastErr)}`);

package/dist/task.d.ts

@@ -1 +1,12 @@
-export declare function createTask(projectId: string, region: string, queueId: string, data: unknown, serviceAccount: string, audience: string, delaySeconds?: number): Promise<string>;
+import { RetryOptions } from './retry';
+export type CreateTaskOpts = {
+    taskId?: string;
+    retryOptions?: RetryOptions;
+};
+export declare function isRetryableCloudTasks(err: any): boolean;
+/**
+ * Create a Cloud Task with retry logic.
+ * If opts.taskId is provided, the task name will be parent + '/tasks/' + taskId — this
+ * makes the operation idempotent (create will fail with ALREADY_EXISTS if it already exists).
+ */
+export declare function createTask(projectId: string, region: string, queueId: string, data: unknown, serviceAccount: string, audience: string, delaySeconds?: number, opts?: CreateTaskOpts): Promise<string>;

package/dist/task.js

@@ -1,9 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRetryableCloudTasks = isRetryableCloudTasks;
 exports.createTask = createTask;
+// src/cloud-tasks.ts
 const tasks_1 = require("@google-cloud/tasks");
+const retry_1 = require("./retry");
 const tasksClient = new tasks_1.CloudTasksClient();
-async function createTask(projectId, region, queueId, data, serviceAccount, audience, delaySeconds = 0) {
+// cloud-tasks errors can be gRPC-style (numeric code) or an Error with code string.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isRetryableCloudTasks(err) {
+    if (!err)
+        return false;
+    // If error explicitly says ALREADY_EXISTS, do not retry (client already has the task)
+    // gRPC ALREADY_EXISTS numeric code is 6
+    if (err?.code === 6 ||
+        err?.grpcCode === 6 ||
+        String(err?.code).toUpperCase().includes('ALREADY_EXISTS')) {
+        return false;
+    }
+    // Otherwise delegate to your general retryable heuristics (network / 14=UNAVAILABLE / 5xx etc.)
+    return (0, retry_1.isRetryableDefault)(err);
+}
+/**
+ * Create a Cloud Task with retry logic.
+ * If opts.taskId is provided, the task name will be parent + '/tasks/' + taskId — this
+ * makes the operation idempotent (create will fail with ALREADY_EXISTS if it already exists).
+ */
+async function createTask(projectId, region, queueId, data, serviceAccount, audience, delaySeconds = 0, opts = {}) {
     if (!projectId || !region || !queueId || !serviceAccount || !audience) {
         throw new Error('Missing required parameters for Cloud Tasks setup');
     }
@@ -14,6 +37,7 @@ async function createTask(projectId, region, queueId, data, serviceAccount, audi
             seconds: Math.floor(now + delaySeconds)
         }
         : undefined;
+    // Build the base task
     const task = {
         httpRequest: {
             httpMethod: tasks_1.protos.google.cloud.tasks.v2.HttpMethod.POST,
@@ -29,10 +53,52 @@ async function createTask(projectId, region, queueId, data, serviceAccount, audi
         },
         scheduleTime: scheduledTime
     };
-    const [response] = await tasksClient.createTask({ parent, task });
-    if (!response.name) {
-        throw new Error('Failed to create task: no name returned');
+    // Optionally set a deterministic name to make task creation idempotent.
+    // The name must be full resource path: projects/PROJECT/locations/REGION/queues/QUEUE/tasks/TASK_ID
+    if (opts.taskId) {
+        // sanitize/validate taskId if you want; Cloud Tasks requires certain name rules.
+        task.name = `${parent}/tasks/${opts.taskId}`;
+    }
+    // retry options with sensible defaults; allow caller to override via opts.retryOptions
+    const retryOpts = {
+        retries: 3,
+        baseDelayMs: 200,
+        maxDelayMs: 3000,
+        isRetryable: isRetryableCloudTasks,
+        onRetry: (err, attempt, delay) => {
+            console.warn(`createTask retry #${attempt} in ${delay}ms — ${String(err?.message ?? err)}`);
+        },
+        ...opts.retryOptions // allow overrides
+    };
+    // the unit-of-work we want to retry
+    const doCreate = async () => {
+        const [response] = await tasksClient.createTask({ parent, task });
+        if (!response?.name) {
+            // unexpected response shape — treat as non-retryable final failure
+            throw new Error('Failed to create task: no name returned');
+        }
+        return response.name;
+    };
+    try {
+        const name = await (0, retry_1.retry)(() => doCreate(), retryOpts);
+        console.log(`✅ Created Cloud Task: ${name}`);
+        return name;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (err) {
+        // If ALREADY_EXISTS happened (and was not considered retryable), you may prefer to
+        // return the constructed task name (if provided) rather than null/throw.
+        if (opts.taskId) {
+            const expectedName = `${parent}/tasks/${opts.taskId}`;
+            // If we got ALREADY_EXISTS, treat as success and return existing name
+            if (err?.original?.code === 6 ||
+                err?.code === 6 ||
+                String(err?.original?.code).toUpperCase().includes('ALREADY_EXISTS')) {
+                console.warn('createTask — task already exists, returning existing name', expectedName);
+                return expectedName;
+            }
+        }
+        console.error('createTask — final failure after retries', { error: err?.message ?? err });
+        throw err; // rethrow (or return null if you prefer)
     }
-    console.log(`✅ Created Cloud Task: ${response.name}`);
-    return response.name;
 }

package/dist/tw/wallet.js

@@ -6,27 +6,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pregenerateInAppWallet = pregenerateInAppWallet;
 const axios_1 = __importDefault(require("axios"));
 const secrets_1 = require("../secrets");
+const retry_1 = require("../retry");
 async function pregenerateInAppWallet(projectId, twClientId, twSecretKeyName, email) {
     const TW_SECRET_KEY = await (0, secrets_1.getSecret)(projectId, twSecretKeyName);
-    try {
-        const response = await axios_1.default.post('https://in-app-wallet.thirdweb.com/api/v1/pregenerate', { strategy: 'email', email }, {
+    if (!TW_SECRET_KEY) {
+        console.error('Missing TW secret key', { projectId, twSecretKeyName });
+        return null;
+    }
+    const doRequest = async () => {
+        const res = await axios_1.default.post('https://in-app-wallet.thirdweb.com/api/v1/pregenerate', { strategy: 'email', email }, {
             headers: {
                 'x-secret-key': TW_SECRET_KEY,
                 'x-client-id': twClientId,
                 'Content-Type': 'application/json'
             },
-            timeout: 5000
+            timeout: 10000
         });
-        const wallet = response.data.wallet;
+        const wallet = res.data?.wallet;
         if (!wallet || !wallet.address) {
-            console.error('Invalid wallet response:', response.data);
-            return null;
+            // server returned 2xx but unexpected shape — don't retry, treat as final failure
+            console.error('Invalid wallet response shape', { status: res.status, data: res.data });
+            throw new Error('Invalid wallet response');
         }
-        console.log('Wallet pregeneration response:', wallet.address);
         return wallet.address;
+    };
+    const opts = {
+        retries: 3,
+        baseDelayMs: 300,
+        maxDelayMs: 2000,
+        timeoutMs: 15000,
+        isRetryable: retry_1.isRetryableAxios,
+        onRetry: (err, attempt, delay) => {
+            console.warn(`pregenerateInAppWallet: retry #${attempt} in ${delay}ms — ${String(err?.message)}`);
+        }
+    };
+    try {
+        const address = await (0, retry_1.retry)(() => doRequest(), opts);
+        return address;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
     }
-    catch (error) {
-        console.error('Error pregenerating wallet:', error);
+    catch (err) {
+        // final failure after retries
+        console.error('pregenerateInAppWallet: final failure', {
+            message: err?.message,
+            // include axios response data when possible
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            responseData: err?.response?.data ?? err?.cause ?? err.original ?? null
+        });
         return null;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opticedge-cloud-utils",
-  "version": "1.1.8",
+  "version": "1.1.9",
   "description": "Common utilities for cloud functions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/retry.ts

@@ -1,5 +1,8 @@
 // src/retry.ts
 /* eslint-disable @typescript-eslint/no-explicit-any */
+
+import axios from 'axios'
+
 export type RetryOptions = {
   retries?: number
   baseDelayMs?: number
@@ -10,18 +13,21 @@ export type RetryOptions = {
   onRetry?: (err: any, attempt: number, nextDelayMs: number) => void
 }
 
-function sleep(ms: number, signal?: AbortSignal | null) {
+export async function sleep(ms: number, signal?: AbortSignal | null) {
   return new Promise<void>((resolve, reject) => {
     if (signal?.aborted) return reject(new Error('Aborted'))
     const t = setTimeout(() => {
-      signal?.removeEventListener('abort', onAbort)
+      signal?.removeEventListener?.('abort', onAbort)
       resolve()
     }, ms)
+
     function onAbort() {
       clearTimeout(t)
+      signal?.removeEventListener?.('abort', onAbort)
       reject(new Error('Aborted'))
     }
-    signal?.addEventListener('abort', onAbort)
+
+    signal?.addEventListener?.('abort', onAbort)
   })
 }
 
@@ -68,6 +74,26 @@ export function isRetryableDefault(err: any): boolean {
   return false
 }
 
+export function isRetryableAxios(err: any): boolean {
+  if (!err) return false
+
+  // If axios knows about it:
+  if (axios.isAxiosError(err)) {
+    // No response -> network error / timeout -> retry
+    if (!err.response) return true
+
+    const status = err.response.status
+    // retry on 429 or 5xx
+    if (status === 429 || (status >= 500 && status < 600)) return true
+
+    // 4xx client errors -> do not retry
+    return false
+  }
+
+  // Fallback to your existing heuristics (gRPC codes, node syscodes, etc.)
+  return isRetryableDefault(err)
+}
+
 export async function retry<T>(fn: () => Promise<T>, opts: RetryOptions = {}): Promise<T> {
   const retries = opts.retries ?? 4
   const base = opts.baseDelayMs ?? 200
@@ -82,8 +108,8 @@ export async function retry<T>(fn: () => Promise<T>, opts: RetryOptions = {}): P
   let attempt = 0
   let lastErr: any
 
-  /* eslint-disable no-constant-condition */
-  while (true) {
+  // attempt = number of retries already performed; initial try is attempt==0
+  while (attempt <= retries) {
     if (signal?.aborted) throw new Error('Aborted')
 
     try {
@@ -95,12 +121,11 @@ export async function retry<T>(fn: () => Promise<T>, opts: RetryOptions = {}): P
         throw err
       }
 
-      if (attempt >= retries) {
-        break
-      }
+      if (attempt >= retries) break
 
-      attempt++
-      const exp = Math.min(max, base * Math.pow(2, attempt - 1))
+      // compute next retry (1-based)
+      const nextAttempt = attempt + 1
+      const exp = Math.min(max, base * Math.pow(2, nextAttempt - 1))
       const delay = Math.floor(Math.random() * exp)
 
       if (typeof timeoutMs === 'number') {
@@ -111,13 +136,14 @@ export async function retry<T>(fn: () => Promise<T>, opts: RetryOptions = {}): P
       }
 
       try {
-        onRetry?.(err, attempt, delay)
-        /* eslint-disable @typescript-eslint/no-unused-vars */
-      } catch (e) {
-        // ignore errors from onRetry
+        // pass 1-based attempt to onRetry to mean "this is the upcoming retry number"
+        onRetry?.(err, nextAttempt, delay)
+      } catch {
+        /* ignore onRetry errors */
       }
 
       await sleep(delay, signal)
+      attempt = nextAttempt
     }
   }
 

package/src/task.ts

@@ -1,7 +1,39 @@
+// src/cloud-tasks.ts
 import { CloudTasksClient, protos } from '@google-cloud/tasks'
+import { retry, isRetryableDefault, RetryOptions } from './retry'
 
 const tasksClient = new CloudTasksClient()
 
+export type CreateTaskOpts = {
+  // optional deterministic id to make createTask idempotent
+  taskId?: string
+  retryOptions?: RetryOptions
+}
+
+// cloud-tasks errors can be gRPC-style (numeric code) or an Error with code string.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isRetryableCloudTasks(err: any): boolean {
+  if (!err) return false
+
+  // If error explicitly says ALREADY_EXISTS, do not retry (client already has the task)
+  // gRPC ALREADY_EXISTS numeric code is 6
+  if (
+    err?.code === 6 ||
+    err?.grpcCode === 6 ||
+    String(err?.code).toUpperCase().includes('ALREADY_EXISTS')
+  ) {
+    return false
+  }
+
+  // Otherwise delegate to your general retryable heuristics (network / 14=UNAVAILABLE / 5xx etc.)
+  return isRetryableDefault(err)
+}
+
+/**
+ * Create a Cloud Task with retry logic.
+ * If opts.taskId is provided, the task name will be parent + '/tasks/' + taskId — this
+ * makes the operation idempotent (create will fail with ALREADY_EXISTS if it already exists).
+ */
 export async function createTask(
   projectId: string,
   region: string,
@@ -9,7 +41,8 @@ export async function createTask(
   data: unknown,
   serviceAccount: string,
   audience: string,
-  delaySeconds: number = 0
+  delaySeconds: number = 0,
+  opts: CreateTaskOpts = {}
 ): Promise<string> {
   if (!projectId || !region || !queueId || !serviceAccount || !audience) {
     throw new Error('Missing required parameters for Cloud Tasks setup')
@@ -25,6 +58,7 @@ export async function createTask(
         }
       : undefined
 
+  // Build the base task
   const task: protos.google.cloud.tasks.v2.ITask = {
     httpRequest: {
       httpMethod: protos.google.cloud.tasks.v2.HttpMethod.POST,
@@ -41,11 +75,57 @@ export async function createTask(
     scheduleTime: scheduledTime
   }
 
-  const [response] = await tasksClient.createTask({ parent, task })
-  if (!response.name) {
-    throw new Error('Failed to create task: no name returned')
+  // Optionally set a deterministic name to make task creation idempotent.
+  // The name must be full resource path: projects/PROJECT/locations/REGION/queues/QUEUE/tasks/TASK_ID
+  if (opts.taskId) {
+    // sanitize/validate taskId if you want; Cloud Tasks requires certain name rules.
+    task.name = `${parent}/tasks/${opts.taskId}`
   }
 
-  console.log(`✅ Created Cloud Task: ${response.name}`)
-  return response.name
+  // retry options with sensible defaults; allow caller to override via opts.retryOptions
+  const retryOpts: RetryOptions = {
+    retries: 3,
+    baseDelayMs: 200,
+    maxDelayMs: 3000,
+    isRetryable: isRetryableCloudTasks,
+    onRetry: (err, attempt, delay) => {
+      console.warn(`createTask retry #${attempt} in ${delay}ms — ${String(err?.message ?? err)}`)
+    },
+    ...opts.retryOptions // allow overrides
+  }
+
+  // the unit-of-work we want to retry
+  const doCreate = async (): Promise<string> => {
+    const [response] = await tasksClient.createTask({ parent, task })
+    if (!response?.name) {
+      // unexpected response shape — treat as non-retryable final failure
+      throw new Error('Failed to create task: no name returned')
+    }
+    return response.name
+  }
+
+  try {
+    const name = await retry(() => doCreate(), retryOpts)
+    console.log(`✅ Created Cloud Task: ${name}`)
+    return name
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (err: any) {
+    // If ALREADY_EXISTS happened (and was not considered retryable), you may prefer to
+    // return the constructed task name (if provided) rather than null/throw.
+    if (opts.taskId) {
+      const expectedName = `${parent}/tasks/${opts.taskId}`
+      // If we got ALREADY_EXISTS, treat as success and return existing name
+      if (
+        err?.original?.code === 6 ||
+        err?.code === 6 ||
+        String(err?.original?.code).toUpperCase().includes('ALREADY_EXISTS')
+      ) {
+        console.warn('createTask — task already exists, returning existing name', expectedName)
+        return expectedName
+      }
+    }
+
+    console.error('createTask — final failure after retries', { error: err?.message ?? err })
+    throw err // rethrow (or return null if you prefer)
+  }
 }

package/src/tw/wallet.ts

@@ -1,5 +1,6 @@
 import axios from 'axios'
 import { getSecret } from '../secrets'
+import { isRetryableAxios, retry, RetryOptions } from '../retry'
 
 export async function pregenerateInAppWallet(
   projectId: string,
@@ -8,9 +9,13 @@ export async function pregenerateInAppWallet(
   email: string
 ): Promise<string | null> {
   const TW_SECRET_KEY = await getSecret(projectId, twSecretKeyName)
+  if (!TW_SECRET_KEY) {
+    console.error('Missing TW secret key', { projectId, twSecretKeyName })
+    return null
+  }
 
-  try {
-    const response = await axios.post(
+  const doRequest = async (): Promise<string> => {
+    const res = await axios.post(
       'https://in-app-wallet.thirdweb.com/api/v1/pregenerate',
       { strategy: 'email', email },
       {
@@ -19,20 +24,45 @@ export async function pregenerateInAppWallet(
           'x-client-id': twClientId,
           'Content-Type': 'application/json'
         },
-        timeout: 5000
+        timeout: 10000
       }
     )
 
-    const wallet = response.data.wallet
+    const wallet = res.data?.wallet
     if (!wallet || !wallet.address) {
-      console.error('Invalid wallet response:', response.data)
-      return null
+      // server returned 2xx but unexpected shape — don't retry, treat as final failure
+      console.error('Invalid wallet response shape', { status: res.status, data: res.data })
+      throw new Error('Invalid wallet response')
     }
 
-    console.log('Wallet pregeneration response:', wallet.address)
     return wallet.address
-  } catch (error) {
-    console.error('Error pregenerating wallet:', error)
+  }
+
+  const opts: RetryOptions = {
+    retries: 3,
+    baseDelayMs: 300,
+    maxDelayMs: 2000,
+    timeoutMs: 15000,
+    isRetryable: isRetryableAxios,
+    onRetry: (err, attempt, delay) => {
+      console.warn(
+        `pregenerateInAppWallet: retry #${attempt} in ${delay}ms — ${String(err?.message)}`
+      )
+    }
+  }
+
+  try {
+    const address = await retry(() => doRequest(), opts)
+    return address
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (err: any) {
+    // final failure after retries
+    console.error('pregenerateInAppWallet: final failure', {
+      message: err?.message,
+      // include axios response data when possible
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      responseData: err?.response?.data ?? err?.cause ?? (err as any).original ?? null
+    })
     return null
   }
 }

package/tests/retry.test.ts

@@ -1,6 +1,59 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // tests/retry.test.ts
-import { retry, isRetryableDefault } from '../src'
+
+import axios from 'axios'
+import { retry, isRetryableDefault, sleep, isRetryableAxios } from '../src'
+
+describe('sleep()', () => {
+  const realAbortController = global.AbortController
+
+  afterEach(() => {
+    // restore timers and AbortController if changed
+    jest.useRealTimers()
+    global.AbortController = realAbortController
+    jest.clearAllMocks()
+  })
+
+  test('resolves after the specified delay', async () => {
+    jest.useFakeTimers()
+    const p = sleep(100)
+
+    // advance timers by the sleep duration
+    jest.advanceTimersByTime(100)
+
+    // allow the Promise microtask queue to run
+    await Promise.resolve()
+
+    await expect(p).resolves.toBeUndefined()
+  })
+
+  test('rejects immediately if signal is already aborted', async () => {
+    const ac = new AbortController()
+    ac.abort()
+
+    await expect(sleep(50, ac.signal)).rejects.toThrow('Aborted')
+  })
+
+  test('rejects when aborted after scheduling', async () => {
+    jest.useFakeTimers()
+    const ac = new AbortController()
+
+    const p = sleep(1000, ac.signal)
+
+    // abort after the sleep has been scheduled but before timeout
+    ac.abort()
+
+    // allow the event-loop microtasks to run
+    await Promise.resolve()
+
+    await expect(p).rejects.toThrow('Aborted')
+
+    // advancing timers should not resolve the promise
+    jest.advanceTimersByTime(1000)
+    await Promise.resolve()
+    await expect(p).rejects.toThrow('Aborted')
+  })
+})
 
 describe('isRetryableDefault', () => {
   test('returns false for falsy errors (covers `if (!err) return false`)', () => {
@@ -53,6 +106,71 @@ describe('isRetryableDefault', () => {
   })
 })
 
+describe('isRetryableAxios()', () => {
+  // Helper to synthesize axios-like errors
+  function makeAxiosError(payload: Partial<any> = {}) {
+    // minimal axios-style error: flag + response optionally
+    const err: any = new Error(payload.message ?? 'axios-err')
+    err.isAxiosError = true
+    if (Object.prototype.hasOwnProperty.call(payload, 'response')) {
+      err.response = payload.response
+    } else if (payload.response === undefined && payload.noResponse) {
+      // explicit network/no-response: leave out response
+    }
+    if (payload.code) err.code = payload.code
+    if (payload.message) err.message = payload.message
+    return err
+  }
+
+  test('returns false when err is falsy', () => {
+    expect(isRetryableAxios(null)).toBe(false)
+    expect(isRetryableAxios(undefined)).toBe(false)
+    // also check other falsy-ish values that shouldn't be considered retryable
+    expect(isRetryableAxios(false as any)).toBe(false)
+    expect(isRetryableAxios('' as any)).toBe(false)
+  })
+
+  test('returns true for network/no-response axios errors', () => {
+    const networkErr = makeAxiosError({ noResponse: true })
+    expect(axios.isAxiosError(networkErr)).toBe(true) // sanity check
+    expect(isRetryableAxios(networkErr)).toBe(true)
+  })
+
+  test('returns true for 500 server error', () => {
+    const serverErr = makeAxiosError({ response: { status: 500, data: {} } })
+    expect(isRetryableAxios(serverErr)).toBe(true)
+  })
+
+  test('returns true for 503 server error', () => {
+    const serverErr = makeAxiosError({ response: { status: 503, data: {} } })
+    expect(isRetryableAxios(serverErr)).toBe(true)
+  })
+
+  test('returns true for 429 rate limit', () => {
+    const rateErr = makeAxiosError({ response: { status: 429, data: {} } })
+    expect(isRetryableAxios(rateErr)).toBe(true)
+  })
+
+  test('returns false for 400 client error (do not retry)', () => {
+    const badReq = makeAxiosError({ response: { status: 400, data: {} } })
+    expect(isRetryableAxios(badReq)).toBe(false)
+  })
+
+  test('delegates to isRetryableDefault for non-axios errors', () => {
+    // make a network-style Node error that isRetryableDefault recognizes
+    const nodeErr = { code: 'ECONNRESET', message: 'socket closed' }
+    expect(isRetryableDefault(nodeErr)).toBe(true) // sanity
+    expect(isRetryableAxios(nodeErr)).toBe(true)
+  })
+
+  test('returns false for non-retryable non-axios error', () => {
+    const normalErr = new Error('something bad but not retryable')
+    // isRetryableDefault likely returns false for a plain Error w/o hint
+    expect(isRetryableDefault(normalErr)).toBe(false)
+    expect(isRetryableAxios(normalErr)).toBe(false)
+  })
+})
+
 describe('retry util', () => {
   afterEach(() => {
     jest.restoreAllMocks()

package/tests/task.test.ts

@@ -1,8 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// tests/createTask.retry.test.ts
 const mockCreateTask = jest.fn()
 const mockQueuePath = jest.fn(
-  (projectId, region, queueId) => `projects/${projectId}/locations/${region}/queues/${queueId}`
+  (projectId: string, region: string, queueId: string) =>
+    `projects/${projectId}/locations/${region}/queues/${queueId}`
 )
 
+// Mock Cloud Tasks client and protos (same as your original file)
 jest.mock('@google-cloud/tasks', () => {
   return {
     CloudTasksClient: jest.fn(() => ({
@@ -25,87 +29,161 @@ jest.mock('@google-cloud/tasks', () => {
   }
 })
 
-import { createTask } from '../src/task'
+// Mock the retry module so tests can inspect how createTask uses it.
+// We'll set mockRetry behavior in each test as needed.
+const realRetryModule = jest.requireActual('../src/retry') as typeof import('../src/retry')
+const mockRetry = jest.fn()
+
+jest.mock('../src/retry', () => ({
+  // spread real exports so isRetryableDefault, isRetryableAxios etc remain available
+  ...realRetryModule,
+  // override only 'retry' with our mock
+  retry: (...args: any[]) => mockRetry(...args)
+}))
+
+import { createTask, isRetryableCloudTasks } from '../src/task'
+
+describe('isRetryableCloudTasks', () => {
+  test('returns false for falsy errors', () => {
+    expect(isRetryableCloudTasks(null)).toBe(false)
+    expect(isRetryableCloudTasks(undefined)).toBe(false)
+    // other falsy-ish values should also be non-retryable
+    expect(isRetryableCloudTasks(false as any)).toBe(false)
+    expect(isRetryableCloudTasks('' as any)).toBe(false)
+  })
+
+  test('treats ALREADY_EXISTS (code: 6) as NOT retryable', () => {
+    expect(isRetryableCloudTasks({ code: 6 })).toBe(false)
+    expect(isRetryableCloudTasks({ grpcCode: 6 })).toBe(false)
+    expect(isRetryableCloudTasks({ code: 'ALREADY_EXISTS' })).toBe(false)
+    expect(isRetryableCloudTasks({ code: 'already_exists' })).toBe(false)
+  })
+
+  test('treats UNAVAILABLE (code: 14) as retryable', () => {
+    expect(isRetryableCloudTasks({ code: 14 })).toBe(true)
+    expect(isRetryableCloudTasks({ grpcCode: 14 })).toBe(true)
+  })
+
+  test('treats HTTP 5xx and 429 as retryable, 4xx not retryable', () => {
+    expect(isRetryableCloudTasks({ response: { status: 500 } })).toBe(true)
+    expect(isRetryableCloudTasks({ response: { status: 503 } })).toBe(true)
+    expect(isRetryableCloudTasks({ response: { status: 429 } })).toBe(true)
+
+    expect(isRetryableCloudTasks({ response: { status: 400 } })).toBe(false)
+    expect(isRetryableCloudTasks({ response: { status: 404 } })).toBe(false)
+  })
+
+  test('treats node network errno like ECONNRESET as retryable (delegated to isRetryableDefault)', () => {
+    // isRetryableDefault recognizes typical node syscodes like 'ECONNRESET'
+    expect(isRetryableCloudTasks({ code: 'ECONNRESET' })).toBe(true)
+    expect(isRetryableCloudTasks({ code: 'ETIMEDOUT' })).toBe(true)
+    expect(isRetryableCloudTasks({ code: 'EAI_AGAIN' })).toBe(true)
+  })
+
+  test('plain Error without hints is not retryable', () => {
+    expect(isRetryableCloudTasks(new Error('oops'))).toBe(false)
+  })
+
+  test('non-standard objects without response but with message may or may not be retryable depending on heuristics', () => {
+    // This test documents the expected behavior: a message-only error generally is NOT retryable
+    // unless the message contains a retryable substring (e.g. "timeout" or "unavailable").
+    expect(isRetryableCloudTasks({ message: 'socket closed' })).toBe(false)
+    expect(isRetryableCloudTasks({ message: 'request timed out' })).toBe(true)
+    expect(isRetryableCloudTasks({ message: 'temporarily unavailable' })).toBe(true)
+  })
+})
+
+describe('createTask (with retry)', () => {
+  const projectId = 'test-project'
+  const region = 'us-central1'
+  const queueId = 'test-queue'
+  const data = { test: 'data' }
+  const serviceAccount = 'test-sa@test.iam.gserviceaccount.com'
+  const audience = 'https://run-url'
+  const mockTaskName =
+    'projects/test-project/locations/us-central1/queues/test-queue/tasks/task-123'
+
+  let warnSpy: jest.SpyInstance
 
-describe('createTask', () => {
   beforeEach(() => {
     mockCreateTask.mockReset()
+    mockQueuePath.mockClear()
+    mockRetry.mockReset()
+    // store the spy instance so we can assert against it safely
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
   })
 
   it('throws error if any required parameter is missing', async () => {
-    // Missing projectId
+    // Ensure retry / createTask are not called for parameter validation errors
     await expect(
       createTask('', 'region', 'queue', {}, 'serviceAccount', 'audience')
     ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
 
-    // Missing region
     await expect(
       createTask('project', '', 'queue', {}, 'serviceAccount', 'audience')
     ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
 
-    // Missing queueId
     await expect(
       createTask('project', 'region', '', {}, 'serviceAccount', 'audience')
     ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
 
-    // Missing serviceAccount
     await expect(createTask('project', 'region', 'queue', {}, '', 'audience')).rejects.toThrow(
       'Missing required parameters for Cloud Tasks setup'
     )
 
-    // Missing audience
     await expect(
       createTask('project', 'region', 'queue', {}, 'serviceAccount', '')
     ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
+
+    expect(mockCreateTask).not.toHaveBeenCalled()
+    expect(mockRetry).not.toHaveBeenCalled()
   })
 
-  it('should create a task and return task name', async () => {
-    const mockTaskName =
-      'projects/test-project/locations/us-central1/queues/test-queue/tasks/task-123'
+  it('should create a task and return task name (calls retry once)', async () => {
+    // Configure retry mock to simply execute the provided function immediately.
+    mockRetry.mockImplementation(async (fn: () => any) => {
+      return await fn()
+    })
+
     mockCreateTask.mockResolvedValue([{ name: mockTaskName }])
 
-    const result = await createTask(
-      'test-project',
-      'us-central1',
-      'test-queue',
-      { test: 'data' },
-      'test-sa@test.iam.gserviceaccount.com',
-      'https://run-url'
-    )
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
 
     expect(result).toBe(mockTaskName)
     expect(mockCreateTask).toHaveBeenCalledTimes(1)
+    expect(mockRetry).toHaveBeenCalledTimes(1)
+    // ensure the createTask was called with an object containing `task`
+    const calledArg = mockCreateTask.mock.calls[0][0]
+    expect(calledArg).toHaveProperty('task')
   })
 
   it('should throw error if task name is missing', async () => {
+    mockRetry.mockImplementation(async (fn: () => any) => {
+      return await fn()
+    })
     mockCreateTask.mockResolvedValue([{}]) // Simulate missing name
 
     await expect(
-      createTask(
-        'test-project',
-        'us-central1',
-        'test-queue',
-        { foo: 'bar' },
-        'test@project.iam.gserviceaccount.com',
-        'https://example.com'
-      )
+      createTask(projectId, region, queueId, { foo: 'bar' }, serviceAccount, audience)
     ).rejects.toThrow('Failed to create task: no name returned')
   })
 
   it('should include scheduleTime if delaySeconds is set', async () => {
-    const mockTaskName = 'projects/test/locations/us-central1/queues/test/tasks/task-456'
-    mockCreateTask.mockResolvedValue([{ name: mockTaskName }])
+    mockRetry.mockImplementation(async (fn: () => any) => await fn())
+    mockCreateTask.mockResolvedValue([
+      { name: 'projects/test/locations/us-central1/queues/test/tasks/task-456' }
+    ])
 
     const delaySeconds = 120
     const before = Math.floor(Date.now() / 1000) + delaySeconds
 
     await createTask(
-      'test',
-      'us-central1',
-      'test',
+      projectId,
+      region,
+      queueId,
       { message: 'delayed' },
-      'sa@test.iam.gserviceaccount.com',
-      'https://run-url',
+      serviceAccount,
+      audience,
       delaySeconds
     )
 
@@ -118,4 +196,142 @@ describe('createTask', () => {
     expect(scheduleTime).toBeGreaterThanOrEqual(before)
     expect(scheduleTime).toBeLessThanOrEqual(after)
   })
+
+  it('retries on transient (UNAVAILABLE) error then succeeds', async () => {
+    // Simulate createTask: first call rejects with transient code 14, second call resolves.
+    mockCreateTask
+      .mockRejectedValueOnce({ code: 14, message: 'UNAVAILABLE' })
+      .mockResolvedValueOnce([{ name: mockTaskName }])
+
+    // Implement a small retry simulator: call fn(); if it throws then call opts.onRetry and call fn() again.
+    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
+      try {
+        return await fn()
+      } catch (err) {
+        // simulate onRetry callback being invoked by retry implementation
+        if (opts?.onRetry) {
+          try {
+            opts.onRetry(err, 1, 0)
+          } catch {
+            // ignore
+          }
+        }
+        return await fn()
+      }
+    })
+
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
+
+    expect(mockCreateTask).toHaveBeenCalledTimes(2)
+    expect(mockRetry).toHaveBeenCalledTimes(1)
+    expect(result).toBe(mockTaskName)
+  })
+
+  it('returns expected name if ALREADY_EXISTS and taskId provided (idempotent)', async () => {
+    // Simulate retry throwing ALREADY_EXISTS error (code: 6)
+    mockRetry.mockImplementation(async () => {
+      throw { code: 6, message: 'ALREADY_EXISTS' }
+    })
+
+    const taskId = 'task-123'
+    const expectedName = `projects/${projectId}/locations/${region}/queues/${queueId}/tasks/${taskId}`
+
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience, 0, {
+      taskId
+    })
+
+    // Should return expected name when ALREADY_EXISTS and taskId provided
+    expect(result).toBe(expectedName)
+    expect(mockRetry).toHaveBeenCalledTimes(1)
+  })
+
+  it('passes an isRetryable to retry that treats ALREADY_EXISTS as non-retryable and UNAVAILABLE as retryable', async () => {
+    // Spy on the options passed to retry and invoke isRetryable with sample errors
+    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
+      // Sanity: opts should exist and include isRetryable
+      expect(opts).toBeDefined()
+      expect(typeof opts.isRetryable).toBe('function')
+
+      const isRetryable = opts.isRetryable
+
+      // ALREADY_EXISTS (gRPC code 6) should NOT be retryable
+      expect(isRetryable({ code: 6 })).toBe(false)
+      // UNAVAILABLE (gRPC code 14) should be retryable
+      expect(isRetryable({ code: 14 })).toBe(true)
+
+      expect(isRetryable({ code: 'ECONNRESET' })).toBe(true)
+
+      // Execute the function normally for this test
+      return await fn()
+    })
+
+    mockCreateTask.mockResolvedValue([{ name: mockTaskName }])
+
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
+    expect(result).toBe(mockTaskName)
+    expect(mockRetry).toHaveBeenCalledTimes(1)
+  })
+
+  it('invokes onRetry with actual error message and logs it', async () => {
+    // first call fails with a retryable transient error, second call succeeds
+    const expectedName = `projects/${projectId}/locations/${region}/queues/${queueId}/tasks/1`
+    mockCreateTask
+      .mockRejectedValueOnce({ code: 14, message: 'UNAVAILABLE' }) // transient
+      .mockResolvedValueOnce([{ name: expectedName }])
+
+    // Simulate retry behaviour: call fn(); if it throws, call onRetry(err, attempt, delay) then try fn() again.
+    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
+      try {
+        return await fn()
+      } catch (err) {
+        if (opts?.onRetry) {
+          opts.onRetry(err, 1, 0)
+        }
+        return await fn()
+      }
+    })
+
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
+    expect(result).toBe(expectedName)
+    expect(mockCreateTask).toHaveBeenCalledTimes(2)
+
+    // assert onRetry logged the attempt and included the error message
+    expect(warnSpy.mock.calls.length).toBeGreaterThanOrEqual(1)
+    const warnMsg = warnSpy.mock.calls[0][0] as string
+    expect(warnMsg).toContain('createTask retry #1 in 0ms')
+    expect(warnMsg).toContain('UNAVAILABLE')
+  })
+
+  it('invokes onRetry with undefined error and logs "undefined" in message', async () => {
+    const expectedName = `projects/${projectId}/locations/${region}/queues/${queueId}/tasks/2`
+    mockCreateTask
+      .mockRejectedValueOnce(new Error('boom')) // this will trigger catch in our mockRetry
+      .mockResolvedValueOnce([{ name: expectedName }])
+
+    // This variant calls onRetry(undefined, ...) to exercise the err?.message ?? err branch.
+    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
+      try {
+        return await fn()
+      } catch {
+        if (opts?.onRetry) {
+          opts.onRetry(undefined, 1, 0) // pass undefined as the error
+        }
+        return await fn()
+      }
+    })
+
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
+    expect(result).toBe(expectedName)
+    expect(mockCreateTask).toHaveBeenCalledTimes(2)
+
+    // Assert the onRetry prefix was logged
+    expect(warnSpy.mock.calls.length).toBeGreaterThanOrEqual(1)
+    const warnMsg = warnSpy.mock.calls[0][0] as string
+    expect(warnMsg).toContain('createTask retry #1 in 0ms')
+
+    // instead of requiring the exact 'undefined' substring (which can vary),
+    // assert there's something logged in the error slot (non-empty)
+    const afterPrefix = warnMsg.replace('createTask retry #1 in 0ms — ', '')
+    expect(afterPrefix.length).toBeGreaterThan(0)
+  })
 })

package/tests/tw/wallet.test.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// tests/wallet.test.ts  (or append to your existing test file)
 import axios from 'axios'
 import { pregenerateInAppWallet } from '../../src/tw/wallet'
 import * as secrets from '../../src/secrets'
@@ -8,7 +10,27 @@ jest.mock('../../src/secrets')
 const mockedAxios = axios as jest.Mocked<typeof axios>
 const mockedGetSecret = secrets.getSecret as jest.Mock
 
-describe('pregenerateInAppWallet', () => {
+const makeSuccessResponse = (data: any) => ({ data, status: 200 })
+
+// small helper to synthesize axios-like errors
+function makeAxiosError(message: string, status?: number, noResponse = false) {
+  const err: any = new Error(message)
+  err.isAxiosError = true
+  if (!noResponse) {
+    if (typeof status === 'number') {
+      err.response = { status, data: { message: `mocked ${status}` } }
+    } else {
+      // no numeric status provided but simulate a response
+      err.response = { status: 500, data: { message: 'mock' } }
+    }
+  } else {
+    // explicitly simulate network error: no response property
+    delete err.response
+  }
+  return err
+}
+
+describe('pregenerateInAppWallet with retry behavior', () => {
   const mockProjectId = 'test-project'
   const mockClientId = 'test-client-id'
   const mockSecretKeyName = 'test-key'
@@ -16,19 +38,66 @@ describe('pregenerateInAppWallet', () => {
   const mockWalletAddress = '0xabc123'
   const mockSecretValue = 'mock-secret-key'
 
+  const realMathRandom = Math.random
+  const realWarn = console.warn
+  const realError = console.error
+
   beforeEach(() => {
     jest.clearAllMocks()
+    // make retry jitter deterministic (so delay becomes 0)
+    Math.random = jest.fn(() => 0)
+
+    jest
+      .spyOn(axios, 'isAxiosError')
+      .mockImplementation((e: any) => Boolean(e && e.isAxiosError) as any)
+    // silence console.warn/error in passing tests (but still allow spying)
+    console.warn = jest.fn()
+    console.error = jest.fn()
   })
 
-  it('returns wallet address on success', async () => {
+  afterEach(() => {
+    // restore
+    Math.random = realMathRandom
+    console.warn = realWarn
+    console.error = realError
+  })
+
+  it('returns null and logs if secret is missing', async () => {
+    // simulate secret manager returning nothing
+    mockedGetSecret.mockResolvedValueOnce(undefined)
+
+    const result = await pregenerateInAppWallet(
+      mockProjectId,
+      mockClientId,
+      mockSecretKeyName,
+      mockEmail
+    )
+
+    // should not call axios at all
+    expect(mockedAxios.post).not.toHaveBeenCalled()
+    expect(result).toBeNull()
+
+    // console.error should be called with "Missing TW secret key"
+    expect((console.error as jest.Mock).mock.calls.length).toBeGreaterThanOrEqual(1)
+    expect((console.error as jest.Mock).mock.calls[0][0]).toEqual('Missing TW secret key')
+    // second arg should contain the projectId and secretName
+    expect((console.error as jest.Mock).mock.calls[0][1]).toEqual(
+      expect.objectContaining({ projectId: mockProjectId, twSecretKeyName: mockSecretKeyName })
+    )
+  })
+
+  it('retries on 500 then succeeds and returns address', async () => {
     mockedGetSecret.mockResolvedValue(mockSecretValue)
-    mockedAxios.post.mockResolvedValue({
-      data: {
-        wallet: {
-          address: mockWalletAddress
+
+    // first call: server 500 -> rejected
+    mockedAxios.post
+      .mockRejectedValueOnce(makeAxiosError('server error', 500))
+      // second call: success
+      .mockResolvedValueOnce({
+        data: {
+          wallet: { address: mockWalletAddress }
         }
-      }
-    })
+      } as any)
 
     const result = await pregenerateInAppWallet(
       mockProjectId,
@@ -38,29 +107,55 @@ describe('pregenerateInAppWallet', () => {
     )
 
     expect(mockedGetSecret).toHaveBeenCalledWith(mockProjectId, mockSecretKeyName)
-    expect(mockedAxios.post).toHaveBeenCalledWith(
-      'https://in-app-wallet.thirdweb.com/api/v1/pregenerate',
-      { strategy: 'email', email: mockEmail },
-      {
-        headers: {
-          'x-secret-key': mockSecretValue,
-          'x-client-id': mockClientId,
-          'Content-Type': 'application/json'
-        },
-        timeout: 5000
-      }
+    expect(mockedAxios.post).toHaveBeenCalledTimes(2)
+    expect(result).toBe(mockWalletAddress)
+    // onRetry should have been called (we log via console.warn in our version)
+    expect((console.warn as jest.Mock).mock.calls.length).toBeGreaterThanOrEqual(1)
+  })
+
+  it('does NOT retry on 400 and returns null immediately', async () => {
+    mockedGetSecret.mockResolvedValue(mockSecretValue)
+    mockedAxios.post.mockRejectedValue(makeAxiosError('bad request', 400))
+
+    const result = await pregenerateInAppWallet(
+      mockProjectId,
+      mockClientId,
+      mockSecretKeyName,
+      mockEmail
     )
 
+    expect(mockedAxios.post).toHaveBeenCalledTimes(1)
+    expect(result).toBeNull()
+    // console.warn should not indicate retry
+    expect((console.warn as jest.Mock).mock.calls.length).toBe(0)
+  })
+
+  it('retries on network/no-response errors and then succeeds', async () => {
+    mockedGetSecret.mockResolvedValue(mockSecretValue)
+
+    // First: network error (no response)
+    mockedAxios.post
+      .mockRejectedValueOnce(makeAxiosError('network down', undefined, true))
+      .mockResolvedValueOnce({
+        data: { wallet: { address: mockWalletAddress } }
+      } as any)
+
+    const result = await pregenerateInAppWallet(
+      mockProjectId,
+      mockClientId,
+      mockSecretKeyName,
+      mockEmail
+    )
+
+    expect(mockedAxios.post).toHaveBeenCalledTimes(2)
     expect(result).toBe(mockWalletAddress)
   })
 
-  it('returns null if wallet.address is missing', async () => {
+  it('exhausts retries on repeated 500s and returns null', async () => {
     mockedGetSecret.mockResolvedValue(mockSecretValue)
-    mockedAxios.post.mockResolvedValue({
-      data: {
-        wallet: {} // Missing address
-      }
-    })
+
+    // Always 500 errors
+    mockedAxios.post.mockRejectedValue(makeAxiosError('server error', 500))
 
     const result = await pregenerateInAppWallet(
       mockProjectId,
@@ -69,12 +164,19 @@ describe('pregenerateInAppWallet', () => {
       mockEmail
     )
 
+    // retry attempts are implementation-dependent (your retry opts). We assert >1 calls
+    expect(mockedAxios.post.mock.calls.length).toBeGreaterThanOrEqual(1)
+    // final result should be null when retries exhausted
     expect(result).toBeNull()
+    // error should have been logged
+    expect((console.error as jest.Mock).mock.calls.length).toBeGreaterThanOrEqual(1)
   })
 
-  it('returns null on axios error', async () => {
-    mockedGetSecret.mockResolvedValue(mockSecretValue)
-    mockedAxios.post.mockRejectedValue(new Error('Network error'))
+  it('logs invalid wallet shape and returns null when wallet.address is missing (2xx response)', async () => {
+    mockedGetSecret.mockResolvedValueOnce(mockSecretValue)
+
+    // Simulate a 200 response that has wallet but no address
+    mockedAxios.post.mockResolvedValueOnce(makeSuccessResponse({ wallet: {} }))
 
     const result = await pregenerateInAppWallet(
       mockProjectId,
@@ -83,6 +185,22 @@ describe('pregenerateInAppWallet', () => {
       mockEmail
     )
 
+    // axios was called once, but the function returns null (final failure)
+    expect(mockedAxios.post).toHaveBeenCalledTimes(1)
     expect(result).toBeNull()
+
+    // console.error should be called with the shape error message
+    expect((console.error as jest.Mock).mock.calls.length).toBeGreaterThanOrEqual(1)
+
+    // the first arg of the logged call should be the string we log in the implementation
+    // (adjust if your message differs)
+    const firstArg = (console.error as jest.Mock).mock.calls[0][0]
+    expect(firstArg).toEqual(
+      'Invalid wallet response shape' /* or 'Invalid wallet response shape' */
+    )
+
+    // the second arg should contain status and data info
+    const secondArg = (console.error as jest.Mock).mock.calls[0][1]
+    expect(secondArg).toEqual(expect.objectContaining({ status: 200, data: { wallet: {} } }))
   })
 })