tapimo 0.7.1 → 0.8.0

package/src/apps/data/routes/zones.ts

@@ -0,0 +1,338 @@
+import { Hono } from 'hono'
+import { AbiEvent, AbiFunction, type Hex } from 'ox'
+import * as z from 'zod/mini'
+
+import type * as App from '../../../App.js'
+import * as Auth from '../../../internal/Auth.js'
+import * as Cache from '../../../internal/Cache.js'
+import * as OpenApi from '../../../internal/OpenApi.js'
+import * as Response from '../../../internal/Response.js'
+import * as Schema from '../../../internal/Schema.js'
+import * as Timing from '../../../internal/Timing.js'
+import * as Value from '../../../internal/Value.js'
+
+const exampleSenderTag = '0x61fc42a734cb44acef497ea0bed612c691195623244136e0739e1929569e2487'
+const exampleTransactionHash = '0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665'
+const exampleWithdrawalId = `${exampleTransactionHash}-4`
+
+const withdrawalProcessedEvent = AbiEvent.from(
+  'event WithdrawalProcessed(address indexed to, bytes32 indexed senderTag, address token, uint128 amount, bool callbackSuccess)',
+)
+const withdrawalProcessedSelector = AbiEvent.getSelector(withdrawalProcessedEvent)
+const lastSyncedTempoBlockNumberFunction = AbiFunction.from(
+  'function lastSyncedTempoBlockNumber() view returns (uint64)',
+)
+
+/** Zod schemas owned by Zone handlers. */
+export namespace schema {
+  /** Schemas for the listZoneWithdrawals operation. */
+  export namespace listZoneWithdrawals {
+    /** Path parameters for a Zone withdrawal list request. */
+    export const Params = z
+      .object({
+        senderTag: Schema.hash(exampleSenderTag).check(
+          z.describe(
+            'The 32-byte correlation tag shared by withdrawals from one sender in one Zone transaction.',
+          ),
+        ),
+      })
+      .check(z.describe('Path parameters used to correlate Zone withdrawals.'))
+
+    /** Query parameters for a Zone withdrawal list request. */
+    export const Query = z
+      .strictObject({
+        chainId: Schema.ChainId.check(
+          z.describe('The chain id of the Zone where the withdrawal originated.'),
+          z.meta({ examples: [421_700_001] }),
+        ),
+      })
+      .check(z.describe('Query parameters used to select the originating Zone.'))
+
+    /** Indexed Zone withdrawal after parent-chain processing. */
+    export const Withdrawal = z
+      .object({
+        blockNumber: z
+          .number()
+          .check(
+            z.int(),
+            z.nonnegative(),
+            z.describe('Parent-chain block containing the withdrawal processing event.'),
+            z.meta({ examples: [123] }),
+          ),
+        id: z
+          .string()
+          .check(
+            z.describe(
+              'Stable withdrawal id built from the parent transaction hash and log index (`${transactionHash}-${logIndex}`).',
+            ),
+            z.meta({ examples: [exampleWithdrawalId] }),
+          ),
+        logIndex: z
+          .number()
+          .check(
+            z.int(),
+            z.nonnegative(),
+            z.describe('Event position within the parent-chain block.'),
+            z.meta({ examples: [4] }),
+          ),
+        status: z
+          .enum(['failed', 'completed'])
+          .check(
+            z.describe('Whether parent-chain delivery or processing failed or completed.'),
+            z.meta({ examples: ['failed', 'completed'] }),
+          ),
+        transactionHash: Schema.hash(exampleTransactionHash).check(
+          z.describe('Parent-chain transaction that processed the withdrawal.'),
+        ),
+        zoneStatus: z
+          .enum(['pending', 'completed'])
+          .check(
+            z.describe(
+              'Completed once the Zone has proven it imported the parent-chain `blockNumber` containing this withdrawal.',
+            ),
+            z.meta({ examples: ['pending', 'completed'] }),
+          ),
+      })
+      .check(z.describe('A Zone withdrawal processed on its parent chain.'))
+
+    /** Non-paginated list of indexed Zone withdrawal outcomes. */
+    export const Response = Schema.describe(
+      z.object({
+        data: z
+          .array(Withdrawal)
+          .check(
+            z.describe(
+              'Indexed parent-chain withdrawal outcomes sharing the sender tag. The list may grow while matching withdrawals are processed.',
+            ),
+          ),
+      }),
+      'A non-paginated list of parent-chain withdrawal outcomes correlated by sender tag.',
+    )
+  }
+}
+
+/** Creates Zone handlers. */
+export function zones() {
+  return new Hono<App.Environment>().get(
+    '/v1/zones/withdrawals/:senderTag',
+    Auth.policy({ apiKey: { scopes: ['data:read'] } }),
+    OpenApi.validate('param', schema.listZoneWithdrawals.Params, {
+      code: 'sender_tag_invalid',
+      message: 'Invalid sender tag',
+    }),
+    OpenApi.validate('query', schema.listZoneWithdrawals.Query, {
+      code: 'query_invalid',
+      message: 'Invalid query parameters',
+    }),
+    OpenApi.describeRoute({
+      description:
+        'Lists L1 withdrawal outcomes by Zone sender tag. L1 success requires every `status` completed; Zone success also requires every `zoneStatus` completed. Empty lists remain pending.',
+      operationId: 'listZoneWithdrawals',
+      responses: OpenApi.responses({
+        errors: {
+          400: {
+            codes: [
+              'api_key_malformed',
+              'chain_id_invalid',
+              'chain_id_unsupported',
+              'query_invalid',
+              'sender_tag_invalid',
+            ],
+          },
+          403: 'The API key does not grant read access to the originating Zone.',
+          502: 'The parent-chain indexer or RPC returned unavailable or malformed data.',
+        },
+        success: {
+          description: 'Indexed parent-chain withdrawal outcomes correlated by sender tag.',
+          examples: {
+            empty: {
+              summary: 'Not indexed',
+              value: { data: [] },
+            },
+            processed: {
+              summary: 'Processed',
+              value: {
+                data: [
+                  {
+                    blockNumber: 123,
+                    id: exampleWithdrawalId,
+                    logIndex: 4,
+                    status: 'completed',
+                    transactionHash: exampleTransactionHash,
+                    zoneStatus: 'pending',
+                  },
+                ],
+              },
+            },
+          },
+          schema: schema.listZoneWithdrawals.Response,
+        },
+      }),
+      summary: 'List Zone withdrawals',
+      tags: ['Zones'],
+    }),
+    Cache.response<App.Environment>({
+      cacheControl: Cache.policies.noStore,
+      name: 'tempo-api:zone-withdrawals:v1',
+      key: (c) => {
+        const principal = Auth.getPrincipal(c)
+        return `${principal?.type ?? 'unknown'}:${principal?.id ?? 'unknown'}:${Cache.urlKey(c, schema.listZoneWithdrawals.Query)}`
+      },
+    }),
+    async (c) => {
+      if (Auth.narrowAccess) return Auth.accessError(c)
+      if (OpenApi.narrowValidation)
+        return OpenApi.validationError(c, {
+          code: 'sender_tag_invalid',
+          message: 'Invalid sender tag',
+        })
+      if (OpenApi.narrowValidation)
+        return OpenApi.validationError(c, {
+          code: 'query_invalid',
+          message: 'Invalid query parameters',
+        })
+      if (OpenApi.narrowValidation)
+        return OpenApi.validationError(c, {
+          code: 'chain_id_invalid',
+          message: 'Invalid chain id',
+        })
+
+      const { senderTag } = c.req.valid('param')
+      const { chainId } = c.req.valid('query')
+      const zone = c.get('zones').get(chainId)
+      if (!zone) return Response.unsupportedChainId(c, chainId, c.get('zones').keys())
+
+      try {
+        const parentChainId = Schema.ChainId.parse(zone.sourceId)
+        const portalContract = zone.contracts?.['portal']
+        const portal = Schema.Address.parse(
+          portalContract && 'address' in portalContract
+            ? portalContract.address
+            : portalContract?.[parentChainId]?.address,
+        )
+        const tidx = c.get('getTidx')(parentChainId)
+        const result = await Timing.time(c, 'zone_withdrawal', () =>
+          tidx.fetch({
+            chainId: parentChainId,
+            engine: 'clickhouse',
+            // Dynamic raw-log query, constrained to schema-validated hex literals.
+            // FINAL collapses replayed physical rows before returning distinct events.
+            query: `
+              SELECT block_num, log_idx, tx_hash, address, selector, topic1, topic2, data
+              FROM logs FINAL
+              WHERE address = '${portal}'
+                AND selector = '${withdrawalProcessedSelector}'
+                AND topic2 = '${senderTag}'
+              ORDER BY block_num ASC, log_idx ASC
+            ` as string,
+          }),
+        )
+        if (result.rows.length === 0)
+          return c.json(Response.validated(schema.listZoneWithdrawals.Response, { data: [] }), 200)
+
+        // TODO: Use `zone_getZoneInfo` once Zone RPC versions stabilize.
+        const tempoBlockNumber = await Timing.time(c, 'zone_status', () =>
+          c
+            .get('getClient')(parentChainId)
+            .readContract({
+              abi: [lastSyncedTempoBlockNumberFunction],
+              address: portal,
+              functionName: 'lastSyncedTempoBlockNumber',
+            }),
+        )
+        const data = resolveWithdrawalProcessed({
+          portal,
+          rows: result.rows,
+          senderTag,
+          tempoBlockNumber,
+        })
+        return c.json(Response.validated(schema.listZoneWithdrawals.Response, data), 200)
+      } catch (cause) {
+        return Response.upstream(c, cause)
+      }
+    },
+  )
+}
+
+/**
+ * Resolves indexed `WithdrawalProcessed` rows into public withdrawal outcomes
+ * and rejects malformed upstream data.
+ */
+export function resolveWithdrawalProcessed(
+  options: resolveWithdrawalProcessed.Options,
+): z.output<typeof schema.listZoneWithdrawals.Response> {
+  const { portal, rows, senderTag, tempoBlockNumber } = options
+  return {
+    data: rows.map((row) => {
+      const address = Schema.Address.safeParse(row['address'])
+      const blockNumber = Value.toNumber(row['block_num'])
+      const data = Schema.Hex.safeParse(row['data'])
+      const logIndex = Value.toNumber(row['log_idx'])
+      const selector = Schema.Hash.safeParse(row['selector'])
+      const topic1 = Schema.Hash.safeParse(row['topic1'])
+      const topic2 = Schema.Hash.safeParse(row['topic2'])
+      const transactionHash = Schema.Hash.safeParse(row['tx_hash'])
+      if (
+        !address.success ||
+        address.data !== portal ||
+        blockNumber === undefined ||
+        !Number.isSafeInteger(blockNumber) ||
+        blockNumber < 0 ||
+        !data.success ||
+        logIndex === undefined ||
+        !Number.isSafeInteger(logIndex) ||
+        logIndex < 0 ||
+        !selector.success ||
+        selector.data !== withdrawalProcessedSelector ||
+        !topic1.success ||
+        !topic2.success ||
+        topic2.data !== senderTag ||
+        !transactionHash.success
+      )
+        throw new Error('Upstream returned a malformed WithdrawalProcessed event')
+
+      const decoded = (() => {
+        try {
+          return AbiEvent.decode(withdrawalProcessedEvent, {
+            data: data.data,
+            topics: [selector.data, topic1.data, topic2.data],
+          })
+        } catch {
+          return undefined
+        }
+      })()
+      if (
+        !decoded ||
+        !Schema.Address.safeParse(decoded.to).success ||
+        decoded.senderTag.toLowerCase() !== senderTag ||
+        !Schema.Address.safeParse(decoded.token).success ||
+        typeof decoded.amount !== 'bigint' ||
+        typeof decoded.callbackSuccess !== 'boolean'
+      )
+        throw new Error('Upstream returned a malformed WithdrawalProcessed event')
+
+      return {
+        blockNumber,
+        id: `${transactionHash.data}-${logIndex}`,
+        logIndex,
+        status: decoded.callbackSuccess ? 'completed' : 'failed',
+        transactionHash: transactionHash.data,
+        zoneStatus: tempoBlockNumber >= BigInt(blockNumber) ? 'completed' : 'pending',
+      }
+    }),
+  }
+}
+
+export declare namespace resolveWithdrawalProcessed {
+  /** Inputs for resolving indexed Zone withdrawal processing rows. */
+  type Options = {
+    /** Configured ZonePortal address on the parent Tempo chain. */
+    portal: z.output<typeof Schema.Address>
+    /** Matching raw TIDX log rows ordered by parent-chain position. */
+    rows: readonly Record<string, unknown>[]
+    /** Sender tag supplied by the caller. */
+    senderTag: Hex.Hex
+    /** Latest parent-chain block the originating Zone proved it imported. */
+    tempoBlockNumber: bigint
+  }
+}

package/src/apps/docs/reference.ts

@@ -113,7 +113,7 @@ function inlineOpenrpc<spec extends { paths: Record<string, unknown> }>(spec: sp
   const paths: Record<string, unknown> = {}
   for (const [pathname, item] of Object.entries(spec.paths)) {
     let next = item
-    if (isRecord(item))
+    if (item && typeof item === 'object' && !Array.isArray(item))
       for (const [method, op] of Object.entries(item))
         if (isRpcOperation(op)) next = { ...item, [method]: { ...op, 'x-openrpc': openrpcSpec } }
     paths[pathname] = next
@@ -124,9 +124,11 @@ function inlineOpenrpc<spec extends { paths: Record<string, unknown> }>(spec: sp
 // The JSON-RPC passthrough's operation id, set by its route definition and
 // targeted by `App.create`'s `applyOpenrpcLink`.
 function isRpcOperation(op: unknown): op is Record<string, unknown> {
-  return isRecord(op) && op['operationId'] === 'rpcRequest'
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === 'object' && !Array.isArray(value)
+  return (
+    !!op &&
+    typeof op === 'object' &&
+    !Array.isArray(op) &&
+    'operationId' in op &&
+    op.operationId === 'rpcRequest'
+  )
 }

package/src/apps/funding/Access.ts

@@ -0,0 +1,26 @@
+import type { Context } from 'hono'
+
+import type * as App from '../../App.js'
+import type * as FundingTransfers from '../../db/tables/fundingTransfers.js'
+import * as Auth from '../../internal/Auth.js'
+import * as Response from '../../internal/Response.js'
+
+/** Returns the funding owner encoded by an API-key principal. */
+export function owner(c: Context<App.Environment>): FundingTransfers.Owner | null {
+  const principal = Auth.getPrincipal(c)
+  if (principal?.type !== 'api_key') return null
+  return {
+    environment: principal.environment,
+    orgId: principal.orgId,
+    projectId: principal.projectId,
+  }
+}
+
+/** Returns the error used when a funding resource has no API-key owner. */
+export function unauthorized(c: Context<App.Environment>) {
+  return Response.error(c, {
+    code: 'unauthorized',
+    message: 'Tempo could not determine which organization owns this funding resource.',
+    status: 401,
+  })
+}

package/src/apps/funding/App.test.ts

@@ -0,0 +1,78 @@
+import { App } from 'tapimo'
+
+import * as Store from '../../internal/Store.js'
+import * as Viem from '../../internal/Viem.js'
+import * as TestApp from '../../../test/App.js'
+import { funding } from './App.js'
+
+const sandbox = {
+  environment: 'sandbox',
+  id: 'key_sandbox_funding',
+  orgId: 'org_test',
+  scopes: ['data:read'],
+  token: 'secret_sandbox_funding',
+} satisfies TestApp.kvStore.Key
+
+function as(key: { token: string }) {
+  return { headers: { authorization: `Bearer ${key.token}` } } as const
+}
+
+describe('funding access', () => {
+  test('rejects sandbox keys on a mainnet-default deployment', async () => {
+    const app = App.create({
+      auth: {},
+      db: TestApp.database(),
+      defaultChainId: Viem.chainId.mainnet,
+      kv: { store: TestApp.kvStore({ keys: [sandbox] }) },
+    }).route('/', funding())
+
+    const response = await app.request('/v1/funding/chains', as(sandbox))
+
+    expect(response.status).toBe(403)
+    expect(((await response.json()) as { error: { code: string } }).error.code).toBe(
+      'api_key_forbidden',
+    )
+  })
+
+  test('requires a matching Zone scope and bypasses the edge cache', async () => {
+    const chainId = 421_700_001
+    const reader = {
+      id: 'key_zone_funding',
+      orgId: 'org_test',
+      scopes: ['data:read', `zone:${chainId}:read`],
+      token: 'secret_zone_funding',
+    } satisfies TestApp.kvStore.Key
+    const app = App.create({
+      auth: {},
+      cache: { store: Store.memory() },
+      db: TestApp.database(),
+      defaultChainId: chainId,
+      kv: { store: TestApp.kvStore({ keys: [reader] }) },
+      zones: [TestApp.zone({ chainId, rpcUrl: `https://${chainId}.rpc.test` })],
+    }).route('/', funding())
+
+    const allowed = await app.request('/v1/funding/chains', as(reader))
+    const anonymous = await app.request('/v1/funding/chains')
+
+    expect(allowed.status).toBe(200)
+    expect(allowed.headers.get('cache-control')).toContain('private')
+    expect(anonymous.status).toBe(403)
+  })
+
+  test('keeps public-chain inventory edge-cacheable on a Zone deployment', async () => {
+    const chainId = 421_700_001
+    const app = App.create({
+      auth: false,
+      cache: { store: Store.memory() },
+      db: TestApp.database(),
+      zones: [TestApp.zone({ chainId, rpcUrl: `https://${chainId}.rpc.test` })],
+    }).route('/', funding())
+
+    const first = await app.request('/v1/funding/chains')
+    const second = await app.request('/v1/funding/chains')
+
+    expect(first.status).toBe(200)
+    expect(second.status).toBe(200)
+    expect(second.headers.get('cache-control')).toContain('public')
+  })
+})

package/src/apps/funding/App.ts

@@ -0,0 +1,63 @@
+import { Hono } from 'hono'
+
+import type * as App from '../../App.js'
+import type * as FundingDepositAddress from '../../internal/funding/DepositAddress.js'
+import type * as FundingProvider from '../../internal/funding/Provider.js'
+import * as Metadata from '../metadata.js'
+import { chains } from './routes/chains.js'
+import { depositAddresses } from './routes/deposit-addresses.js'
+import { providers } from './routes/providers.js'
+import { quotes } from './routes/quotes.js'
+import { transfers } from './routes/transfers.js'
+
+/**
+ * Mounts the Funding & Bridge API, including quotes, inventory, reusable
+ * deposit addresses, detected deposits, and transfers.
+ *
+ * ```ts
+ * App.create(options).route('/', data()).route('/', funding())
+ * ```
+ */
+export function funding(options: funding.Options = {}) {
+  const app = new Hono<App.Environment>()
+    .route('/', quotes())
+    .route('/', chains())
+    .route('/', providers())
+    .route('/', depositAddresses(options))
+    .route('/', transfers())
+  return Metadata.defaultChain(Metadata.attach(app, openapi))
+}
+
+export declare namespace funding {
+  /** Inbound funding route configuration. */
+  type Options = {
+    /** Enqueues one deposit address for asynchronous reconciliation. */
+    dispatchReconciliation?:
+      | ((message: FundingProvider.Webhook.receive.Dispatchable) => Promise<void>)
+      | undefined
+    /** Registers a created address with a source-chain observer. */
+    registerDepositAddress?: ((address: FundingDepositAddress.Public) => Promise<void>) | undefined
+  }
+}
+
+const openapi = {
+  tags: [
+    { name: 'Chains', description: 'Source chains and stablecoins supported for funding.' },
+    {
+      name: 'Deposit Addresses',
+      description: 'Reusable funding addresses and deposits detected at those addresses.',
+    },
+    { name: 'Providers', description: 'Providers available for inbound funding.' },
+    { name: 'Quotes', description: 'Live quotes for funding Tempo from other chains.' },
+    {
+      name: 'Transfers',
+      description: 'Inbound funding transfers.',
+    },
+  ],
+  'x-tagGroups': [
+    {
+      name: 'Funding & Bridge API',
+      tags: ['Chains', 'Deposit Addresses', 'Providers', 'Quotes', 'Transfers'],
+    },
+  ],
+} satisfies App.create.Metadata

package/src/apps/funding/Inventory.ts

@@ -0,0 +1,30 @@
+import type { Context } from 'hono'
+
+import type * as App from '../../App.js'
+import type * as Db from '../../db/Db.js'
+import * as FundingProvider from '../../internal/funding/Provider.js'
+
+const sourceScopes = new WeakMap<Db.Source, number>()
+let nextSourceScope = 0
+
+/** Returns an inventory cache key scoped by request URL, providers, and database source. */
+export function key(c: Context<App.Environment>) {
+  const url = new URL(c.req.url)
+  const providers = c
+    .get('providers')
+    .filter(FundingProvider.is)
+    .map((provider) => provider.id)
+    .sort()
+  url.searchParams.set('__tempo_database', String(sourceScope(c.get('dbCached'))))
+  url.searchParams.set('__tempo_providers', providers.join(','))
+  return url.toString()
+}
+
+function sourceScope(source: Db.Source) {
+  const current = sourceScopes.get(source)
+  if (current !== undefined) return current
+  // A production isolate has one source, while multi-app runtimes receive distinct scopes.
+  const scope = nextSourceScope++
+  sourceScopes.set(source, scope)
+  return scope
+}

package/src/apps/funding/ProviderAttempts.ts

@@ -0,0 +1,26 @@
+import * as FundingProvider from '../../internal/funding/Provider.js'
+import type * as Log from '../../internal/Log.js'
+
+/** Formats one provider attempt for the canonical request log. */
+export function format(attempt: FundingProvider.ProviderAttempt): Log.FundingProviderAttempt {
+  const { id } = attempt.provider
+  if (attempt.outcome !== 'failed')
+    return {
+      durationMs: attempt.durationMs,
+      id,
+      operation: attempt.operation,
+      outcome: attempt.outcome,
+    }
+
+  return {
+    durationMs: attempt.durationMs,
+    failure: FundingProvider.failure({
+      cause: attempt.cause,
+      operation: attempt.operation,
+      provider: attempt.provider,
+    }).failure,
+    id,
+    operation: attempt.operation,
+    outcome: attempt.outcome,
+  }
+}

package/src/apps/funding/index.ts

@@ -0,0 +1 @@
+export { funding } from './App.js'

package/src/apps/funding/routes/chains.test.ts

@@ -0,0 +1,78 @@
+import * as Across from '../../../internal/funding/providers/across.js'
+
+import * as Relay from '../../../internal/funding/providers/relay.js'
+
+import * as Rhino from '../../../internal/funding/providers/rhino.js'
+
+import * as Squid from '../../../internal/funding/providers/squid.js'
+
+import * as Symbiosis from '../../../internal/funding/providers/symbiosis.js'
+
+import * as TestApp from '../../../../test/App.js'
+
+import * as TestFunding from '../../../../test/Funding.js'
+
+import * as Funding from './chains.js'
+
+const db = TestApp.database()
+
+const providers = [
+  Across.across({
+    apiKey: 'across-api-key',
+    integratorId: '0xdead',
+    userAddress: '0x1111111111111111111111111111111111111111',
+  }),
+  Relay.relay({ userAddress: '0x1111111111111111111111111111111111111111' }),
+  Rhino.rhino(),
+  Squid.squid({
+    integratorId: 'squid-integrator-id',
+    userAddress: '0x1111111111111111111111111111111111111111',
+  }),
+  Symbiosis.symbiosis({ userAddress: '0x1111111111111111111111111111111111111111' }),
+] as const
+
+beforeAll(() => TestFunding.publish(db))
+
+function create(options: TestApp.create.Options = {}) {
+  return TestApp.create({ ...options, db })
+}
+
+describe('funding OpenAPI', () => {
+  test('publishes get operation ids for funding inventory', async () => {
+    const app = create({ auth: false })
+    const spec = await (await app.request('/openapi.json')).json()
+
+    expect({
+      chains: spec.paths['/v1/funding/chains'].get.operationId,
+      providers: spec.paths['/v1/funding/providers'].get.operationId,
+    }).toEqual({
+      chains: 'getFundingChains',
+      providers: 'getFundingProviders',
+    })
+  })
+})
+
+describe('GET /funding/chains', () => {
+  test('lists only inputs supported by quote providers', async () => {
+    const response = await create({ providers }).request('/v1/funding/chains', {
+      headers: TestApp.auth.headers,
+    })
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.getFundingChains.Response)
+
+    expect(body.data.map((chain) => chain.id)).toEqual([
+      'eip155:1',
+      'eip155:56',
+      'eip155:8453',
+      'eip155:137',
+      'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+      'tron:0x2b6653dc',
+    ])
+    expect(body.data.flatMap((chain) => chain.tokens.map((token) => token.symbol))).toEqual(
+      expect.arrayContaining(['USDC', 'USDT']),
+    )
+    expect(
+      body.data.flatMap((chain) => chain.tokens).every((token) => token.currency === 'USD'),
+    ).toBe(true)
+  })
+})