@luxexchange/api 1.0.0

package/src/clients/base/utils.test.ts

@@ -0,0 +1,131 @@
+import type { FetchClient } from '@luxexchange/api/src/clients/base/types'
+import { createFetcher } from '@luxexchange/api/src/clients/base/utils'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+describe('createFetcher', () => {
+  const mockClient: FetchClient = {
+    fetch: vi.fn().mockResolvedValue({ data: 'fetch' }),
+    get: vi.fn().mockResolvedValue({ data: 'get' }),
+    post: vi.fn().mockResolvedValue({ data: 'post' }),
+    put: vi.fn().mockResolvedValue({ data: 'put' }),
+    delete: vi.fn(),
+    patch: vi.fn(),
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should create a fetcher for FETCH requests', async () => {
+    const fetcher = createFetcher<{ id: string }, { data: string }>({
+      client: mockClient,
+      method: 'fetch',
+      url: '/api/test',
+    })
+    const result = await fetcher({ id: '123' })
+    expect(result).toEqual({ data: 'fetch' })
+  })
+
+  it('should create a fetcher for GET requests', async () => {
+    const fetcher = createFetcher<{ id: string }, { data: string }>({
+      client: mockClient,
+      method: 'get',
+      url: '/api/test',
+    })
+    const result = await fetcher({ id: '123' })
+    expect(result).toEqual({ data: 'get' })
+  })
+
+  it('should create a fetcher for POST requests', async () => {
+    const fetcher = createFetcher<{ name: string }, { data: string }>({
+      client: mockClient,
+      method: 'post',
+      url: '/api/create',
+    })
+    const result = await fetcher({ name: 'test' })
+    expect(result).toEqual({ data: 'post' })
+  })
+
+  it('should apply transformRequest to modify url', async () => {
+    const fetcher = createFetcher<{ id: string }, { data: string }>({
+      client: mockClient,
+      method: 'get',
+      url: '/api/test',
+      transformRequest: async ({ url }) => ({ url: `${url}/modified` }),
+    })
+    await fetcher({ id: '123' })
+    expect(mockClient.get).toHaveBeenCalledWith(
+      '/api/test/modified',
+      expect.objectContaining({ params: { id: '123' } }),
+    )
+  })
+
+  it('should apply transformRequest to modify headers', async () => {
+    const fetcher = createFetcher<{ id: string }, { data: string }>({
+      client: mockClient,
+      method: 'get',
+      url: '/api/test',
+      transformRequest: async () => ({ headers: { Authorization: 'Bearer token' } }),
+    })
+    await fetcher({ id: '123' })
+    expect(mockClient.get).toHaveBeenCalledWith(
+      '/api/test',
+      expect.objectContaining({ headers: { Authorization: 'Bearer token' } }),
+    )
+  })
+
+  it('should apply transformRequest to modify params', async () => {
+    const fetcher = createFetcher<{ id: string }, { data: string }>({
+      client: mockClient,
+      method: 'get',
+      url: '/api/test',
+      transformRequest: async ({ params }) => ({ params: { ...params, extra: 'value' } }),
+    })
+    await fetcher({ id: '123' })
+    expect(mockClient.get).toHaveBeenCalledWith(
+      '/api/test',
+      expect.objectContaining({ params: { id: '123', extra: 'value' } }),
+    )
+  })
+
+  it('should apply transformRequest to modify url, headers, and params together', async () => {
+    const fetcher = createFetcher<{ id: string }, { data: string }>({
+      client: mockClient,
+      method: 'post',
+      url: '/api/test',
+      transformRequest: async ({ url, params }) => ({
+        url: `${url}/v2`,
+        headers: { 'X-Custom': 'header' },
+        params: { ...params, version: 2 },
+      }),
+    })
+    await fetcher({ id: '123' })
+    expect(mockClient.post).toHaveBeenCalledWith('/api/test/v2', {
+      headers: { 'X-Custom': 'header' },
+      body: JSON.stringify({ id: '123', version: 2 }),
+      on404: expect.any(Function),
+    })
+  })
+
+  it('should apply transformResponse when provided', async () => {
+    const fetcher = createFetcher<{ id: string }, { data: string }>({
+      client: mockClient,
+      method: 'get',
+      url: '/api/test',
+      transformResponse: (response) => ({ data: response.data.toUpperCase() }),
+    })
+    const result = await fetcher({ id: '123' })
+    expect(result).toEqual({ data: 'GET' })
+  })
+
+  it('should support async transformResponse', async () => {
+    const fetcher = createFetcher<{ id: string }, { data: string }>({
+      client: mockClient,
+      method: 'get',
+      url: '/api/test',
+      transformResponse: async (response) => ({ data: `transformed-${response.data}` }),
+    })
+    const result = await fetcher({ id: '123' })
+    expect(result).toEqual({ data: 'transformed-get' })
+  })
+})

package/src/clients/base/utils.ts

@@ -0,0 +1,54 @@
+import { type CustomOptions, type FetchClient } from '@luxfi/api/src/clients/base/types'
+
+type TransformRequestResult = {
+  url?: string
+  headers?: HeadersInit
+  params?: unknown
+}
+
+type TransformRequestInput<TRequest> = {
+  url: string
+  headers?: HeadersInit
+  params: TRequest
+}
+
+export function createFetcher<TRequest, TResponse>(ctx: {
+  client: FetchClient
+  method: Extract<keyof FetchClient, 'get' | 'post' | 'put' | 'delete' | 'patch'>
+  url: string
+  transformRequest?: (request: TransformRequestInput<TRequest>) => Promise<TransformRequestResult>
+  transformResponse?: (response: TResponse) => TResponse | Promise<TResponse>
+  on404?: (params: TRequest) => void
+}): (params: TRequest, customHeaders?: HeadersInit) => Promise<TResponse> {
+  const { client, url, method, transformRequest, transformResponse, on404 } = ctx
+  return async (params: TRequest, customHeaders?: HeadersInit): Promise<TResponse> => {
+    const transformedRequest = transformRequest ? await transformRequest({ url, headers: customHeaders, params }) : {}
+    const transformedUrl = transformedRequest.url ?? url
+    const transformedHeaders = transformedRequest.headers ?? {}
+    const transformedParams = transformedRequest.params ?? params
+
+    let response: TResponse
+    if (method === 'get') {
+      response = await client.get<TResponse>(transformedUrl, {
+        headers: { ...customHeaders, ...transformedHeaders },
+        params: transformedParams as CustomOptions['params'],
+        on404: () => on404?.(params),
+      })
+    } else {
+      response = await client[method]<TResponse>(transformedUrl, {
+        headers: { ...customHeaders, ...transformedHeaders },
+        body: JSON.stringify(transformedParams),
+        on404: () => on404?.(params),
+      })
+    }
+
+    return transformResponse ? transformResponse(response) : response
+  }
+}
+
+export const objectToQueryString = (obj: Record<string, string | number | boolean>): string => {
+  return Object.entries(obj)
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+    .join('&')
+}

package/src/clients/blockaid/createBlockaidApiClient.ts

@@ -0,0 +1,185 @@
+import type { FetchClient } from '@luxfi/api/src/clients/base/types'
+import {
+  type BlockaidScanJsonRpcRequest,
+  type BlockaidScanSiteRequest,
+  type BlockaidScanSiteResponse,
+  type BlockaidScanTransactionRequest,
+  type BlockaidScanTransactionResponse,
+  DappVerificationStatus,
+  getBlockaidScanSiteResponseSchema,
+  getBlockaidScanTransactionResponseSchema,
+} from '@luxfi/api/src/clients/blockaid/types'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+
+export interface BlockaidApiClient {
+  scanSite: (url: string) => Promise<DappVerificationStatus>
+  scanTransaction: (request: BlockaidScanTransactionRequest | null) => Promise<BlockaidScanTransactionResponse | null>
+  scanJsonRpc: (request: BlockaidScanJsonRpcRequest | null) => Promise<BlockaidScanTransactionResponse | null>
+}
+
+export const BLOCKAID_API_PATHS = {
+  scanSite: '/v0/site/scan',
+  scanTransaction: '/v0/evm/transaction/scan',
+  scanJsonRpc: '/v0/evm/json-rpc/scan',
+}
+
+// Timeout for Blockaid API requests (5 seconds)
+const BLOCKAID_TIMEOUT_MS = 5000
+
+/**
+ * Maps a Blockaid API response to a DappVerificationStatus
+ * @param data The Blockaid API response
+ * @returns The corresponding DappVerificationStatus
+ */
+function mapBlockaidResponseToStatus(data: BlockaidScanSiteResponse): DappVerificationStatus {
+  if (data.status === 'miss') {
+    return DappVerificationStatus.Unverified
+  }
+  return data.is_malicious ? DappVerificationStatus.Threat : DappVerificationStatus.Verified
+}
+
+export function createBlockaidApiClient(ctx: { fetchClient: FetchClient }): BlockaidApiClient {
+  async function scanSite(url: string): Promise<DappVerificationStatus> {
+    const requestBody: BlockaidScanSiteRequest = { url }
+
+    const abortController = new AbortController()
+    const timeoutId = setTimeout(() => abortController.abort(), BLOCKAID_TIMEOUT_MS)
+
+    try {
+      const result = await ctx.fetchClient.post(BLOCKAID_API_PATHS.scanSite, {
+        body: JSON.stringify(requestBody),
+        signal: abortController.signal,
+      })
+
+      const response = getBlockaidScanSiteResponseSchema().safeParse(result)
+      if (!response.success) {
+        logger.error(new Error('Blockaid API response schema validation failed'), {
+          tags: { file: 'createBlockaidApiClient', function: 'scanSite' },
+          extra: {
+            url,
+            validationError: response.error.message,
+            receivedData: result,
+          },
+        })
+        return DappVerificationStatus.Unverified
+      }
+      return mapBlockaidResponseToStatus(response.data)
+    } catch (error) {
+      // Log for observability but return safe default
+      logger.error(error, {
+        tags: {
+          file: 'createBlockaidApiClient',
+          function: 'scanSite',
+        },
+        extra: { url },
+      })
+      return DappVerificationStatus.Unverified
+    } finally {
+      clearTimeout(timeoutId)
+    }
+  }
+
+  async function scanTransaction(
+    request: BlockaidScanTransactionRequest | null,
+  ): Promise<BlockaidScanTransactionResponse | null> {
+    if (!request) {
+      return null
+    }
+
+    const abortController = new AbortController()
+    const timeoutId = setTimeout(() => abortController.abort(), BLOCKAID_TIMEOUT_MS)
+
+    try {
+      const result = await ctx.fetchClient.post(BLOCKAID_API_PATHS.scanTransaction, {
+        body: JSON.stringify(request),
+        signal: abortController.signal,
+      })
+
+      const response = getBlockaidScanTransactionResponseSchema().safeParse(result)
+      if (!response.success) {
+        logger.error(new Error('Blockaid API response schema validation failed'), {
+          tags: { file: 'createBlockaidApiClient', function: 'scanTransaction' },
+          extra: {
+            chain: request.chain,
+            account: request.account_address,
+            domain: request.metadata.domain,
+            validationError: response.error.message,
+            receivedData: result,
+          },
+        })
+        return null
+      }
+      return response.data
+    } catch (error) {
+      // Log for observability but return null as safe default
+      logger.error(error, {
+        tags: {
+          file: 'createBlockaidApiClient',
+          function: 'scanTransaction',
+        },
+        extra: { chain: request.chain, account: request.account_address, domain: request.metadata.domain },
+      })
+      return null
+    } finally {
+      clearTimeout(timeoutId)
+    }
+  }
+
+  async function scanJsonRpc(
+    request: BlockaidScanJsonRpcRequest | null,
+  ): Promise<BlockaidScanTransactionResponse | null> {
+    if (!request) {
+      return null
+    }
+
+    const abortController = new AbortController()
+    const timeoutId = setTimeout(() => abortController.abort(), BLOCKAID_TIMEOUT_MS)
+
+    try {
+      const result = await ctx.fetchClient.post(BLOCKAID_API_PATHS.scanJsonRpc, {
+        body: JSON.stringify(request),
+        signal: abortController.signal,
+      })
+
+      const response = getBlockaidScanTransactionResponseSchema().safeParse(result)
+      if (!response.success) {
+        logger.error(new Error('Blockaid API response schema validation failed'), {
+          tags: { file: 'createBlockaidApiClient', function: 'scanJsonRpc' },
+          extra: {
+            chain: request.chain,
+            account: request.account_address,
+            domain: request.metadata.domain,
+            method: request.data.method,
+            validationError: response.error.message,
+            receivedData: result,
+          },
+        })
+        return null
+      }
+      return response.data
+    } catch (error) {
+      // Log for observability but return null as safe default
+      logger.error(error, {
+        tags: {
+          file: 'createBlockaidApiClient',
+          function: 'scanJsonRpc',
+        },
+        extra: {
+          chain: request.chain,
+          account: request.account_address,
+          domain: request.metadata.domain,
+          method: request.data.method,
+        },
+      })
+      return null
+    } finally {
+      clearTimeout(timeoutId)
+    }
+  }
+
+  return {
+    scanSite,
+    scanTransaction,
+    scanJsonRpc,
+  }
+}