opticedge-cloud-utils 1.1.13 → 1.1.15

package/tests/tw/utils.test.ts

@@ -1,29 +1,29 @@
-import { isValidWebhookSignature } from '../../src/tw/utils'
-import crypto from 'crypto'
-
-describe('isValidWebhookSignature', () => {
-  const secret = 'test_secret'
-  const body = '{"message":"hello"}'
-
-  it('returns true for a valid signature', () => {
-    const validSignature = crypto.createHmac('sha256', secret).update(body).digest('hex')
-
-    expect(isValidWebhookSignature(secret, body, validSignature)).toBe(true)
-  })
-
-  it('returns false for an invalid signature', () => {
-    const invalidSignature = 'invalidsignature123'
-
-    expect(isValidWebhookSignature(secret, body, invalidSignature)).toBe(false)
-  })
-
-  it('returns false if body or secret is tampered', () => {
-    const originalSignature = crypto.createHmac('sha256', secret).update(body).digest('hex')
-
-    // wrong body
-    expect(isValidWebhookSignature(secret, '{"message":"tampered"}', originalSignature)).toBe(false)
-
-    // wrong secret
-    expect(isValidWebhookSignature('wrong_secret', body, originalSignature)).toBe(false)
-  })
-})
+import { isValidWebhookSignature } from '../../src/tw/utils'
+import crypto from 'crypto'
+
+describe('isValidWebhookSignature', () => {
+  const secret = 'test_secret'
+  const body = '{"message":"hello"}'
+
+  it('returns true for a valid signature', () => {
+    const validSignature = crypto.createHmac('sha256', secret).update(body).digest('hex')
+
+    expect(isValidWebhookSignature(secret, body, validSignature)).toBe(true)
+  })
+
+  it('returns false for an invalid signature', () => {
+    const invalidSignature = 'invalidsignature123'
+
+    expect(isValidWebhookSignature(secret, body, invalidSignature)).toBe(false)
+  })
+
+  it('returns false if body or secret is tampered', () => {
+    const originalSignature = crypto.createHmac('sha256', secret).update(body).digest('hex')
+
+    // wrong body
+    expect(isValidWebhookSignature(secret, '{"message":"tampered"}', originalSignature)).toBe(false)
+
+    // wrong secret
+    expect(isValidWebhookSignature('wrong_secret', body, originalSignature)).toBe(false)
+  })
+})

package/tests/tw/wallet.test.ts

@@ -1,206 +1,206 @@
-/* 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' } }
-    }
-  } 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'
-  const mockEmail = 'user@example.com'
-  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()
-  })
-
-  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)
-
-    // 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,
-      mockClientId,
-      mockSecretKeyName,
-      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
-    )
-
-    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('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
-    )
-
-    // 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('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,
-      mockClientId,
-      mockSecretKeyName,
-      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: {} } }))
-  })
-})
+/* 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' } }
+    }
+  } 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'
+  const mockEmail = 'user@example.com'
+  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()
+  })
+
+  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)
+
+    // 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,
+      mockClientId,
+      mockSecretKeyName,
+      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
+    )
+
+    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('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
+    )
+
+    // 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('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,
+      mockClientId,
+      mockSecretKeyName,
+      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: {} } }))
+  })
+})

package/tests/validator.ts

@@ -1,37 +1,37 @@
-// isValidEmail.test.ts
-import { describe, it, expect } from '@jest/globals'
-import { isValidEmail } from '../src'
-
-describe('isValidEmail', () => {
-  it('returns true for simple valid emails', () => {
-    expect(isValidEmail('test@example.com')).toBe(true)
-    expect(isValidEmail('user.name@domain.co')).toBe(true)
-    expect(isValidEmail('user_name+tag@sub.domain.org')).toBe(true)
-  })
-
-  it('returns false for missing parts', () => {
-    expect(isValidEmail('')).toBe(false)
-    expect(isValidEmail('plainaddress')).toBe(false)
-    expect(isValidEmail('@no-local-part.com')).toBe(false)
-    expect(isValidEmail('username@')).toBe(false)
-    expect(isValidEmail('user@domain')).toBe(false)
-    expect(isValidEmail('username@.com')).toBe(false)
-  })
-
-  it('handles whitespace correctly', () => {
-    expect(isValidEmail('   test@example.com   ')).toBe(true) // trims input
-    expect(isValidEmail('\nuser@domain.com\t')).toBe(true)
-  })
-
-  it('rejects invalid characters or formats', () => {
-    expect(isValidEmail('user@@domain.com')).toBe(false)
-    expect(isValidEmail('user@domain,com')).toBe(false)
-    expect(isValidEmail('user@domain..com')).toBe(false)
-    expect(isValidEmail('user@.domain.com')).toBe(false)
-    expect(isValidEmail('user@domain com')).toBe(false)
-  })
-
-  it('accepts minimal valid domain structures', () => {
-    expect(isValidEmail('x@y.z')).toBe(true) // still valid
-  })
-})
+// isValidEmail.test.ts
+import { describe, it, expect } from '@jest/globals'
+import { isValidEmail } from '../src'
+
+describe('isValidEmail', () => {
+  it('returns true for simple valid emails', () => {
+    expect(isValidEmail('test@example.com')).toBe(true)
+    expect(isValidEmail('user.name@domain.co')).toBe(true)
+    expect(isValidEmail('user_name+tag@sub.domain.org')).toBe(true)
+  })
+
+  it('returns false for missing parts', () => {
+    expect(isValidEmail('')).toBe(false)
+    expect(isValidEmail('plainaddress')).toBe(false)
+    expect(isValidEmail('@no-local-part.com')).toBe(false)
+    expect(isValidEmail('username@')).toBe(false)
+    expect(isValidEmail('user@domain')).toBe(false)
+    expect(isValidEmail('username@.com')).toBe(false)
+  })
+
+  it('handles whitespace correctly', () => {
+    expect(isValidEmail('   test@example.com   ')).toBe(true) // trims input
+    expect(isValidEmail('\nuser@domain.com\t')).toBe(true)
+  })
+
+  it('rejects invalid characters or formats', () => {
+    expect(isValidEmail('user@@domain.com')).toBe(false)
+    expect(isValidEmail('user@domain,com')).toBe(false)
+    expect(isValidEmail('user@domain..com')).toBe(false)
+    expect(isValidEmail('user@.domain.com')).toBe(false)
+    expect(isValidEmail('user@domain com')).toBe(false)
+  })
+
+  it('accepts minimal valid domain structures', () => {
+    expect(isValidEmail('x@y.z')).toBe(true) // still valid
+  })
+})

package/tsconfig.json

@@ -1,17 +1,17 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "CommonJS",
-    "declaration": true,
-    "outDir": "./dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "moduleResolution": "node",
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    "forceConsistentCasingInFileNames": true,
-    "types": ["node", "jest"]
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node", "jest"]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}