tapimo 0.9.0 → 0.10.1

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

@@ -0,0 +1,85 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+const fixtures = {
+  4217: {
+    base: '0x20c0000000000000000000001a47bebe936d00d7',
+    filledOrderId: '3881',
+    orderId: '3312',
+  },
+  42431: {
+    base: '0x20c000000000000000000000746cbc54ce86a3cb',
+    filledOrderId: '18047908',
+    orderId: '18048313',
+  },
+} as const
+
+QueryBench.bench({
+  name: 'getSwaps',
+  path: '/v1/exchange/swaps',
+  queries: ['include=token.logoUri', 'include=token.verified', 'valuation.currency=USD'],
+})
+
+QueryBench.bench({
+  name: 'getPairs',
+  path: '/v1/exchange/pairs',
+  queries: ['include=tokens', 'include=totalCount', 'sort=liquidity'],
+})
+
+QueryBench.bench({
+  name: 'getPair',
+  path: {
+    4217: `/v1/exchange/pairs/${fixtures[4217].base}`,
+    42431: `/v1/exchange/pairs/${fixtures[42431].base}`,
+  },
+  queries: ['include=tokens'],
+})
+
+QueryBench.bench({
+  name: 'getOrders',
+  path: '/v1/exchange/orders',
+  queries: ['include=tokens', 'include=totalCount'],
+})
+
+QueryBench.bench({
+  name: 'getOrders?base',
+  path: {
+    4217: `/v1/exchange/orders?base=${fixtures[4217].base}`,
+    42431: `/v1/exchange/orders?base=${fixtures[42431].base}`,
+  },
+})
+
+QueryBench.bench({
+  name: 'getOrder',
+  path: {
+    4217: `/v1/exchange/orders/${fixtures[4217].orderId}`,
+    42431: `/v1/exchange/orders/${fixtures[42431].orderId}`,
+  },
+  queries: ['include=tokens'],
+})
+
+QueryBench.bench({
+  name: 'getOrderFills',
+  path: {
+    4217: `/v1/exchange/orders/${fixtures[4217].filledOrderId}/fills`,
+    42431: `/v1/exchange/orders/${fixtures[42431].filledOrderId}/fills`,
+  },
+  queries: ['include=totalCount'],
+})
+
+QueryBench.bench({
+  name: 'getPairOhlc',
+  path: {
+    4217: `/v1/exchange/pairs/${fixtures[4217].base}/ohlc`,
+    42431: `/v1/exchange/pairs/${fixtures[42431].base}/ohlc`,
+  },
+  queries: ['include=tokens'],
+})
+
+QueryBench.bench({
+  name: 'getPairDepth',
+  path: {
+    4217: `/v1/exchange/pairs/${fixtures[4217].base}/depth`,
+    42431: `/v1/exchange/pairs/${fixtures[42431].base}/depth`,
+  },
+  queries: ['include=tokens'],
+})

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

@@ -690,6 +690,7 @@ describe('GET /exchange/swaps', () => {
     expect(response.status).toBe(200)
     const body = await TestApp.json(response, Exchanges.schema.getSwaps.Response)
     expect(body.data.length).toBeLessThanOrEqual(10)
+    expect(response.headers.get('server-timing')).not.toContain('valuation_rates;dur=')
     if (body.data.length === 0) return
 
     for (const swap of body.data) {
@@ -708,6 +709,7 @@ describe('GET /exchange/swaps', () => {
       expect(swap.sourceAmount.currency).toBe(swap.sourceToken.currency)
       expect(swap.sourceAmount.decimals).toBe(swap.sourceToken.decimals)
       expect(swap.sourceAmount.formatted).toMatch(/^\d+(\.\d+)?$/)
+      expect('valuation' in swap.sourceAmount).toBe(false)
       expect(swap.destinationToken.address).toMatch(/^0x[0-9a-f]{40}$/)
       expect(swap.destinationToken).not.toHaveProperty('amount')
       expect(typeof swap.destinationToken.currency).toBe('string')
@@ -720,6 +722,7 @@ describe('GET /exchange/swaps', () => {
       expect(swap.destinationAmount.currency).toBe(swap.destinationToken.currency)
       expect(swap.destinationAmount.decimals).toBe(swap.destinationToken.decimals)
       expect(swap.destinationAmount.formatted).toMatch(/^\d+(\.\d+)?$/)
+      expect('valuation' in swap.destinationAmount).toBe(false)
       expect(swap.rate).toMatch(/^\d+(\.\d+)?$/)
       expect(swap.filledAt).toMatch(/^\d{4}-\d{2}-\d{2}T/)
       // `route` spans source → destination; its ends mirror the side tokens.
@@ -739,10 +742,12 @@ describe('GET /exchange/swaps', () => {
         expect(fill.sourceAmount.baseUnits).toMatch(/^\d+$/)
         expect(fill.sourceAmount.currency).toBe(fill.sourceToken.currency)
         expect(fill.sourceAmount.decimals).toBe(fill.sourceToken.decimals)
+        expect('valuation' in fill.sourceAmount).toBe(false)
         expect(fill.destinationToken).not.toHaveProperty('amount')
         expect(fill.destinationAmount.baseUnits).toMatch(/^\d+$/)
         expect(fill.destinationAmount.currency).toBe(fill.destinationToken.currency)
         expect(fill.destinationAmount.decimals).toBe(fill.destinationToken.decimals)
+        expect('valuation' in fill.destinationAmount).toBe(false)
       }
       for (let i = 1; i < swap.fills.length; i++)
         expect(swap.fills[i]!.logIndex).toBeGreaterThan(swap.fills[i - 1]!.logIndex)
@@ -1033,7 +1038,7 @@ describe('POST /exchange/quotes', () => {
     }, 120_000)
 
     test('quotes exact-source liquidity and returns approval then sell calls', async () => {
-      // Pin an empty curated list so both legs deterministically value `null`.
+      // Pin an empty curated list so optional curated fields stay deterministic.
       const db = TestApp.database()
       await TestApp.verifiedSeed(db, Runtime.get().chainId, { tokens: [] })
       const client = TestApp.client({ db })
@@ -1061,7 +1066,6 @@ describe('POST /exchange/quotes', () => {
         currency: 'USD',
         decimals: 6,
         formatted: '0.000001',
-        valuation: null,
       })
       expect(body.destinationToken).toMatchObject({
         address: Addresses.pathUsd,
@@ -1076,7 +1080,6 @@ describe('POST /exchange/quotes', () => {
         currency: 'USD',
         decimals: 6,
         formatted: '0.000001',
-        valuation: null,
       })
       expect(body.sourceToken).toMatchObject({
         address: baseToken,
@@ -1103,7 +1106,7 @@ describe('POST /exchange/quotes', () => {
     }, 60_000)
 
     test('quotes exact-destination liquidity and returns approval then buy calls', async () => {
-      // Pin an empty curated list so both legs deterministically value `null`.
+      // Pin an empty curated list so optional curated fields stay deterministic.
       const db = TestApp.database()
       await TestApp.verifiedSeed(db, Runtime.get().chainId, { tokens: [] })
       const client = TestApp.client({ db })
@@ -1132,7 +1135,6 @@ describe('POST /exchange/quotes', () => {
         currency: 'USD',
         decimals: 6,
         formatted: '0.000001',
-        valuation: null,
       })
       expect(body.destinationToken).toMatchObject({
         address: baseToken,
@@ -1147,7 +1149,6 @@ describe('POST /exchange/quotes', () => {
         currency: 'USD',
         decimals: 6,
         formatted: '0.000002',
-        valuation: null,
       })
       expect(body.sourceAmount).toEqual(body.destinationAmount)
       expect(body.sourceToken).toMatchObject({

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

@@ -1776,18 +1776,22 @@ export function exchanges(options: exchanges.Options = {}) {
         try {
           // Value quoted amounts via their curated display currency; snapshot
           // or rate failures degrade the values to `null`, never the quote.
-          const denomination = query['valuation.currency'] ?? 'USD'
-          const snapshot = await VerifiedTokens.snapshot(c, chainId).catch(() => undefined)
-          const rates = await Valuation.ratesFor(c, {
-            currencies: snapshot
-              ? [request.destinationToken, request.sourceToken].flatMap((address) => {
-                  const held = snapshot.byAddress.get(address.toLowerCase())?.currency
-                  return held === undefined ? [] : [held]
-                })
-              : [],
-            denomination,
-            oracle,
-          })
+          const denomination = query['valuation.currency']
+          const snapshot = denomination
+            ? await VerifiedTokens.snapshot(c, chainId).catch(() => undefined)
+            : undefined
+          const rates = denomination
+            ? await Valuation.ratesFor(c, {
+                currencies: snapshot
+                  ? [request.destinationToken, request.sourceToken].flatMap((address) => {
+                      const held = snapshot.byAddress.get(address.toLowerCase())?.currency
+                      return held === undefined ? [] : [held]
+                    })
+                  : [],
+                denomination,
+                oracle,
+              })
+            : undefined
           const valued = (
             baseUnits: bigint | string,
             address: string,
@@ -1798,12 +1802,16 @@ export function exchanges(options: exchanges.Options = {}) {
               currency: token.currency,
               decimals: token.decimals,
             }),
-            valuation: Valuation.valuationFor({
-              amount: BigInt(baseUnits),
-              denomination,
-              rates,
-              token: snapshot?.byAddress.get(address.toLowerCase()),
-            }),
+            ...(denomination
+              ? {
+                  valuation: Valuation.valuationFor({
+                    amount: BigInt(baseUnits),
+                    denomination,
+                    rates,
+                    token: snapshot?.byAddress.get(address.toLowerCase()),
+                  }),
+                }
+              : {}),
           })
 
           if (options.nativeDex === false || amount > maxSwapAmount)
@@ -2210,23 +2218,25 @@ export function exchanges(options: exchanges.Options = {}) {
           })
           // Value amounts via their curated display currency; snapshot or rate
           // failures degrade the values to `null`, never the feed.
-          const denomination = options['valuation.currency'] ?? 'USD'
+          const denomination = options['valuation.currency']
           const snapshot =
-            page.data.length > 0
+            denomination !== undefined && page.data.length > 0
               ? await VerifiedTokens.snapshot(c, chainId).catch(() => undefined)
               : undefined
-          const rates = await Valuation.ratesFor(c, {
-            currencies: snapshot
-              ? page.data.flatMap((swap) =>
-                  swap.route.flatMap((address) => {
-                    const held = snapshot.byAddress.get(address.toLowerCase())?.currency
-                    return held === undefined ? [] : [held]
-                  }),
-                )
-              : [],
-            denomination,
-            oracle,
-          })
+          const rates = denomination
+            ? await Valuation.ratesFor(c, {
+                currencies: snapshot
+                  ? page.data.flatMap((swap) =>
+                      swap.route.flatMap((address) => {
+                        const held = snapshot.byAddress.get(address.toLowerCase())?.currency
+                        return held === undefined ? [] : [held]
+                      }),
+                    )
+                  : [],
+                denomination,
+                oracle,
+              })
+            : undefined
           const enrichSide = (side: getSwaps.Side) => {
             const token = tokensByAddress.get(side.address)
             if (!token) throw new Error(`Token metadata unavailable for ${side.address}`)
@@ -2237,12 +2247,16 @@ export function exchanges(options: exchanges.Options = {}) {
                   currency: token.currency,
                   decimals: token.decimals,
                 }),
-                valuation: Valuation.valuationFor({
-                  amount: BigInt(side.amount),
-                  denomination,
-                  rates,
-                  token: snapshot?.byAddress.get(side.address.toLowerCase()),
-                }),
+                ...(denomination
+                  ? {
+                      valuation: Valuation.valuationFor({
+                        amount: BigInt(side.amount),
+                        denomination,
+                        rates,
+                        token: snapshot?.byAddress.get(side.address.toLowerCase()),
+                      }),
+                    }
+                  : {}),
               },
               token: {
                 address: side.address,
@@ -3705,12 +3719,8 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
     }
 
     // A selective row predicate (`taker`/`maker`/`participant`/`transactionHash`)
-    // makes matching fills sparse across a wide block range, so enumerate the
-    // exact blocks holding a matching fill up front: it is cheap (bloom-indexed,
-    // no `GROUP BY`/`groupArray`) and lets the window sweep jump straight to the
-    // next populated block instead of paying a full grouped round-trip for every
-    // empty `swapWindowBlocks` gap between clusters. The block list also yields
-    // the scan bounds, so no separate `min`/`max` query is needed.
+    // makes matching fills sparse across a wide block range. Find the next
+    // populated block before each window so the sweep skips empty gaps.
     //
     // The discovery predicate must be a *superset* of the grouped page query's
     // matches. The page query applies `maker`/`participant` as existential
@@ -3735,24 +3745,35 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
       if (witnesses.length > 0) blockFilters.push(`(${witnesses.join(' OR ')})`)
     }
 
-    // Distinct matching blocks, ascending (binary-searched in `windowFrom`).
-    // Only populated for selective queries; the unfiltered feed would match
-    // nearly every block, so it keeps the `min`/`max` bound + fixed-stride sweep.
-    let matchingBlocks: number[] | undefined
-    const bounds = await Timing.time(c, 'swap_bounds', async () => {
+    const cursorBlock = cursor !== undefined ? Number(cursor[0]) : undefined
+
+    // Keep discovery bounded so TIDX response limits cannot truncate the scan
+    // head. The predicate stays a superset of the grouped query.
+    const findMatchingBlock = async (anchor: number | undefined) => {
+      const filters = [...blockFilters]
+      if (anchor !== undefined)
+        filters.push(`f.block_num ${order === 'asc' ? '>=' : '<='} ${anchor}`)
+      const result = await tidx.fetch({
+        chainId,
+        engine: 'clickhouse',
+        query:
+          `SELECT f.block_num AS block_num FROM dex_fills f WHERE ${filters.join(' AND ')} ORDER BY block_num ${direction} LIMIT 1` as string,
+      })
+      const row = result.rows[0]
+      return row ? Value.toNumber(row['block_num']) : undefined
+    }
+
+    type ScanBounds = BlockWindow & { firstMatchingBlock?: number | undefined }
+    const bounds: ScanBounds | undefined = await Timing.time(c, 'swap_bounds', async () => {
       if (selective) {
-        const result = await tidx.fetch({
-          chainId,
-          engine: 'clickhouse',
-          query:
-            `SELECT DISTINCT f.block_num AS block_num FROM dex_fills f WHERE ${blockFilters.join(' AND ')} ORDER BY block_num ASC` as string,
-        })
-        matchingBlocks = result.rows
-          .map((row) => Value.toNumber(row['block_num']))
-          .filter((block): block is number => block !== undefined)
-        const lo = matchingBlocks[0]
-        const hi = matchingBlocks.at(-1)
-        return lo !== undefined && hi !== undefined ? { hi, lo } : undefined
+        const firstMatchingBlock = await findMatchingBlock(cursorBlock)
+        return firstMatchingBlock !== undefined
+          ? {
+              firstMatchingBlock,
+              hi: toBlock ?? Number.MAX_SAFE_INTEGER,
+              lo: fromBlock ?? 0,
+            }
+          : undefined
       }
       const result = await tidx.fetch({
         chainId,
@@ -3779,60 +3800,38 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
       // exhausts the window and slides the sweep to the next disjoint range.
       const batchLimit = limit + 1
       let activeCursor = cursor
-      const cursorBlock = cursor !== undefined ? Number(cursor[0]) : undefined
-
-      // Snap an anchor block onto the matching-block list (selective queries):
-      // the largest matching block `<= value` (desc) / smallest `>= value`
-      // (asc). This collapses the empty gaps between fill clusters — `slideWindow`
-      // jumps straight to the next populated block. `undefined` when no matching
-      // block remains in range. `matchingBlocks` is ascending.
-      const lastAtMost = (value: number): number | undefined => {
-        if (matchingBlocks === undefined) return value
-        let lo = 0
-        let hi = matchingBlocks.length
-        while (lo < hi) {
-          const mid = (lo + hi) >> 1
-          if (matchingBlocks[mid]! <= value) lo = mid + 1
-          else hi = mid
-        }
-        return lo === 0 ? undefined : matchingBlocks[lo - 1]
-      }
-      const firstAtLeast = (value: number): number | undefined => {
-        if (matchingBlocks === undefined) return value
-        let lo = 0
-        let hi = matchingBlocks.length
-        while (lo < hi) {
-          const mid = (lo + hi) >> 1
-          if (matchingBlocks[mid]! < value) lo = mid + 1
-          else hi = mid
-        }
-        return lo === matchingBlocks.length ? undefined : matchingBlocks[lo]
-      }
 
-      const windowFrom = (anchor: number | undefined): BlockWindow | undefined => {
+      // Selective scans jump to the next populated block through a bounded
+      // lookup. Unfiltered scans retain the fixed-stride min/max sweep.
+      const windowFrom = async (
+        anchor: number | undefined,
+        knownMatchingBlock?: number,
+      ): Promise<BlockWindow | undefined> => {
         if (order === 'desc') {
-          const hi = lastAtMost(Math.min(upperBound, anchor ?? upperBound))
+          const value = Math.min(upperBound, anchor ?? upperBound)
+          const hi = selective ? (knownMatchingBlock ?? (await findMatchingBlock(value))) : value
           return hi !== undefined && hi >= lowerBound
             ? { hi, lo: Math.max(lowerBound, hi - swapWindowBlocks + 1) }
             : undefined
         }
-        const lo = firstAtLeast(Math.max(lowerBound, anchor ?? lowerBound))
+        const value = Math.max(lowerBound, anchor ?? lowerBound)
+        const lo = selective ? (knownMatchingBlock ?? (await findMatchingBlock(value))) : value
         return lo !== undefined && lo <= upperBound
           ? { hi: Math.min(upperBound, lo + swapWindowBlocks - 1), lo }
           : undefined
       }
 
-      let window = windowFrom(cursorBlock)
+      let window = await windowFrom(cursorBlock, bounds.firstMatchingBlock)
 
       // Slide to the next disjoint window away from the newest block and reset
       // the cursor: every row in the next window is already past the cursor
       // anchor in the requested order, so no anchor refinement is needed.
-      const slideWindow = () => {
+      const slideWindow = async () => {
         activeCursor = undefined
         window =
           window === undefined
             ? undefined
-            : windowFrom(order === 'desc' ? window.lo - 1 : window.hi + 1)
+            : await windowFrom(order === 'desc' ? window.lo - 1 : window.hi + 1)
       }
 
       while (accumulated.length <= limit && window !== undefined) {
@@ -3857,14 +3856,14 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
         const tail = groups.at(-1)
         if (tail === undefined) {
           if (fetchedFull) break
-          slideWindow()
+          await slideWindow()
           continue
         }
 
         // A short batch exhausts this window; a full one may leave more groups
         // in it, so advance the keyset cursor and re-query the same window.
         if (!fetchedFull) {
-          slideWindow()
+          await slideWindow()
           continue
         }
         const next = cursorAfterWholeGroup(tail)
@@ -3875,7 +3874,7 @@ async function getSwaps(c: Context<App.Environment>, options: getSwaps.Options)
           Number(activeCursor[1]) === next[1] &&
           Number(activeCursor[2]) === next[2]
         ) {
-          slideWindow()
+          await slideWindow()
           continue
         }
         activeCursor = [next[0], next[1], next[2]]
@@ -5623,30 +5622,38 @@ async function providerQuoteResponse(
   if (!destinationToken || !sourceToken)
     throw new Error('Unable to resolve exchange quote token metadata')
 
-  const denomination = query['valuation.currency'] ?? 'USD'
-  const snapshot = await VerifiedTokens.snapshot(c, chainId).catch(() => undefined)
-  const rates = await Valuation.ratesFor(c, {
-    currencies: snapshot
-      ? [request.destinationToken, request.sourceToken].flatMap((address) => {
-          const held = snapshot.byAddress.get(address.toLowerCase())?.currency
-          return held === undefined ? [] : [held]
-        })
-      : [],
-    denomination,
-    oracle,
-  })
+  const denomination = query['valuation.currency']
+  const snapshot = denomination
+    ? await VerifiedTokens.snapshot(c, chainId).catch(() => undefined)
+    : undefined
+  const rates = denomination
+    ? await Valuation.ratesFor(c, {
+        currencies: snapshot
+          ? [request.destinationToken, request.sourceToken].flatMap((address) => {
+              const held = snapshot.byAddress.get(address.toLowerCase())?.currency
+              return held === undefined ? [] : [held]
+            })
+          : [],
+        denomination,
+        oracle,
+      })
+    : undefined
   const valued = (
     baseUnits: bigint | string,
     address: string,
     token: { currency: string; decimals: number },
   ) => ({
     ...Value.tokenAmount({ baseUnits, currency: token.currency, decimals: token.decimals }),
-    valuation: Valuation.valuationFor({
-      amount: BigInt(baseUnits),
-      denomination,
-      rates,
-      token: snapshot?.byAddress.get(address.toLowerCase()),
-    }),
+    ...(denomination
+      ? {
+          valuation: Valuation.valuationFor({
+            amount: BigInt(baseUnits),
+            denomination,
+            rates,
+            token: snapshot?.byAddress.get(address.toLowerCase()),
+          }),
+        }
+      : {}),
   })
   const execution =
     quote.status === 'ready'

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

@@ -0,0 +1,13 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+QueryBench.bench({
+  name: 'getFeeAmmPools',
+  path: '/v1/fee-amm/pools',
+  queries: ['include=token.logoUri', 'include=token.verified'],
+})
+
+QueryBench.bench({
+  name: 'getFeeAmmMints',
+  path: '/v1/fee-amm/mints',
+  queries: ['include=totalCount'],
+})

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

@@ -0,0 +1,8 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+const sql = 'SELECT num, hash FROM blocks ORDER BY num DESC LIMIT 1'
+
+QueryBench.bench({
+  name: 'indexerQuery',
+  path: `/v1/indexer/query?sql=${encodeURIComponent(sql)}`,
+})

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

@@ -150,7 +150,7 @@ describe('GET /indexer/query', () => {
       const client = TestApp.client()
       const response = await client.v1.indexer.query.$get(
         { query: { sql: 'select 1', chainId } },
-        TestApp.auth,
+        { headers: { 'x-api-key': TestApp.key.token } },
       )
 
       expect(response.status).toMatchInlineSnapshot(`200`)
@@ -161,6 +161,7 @@ describe('GET /indexer/query', () => {
       // Tempo API enforces the documented execution bounds upstream even when the
       // caller omits them.
       const upstream = new URL((fetch.mock.calls[0]![0] as Request).url)
+      expect((fetch.mock.calls[0]![0] as Request).headers.get('x-api-key')).toBeNull()
       expect(upstream.searchParams.get('timeout_ms')).toMatchInlineSnapshot(`"5000"`)
       expect(upstream.searchParams.get('limit')).toMatchInlineSnapshot(`"10000"`)
     } finally {

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

@@ -23,10 +23,11 @@ const strippedHeaders = new Set([
   'keep-alive',
   'proxy-authorization',
   'te',
+  'tempo-api-key',
   'trailer',
   'transfer-encoding',
   'upgrade',
-  'tempo-api-key',
+  'x-api-key',
   ZoneRpcAuthentication.headerName.toLowerCase(),
 ])
 
@@ -63,7 +64,7 @@ export namespace schema {
           z.meta({ examples: [1] }),
         ),
       engine: z
-        .optional(z.enum(['postgres', 'clickhouse']))
+        .optional(z.enum(['postgres', 'clickhouse', 'tiered']))
         .check(
           z.describe('Indexer engine that ran the query.'),
           z.meta({ examples: ['postgres'] }),

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

@@ -0,0 +1,39 @@
+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: 'getReceipts',
+  path: '/v1/transactions/receipts',
+  queries: [
+    'include=feeToken.logoUri',
+    'include=feeToken.verified',
+    'include=totalCount',
+    'valuation.currency=USD',
+  ],
+})
+
+QueryBench.bench({
+  name: 'getReceipts?address&include=totalCount',
+  path: {
+    4217: `/v1/transactions/receipts?address=${address[4217]}&include=totalCount`,
+    42431: `/v1/transactions/receipts?address=${address[42431]}&include=totalCount`,
+  },
+})
+
+QueryBench.bench({
+  name: 'getReceipt',
+  path: {
+    4217: `/v1/transactions/${hash[4217]}/receipt`,
+    42431: `/v1/transactions/${hash[42431]}/receipt`,
+  },
+  queries: ['include=feeToken.logoUri', 'include=feeToken.verified', 'valuation.currency=USD'],
+})