tapimo 0.9.0 → 0.10.1

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

@@ -60,6 +60,8 @@ describe('GET /transactions/:transactionHash/receipt', () => {
     expect(body.feeAmount.currency).toBe('USD')
     expect(body.feeAmount.decimals).toBe(6)
     expect(body.feeAmount.formatted).toMatch(/^\d+(\.\d+)?$/)
+    expect('valuation' in body.feeAmount).toBe(false)
+    expect(response.headers.get('server-timing')).not.toContain('valuation_rates;dur=')
     // Core fee-token metadata is present by default while the raw address stays
     // under `meta.rpc`. Curated fields remain opt-in.
     if (body.meta.rpc.feeToken) {
@@ -272,6 +274,27 @@ describe('GET /transactions/receipts', () => {
     for (const receipt of body.data) expect(receipt.status).toBe('success')
   })
 
+  test('narrows receipts by fee token', async () => {
+    const client = TestApp.client()
+    const response = await client.v1.transactions.receipts.$get(
+      {
+        query: {
+          feeToken: TestApp.tokenWithHolders,
+          include: 'totalCount',
+          limit: '5',
+        },
+      },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Receipts.schema.getReceipts.Response)
+    expect(response.status).toBe(200)
+    expect(body.data.length).toBeGreaterThan(0)
+    expect(body.meta).toBeDefined()
+    expect(body.meta!.totalCount).toBeGreaterThanOrEqual(body.data.length)
+    for (const receipt of body.data)
+      expect(receipt.meta.rpc.feeToken).toBe(TestApp.tokenWithHolders)
+  })
+
   test('embeds a capped total count on demand via include=totalCount', async () => {
     const client = TestApp.client()
 
@@ -294,13 +317,7 @@ describe('GET /transactions/receipts', () => {
     expect(body.meta!.totalCount).toBeGreaterThanOrEqual(body.data.length)
     expect(body.meta!.totalCount).toBeLessThanOrEqual(Schema.countCap)
     expect(body.meta!.totalCountCapped).toBe(body.meta!.totalCount! >= Schema.countCap)
-    // Fees are USD, so the default denomination values them at identity with
-    // no rate provenance.
-    for (const receipt of body.data)
-      expect(receipt.feeAmount.valuation).toEqual({
-        amount: receipt.feeAmount.formatted,
-        currency: 'USD',
-      })
+    for (const receipt of body.data) expect('valuation' in receipt.feeAmount).toBe(false)
     expect(body.meta!.valuation).toBeUndefined()
 
     // Without `include=totalCount`, the same page omits `meta` and the count.

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

@@ -553,22 +553,28 @@ export function receipts(options: receipts.Options = {}) {
 
           // Value each fee via its own currency tag, in the requested
           // denomination.
-          const denomination = query['valuation.currency'] ?? 'USD'
-          const rates = await Valuation.ratesFor(c, {
-            currencies: receipts.data.map((receipt) => receipt.feeAmount.currency),
-            denomination,
-            oracle,
-          })
+          const denomination = query['valuation.currency']
+          const rates = denomination
+            ? await Valuation.ratesFor(c, {
+                currencies: receipts.data.map((receipt) => receipt.feeAmount.currency),
+                denomination,
+                oracle,
+              })
+            : undefined
           const data = receipts.data.map((receipt) => ({
             ...receipt,
             feeAmount: {
               ...receipt.feeAmount,
-              valuation: Valuation.valuationFor({
-                amount: BigInt(receipt.feeAmount.baseUnits),
-                denomination,
-                rates,
-                token: receipt.feeAmount,
-              }),
+              ...(denomination
+                ? {
+                    valuation: Valuation.valuationFor({
+                      amount: BigInt(receipt.feeAmount.baseUnits),
+                      denomination,
+                      rates,
+                      token: receipt.feeAmount,
+                    }),
+                  }
+                : {}),
             },
           }))
 
@@ -680,22 +686,28 @@ export function receipts(options: receipts.Options = {}) {
 
           // Value the fee via its own currency tag, in the requested
           // denomination.
-          const denomination = query['valuation.currency'] ?? 'USD'
-          const rates = await Valuation.ratesFor(c, {
-            currencies: [enriched.feeAmount.currency],
-            denomination,
-            oracle,
-          })
+          const denomination = query['valuation.currency']
+          const rates = denomination
+            ? await Valuation.ratesFor(c, {
+                currencies: [enriched.feeAmount.currency],
+                denomination,
+                oracle,
+              })
+            : undefined
           const valued = {
             ...enriched,
             feeAmount: {
               ...enriched.feeAmount,
-              valuation: Valuation.valuationFor({
-                amount: BigInt(enriched.feeAmount.baseUnits),
-                denomination,
-                rates,
-                token: enriched.feeAmount,
-              }),
+              ...(denomination
+                ? {
+                    valuation: Valuation.valuationFor({
+                      amount: BigInt(enriched.feeAmount.baseUnits),
+                      denomination,
+                      rates,
+                      token: enriched.feeAmount,
+                    }),
+                  }
+                : {}),
             },
             meta: {
               ...enriched.meta,
@@ -771,9 +783,9 @@ export function getReceipts(c: Context<App.Environment>, options: getReceipts.Op
   return Timing.time(c, 'receipts', () =>
     Store.memoize(
       async () => {
-        // Page the `receipts` table alone, then enrich each row with the
-        // `type`/`fee_token` it does not store via a follow-up `txs` lookup
-        // (the blocks-feed pattern). Paging straight off `receipts` avoids the
+        // Page the `receipts` table alone. Fee-token queries read metadata
+        // denormalized on ClickHouse; other queries hydrate it from `txs`.
+        // Paging straight off `receipts` avoids the
         // `receipts JOIN txs` shape, which TIDX's planner cannot execute under
         // address scope: a `UNION` of two JOINs (or the `(from = X OR to = X)`
         // form) reliably returns `db error` (HTTP 422) for high-traffic
@@ -785,10 +797,9 @@ export function getReceipts(c: Context<App.Environment>, options: getReceipts.Op
         if (sender !== undefined) filters.push(`"from" = '${sender}'`)
         if (recipient !== undefined) filters.push(`"to" = '${recipient}'`)
         if (feePayer !== undefined) filters.push(`fee_payer = '${feePayer}'`)
-        // `fee_token` lives on `txs`, not `receipts`; filter via a subquery so
-        // the page query stays single-table.
-        if (feeToken !== undefined)
-          filters.push(`tx_hash IN (SELECT hash FROM txs WHERE fee_token = '${feeToken}')`)
+        // ClickHouse receipts denormalize fee metadata specifically to avoid
+        // an unbounded transaction-hash semi-join for this filter.
+        if (feeToken !== undefined) filters.push(`fee_token = '${feeToken}'`)
         if (fromBlock !== undefined) filters.push(`block_num >= ${fromBlock}`)
         if (toBlock !== undefined) filters.push(`block_num <= ${toBlock}`)
         if (fromTimestamp !== undefined) filters.push(`block_timestamp >= '${fromTimestamp}'`)
@@ -804,7 +815,7 @@ export function getReceipts(c: Context<App.Environment>, options: getReceipts.Op
 
         const columns = `block_num, block_timestamp, tx_idx, tx_hash, "from", "to",
                    contract_address, gas_used, cumulative_gas_used, effective_gas_price,
-                   status, fee_payer`
+                   status, fee_payer${feeToken === undefined ? '' : ', type, fee_token'}`
 
         // For address-scoped queries, run one branch per side and `UNION` so
         // each branch returns at most `limit + 1` index-ordered rows, the outer
@@ -814,14 +825,15 @@ export function getReceipts(c: Context<App.Environment>, options: getReceipts.Op
         //
         // The `receipts` table only indexes `from`, not `to` (a `to` scan over
         // ~25M rows hits the indexer's statement timeout and returns `db error`,
-        // HTTP 422). The `from` branch filters `receipts` directly; the `to`
-        // branch resolves matching transaction hashes from `txs` (which indexes
-        // `to`) and looks them up by the indexed `receipts.tx_hash`.
+        // HTTP 422). A fee-payer filter bounds the direct `to` scan through the
+        // receipt fee-payer index. Other `to` branches resolve matching hashes
+        // through the indexed `txs.to` and `receipts.tx_hash` columns.
         const sideQuery = (side: 'from' | 'to', addr: string) => {
-          const predicate =
-            side === 'from'
-              ? `"from" = '${addr}'`
-              : `tx_hash IN (SELECT hash FROM txs WHERE "to" = '${addr}')`
+          const predicate = (() => {
+            if (side === 'from') return `"from" = '${addr}'`
+            if (feePayer !== undefined) return `"to" = '${addr}'`
+            return `tx_hash IN (SELECT hash FROM txs WHERE "to" = '${addr}')`
+          })()
           const where = [predicate, ...filters].join(' AND ')
           // In the offset lane each branch over-fetches the full window
           // (`offset + limit + 1` rows) because the skip applies to the merged
@@ -847,7 +859,11 @@ export function getReceipts(c: Context<App.Environment>, options: getReceipts.Op
               LIMIT ${limit + 1}${skip}
             `
 
-        const result = await tidx.fetch({ chainId, query: query as string })
+        const result = await tidx.fetch({
+          chainId,
+          ...(feeToken !== undefined ? { engine: 'clickhouse' } : {}),
+          query: query as string,
+        })
 
         // The next page anchors below the last fetched row's `(block, tx_idx)`.
         const page = Cursor.paginate({
@@ -860,11 +876,8 @@ export function getReceipts(c: Context<App.Environment>, options: getReceipts.Op
           },
         })
 
-        // Enrich the page with `type`/`fee_token` from `txs` in a single
-        // `IN (...)` lookup scoped to the page's transaction hashes. `txs` is
-        // sorted by `(block_num, idx)` with no hash index, so the hash list
-        // must be paired with the page's block numbers — a bare `hash IN`
-        // full-scans the table.
+        // Enrich non-fee-token pages with metadata from `txs`. Pairing hashes
+        // with their blocks avoids a full-table hash scan.
         const hashes = [
           ...new Set(
             page.rows
@@ -880,7 +893,7 @@ export function getReceipts(c: Context<App.Environment>, options: getReceipts.Op
           ),
         ]
         const txByHash = new Map<string, { feeToken: unknown; type: unknown }>()
-        if (hashes.length > 0 && blocks.length > 0) {
+        if (feeToken === undefined && hashes.length > 0 && blocks.length > 0) {
           const txs = await tidx.fetch({
             chainId,
             query: `SELECT hash, type, fee_token FROM txs WHERE block_num IN (${blocks.join(
@@ -900,7 +913,8 @@ export function getReceipts(c: Context<App.Environment>, options: getReceipts.Op
         const data: humanizeReceipt.Output[] = []
         for (const row of page.rows) {
           const tx = typeof row['tx_hash'] === 'string' ? txByHash.get(row['tx_hash']) : undefined
-          const merged = { ...row, fee_token: tx?.feeToken, type: tx?.type }
+          const merged =
+            feeToken === undefined ? { ...row, fee_token: tx?.feeToken, type: tx?.type } : row
           const rpc = schema.Rpc.Receipt.safeParse(toRpcReceipt(merged))
           if (rpc.success) data.push(humanizeReceipt(rpc.data))
         }
@@ -950,8 +964,7 @@ function countFilters(options: countReceipts.Options): string[] {
   if (options.sender !== undefined) filters.push(`"from" = '${options.sender}'`)
   if (options.recipient !== undefined) filters.push(`"to" = '${options.recipient}'`)
   if (options.feePayer !== undefined) filters.push(`fee_payer = '${options.feePayer}'`)
-  if (options.feeToken !== undefined)
-    filters.push(`tx_hash IN (SELECT hash FROM txs WHERE fee_token = '${options.feeToken}')`)
+  if (options.feeToken !== undefined) filters.push(`fee_token = '${options.feeToken}'`)
   if (options.fromBlock !== undefined) filters.push(`block_num >= ${options.fromBlock}`)
   if (options.toBlock !== undefined) filters.push(`block_num <= ${options.toBlock}`)
   if (options.fromTimestamp !== undefined)
@@ -1003,7 +1016,11 @@ export function countReceipts(
             ) AS capped
           `
         }
-        const result = await tidx.fetch({ chainId, query: query as string })
+        const result = await tidx.fetch({
+          chainId,
+          ...(options.feeToken !== undefined ? { engine: 'clickhouse' } : {}),
+          query: query as string,
+        })
         const totalCount = Value.toNumber(result.rows[0]?.['total']) ?? 0
         return { totalCountCapped: totalCount >= Schema.countCap, totalCount }
       },

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

@@ -0,0 +1,14 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+QueryBench.bench({
+  body: {
+    id: 1,
+    jsonrpc: '2.0',
+    method: 'eth_blockNumber',
+    params: [],
+  },
+  chainId: false,
+  method: 'POST',
+  name: 'rpcRequest',
+  path: { 4217: '/rpc/mainnet', 42431: '/rpc/testnet' },
+})

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

@@ -53,6 +53,30 @@ function zoneToken() {
 }
 
 describe('POST /rpc', () => {
+  test('allows 20 public requests per second', async () => {
+    vi.useFakeTimers({ now: new Date('2026-08-12T00:00:00.000Z') })
+    try {
+      const app = TestApp.create()
+      const request = () =>
+        app.request('/rpc', {
+          body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'tempo_blockNumber' }),
+          method: 'POST',
+        })
+      const responses = await Promise.all(
+        Array.from({ length: 21 }, () => Promise.resolve(request())),
+      )
+      const limited = responses.find((response) => response.status === 429)!
+
+      expect(responses.filter((response) => response.status === 401)).toHaveLength(20)
+      expect(limited.headers.get('RateLimit-Limit')).toBe('20')
+
+      vi.advanceTimersByTime(1_000)
+      expect((await Promise.resolve(request())).status).toBe(401)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   test('routes by principal: a resolver sees the request principal and routes accordingly', async () => {
     const fetch = mockRpc()
     // A resolver that routes API-key principals to the private upstream and
@@ -113,6 +137,7 @@ describe('POST /rpc', () => {
             'content-type': 'application/json',
             cookie: 'session=secret',
             'tempo-api-key': 'caller-key',
+            'x-api-key': 'legacy-caller-key',
             'x-authorization-token': 'zone-secret',
             'x-client-trace': 'trace_test',
           },
@@ -139,6 +164,7 @@ describe('POST /rpc', () => {
       expect(call.headers['authorization']).toMatchInlineSnapshot(`"Basic cnBjOnNlY3JldA=="`)
       expect(call.headers['cookie']).toMatchInlineSnapshot(`null`)
       expect(call.headers['tempo-api-key']).toMatchInlineSnapshot(`null`)
+      expect(call.headers['x-api-key']).toBeNull()
       expect(call.headers['x-authorization-token']).toBeNull()
       expect(call.headers['x-client-trace']).toMatchInlineSnapshot(`"trace_test"`)
     } finally {
@@ -1156,6 +1182,7 @@ function mockRpc() {
         authorization: request.headers.get('authorization'),
         cookie: request.headers.get('cookie'),
         'tempo-api-key': request.headers.get('tempo-api-key'),
+        'x-api-key': request.headers.get('x-api-key'),
         'x-authorization-token': request.headers.get('x-authorization-token'),
         'x-client-trace': request.headers.get('x-client-trace'),
       },

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

@@ -26,6 +26,7 @@ const strippedHeaders = new Set([
   'trailer',
   'transfer-encoding',
   'upgrade',
+  'x-api-key',
   ZoneRpcAuthentication.headerName.toLowerCase(),
 ])
 
@@ -163,7 +164,10 @@ export namespace schema {
 export function rpc() {
   return new Hono<App.Environment>().post(
     '/rpc/:chain{(mainnet|testnet|[0-9]+)}?',
-    Auth.policy({ apiKey: { scopes: ['data:read'] }, public: true }),
+    Auth.policy({
+      apiKey: { scopes: ['data:read'] },
+      public: { rateLimit: { limit: 20, period: 'second' } },
+    }),
     OpenApi.describeRoute({
       description:
         'Sends a single or batch Ethereum JSON-RPC request directly to Tempo. Use `/rpc/testnet`, `/rpc/mainnet`, or `/rpc/:chain` to choose a chain. Zone read scopes permit read-only methods; Zone write scopes also permit signed transaction broadcasts. A Zone token in `X-Authorization-Token` is forwarded to the authenticated Zone RPC. This passthrough is not part of the stable API contract and is supported on a best-effort basis only. It has no compatibility, latency, availability, or data-freshness guarantees, and breaking changes may happen with limited notice.',

package/src/apps/data/routes/tokenlist.bench.ts

@@ -0,0 +1,3 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+QueryBench.bench({ name: 'getTokenList', path: '/v1/tokenlist' })

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

@@ -0,0 +1,76 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+const address = {
+  4217: '0xc24357119432595a547cb2c1e41c51d753645519',
+  42431: '0x15496d3123afb2cfadc0ac068eadd11d0f8ae799',
+} as const
+
+QueryBench.bench({
+  name: 'getTokens',
+  path: '/v1/tokens',
+  queries: [
+    `addresses=${QueryBench.pathUsd}`,
+    `addresses=${QueryBench.pathUsd}&include=admin,createdAt,holderCount,quoteToken,transferStats`,
+    'include=admin',
+    'include=createdAt',
+    'include=holderCount',
+    'include=quoteToken',
+    'include=transferStats',
+    'verified=true',
+    'verified=true&include=admin,createdAt,holderCount,quoteToken,transferStats',
+  ],
+})
+
+QueryBench.bench({
+  name: 'getTokenBySymbol',
+  path: '/v1/tokens/pathUSD',
+  queries: [
+    'include=admin',
+    'include=createdAt',
+    'include=holderCount',
+    'include=quoteToken',
+    'include=transferStats',
+  ],
+})
+
+QueryBench.bench({
+  name: 'getToken',
+  path: `/v1/tokens/${QueryBench.pathUsd}`,
+  queries: [
+    'include=admin',
+    'include=createdAt',
+    'include=holderCount',
+    'include=quoteToken',
+    'include=transferStats',
+  ],
+})
+
+QueryBench.bench({
+  name: 'getTokenLogo',
+  path: `/v1/tokens/${QueryBench.pathUsd}/logo`,
+})
+
+QueryBench.bench({
+  name: 'getTokenHolders',
+  path: `/v1/tokens/${QueryBench.pathUsd}/holders`,
+  queries: ['include=token', 'include=totalCount'],
+})
+
+QueryBench.bench({
+  name: 'getTokenTransactions',
+  path: `/v1/tokens/${QueryBench.pathUsd}/transactions`,
+  queries: [
+    'include=feeToken.logoUri',
+    'include=feeToken.verified',
+    'include=token',
+    'include=totalCount',
+  ],
+})
+
+QueryBench.bench({
+  name: 'getTokenTransactions?feePayer&include=totalCount',
+  path: {
+    4217: `/v1/tokens/${QueryBench.pathUsd}/transactions?feePayer=${address[4217]}&include=totalCount`,
+    42431: `/v1/tokens/${QueryBench.pathUsd}/transactions?feePayer=${address[42431]}&include=totalCount`,
+  },
+})

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

@@ -1121,6 +1121,57 @@ describe('GET /tokens/:token/transactions', () => {
     expect(secondBody.data.every((entry) => !firstHashes.has(entry.hash))).toBe(true)
   })
 
+  test('filters and counts by fee payer through receipts with pagination', async () => {
+    const client = app()
+    const seedResponse = await client.v1.tokens[':token'].transactions.$get(
+      { param: { token: TestApp.token }, query: { limit: '50' } },
+      TestApp.auth,
+    )
+    const seed = await TestApp.json(seedResponse, Tokens.schema.getTokenTransactions.Response)
+    const feePayers = seed.data.flatMap((transaction) => {
+      const feePayer = transaction.meta.rpc.feePayer
+      return typeof feePayer === 'string' ? [feePayer] : []
+    })
+    const feePayer = feePayers.find(
+      (candidate) => feePayers.filter((value) => value === candidate).length > 5,
+    )
+    if (!feePayer) return
+
+    const first = await client.v1.tokens[':token'].transactions.$get(
+      {
+        param: { token: TestApp.token },
+        query: { feePayer, include: 'totalCount', limit: '5' },
+      },
+      TestApp.auth,
+    )
+    const firstBody = await TestApp.json(first, Tokens.schema.getTokenTransactions.Response)
+    expect(first.status).toBe(200)
+    expect(first.headers.get('server-timing')).toContain('receipts;dur=')
+    expect(first.headers.get('server-timing')).toContain('receipts_count;dur=')
+    expect(firstBody.data).toHaveLength(5)
+    expect(firstBody.meta?.totalCount).toBeGreaterThanOrEqual(firstBody.data.length)
+    expect(firstBody.data.every((transaction) => transaction.meta.rpc.feePayer === feePayer)).toBe(
+      true,
+    )
+    if (!firstBody.nextCursor) return
+
+    const second = await client.v1.tokens[':token'].transactions.$get(
+      {
+        param: { token: TestApp.token },
+        query: { cursor: firstBody.nextCursor, feePayer, limit: '5' },
+      },
+      TestApp.auth,
+    )
+    const secondBody = await TestApp.json(second, Tokens.schema.getTokenTransactions.Response)
+    expect(second.status).toBe(200)
+    expect(secondBody.data.length).toBeGreaterThan(0)
+    expect(secondBody.data.every((transaction) => transaction.meta.rpc.feePayer === feePayer)).toBe(
+      true,
+    )
+    const firstHashes = new Set(firstBody.data.map((transaction) => transaction.hash))
+    expect(secondBody.data.every((transaction) => !firstHashes.has(transaction.hash))).toBe(true)
+  })
+
   test('returns 400 for an invalid token address', async () => {
     // The typed client requires `token: `Hex.Hex`` so an invalid literal
     // cannot pass through it; exercise the validator via `app.request`.

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

@@ -0,0 +1,40 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+const hash = {
+  4217: '0x7f98e4b2bf4d1444b257526f7dd294ac3480d73cd91f723bf0df6062d1ba1c82',
+  42431: '0x1c8ccebb169f863b72388cc057fcecee240032eb7d2c64aa6f6fb8e5a60d3f9a',
+} as const
+
+const address = {
+  4217: '0xc24357119432595a547cb2c1e41c51d753645519',
+  42431: '0x15496d3123afb2cfadc0ac068eadd11d0f8ae799',
+} as const
+
+QueryBench.bench({
+  name: 'getTransactions',
+  path: '/v1/transactions',
+  queries: [
+    'include=feeToken.logoUri',
+    'include=feeToken.verified',
+    'include=receipt',
+    'include=totalCount',
+    'status=success&include=totalCount',
+  ],
+})
+
+QueryBench.bench({
+  name: 'getTransactions?address&include=totalCount',
+  path: {
+    4217: `/v1/transactions?address=${address[4217]}&include=totalCount`,
+    42431: `/v1/transactions?address=${address[42431]}&include=totalCount`,
+  },
+})
+
+QueryBench.bench({
+  name: 'getTransaction',
+  path: {
+    4217: `/v1/transactions/${hash[4217]}`,
+    42431: `/v1/transactions/${hash[42431]}`,
+  },
+  queries: ['include=feeToken.logoUri', 'include=feeToken.verified', 'include=receipt'],
+})

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

@@ -311,6 +311,48 @@ describe('GET /transactions', () => {
     `)
   })
 
+  test('filters and counts by fee payer through receipts with pagination', async () => {
+    const client = TestApp.client()
+    const seedResponse = await client.v1.transactions.$get({ query: { limit: '50' } }, TestApp.auth)
+    const seed = await TestApp.json(seedResponse, Transactions.schema.getTransactions.Response)
+    const feePayers = seed.data.flatMap((transaction) => {
+      const feePayer = transaction.meta.rpc.feePayer
+      return typeof feePayer === 'string' ? [feePayer] : []
+    })
+    const feePayer = feePayers.find(
+      (candidate) => feePayers.filter((value) => value === candidate).length > 5,
+    )
+    if (!feePayer) return
+
+    const first = await client.v1.transactions.$get(
+      { query: { feePayer, include: 'totalCount', limit: '5' } },
+      TestApp.auth,
+    )
+    const firstBody = await TestApp.json(first, Transactions.schema.getTransactions.Response)
+    expect(first.status).toBe(200)
+    expect(first.headers.get('server-timing')).toContain('receipts;dur=')
+    expect(first.headers.get('server-timing')).toContain('receipts_count;dur=')
+    expect(firstBody.data).toHaveLength(5)
+    expect(firstBody.meta?.totalCount).toBeGreaterThanOrEqual(firstBody.data.length)
+    expect(firstBody.data.every((transaction) => transaction.meta.rpc.feePayer === feePayer)).toBe(
+      true,
+    )
+    if (!firstBody.nextCursor) return
+
+    const second = await client.v1.transactions.$get(
+      { query: { cursor: firstBody.nextCursor, feePayer, limit: '5' } },
+      TestApp.auth,
+    )
+    const secondBody = await TestApp.json(second, Transactions.schema.getTransactions.Response)
+    expect(second.status).toBe(200)
+    expect(secondBody.data.length).toBeGreaterThan(0)
+    expect(secondBody.data.every((transaction) => transaction.meta.rpc.feePayer === feePayer)).toBe(
+      true,
+    )
+    const firstHashes = new Set(firstBody.data.map((transaction) => transaction.hash))
+    expect(secondBody.data.every((transaction) => !firstHashes.has(transaction.hash))).toBe(true)
+  })
+
   test('filters reverted transactions by execution status', async () => {
     const client = TestApp.client()
     const response = await client.v1.transactions.$get(