tapimo 0.9.0 → 0.10.1

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

@@ -297,8 +297,8 @@ describe('GET /addresses/:address/balances', () => {
           currency: 'USD',
           decimals: 6,
           logoUri: 'https://example.com/pathusd.svg',
-          name: 'PathUSD',
-          symbol: 'pathUSD',
+          name: 'Curated PathUSD',
+          symbol: 'curatedUSD',
         },
       ],
     })
@@ -321,9 +321,49 @@ describe('GET /addresses/:address/balances', () => {
     const body = await TestApp.json(response, Balances.schema.getAddressBalances.Response)
     expect(response.status).toBe(200)
     expect(body.data.length).toBeGreaterThan(0)
+    expect(response.headers.get('server-timing')).not.toContain('token_logo;dur=')
+    expect(response.headers.get('server-timing')).not.toContain('token_metadata;dur=')
     for (const balance of body.data) expect(balance.token.verified).toBe(true)
     const pathUsd = body.data.find((balance) => balance.token.address === TestApp.tokenWithHolders)
-    expect(pathUsd?.token.logoUri).toMatch(/^http/)
+    expect(pathUsd?.token).toMatchObject({
+      logoUri: 'https://example.com/pathusd.svg',
+      name: 'Curated PathUSD',
+      symbol: 'curatedUSD',
+    })
+  })
+
+  test('includes uploaded logos for verified tokens without a logo URI', async () => {
+    const logoDb = TestApp.database()
+    await TestApp.verifiedSeed(logoDb, runtime.chainId, {
+      tokens: [
+        {
+          address: TestApp.tokenWithHolders,
+          currency: 'USD',
+          decimals: 6,
+          name: 'Curated PathUSD',
+          symbol: 'curatedUSD',
+        },
+      ],
+    })
+    const client = app({ db: logoDb })
+    const holder = await holderWithBalance
+
+    const response = await client.v1.addresses[':address'].balances.$get(
+      {
+        param: { address: holder },
+        query: { limit: '20', verified: 'true' },
+      },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Balances.schema.getAddressBalances.Response)
+    const pathUsd = body.data.find((balance) => balance.token.address === TestApp.tokenWithHolders)
+
+    expect(response.status).toBe(200)
+    expect(response.headers.get('server-timing')).toContain('token_logo;dur=')
+    expect(response.headers.get('server-timing')).not.toContain('token_metadata;dur=')
+    expect(pathUsd?.token.logoUri).toBe(
+      `http://localhost/assets/${runtime.chainId}/icons/${TestApp.tokenWithHolders}`,
+    )
   })
 
   test('narrows balances by currency and retains verification', async () => {
@@ -360,7 +400,23 @@ describe('GET /addresses/:address/balances', () => {
     for (const balance of body.data) expect(typeof balance.feeEligible).toBe('boolean')
   })
 
-  test('values each verified holding in the default denomination', async () => {
+  test('skips the fee-token lookup when an address has no holdings', async () => {
+    const client = app()
+    const response = await client.v1.addresses[':address'].balances.$get(
+      {
+        param: { address: privateKeyToAccount(generatePrivateKey()).address },
+        query: {},
+      },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Balances.schema.getAddressBalances.Response)
+
+    expect(response.status).toBe(200)
+    expect(body.data).toEqual([])
+    expect(response.headers.get('server-timing')).not.toContain('fee_token_set;dur=')
+  })
+
+  test('omits valuations unless a denomination is requested', async () => {
     await TestApp.verifiedSeed(db, runtime.chainId)
     const client = app()
     const holder = await holderWithBalance
@@ -371,12 +427,8 @@ describe('GET /addresses/:address/balances', () => {
     )
     const body = await TestApp.json(response, Balances.schema.getAddressBalances.Response)
     expect(response.status).toBe(200)
-
-    // The guaranteed pathUSD holding is curated USD, so its USD value is the
-    // holding itself; unverified holdings are never valued.
-    const pathUsd = body.data.find((entry) => entry.token.address === TestApp.tokenWithHolders)
-    expect(pathUsd?.valuation).toEqual({ amount: pathUsd!.formatted, currency: 'USD' })
-    for (const entry of body.data) if (!entry.token.verified) expect(entry.valuation).toBeNull()
+    expect(response.headers.get('server-timing')).not.toContain('valuation_rates;dur=')
+    for (const entry of body.data) expect('valuation' in entry).toBe(false)
   })
 
   test('values holdings in a requested denomination', async () => {
@@ -444,6 +496,26 @@ describe('GET /addresses/:address/balances', () => {
     expect(stable.error.code).toMatchInlineSnapshot(`"query_invalid"`)
   })
 
+  test('rejects unsupported denominations before balance RPC failures', async () => {
+    const client = app({
+      fx: { oracle: fixed },
+      rpc: { url: () => 'http://127.0.0.1:1' },
+    })
+    const holder = await holderWithBalance
+
+    const response = await client.v1.addresses[':address'].balances.$get(
+      {
+        param: { address: holder },
+        query: { 'valuation.currency': 'JPY' },
+      },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+
+    expect(response.status).toMatchInlineSnapshot(`400`)
+    expect(body.error.code).toMatchInlineSnapshot(`"query_invalid"`)
+  })
+
   test('restricts the page to fee tokens when feeEligible=true', async () => {
     const client = app()
     const holder = await holderWithBalance
@@ -489,7 +561,44 @@ describe('GET /v1/addresses/:address/balances/:token', () => {
     expect(body.token.address).toBe(TestApp.tokenWithHolders)
     expect(body.amount).toMatch(/^\d+$/)
     expect(core_Value.from(body.formatted, body.decimals)).toBe(BigInt(body.amount))
+    expect('valuation' in body).toBe(false)
+    expect(response.headers.get('server-timing')).not.toContain('valuation_rates;dur=')
+  })
+
+  test('values one balance when a denomination is requested', async () => {
+    const client = app()
+    const holder = await holderWithBalance
+    const response = await client.v1.addresses[':address'].balances[':token'].$get(
+      {
+        param: { address: holder, token: TestApp.tokenWithHolders },
+        query: { 'valuation.currency': 'USD' },
+      },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Balances.schema.getAddressBalance.Response)
+
+    expect(response.status).toBe(200)
     expect(body.valuation).toEqual({ amount: body.formatted, currency: 'USD' })
+    expect(response.headers.get('server-timing')).toContain('valuation_rates;dur=')
+  })
+
+  test('rejects an unsupported denomination before a balance RPC failure', async () => {
+    const client = app({
+      fx: { oracle: fixed },
+      rpc: { url: () => 'http://127.0.0.1:1' },
+    })
+    const holder = await holderWithBalance
+    const response = await client.v1.addresses[':address'].balances[':token'].$get(
+      {
+        param: { address: holder, token: TestApp.tokenWithHolders },
+        query: { 'valuation.currency': 'JPY' },
+      },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+
+    expect(response.status).toMatchInlineSnapshot(`400`)
+    expect(body.error.code).toMatchInlineSnapshot(`"query_invalid"`)
   })
 
   test('returns zero for a token the account does not hold', async () => {

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

@@ -66,7 +66,12 @@ export namespace schema {
         include: Schema.totalCountInclude,
         limit: Schema.Limit,
         page: Schema.Page,
-        'valuation.currency': Schema.Denomination,
+        'valuation.currency': Schema.Denomination.check(
+          z.describe(
+            'When present, include each holding’s nominal value in this denomination. ' +
+              'Case-insensitive and must be priced by the configured FX oracle.',
+          ),
+        ),
         verified: z
           .optional(Schema.booleanQuery())
           .check(
@@ -141,11 +146,11 @@ export namespace schema {
           ),
         token: Tokens.schema.Token,
         valuation: z
-          .nullable(Valuation.schema.Value)
+          .optional(z.nullable(Valuation.schema.Value))
           .check(
             z.describe(
-              'The holding’s nominal value in the requested `valuation.currency`, or `null` when the ' +
-                'token is unverified, its display currency has no rate, or rates were unavailable.',
+              'The holding’s nominal value when `valuation.currency` is requested, or `null` when ' +
+                'the token is unverified, its display currency has no rate, or rates were unavailable.',
             ),
           ),
       }),
@@ -198,7 +203,12 @@ export namespace schema {
     export const Query = z
       .strictObject({
         chainId: Schema.ChainIdQuery,
-        'valuation.currency': Schema.Denomination,
+        'valuation.currency': Schema.Denomination.check(
+          z.describe(
+            'When present, include the holding’s nominal value in this denomination. ' +
+              'Case-insensitive and must be priced by the configured FX oracle.',
+          ),
+        ),
       })
       .check(z.describe('Query parameters for reading one account token balance.'))
 
@@ -229,7 +239,7 @@ export function addresses(options: addresses.Options = {}) {
       }),
       OpenApi.describeRoute({
         description:
-          'Lists how much of each TIP-20 token an account holds, ordered from largest to smallest balance. Amounts are returned in raw base units and human-readable form, and each verified holding carries its nominal value in the requested denomination.',
+          'Lists how much of each TIP-20 token an account holds, ordered from largest to smallest balance. Amounts are returned in raw base units and human-readable form. Pass `valuation.currency` to include nominal values.',
         operationId: 'getAddressBalances',
         responses: OpenApi.responses({
           errors: { 502: 'Could not read balance or token data from an upstream service.' },
@@ -269,26 +279,13 @@ export function addresses(options: addresses.Options = {}) {
           const verified = query.verified || query.currency !== undefined
           const feeEligible = query.feeEligible ?? false
 
-          // The fee-token set powers both the per-row `feeEligible` flag (always)
-          // and the optional `feeEligible=true` page restriction. It is memoized
-          // per chain (a near-constant), so one read feeds the page, the count,
-          // and the row enrichment. It is a best-effort enrichment: a lookup
-          // failure omits `feeEligible` rather than failing the page — unless the
-          // caller explicitly asked to filter by `feeEligible`, where the filter
-          // can't be honored, so the failure surfaces as the declared `502`.
-          const feeTokens = await FeeAmm.feeTokenSet(c, chainId).catch((cause) => {
-            if (feeEligible) throw cause
-            return undefined
-          })
-
           const balances = await getAddressBalances(c, {
             address,
             chainId,
             currency: query.currency,
             cursor: query.cursor,
-            denomination: query['valuation.currency'] ?? 'USD',
+            denomination: query['valuation.currency'],
             feeEligible,
-            feeTokens,
             includeTotalCount: query.include.includes('totalCount'),
             limit: query.limit,
             oracle,
@@ -356,29 +353,43 @@ export function addresses(options: addresses.Options = {}) {
         const { address, token } = c.req.valid('param')
         const query = c.req.valid('query')
         const chainId = query.chainId ?? c.get('chainId')
+        const denomination = query['valuation.currency']
 
         try {
-          const snapshot = await VerifiedTokens.snapshot(c, chainId)
-          const [balance, resolvedToken] = await Promise.all([
+          const rates = denomination
+            ? await Valuation.rateSet(c, oracle)
+                .then((rates) => {
+                  if (denomination !== rates.base && rates.rates[denomination] === undefined)
+                    throw new Valuation.UnsupportedDenominationError(denomination, oracle.name)
+                  return rates
+                })
+                .catch((cause) => {
+                  if (cause instanceof Valuation.UnsupportedDenominationError) throw cause
+                  return undefined
+                })
+            : undefined
+          const snapshotPromise = VerifiedTokens.snapshot(c, chainId)
+          const resolvedTokenPromise = snapshotPromise.then((snapshot) =>
+            Timing.time(c, 'token', () =>
+              Tokens.resolveToken(c, { address: token, chainId, include: [], snapshot }),
+            ),
+          )
+          const client = c.get('getClient')(chainId)
+          const caller = c.get('zones').has(chainId)
+            ? (await client.zone.getZoneInfo()).sequencers[0]
+            : undefined
+          const [balance, feeTokens, snapshot, resolvedToken] = await Promise.all([
             Timing.time(c, 'balance_rpc', async () => {
-              const result = await Actions.token.getBalance(c.get('getClient')(chainId), {
+              const call = Actions.token.getBalance.call(client, {
                 account: address,
                 token,
               })
-              return result.amount
+              return client.readContract({ ...call, account: caller })
             }),
-            Timing.time(c, 'token', () =>
-              Tokens.resolveToken(c, { address: token, chainId, include: [], snapshot }),
-            ),
+            FeeAmm.feeTokenSet(c, chainId).catch(() => undefined),
+            snapshotPromise,
+            resolvedTokenPromise,
           ])
-          const denomination = query['valuation.currency'] ?? 'USD'
-          const rates = await Valuation.ratesFor(c, {
-            currencies: snapshot.byAddress.has(token) ? [resolvedToken.currency] : [],
-            denomination,
-            oracle,
-          })
-          const feeTokens = await FeeAmm.feeTokenSet(c, chainId).catch(() => undefined)
-
           return c.json(
             Response.validated(schema.getAddressBalance.Response, {
               amount: balance.toString(),
@@ -388,12 +399,16 @@ export function addresses(options: addresses.Options = {}) {
               formatted: core_Value.format(balance, resolvedToken.decimals),
               id: token,
               token: resolvedToken,
-              valuation: Valuation.valuationFor({
-                amount: balance,
-                denomination,
-                rates,
-                token: snapshot.byAddress.get(token),
-              }),
+              ...(denomination
+                ? {
+                    valuation: Valuation.valuationFor({
+                      amount: balance,
+                      denomination,
+                      rates,
+                      token: snapshot.byAddress.get(token),
+                    }),
+                  }
+                : {}),
             }),
             200,
           )
@@ -430,7 +445,6 @@ async function getAddressBalances(
     currency,
     denomination,
     feeEligible,
-    feeTokens,
     includeTotalCount,
     limit,
     oracle,
@@ -440,8 +454,9 @@ async function getAddressBalances(
   const cursor = options.cursor ? Cursor.decode(options.cursor, ['uint', 'address']) : undefined
   const offset = options.page !== undefined && options.page > 1 ? (options.page - 1) * limit : 0
 
-  // Validate the requested denomination independently of the current page.
-  await Valuation.ratesFor(c, { currencies: [], denomination, oracle })
+  // Validate an explicit denomination before balance discovery and correction
+  // so dependency failures cannot mask a caller error.
+  if (denomination) await Valuation.ratesFor(c, { currencies: [], denomination, oracle })
 
   // Build the optional `token IN (…)` restriction before hitting TIDX. The
   // verified/`currency` filter and the `feeEligible` filter each contribute a set
@@ -450,17 +465,32 @@ async function getAddressBalances(
   // intersection. If any active filter rules every token out, return an empty
   // page without a round trip. The snapshot is reused for the page enrichment
   // below.
-  const snapshot = await VerifiedTokens.snapshot(c, chainId)
-  const allowed = allowedTokens({ currency, feeEligible, feeTokens, snapshot, verified })
+  const snapshotPromise = VerifiedTokens.snapshot(c, chainId)
+  // Fee filtering can fail before the concurrently started snapshot is awaited.
+  // Observing this branch prevents an unhandled rejection; the later await still propagates it.
+  void snapshotPromise.catch(() => undefined)
+  const [snapshot_filter, feeTokens_filter] = await Promise.all([
+    verified ? snapshotPromise : Promise.resolve(undefined),
+    feeEligible ? FeeAmm.feeTokenSet(c, chainId) : Promise.resolve(undefined),
+  ])
+  const allowed = allowedTokens({
+    currency,
+    feeEligible,
+    feeTokens: feeTokens_filter,
+    snapshot: snapshot_filter,
+    verified,
+  })
   const tokenFilter = allowed?.map((address) => `'${address}'`)
-  if (tokenFilter?.length === 0)
+  if (tokenFilter?.length === 0) {
+    await snapshotPromise
     return {
       data: [],
       ...(includeTotalCount ? { meta: { totalCount: 0, totalCountCapped: false } } : {}),
       nextCursor: null,
     }
+  }
 
-  const holdings = await Timing.time(c, 'balances_discovery', async () => {
+  const holdingsPromise = Timing.time(c, 'balances_discovery', async () => {
     const tokenIn = tokenFilter ? ` AND token IN (${tokenFilter.join(', ')})` : ''
 
     const result = await tidx.fetch({
@@ -481,36 +511,58 @@ async function getAddressBalances(
     })
   })
 
-  if (holdings.length === 0)
+  // Correction starts as soon as discovery completes. Snapshot and fee-token
+  // cache misses continue concurrently until enrichment needs their results.
+  const correctedPromise = holdingsPromise.then(async (holdings) => {
+    if (holdings.length === 0) return []
+    const client = c.get('getClient')(chainId)
+    const caller = c.get('zones').has(chainId)
+      ? (await client.zone.getZoneInfo()).sequencers[0]
+      : undefined
+    return Timing.time(c, 'balances_rpc', async () => {
+      // Concurrent reads enter viem's shared batch window and become one
+      // deployless multicall. A failed read fails the request rather than serving
+      // a stale or partial balance page.
+      const results = await Promise.all(
+        holdings.map(async (holding) => {
+          const call = Actions.token.getBalance.call(client, {
+            account: address,
+            token: holding.address,
+          })
+          const amount = await client.readContract({ ...call, account: caller })
+          return amount === 0n ? undefined : { address: holding.address, amount: amount.toString() }
+        }),
+      )
+      const rows = results.filter((holding) => holding !== undefined)
+
+      rows.sort((a, b) => {
+        const delta = BigInt(b.amount) - BigInt(a.amount)
+        if (delta !== 0n) return delta > 0n ? 1 : -1
+        return a.address < b.address ? -1 : a.address > b.address ? 1 : 0
+      })
+      return rows
+    })
+  })
+  const feeTokensPromise = feeEligible
+    ? Promise.resolve(feeTokens_filter)
+    : holdingsPromise.then((holdings) =>
+        holdings.length === 0 ? undefined : FeeAmm.feeTokenSet(c, chainId).catch(() => undefined),
+      )
+
+  const [holdings, snapshot, feeTokens, corrected] = await Promise.all([
+    holdingsPromise,
+    snapshotPromise,
+    feeTokensPromise,
+    correctedPromise,
+  ])
+
+  if (holdings.length === 0) {
     return {
       data: [],
       ...(includeTotalCount ? { meta: { totalCount: 0, totalCountCapped: false } } : {}),
       nextCursor: null,
     }
-
-  const client = c.get('getClient')(chainId)
-  const corrected = await Timing.time(c, 'balances_rpc', async () => {
-    // Concurrent reads enter viem's shared batch window and become one
-    // deployless multicall. A failed read fails the request rather than serving
-    // a stale or partial balance page.
-    const results = await Promise.all(
-      holdings.map(async (holding) => {
-        const { amount } = await Actions.token.getBalance(client, {
-          account: address,
-          token: holding.address,
-        })
-        return amount === 0n ? undefined : { address: holding.address, amount: amount.toString() }
-      }),
-    )
-    const rows = results.filter((holding) => holding !== undefined)
-
-    rows.sort((a, b) => {
-      const delta = BigInt(b.amount) - BigInt(a.amount)
-      if (delta !== 0n) return delta > 0n ? 1 : -1
-      return a.address < b.address ? -1 : a.address > b.address ? 1 : 0
-    })
-    return rows
-  })
+  }
 
   const positioned = (() => {
     if (!cursor) return corrected.slice(offset)
@@ -528,7 +580,7 @@ async function getAddressBalances(
     key: (holding) => [holding.amount, holding.address],
   })
 
-  if (page.rows.length === 0)
+  if (page.rows.length === 0) {
     return {
       data: [],
       ...(includeTotalCount
@@ -536,22 +588,38 @@ async function getAddressBalances(
         : {}),
       nextCursor: page.nextCursor,
     }
+  }
 
-  const rates = await Valuation.ratesFor(c, {
-    currencies: page.rows.flatMap((row) => {
-      const held = snapshot.byAddress.get(row.address.toLowerCase())?.currency
-      return held === undefined ? [] : [held]
-    }),
-    denomination,
-    oracle,
-  })
+  const ratesPromise = denomination
+    ? Valuation.ratesFor(c, {
+        currencies: page.rows.flatMap((row) => {
+          const held = snapshot.byAddress.get(row.address.toLowerCase())?.currency
+          return held === undefined ? [] : [held]
+        }),
+        denomination,
+        oracle,
+      })
+    : Promise.resolve(undefined)
 
   // Balance tokens retain their logo and verification metadata by default.
-  const resolved = await Timing.time(c, 'tokens', () =>
+  const resolvedPromise = Timing.time(c, 'tokens', () =>
     Promise.all(
       page.rows.map(async (holding) => {
         try {
           const token = Schema.Address.parse(holding.address.toLowerCase())
+          const verifiedToken = snapshot.byAddress.get(token)
+          // The curated list owns verified-token metadata, but uploaded logos live only in the asset store.
+          if (verifiedToken)
+            return {
+              amount: holding.amount,
+              logoUri:
+                verifiedToken.logoUri ??
+                (await Timing.time(c, 'token_logo', () =>
+                  Tokens.getTokenLogo(c, { address: token, chainId }),
+                ).catch(() => undefined)),
+              metadata: verifiedToken,
+              token,
+            }
           const [logoUri, metadata] = await Promise.all([
             Timing.time(c, 'token_logo', () =>
               Tokens.getTokenLogo(c, { address: token, chainId }),
@@ -567,6 +635,7 @@ async function getAddressBalances(
       }),
     ),
   )
+  const [rates, resolved] = await Promise.all([ratesPromise, resolvedPromise])
 
   const data: z.output<typeof schema.getAddressBalances.Balance>[] = []
   for (const entry of resolved) {
@@ -591,12 +660,16 @@ async function getAddressBalances(
         symbol: entry.metadata.symbol,
         verified: snapshot.byAddress.has(entry.token),
       },
-      valuation: Valuation.valuationFor({
-        amount: BigInt(entry.amount),
-        denomination,
-        rates,
-        token: snapshot.byAddress.get(entry.token),
-      }),
+      ...(denomination
+        ? {
+            valuation: Valuation.valuationFor({
+              amount: BigInt(entry.amount),
+              denomination,
+              rates,
+              token: snapshot.byAddress.get(entry.token),
+            }),
+          }
+        : {}),
     })
   }
 
@@ -620,15 +693,9 @@ declare namespace getAddressBalances {
     /** Opaque keyset cursor anchoring the page; omit for the head page. */
     cursor?: string | undefined
     /** Currency the per-row valuations are denominated in (uppercase). */
-    denomination: string
-    /** When true, restrict the page to fee-usable tokens (members of `feeTokens`). */
+    denomination?: string | undefined
+    /** When true, restrict the page to fee-usable tokens. */
     feeEligible?: boolean | undefined
-    /**
-     * The chain's fee-token set, if resolved (best-effort): flags each row's
-     * `feeEligible` and backs the `feeEligible` filter. Undefined when the lookup
-     * failed, in which case `feeEligible` is omitted from rows.
-     */
-    feeTokens?: ReadonlySet<string> | undefined
     /** When true, include the corrected candidate count in response metadata. */
     includeTotalCount: boolean
     limit: number

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

@@ -0,0 +1,34 @@
+import * as QueryBench from '../../../../test/QueryBench.js'
+
+const fixtures = {
+  4217: { number: 34_335_551, timestamp: 1_786_485_830 },
+  42431: { number: 30_469_074, timestamp: 1_786_485_831 },
+} as const
+
+QueryBench.bench({ name: 'getBlocks', path: '/v1/blocks' })
+
+QueryBench.bench({
+  name: 'getBlock',
+  path: {
+    4217: `/v1/blocks/${fixtures[4217].number}`,
+    42431: `/v1/blocks/${fixtures[42431].number}`,
+  },
+})
+
+QueryBench.bench({
+  chainId: false,
+  name: 'getBlockByTimestamp',
+  path: {
+    4217: `/chains/4217/blocks/by-timestamp?closest=before&timestamp=${fixtures[4217].timestamp}`,
+    42431: `/chains/42431/blocks/by-timestamp?closest=before&timestamp=${fixtures[42431].timestamp}`,
+  },
+})
+
+QueryBench.bench({
+  chainId: false,
+  name: 'getBlockByTimestamp?closest=after',
+  path: {
+    4217: `/chains/4217/blocks/by-timestamp?closest=after&timestamp=${fixtures[4217].timestamp}`,
+    42431: `/chains/42431/blocks/by-timestamp?closest=after&timestamp=${fixtures[42431].timestamp}`,
+  },
+})

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

@@ -232,20 +232,26 @@ describe('GET /blocks', () => {
 
 describe('GET /blocks/:block (ISO 8601 timestamp)', () => {
   test('resolves an ISO 8601 timestamp to the first block at or after it', async () => {
-    expect(recent).toBeDefined()
-    const recentBlock = await Viem.getClient().getBlock({ blockNumber: recent!.number })
-    const seconds = Number(recentBlock.timestamp)
-    const iso = new Date(seconds * 1000).toISOString()
     const client = TestApp.client()
+    // Seed from TIDX rather than the RPC head, which can advance beyond the
+    // indexer's timestamp lookup watermark.
+    const blocksResponse = await client.v1.blocks.$get({ query: { limit: '5' } }, TestApp.auth)
+    const blocks = await TestApp.json(blocksResponse, Blocks.schema.getBlocks.Response)
+    const indexed = blocks.data[0]
+    expect(blocksResponse.status).toBe(200)
+    expect(indexed).toBeDefined()
+
     const response = await client.v1.blocks[':block'].$get(
-      { param: { block: iso }, query: {} },
+      { param: { block: indexed!.timestamp }, query: {} },
       TestApp.auth,
     )
     const body = await TestApp.json(response, Blocks.schema.getBlock.Response)
     expect(response.status).toBe(200)
     expect(typeof body.number).toBe('number')
     // The returned block's timestamp must be >= the requested timestamp.
-    expect(new Date(body.timestamp).getTime() / 1000).toBeGreaterThanOrEqual(seconds)
+    expect(new Date(body.timestamp).getTime()).toBeGreaterThanOrEqual(
+      new Date(indexed!.timestamp).getTime(),
+    )
   })
 
   test('returns 404 for a far-future timestamp with no indexed block', async () => {