tapimo 0.15.1 → 0.18.0

package/src/apps/data/routes/fee-amm.ts

@@ -1,5 +1,6 @@
 import { Hono, type Context } from 'hono'
 import { AbiEvent, AbiParameters, Hash, type Hex } from 'ox'
+import { zeroAddress } from 'viem'
 import { Abis, Addresses } from 'viem/tempo'
 import * as z from 'zod/mini'
 
@@ -7,6 +8,7 @@ import type * as App from '../../../App.js'
 import * as Auth from '../../../internal/Auth.js'
 import * as Cache from '../../../internal/Cache.js'
 import * as Cursor from '../../../internal/Cursor.js'
+import type * as Log from '../../../internal/Log.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
@@ -695,35 +697,16 @@ declare namespace listPools {
   }
 }
 
-/**
- * The set of token addresses usable to pay transaction fees on a chain: the
- * curated verified tokens that have at least one Fee AMM pool (i.e. appear as a
- * `userToken` / topic2 in the FeeManager's `Mint` logs), plus the protocol
- * default fee token (`pathUSD`), which pays fees without needing a pool.
- * Addresses are lowercased to match the indexer's stored casing.
- *
- * The set is intentionally gated to the verified list rather than every pooled
- * token: anyone can mint a single-mint spam pool, so the raw set of pool
- * `userToken`s is unbounded (tens of thousands on busy chains) and those
- * liquidity-less pools can't actually settle fees. Restricting to verified
- * tokens keeps the set small (a handful of USD stablecoins), bounds the scan
- * (the `topic2 IN (…)` candidate list is the verified list), and matches the
- * tokens fees are realistically paid in.
- *
- * Memoized per chain and verified-snapshot version (the only inputs), so
- * callers — e.g. the address balances endpoint — can flag which holdings are
- * fee-usable without a second `/fee-amm/pools` query.
- */
+/** Returns lowercased verified tokens currently usable for transaction fees. The protocol default (`pathUSD`) is always included. */
 export async function feeTokenSet(
   c: Context<App.Environment>,
   chainId: z.output<typeof Schema.ChainId>,
 ): Promise<Set<string>> {
   const store = c.get('store')
-  const tidx = c.get('getTidx')(chainId)
   const snapshot = await VerifiedTokens.snapshot(c, chainId)
   // pathUSD is always fee-usable; the verified tokens are the only other
   // candidates we probe for a pool. With no verified candidates there is
-  // nothing to query — pathUSD stands alone.
+  // nothing to query, so pathUSD stands alone.
   const candidates = snapshot.list.map((token) => token.address.toLowerCase())
   if (candidates.length === 0) return new Set([pathUsd])
 
@@ -733,36 +716,106 @@ export async function feeTokenSet(
     Store.memoize(
       async () => {
         const tokens = new Set<string>([pathUsd])
-        // PostgreSQL's `topic2` index proves negative lookups without scanning
-        // FeeManager history. Probe serially so an uncapped verified list
-        // cannot fan out indexer load.
-        for (const address of candidates) {
-          const topic = padTopic(address as `0x${string}`)
-          const result = await tidx.fetch({
-            chainId,
-            engine: 'postgres',
-            query: `
-              SELECT 1 AS present
-              FROM logs
-              WHERE address = '${feeManager}' AND selector IN ('${mintTopic}', '${legacyMintTopic}')
-                AND topic2 = '${topic}'
-              LIMIT 1
-            ` as string,
+        const validatorTokens = await getValidatorTokens(c, { chainId })
+        // Verified candidates prevent permissionless spam pools from expanding
+        // the lookup. Small batches also bound RPC fan-out for Zone clients.
+        const probes = candidates
+          .filter((address) => {
+            if (!validatorTokens.includes(address)) return true
+            tokens.add(address)
+            return false
           })
-          if (result.rows.length > 0) tokens.add(address)
+          .flatMap((userToken) =>
+            validatorTokens.map((validatorToken) => ({ userToken, validatorToken })),
+          )
+        const unresolved = new Map<string, unknown>()
+        for (let index = 0; index < probes.length; index += 8) {
+          const group = probes.slice(index, index + 8)
+          const results = await Promise.allSettled(
+            group.map(({ userToken, validatorToken }) =>
+              readPoolReserves(c, {
+                chainId,
+                userToken: userToken as z.output<typeof Schema.Address>,
+                validatorToken: validatorToken as z.output<typeof Schema.Address>,
+              }),
+            ),
+          )
+          for (const [offset, result] of results.entries()) {
+            const userToken = group[offset]!.userToken
+            if (result.status === 'rejected') {
+              unresolved.set(userToken, result.reason)
+              continue
+            }
+            if (BigInt(result.value.userToken) > 0n && BigInt(result.value.validatorToken) > 0n) {
+              tokens.add(userToken)
+              unresolved.delete(userToken)
+            }
+          }
         }
+        const failure = Array.from(unresolved).find(([address]) => !tokens.has(address))
+        if (failure) throw failure[1]
         return Array.from(tokens)
       },
       {
-        key: `feeamm:v2:${chainId}:fee-token-set:v:${snapshot.version}`,
+        key: `feeamm:v3:${chainId}:fee-token-set:v:${snapshot.version}`,
         store,
-        ttl: Ttl.minutes(5),
+        ttl: Ttl.seconds(30),
       },
     ),
-  )
+  ).catch((cause) => {
+    const failure = {
+      chainId,
+      failure: 'unknown',
+      id: 'rpc',
+      operation: 'feeTokenSet',
+    } satisfies Log.ProviderFailure
+    c.set('providerFailures', [...(c.get('providerFailures') ?? []), failure])
+    throw cause
+  })
   return new Set(addresses)
 }
 
+/** Resolves the distinct fee tokens preferred by active validators. */
+async function getValidatorTokens(
+  c: Context<App.Environment>,
+  options: getValidatorTokens.Options,
+) {
+  const { chainId } = options
+  const client = c.get('getClient')(chainId)
+  const validators = await client.readContract({
+    abi: Abis.validatorConfig,
+    address: Addresses.validator,
+    functionName: 'getValidators',
+  })
+  const active = validators.filter((validator) => validator.active)
+  if (active.length === 0) return [pathUsd]
+  const preferred = await Promise.all(
+    active.map((validator) =>
+      client.readContract({
+        abi: Abis.feeManager,
+        address: Addresses.feeManager,
+        args: [validator.validatorAddress],
+        functionName: 'validatorTokens',
+      }),
+    ),
+  )
+  return Array.from(
+    new Set(
+      preferred.map((address) =>
+        address.toLowerCase() === zeroAddress ? pathUsd : address.toLowerCase(),
+      ),
+    ),
+  )
+}
+
+declare namespace getValidatorTokens {
+  /** Options for resolving active validators' preferred fee tokens. */
+  type Options = {
+    /** Chain whose validator preferences should be read. */
+    chainId: z.output<typeof Schema.ChainId>
+  }
+}
+
 /**
  * Reads a pool's current on-chain reserves via `FeeManager.getPool`, memoized
  * briefly per pool. Reserves are best-effort decoration on the pool listing:
@@ -775,28 +828,37 @@ function getPoolReserves(
   options: getPoolReserves.Options,
 ): Promise<getPoolReserves.Reserves | null> {
   const { chainId, userToken, validatorToken } = options
-  const client = c.get('getClient')(chainId)
   const store = c.get('store')
 
-  return Store.memoize(
-    async () => {
-      const pool = await client.readContract({
-        abi: Abis.feeAmm,
-        address: Addresses.feeManager,
-        args: [userToken, validatorToken],
-        functionName: 'getPool',
-      })
-      return {
-        userToken: pool.reserveUserToken.toString(),
-        validatorToken: pool.reserveValidatorToken.toString(),
-      }
-    },
-    {
-      key: `feeamm:v1:${chainId}:pool:${userToken}:${validatorToken}:reserves`,
-      store,
-      ttl: Ttl.seconds(30),
-    },
-  ).catch(() => null)
+  return Store.memoize(() => readPoolReserves(c, { chainId, userToken, validatorToken }), {
+    key: `feeamm:v1:${chainId}:pool:${userToken}:${validatorToken}:reserves`,
+    store,
+    ttl: Ttl.seconds(30),
+  }).catch(() => null)
+}
+
+/** Reads a pool's current on-chain reserves and propagates RPC failures. */
+async function readPoolReserves(
+  c: Context<App.Environment>,
+  options: readPoolReserves.Options,
+): Promise<getPoolReserves.Reserves> {
+  const { chainId, userToken, validatorToken } = options
+  const client = c.get('getClient')(chainId)
+  const pool = await client.readContract({
+    abi: Abis.feeAmm,
+    address: Addresses.feeManager,
+    args: [userToken, validatorToken],
+    functionName: 'getPool',
+  })
+  return {
+    userToken: pool.reserveUserToken.toString(),
+    validatorToken: pool.reserveValidatorToken.toString(),
+  }
+}
+
+declare namespace readPoolReserves {
+  /** Options for reading one fee pool. */
+  type Options = getPoolReserves.Options
 }
 
 declare namespace getPoolReserves {

package/src/apps/data/routes/receipts.test.ts

@@ -346,18 +346,30 @@ async function findRecentTransactionHash() {
 }
 
 describe('GET /transactions/receipts?address=…', () => {
-  test('returns receipts involving an address', async () => {
+  let account: string
+
+  beforeAll(async () => {
     const client = TestApp.client()
-    // Seed a real sender from the global receipt feed.
-    const seedResponse = await client.v1.transactions.receipts.$get(
-      { query: { limit: '5' } },
-      TestApp.auth,
+    // A replica can briefly return an empty head page. Require an indexed receipt before testing address filters.
+    account = await vi.waitFor(
+      async () => {
+        const response = await client.v1.transactions.receipts.$get(
+          { query: { limit: '5' } },
+          { headers: { ...TestApp.auth.headers, 'cache-control': 'no-store' } },
+        )
+        const body = await TestApp.json(response, Receipts.schema.getReceipts.Response)
+        expect(response.status).toBe(200)
+        expect(body.data.length).toBeGreaterThan(0)
+        const sender = body.data[0]!.sender
+        expect(sender).toMatch(/^0x[0-9a-f]{40}$/)
+        return sender
+      },
+      { interval: 1_000, timeout: 30_000 },
     )
-    const seed = await TestApp.json(seedResponse, Receipts.schema.getReceipts.Response)
-    expect(seedResponse.status).toBe(200)
-    const account = seed.data[0]!.sender
-    expect(account).toMatch(/^0x[0-9a-f]{40}$/)
+  })
 
+  test('returns receipts involving an address', async () => {
+    const client = TestApp.client()
     const baseResponse = await client.v1.transactions.receipts.$get(
       { query: { address: account, limit: '5' } },
       TestApp.auth,
@@ -390,15 +402,6 @@ describe('GET /transactions/receipts?address=…', () => {
 
   test('narrows receipts by execution status', async () => {
     const client = TestApp.client()
-    const seedResponse = await client.v1.transactions.receipts.$get(
-      { query: { limit: '5' } },
-      TestApp.auth,
-    )
-    const seed = await TestApp.json(seedResponse, Receipts.schema.getReceipts.Response)
-    expect(seedResponse.status).toBe(200)
-    const account = seed.data[0]!.sender
-    expect(account).toMatch(/^0x[0-9a-f]{40}$/)
-
     const response = await client.v1.transactions.receipts.$get(
       { query: { address: account, limit: '5', status: 'success' } },
       TestApp.auth,

package/src/apps/data/routes/rpc.test.ts

@@ -1230,7 +1230,7 @@ describe('POST /rpc', () => {
         {
           "error": {
             "code": "api_key_forbidden",
-            "message": "API key missing required scope",
+            "message": "API key is missing required permissions: data:read. Use an API key with these scopes.",
           },
         }
       `)
@@ -1531,7 +1531,7 @@ describe('POST /rpc/relay', () => {
       {
         "error": {
           "code": "api_key_forbidden",
-          "message": "API key missing required scope",
+          "message": "API key is missing required permissions: rpc-relay:read. Use an API key with these scopes.",
         },
       }
     `)

package/src/apps/data/routes/tokens.provenance.test.ts

@@ -0,0 +1,157 @@
+import * as fs from 'node:fs'
+import {
+  GenericContainer,
+  Network,
+  type StartedNetwork,
+  type StartedTestContainer,
+  Wait,
+} from 'testcontainers'
+import { encodeAbiParameters, encodeEventTopics, parseAbi, zeroAddress, zeroHash } from 'viem'
+
+import * as TestApp from '../../../../test/App.js'
+import * as Runtime from '../../../../test/runtime.js'
+import * as Tokens from './tokens.js'
+
+const abi = parseAbi([
+  'event TokenCreated(address indexed token, string name, string symbol, string currency, address quoteToken, address admin, bytes32 salt)',
+])
+const attacker = '0x1111111111111111111111111111111111111111'
+const token = '0x20c0000000000000000000000000000000000001'
+
+let url: string
+
+describe.runIf(Runtime.get().mode === 'testnet')('Token provenance', () => {
+  let app: ReturnType<typeof TestApp.create>
+  let clickhouse: StartedTestContainer
+  let indexer: StartedTestContainer
+  let network: StartedNetwork
+  let postgres: StartedTestContainer
+
+  beforeAll(async () => {
+    const compose = fs.readFileSync(
+      new URL('../../../../docker-compose.yml', import.meta.url),
+      'utf8',
+    )
+    const image = compose.match(/TEMPO_API_TIDX_IMAGE:-([^}]+)}/)?.[1]
+    const image_clickhouse = compose.match(/TEMPO_API_CLICKHOUSE_IMAGE:-([^}]+)}/)?.[1]
+    const image_postgres = compose.match(/TEMPO_API_POSTGRES_IMAGE:-([^}]+)}/)?.[1]
+    if (!image || !image_clickhouse || !image_postgres)
+      throw new Error('Missing pinned database images.')
+    network = await new Network().start()
+    postgres = await new GenericContainer(image_postgres)
+      .withEnvironment({ POSTGRES_PASSWORD: 'postgres' })
+      .withNetwork(network)
+      .withNetworkAliases('postgres')
+      .withExposedPorts(5432)
+      .withWaitStrategy(Wait.forLogMessage(/database system is ready to accept connections/, 2))
+      .start()
+    clickhouse = await new GenericContainer(image_clickhouse)
+      .withEnvironment({ CLICKHOUSE_PASSWORD: 'clickhouse', CLICKHOUSE_USER: 'clickhouse' })
+      .withNetwork(network)
+      .withNetworkAliases('clickhouse')
+      .withExposedPorts(8123)
+      .withWaitStrategy(Wait.forHttp('/ping', 8123))
+      .start()
+    url = `http://${clickhouse.getHost()}:${clickhouse.getMappedPort(8123)}`
+    indexer = await new GenericContainer(image)
+      .withPlatform('linux/amd64')
+      .withNetwork(network)
+      .withCopyContentToContainer([
+        {
+          content: `
+[http]
+enabled = true
+port = 8080
+bind = "0.0.0.0"
+[prometheus]
+enabled = false
+[[chains]]
+name = "token-provenance"
+chain_id = 42431
+rpc_url = "http://127.0.0.1:1"
+pg_url = "postgres://postgres:postgres@postgres:5432/postgres"
+backfill = false
+[chains.clickhouse]
+enabled = true
+url = "http://clickhouse:8123"
+user = "clickhouse"
+password_env = "CLICKHOUSE_PASSWORD"
+repair_derived_on_startup = false
+`,
+          target: '/tmp/config.toml',
+        },
+      ])
+      .withEnvironment({ CLICKHOUSE_PASSWORD: 'clickhouse' })
+      .withCommand(['up', '--config', '/tmp/config.toml'])
+      .withExposedPorts(8080)
+      .withWaitStrategy(Wait.forListeningPorts())
+      .withStartupTimeout(120_000)
+      .start()
+    await vi.waitFor(
+      async () => {
+        const response = await query(
+          "SELECT count() FROM system.tables WHERE database = 'tidx_42431' AND name = 'logs'",
+        )
+        expect(response.trim()).toBe('1')
+      },
+      { timeout: 60_000 },
+    )
+    app = TestApp.create({
+      auth: false,
+      cache: { edge: false },
+      rpc: { url: 'http://127.0.0.1:1' },
+      tidx: { baseUrl: `http://${indexer.getHost()}:${indexer.getMappedPort(8080)}` },
+    })
+  })
+
+  afterAll(async () => {
+    await indexer?.stop()
+    await clickhouse?.stop()
+    await postgres?.stop()
+    await network?.stop()
+  })
+
+  test('excludes TokenCreated logs from non-factory emitters', async () => {
+    await insertForgedToken()
+
+    const response = await app.request('/v1/tokens?chainId=42431&limit=5')
+    expect(response.status, await response.clone().text()).toBe(200)
+    const body = await TestApp.json(response, Tokens.schema.getTokens.Response)
+    expect(body).toEqual({ data: [], nextCursor: null })
+  })
+})
+
+async function query(sql: string) {
+  const response = await fetch(url, {
+    body: sql,
+    headers: { Authorization: `Basic ${btoa('clickhouse:clickhouse')}` },
+    method: 'POST',
+  })
+  const body = await response.text()
+  if (!response.ok) throw new Error(body)
+  return body
+}
+
+async function insertForgedToken() {
+  const [selector, topic1] = encodeEventTopics({
+    abi,
+    args: { token },
+    eventName: 'TokenCreated',
+  })
+  if (typeof selector !== 'string' || typeof topic1 !== 'string')
+    throw new Error('Invalid TokenCreated event topics.')
+  const data = encodeAbiParameters(
+    [
+      { type: 'string' },
+      { type: 'string' },
+      { type: 'string' },
+      { type: 'address' },
+      { type: 'address' },
+      { type: 'bytes32' },
+    ],
+    ['Forged USD', 'FUSD', 'USD', zeroAddress, attacker, zeroHash],
+  )
+  await query(`INSERT INTO tidx_42431.logs
+    (block_num, block_timestamp, log_idx, tx_idx, tx_hash, address, selector, topic0, topic1, data)
+    VALUES (100, '2026-01-01 00:00:00', 0, 0, '${zeroHash}', '${attacker}', '${selector}', '${selector}', '${topic1}', '${data}')`)
+}

package/src/apps/data/routes/tokens.test.ts

@@ -19,7 +19,7 @@ function app(options: TestApp.create.Options = {}) {
   return TestApp.client({ db, ...options })
 }
 
-const verifiedTokenCount = 6
+const verifiedTokenCount = 7
 
 describe('getTokenMetadata', () => {
   const address = '0x20c0000000000000000000000000000000000001'
@@ -914,14 +914,14 @@ describe('GET /tokens?verified=true', () => {
 
   test('paginates the verified list via limit + cursor', async () => {
     const client = app({ assetsPath: false })
-    // Full list for comparison (6 verified tokens on the test chain).
+    // Full list for comparison (7 verified tokens on the test chain).
     const full = await TestApp.json(
       await client.v1.tokens.$get({ query: { verified: 'true' } }, TestApp.auth),
       Tokens.schema.getTokens.Response,
     )
 
     // First page: a bounded slice with a cursor to the next page (`minLimit` is
-    // 5, and the test chain has 6 verified tokens, so a page of 5 leaves 1).
+    // 5, and the test chain has 7 verified tokens, so a page of 5 leaves 2).
     const first = await TestApp.json(
       await client.v1.tokens.$get({ query: { verified: 'true', limit: '5' } }, TestApp.auth),
       Tokens.schema.getTokens.Response,
@@ -937,7 +937,7 @@ describe('GET /tokens?verified=true', () => {
       ),
       Tokens.schema.getTokens.Response,
     )
-    expect(second.data.length).toBe(1)
+    expect(second.data.length).toBe(verifiedTokenCount - 5)
     expect(second.nextCursor).toBeNull()
 
     // The two pages reconstruct the full list in order, with no overlap.

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

@@ -1,7 +1,7 @@
 import { Hono, type Context } from 'hono'
 import { AbiEvent, AbiParameters, Hash } from 'ox'
 import { type Address, ContractFunctionExecutionError } from 'viem'
-import { Abis } from 'viem/tempo'
+import { Abis, Addresses } from 'viem/tempo'
 import * as z from 'zod/mini'
 
 import * as Assets from '../../../Assets.js'
@@ -52,6 +52,7 @@ const tokenCreatedSignature =
 // lookup reads the raw `logs` table by topic0 and ABI-decodes the data blob
 // instead.
 const tokenCreatedTopic = AbiEvent.getSelector(tokenCreatedSignature)
+const tip20Factory = Addresses.tip20Factory.toLowerCase()
 
 // Non-indexed `TokenCreated` data layout, in event-parameter order:
 // `[name, symbol, currency, quoteToken, admin, salt]`.
@@ -2072,7 +2073,7 @@ export async function getTokenCreatedAtByAddress(
 
   if (addresses.length === 0) return {}
 
-  const key = (address: string) => `token:v1:${options.chainId}:${address}:created_at`
+  const key = (address: string) => `token:v2:${options.chainId}:${address}:created_at`
 
   const cached = await Promise.all(addresses.map((address) => store.get(key(address))))
   const createdAtByAddress: Record<string, string> = {}
@@ -2095,7 +2096,8 @@ export async function getTokenCreatedAtByAddress(
       query: `
         SELECT token, block_timestamp
         FROM tokencreated
-        WHERE token IN (${misses.map((address) => `'${address}'`).join(', ')})
+        WHERE address = '${tip20Factory}'
+          AND token IN (${misses.map((address) => `'${address}'`).join(', ')})
       `,
       signatures: [tokenCreatedSignature],
     })
@@ -2165,7 +2167,7 @@ async function getTokenCreatedByAddress(
 
   if (addresses.length === 0) return {}
 
-  const key = (address: string) => `token:v2:${options.chainId}:${address}:created`
+  const key = (address: string) => `token:v3:${options.chainId}:${address}:created`
 
   const cached = await Promise.all(addresses.map((address) => store.get(key(address))))
   const createdByAddress: Record<string, getTokenCreatedByAddress.Created> = {}
@@ -2193,6 +2195,7 @@ async function getTokenCreatedByAddress(
         SELECT topic1, data, block_timestamp
         FROM logs
         WHERE selector = '${tokenCreatedTopic}'
+          AND address = '${tip20Factory}'
           AND topic1 IN (${misses.map((address) => `'0x${'0'.repeat(24)}${address.slice(2)}'`).join(', ')})
       ` as string,
     })
@@ -2445,7 +2448,9 @@ async function getTokens(c: Context<App.Environment>, options: getTokens.Options
         // here are real columns like `block_num` and `currency`, plus the
         // cursor keyset; verified-only mode is handled above by serving the
         // curated static list directly.
-        const filters: string[] = []
+        // Authenticate the emitter before pagination so forged events cannot
+        // crowd canonical factory-created tokens out of the public list.
+        const filters = [`address = '${tip20Factory}'`]
         if (cursor !== undefined)
           filters.push(
             Cursor.keyset([
@@ -2490,7 +2495,7 @@ async function getTokens(c: Context<App.Environment>, options: getTokens.Options
         }
       },
       {
-        key: `token:v1:${options.chainId}:indexed:${order}:${encodeURIComponent(options.currency?.toLowerCase() ?? '')}:${cursor ? `cursor:${cursor[0]}:${cursor[1]}` : offset !== undefined ? `page:${options.page}` : 'head'}:${limit}`,
+        key: `token:v2:${options.chainId}:indexed:${order}:${encodeURIComponent(options.currency?.toLowerCase() ?? '')}:${cursor ? `cursor:${cursor[0]}:${cursor[1]}` : offset !== undefined ? `page:${options.page}` : 'head'}:${limit}`,
         store,
         ttl: Ttl.minutes(2),
       },

package/src/apps/data/routes/transactions.test.ts

@@ -3,6 +3,7 @@
 import { Schema } from 'tapimo/server'
 import { Hex } from 'ox'
 import { zeroHash } from 'viem'
+import { Addresses } from 'viem/tempo'
 
 import * as TestApp from '../../../../test/App.js'
 import * as Runtime from '../../../../test/runtime.js'
@@ -502,4 +503,32 @@ describe('GET /transactions?address=…', () => {
       head.data.slice(5, 10).map((entry) => entry.hash),
     )
   })
+
+  test('serves an ascending page for a token contract that never sends', async () => {
+    // A TIP-20 contract never sends, so its `"from"` side has no matches: the
+    // ascending shape that can time out into the fenced retry.
+    const client = TestApp.client()
+    const response = await client.v1.transactions.$get(
+      { query: { address: Addresses.pathUsd, include: 'receipt', limit: '10', order: 'asc' } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Transactions.schema.getTransactions.Response)
+    expect(response.status).toBe(200)
+    expect({
+      ascending: body.data.every(
+        (entry, index) =>
+          index === 0 || (body.data[index - 1]!.blockNumber ?? 0) <= (entry.blockNumber ?? 0),
+      ),
+      everyReceiptMatchesHash: body.data.every(
+        (entry) => entry.meta.receipt?.transactionHash === entry.hash,
+      ),
+      everyRecipientIsToken: body.data.every((entry) => entry.recipient === Addresses.pathUsd),
+    }).toMatchInlineSnapshot(`
+      {
+        "ascending": true,
+        "everyReceiptMatchesHash": true,
+        "everyRecipientIsToken": true,
+      }
+    `)
+  })
 })