opticedge-cloud-utils 1.1.14 → 1.1.16

package/.eslintignore

@@ -1,2 +1,2 @@
-# Ignore compiled output
-dist/
+# Ignore compiled output
+dist/

package/.prettierignore

@@ -1,4 +1,4 @@
-node_modules
-dist
-build
-coverage
+node_modules
+dist
+build
+coverage

package/dist/tw/wallet.d.ts

@@ -1 +1 @@
-export declare function pregenerateInAppWallet(projectId: string, twClientId: string, twSecretKeyName: string, email: string): Promise<string | null>;
+export declare function pregenerateInAppWallet(twClientId: string, twSecretKey: string, email: string): Promise<string | null>;

package/dist/tw/wallet.js

@@ -4,21 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pregenerateInAppWallet = pregenerateInAppWallet;
+// src/tw/wallet.ts
 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);
-    if (!TW_SECRET_KEY) {
-        console.error('Missing TW secret key', { projectId, twSecretKeyName });
+async function pregenerateInAppWallet(twClientId, twSecretKey, email) {
+    if (!twClientId || !twSecretKey || !email) {
+        console.error('Missing client id or secret or email');
         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,
+                'Content-Type': 'application/json',
                 'x-client-id': twClientId,
-                'Content-Type': 'application/json'
+                'x-secret-key': twSecretKey
             },
             timeout: 10000
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opticedge-cloud-utils",
-  "version": "1.1.14",
+  "version": "1.1.16",
   "description": "Common utilities for cloud functions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,7 +20,7 @@
     "@google-cloud/tasks": "^6.1.0",
     "axios": "^1.10.0",
     "google-auth-library": "^9.15.1",
-    "mongodb": "^6.16.0"
+    "mongodb": "^7.0.0"
   },
   "devDependencies": {
     "@google-cloud/functions-framework": "^4.0.0",

package/src/tw/wallet.ts

@@ -1,16 +1,14 @@
+// src/tw/wallet.ts
 import axios from 'axios'
-import { getSecret } from '../secrets'
 import { isRetryableAxios, retry, RetryOptions } from '../retry'
 
 export async function pregenerateInAppWallet(
-  projectId: string,
   twClientId: string,
-  twSecretKeyName: string,
+  twSecretKey: string,
   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 })
+  if (!twClientId || !twSecretKey || !email) {
+    console.error('Missing client id or secret or email')
     return null
   }
 
@@ -20,9 +18,9 @@ export async function pregenerateInAppWallet(
       { strategy: 'email', email },
       {
         headers: {
-          'x-secret-key': TW_SECRET_KEY,
+          'Content-Type': 'application/json',
           'x-client-id': twClientId,
-          'Content-Type': 'application/json'
+          'x-secret-key': twSecretKey
         },
         timeout: 10000
       }

package/tests/tw/wallet.test.ts

@@ -1,42 +1,35 @@
+// tests/tw/wallet.test.ts
 /* 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'
 
 jest.mock('axios')
-jest.mock('../../src/secrets')
-
 const mockedAxios = axios as jest.Mocked<typeof axios>
-const mockedGetSecret = secrets.getSecret as jest.Mock
-
-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' } }
+    err.response = {
+      status: typeof status === 'number' ? status : 500,
+      data: { message: `mocked ${status ?? 500}` }
     }
   } else {
-    // explicitly simulate network error: no response property
+    // simulate network error (no response)
     delete err.response
   }
   return err
 }
 
-describe('pregenerateInAppWallet with retry behavior', () => {
-  const mockProjectId = 'test-project'
+function makeSuccessResponse(data: any) {
+  return { data, status: 200 }
+}
+
+describe('pregenerateInAppWallet (current signature)', () => {
   const mockClientId = 'test-client-id'
-  const mockSecretKeyName = 'test-key'
+  const mockSecretKey = 'test-secret-key'
   const mockEmail = 'user@example.com'
   const mockWalletAddress = '0xabc123'
-  const mockSecretValue = 'mock-secret-key'
 
   const realMathRandom = Math.random
   const realWarn = console.warn
@@ -44,162 +37,93 @@ describe('pregenerateInAppWallet with retry behavior', () => {
 
   beforeEach(() => {
     jest.clearAllMocks()
-    // make retry jitter deterministic (so delay becomes 0)
+    // make retry jitter deterministic (so delays don't interfere)
     Math.random = jest.fn(() => 0)
 
+    // axios.isAxiosError helper
     jest
       .spyOn(axios, 'isAxiosError')
       .mockImplementation((e: any) => Boolean(e && e.isAxiosError) as any)
-    // silence console.warn/error in passing tests (but still allow spying)
+
+    // silence logs during tests but keep spies
     console.warn = jest.fn()
     console.error = jest.fn()
   })
 
   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
+  it('returns null and logs if params missing', async () => {
+    const res = await pregenerateInAppWallet('', mockSecretKey, mockEmail)
     expect(mockedAxios.post).not.toHaveBeenCalled()
-    expect(result).toBeNull()
-
-    // console.error should be called with "Missing TW secret key"
+    expect(res).toBeNull()
     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 })
+    expect((console.error as jest.Mock).mock.calls[0][0]).toEqual(
+      'Missing client id or secret or email'
     )
   })
 
   it('retries on 500 then succeeds and returns address', async () => {
-    mockedGetSecret.mockResolvedValue(mockSecretValue)
-
-    // first call: server 500 -> rejected
+    // first: 500, then success
     mockedAxios.post
       .mockRejectedValueOnce(makeAxiosError('server error', 500))
-      // second call: success
-      .mockResolvedValueOnce({
-        data: {
-          wallet: { address: mockWalletAddress }
-        }
-      } as any)
-
-    const result = await pregenerateInAppWallet(
-      mockProjectId,
-      mockClientId,
-      mockSecretKeyName,
-      mockEmail
-    )
+      .mockResolvedValueOnce({ data: { wallet: { address: mockWalletAddress } } } as any)
+
+    const result = await pregenerateInAppWallet(mockClientId, mockSecretKey, mockEmail)
 
-    expect(mockedGetSecret).toHaveBeenCalledWith(mockProjectId, mockSecretKeyName)
     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
-    )
+    const result = await pregenerateInAppWallet(mockClientId, mockSecretKey, mockEmail)
 
     expect(mockedAxios.post).toHaveBeenCalledTimes(1)
     expect(result).toBeNull()
-    // console.warn should not indicate retry
+    // no retry log
     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
-    )
+      .mockResolvedValueOnce({ data: { wallet: { address: mockWalletAddress } } } as any)
+
+    const result = await pregenerateInAppWallet(mockClientId, mockSecretKey, mockEmail)
 
     expect(mockedAxios.post).toHaveBeenCalledTimes(2)
     expect(result).toBe(mockWalletAddress)
   })
 
   it('exhausts retries on repeated 500s and returns null', async () => {
-    mockedGetSecret.mockResolvedValue(mockSecretValue)
-
-    // Always 500 errors
     mockedAxios.post.mockRejectedValue(makeAxiosError('server error', 500))
 
-    const result = await pregenerateInAppWallet(
-      mockProjectId,
-      mockClientId,
-      mockSecretKeyName,
-      mockEmail
-    )
+    const result = await pregenerateInAppWallet(mockClientId, mockSecretKey, mockEmail)
 
-    // retry attempts are implementation-dependent (your retry opts). We assert >1 calls
+    // retry behavior is implementation-dependent; assert at least one call and final null
     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('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
+  it('logs invalid wallet shape and returns null when wallet.address missing (2xx response)', async () => {
     mockedAxios.post.mockResolvedValueOnce(makeSuccessResponse({ wallet: {} }))
 
-    const result = await pregenerateInAppWallet(
-      mockProjectId,
-      mockClientId,
-      mockSecretKeyName,
-      mockEmail
-    )
+    const result = await pregenerateInAppWallet(mockClientId, mockSecretKey, 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
+    // ensure we logged the invalid shape (the implementation logs then throws)
     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
+    expect(firstArg).toEqual('Invalid wallet response shape')
     const secondArg = (console.error as jest.Mock).mock.calls[0][1]
     expect(secondArg).toEqual(expect.objectContaining({ status: 200, data: { wallet: {} } }))
   })