tapimo 0.10.0 → 0.10.2

package/src/internal/Store.test.ts

@@ -389,6 +389,39 @@ describe('durableObject', () => {
     `)
   })
 
+  test('preserves bigint values and collision-shaped strings', async () => {
+    const { namespace } = TestStore.durableObjectNamespace()
+    const store = Store.durableObject<{
+      value: { bigint: bigint; legacyMarker: string; valueMarker: string }
+    }>(namespace)
+    const value = {
+      bigint: 42n,
+      legacyMarker: '123#__bigint',
+      valueMarker: 'tempo-api:store:value:bigint:123',
+    }
+
+    await store.put('value', value)
+    await store.update('value', (current) => ({
+      op: 'set',
+      result: undefined,
+      value: { ...current!, bigint: current!.bigint + 1n },
+    }))
+
+    expect(await store.get('value')).toEqual({ ...value, bigint: 43n })
+  })
+
+  test('reads typed values written with the legacy codec', async () => {
+    const { getState, namespace } = TestStore.durableObjectNamespace()
+    await getState('channel').put('channel', 'tempo-api:store:json:v1:{"spent":"42#__bigint"}')
+    const store = Store.durableObject<TypedItems>(namespace)
+
+    expect(await store.get('channel')).toMatchInlineSnapshot(`
+      {
+        "spent": 42n,
+      }
+    `)
+  })
+
   test('keeps typed updates linearizable', async () => {
     const { namespace } = TestStore.durableObjectNamespace()
     const storeA = Store.durableObject<TypedItems>(namespace)
@@ -439,11 +472,11 @@ describe('durableObject', () => {
 
   test('rejects typed values written with an unknown codec version', async () => {
     const { getState, namespace } = TestStore.durableObjectNamespace()
-    await getState('channel').put('channel', 'tempo-api:store:json:v2:{}')
+    await getState('channel').put('channel', 'tempo-api:store:json:v3:{}')
     const store = Store.durableObject<TypedItems>(namespace)
 
     await expect(store.get('channel')).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[Store.DurableObjectCodecError: Unsupported Durable Object store codec version: v2]`,
+      `[Store.DurableObjectCodecError: Unsupported Durable Object store codec version: v3]`,
     )
   })
 
@@ -744,11 +777,9 @@ describe('memoize', () => {
     const values = await Promise.all(requests)
 
     expect(calls).toMatchInlineSnapshot(`1`)
-    expect(JSON.parse((await store.get('memo:test')) ?? 'null')).toMatchInlineSnapshot(`
-      {
-        "value": "fresh",
-      }
-    `)
+    expect(await store.get('memo:test')).toMatchInlineSnapshot(
+      `"tempo-api:store:json:v2:{"value":"fresh"}"`,
+    )
     expect(values).toMatchInlineSnapshot(`
       [
         {
@@ -805,8 +836,65 @@ describe('memoize', () => {
     `)
   })
 
+  test('preserves bigint values and collision-shaped strings on cache hits', async () => {
+    const store = Store.memory()
+    let calls = 0
+    const fetch = async () => {
+      calls += 1
+      return {
+        bigint: 42n,
+        legacyMarker: '123#__bigint',
+        valueMarker: 'tempo-api:store:value:bigint:123',
+      }
+    }
+
+    const first = await Store.memoize(fetch, { key: 'memo:test', store, ttl: 60_000 })
+    const second = await Store.memoize(fetch, { key: 'memo:test', store, ttl: 60_000 })
+
+    expect(first).toEqual(second)
+    expect(second).toEqual({
+      bigint: 42n,
+      legacyMarker: '123#__bigint',
+      valueMarker: 'tempo-api:store:value:bigint:123',
+    })
+    expect(calls).toBe(1)
+  })
+
+  test('does not cache undefined results', async () => {
+    const store = Store.memory()
+    let calls = 0
+    const fetch = async () => {
+      calls += 1
+      return undefined
+    }
+
+    const first = await Store.memoize(fetch, { key: 'memo:test', store, ttl: 60_000 })
+    const second = await Store.memoize(fetch, { key: 'memo:test', store, ttl: 60_000 })
+
+    expect(first).toBeUndefined()
+    expect(second).toBeUndefined()
+    expect(await store.get('memo:test')).toBeNull()
+    expect(calls).toBe(2)
+  })
+
+  test('refreshes legacy untagged cache entries', async () => {
+    const store = Store.memory({ entries: [['memo:test', '{"value":"123#__bigint"}']] })
+    let calls = 0
+
+    const value = await Store.memoize(
+      async () => {
+        calls += 1
+        return { value: '123#__bigint' }
+      },
+      { key: 'memo:test', store, ttl: 60_000 },
+    )
+
+    expect(value).toEqual({ value: '123#__bigint' })
+    expect(calls).toBe(1)
+  })
+
   test('refreshes corrupt cache entries', async () => {
-    const store = Store.memory({ entries: [['memo:test', 'not-json']] })
+    const store = Store.memory({ entries: [['memo:test', 'tempo-api:store:json:v2:not-json']] })
 
     const value = await Store.memoize(async () => ({ value: 'fresh' }), {
       key: 'memo:test',
@@ -819,11 +907,9 @@ describe('memoize', () => {
         "value": "fresh",
       }
     `)
-    expect(JSON.parse((await store.get('memo:test')) ?? 'null')).toMatchInlineSnapshot(`
-      {
-        "value": "fresh",
-      }
-    `)
+    expect(await store.get('memo:test')).toMatchInlineSnapshot(
+      `"tempo-api:store:json:v2:{"value":"fresh"}"`,
+    )
   })
 })
 

package/src/internal/Store.ts

@@ -578,7 +578,8 @@ export declare namespace durableObject {
 /**
  * Wraps an async producer with store-backed caching. Returns the cached value if
  * present and valid; otherwise runs `fetch`, stores the JSON-encoded result
- * under `key` with `ttl` milliseconds, and returns it.
+ * under `key` with `ttl` milliseconds, and returns it. Undefined results are
+ * returned without being cached.
  */
 export async function memoize<value>(
   fetch: () => Promise<value>,
@@ -587,9 +588,11 @@ export async function memoize<value>(
   const { key, store, ttl } = options
 
   const raw = await store.get(key)
-  if (raw) {
+  // Old cache entries used ambiguous untagged bigint strings. Refresh them
+  // instead of guessing whether a matching string was originally a bigint.
+  if (raw?.startsWith(jsonCodecPrefix)) {
     try {
-      return Json.parse(raw) as value
+      return jsonDecode(raw) as value
     } catch {
       // Corrupt entries are treated as misses so the next call refreshes.
     }
@@ -604,7 +607,8 @@ export async function memoize<value>(
   // fetch is still in flight.
   const flight = (async () => {
     const value = await fetch()
-    await store.put(key, Json.stringify(value), { ttl })
+    if (value === undefined) return value
+    await store.put(key, jsonEncode(value), { ttl })
     return value
   })()
   flights.set(key, flight)
@@ -721,24 +725,55 @@ async function durableObjectRetry<value>(call: () => Promise<value>): Promise<va
   }
 }
 
-const durableObjectCodecRoot = 'tempo-api:store:json:'
-const durableObjectCodecVersion = 'v1'
-const durableObjectCodecPrefix = `${durableObjectCodecRoot}${durableObjectCodecVersion}:`
+const jsonCodecRoot = 'tempo-api:store:json:'
+const jsonCodecVersion = 'v2'
+const jsonCodecPrefix = `${jsonCodecRoot}${jsonCodecVersion}:`
+const jsonValuePrefix = 'tempo-api:store:value:'
+const legacyDurableObjectCodecPrefix = `${jsonCodecRoot}v1:`
+
+function jsonEncode(value: unknown): string {
+  const encoded = JSON.stringify(value, (_key, item) => {
+    if (typeof item === 'bigint') return `${jsonValuePrefix}bigint:${item}`
+    if (typeof item === 'string' && item.startsWith(jsonValuePrefix))
+      return `${jsonValuePrefix}string:${item}`
+    return item
+  })
+  if (encoded === undefined) throw new TypeError('Store value is not serializable')
+  return `${jsonCodecPrefix}${encoded}`
+}
+
+function jsonDecode(value: string): unknown {
+  return JSON.parse(value.slice(jsonCodecPrefix.length), (_key, item) => {
+    if (typeof item !== 'string' || !item.startsWith(jsonValuePrefix)) return item
+    if (item.startsWith(`${jsonValuePrefix}string:`))
+      return item.slice(`${jsonValuePrefix}string:`.length)
+    if (item.startsWith(`${jsonValuePrefix}bigint:`)) {
+      const bigint = item.slice(`${jsonValuePrefix}bigint:`.length)
+      if (!/^-?\d+$/.test(bigint)) throw new TypeError('Store bigint is malformed')
+      return BigInt(bigint)
+    }
+    throw new TypeError('Store value tag is unsupported')
+  })
+}
 
 function durableObjectEncode(value: unknown): string {
-  if (typeof value === 'string' && !value.startsWith(durableObjectCodecRoot)) return value
-  const encoded = Json.stringify(value)
-  if (encoded === undefined) throw new TypeError('Durable Object store value is not serializable')
-  return `${durableObjectCodecPrefix}${encoded}`
+  if (typeof value === 'string' && !value.startsWith(jsonCodecRoot)) return value
+  try {
+    return jsonEncode(value)
+  } catch (cause) {
+    throw new TypeError('Durable Object store value is not serializable', {
+      cause,
+    })
+  }
 }
 
 function durableObjectDecode(value: null | string): unknown {
-  if (value === null || !value.startsWith(durableObjectCodecRoot)) return value
-  if (!value.startsWith(durableObjectCodecPrefix)) {
-    const [version] = value.slice(durableObjectCodecRoot.length).split(':')
-    throw new DurableObjectCodecError(version)
-  }
-  return Json.parse(value.slice(durableObjectCodecPrefix.length))
+  if (value === null || !value.startsWith(jsonCodecRoot)) return value
+  if (value.startsWith(jsonCodecPrefix)) return jsonDecode(value)
+  if (value.startsWith(legacyDurableObjectCodecPrefix))
+    return Json.parse(value.slice(legacyDurableObjectCodecPrefix.length))
+  const [version] = value.slice(jsonCodecRoot.length).split(':')
+  throw new DurableObjectCodecError(version)
 }
 
 function cloudflareKvExpirationTtl(ttl: number | undefined) {

package/src/internal/Tidx.test.ts

@@ -330,9 +330,9 @@ describe('resolve', () => {
   test('passes Zone metadata to the resolver', () => {
     expect(
       Tidx.resolve(({ zone }) => ({ baseUrl: zone ? 'http://tidx:8080' : undefined }), {
-        chainId: Zones.zoneModerato.id,
+        chainId: Zones.zoneModeratoInternal.id,
         principal: null,
-        zone: Zones.zoneModerato,
+        zone: Zones.zoneModeratoInternal,
       }),
     ).toMatchInlineSnapshot(`
       {
@@ -469,7 +469,7 @@ describe('getClient', () => {
     )
     try {
       const client = Tidx.getClient({
-        chainId: Zones.zoneModerato.id,
+        chainId: Zones.zoneModeratoInternal.id,
         tidx: {
           baseUrl: 'https://internal.indexer',
           zoneHeaders: {
@@ -477,7 +477,7 @@ describe('getClient', () => {
             'CF-Access-Client-Secret': 'client-secret',
           },
         },
-        zone: Zones.zoneModerato,
+        zone: Zones.zoneModeratoInternal,
       })
       await client.fetch({ query: 'select 1' })
 

package/src/internal/Tidx.ts

@@ -1,7 +1,8 @@
 import { Tidx } from 'tidx.ts'
 import type { Chain } from 'viem'
 
-import * as Auth from './Auth.js'
+import type * as Auth from './Auth.js'
+import * as Credential from './Credential.js'
 import * as Errors from './Errors.js'
 import type * as Log from './Log.js'
 import * as Viem from './Viem.js'
@@ -40,7 +41,7 @@ export function resolve(
 ): resolve.Resolved {
   const config = typeof tidx === 'function' ? tidx(context) : tidx
   return {
-    ...Auth.resolveCredential({ chainId: context.chainId, value: config?.auth }),
+    ...Credential.resolveCredential({ chainId: context.chainId, value: config?.auth }),
     ...(context.zone && config?.zoneHeaders ? { zoneHeaders: config.zoneHeaders } : {}),
     baseUrl:
       Viem.resolveUrl(config?.baseUrl, context.chainId) ??
@@ -319,7 +320,7 @@ export declare namespace getClient {
   type Tidx =
     | {
         /** Shared or per-chain TIDX credentials. Values containing `:` use Basic auth; others use Bearer auth. */
-        auth?: Auth.ChainCredential | undefined
+        auth?: Credential.ChainCredential | undefined
         /** Resolves the TIDX base URL for a Tempo chain id, or a static base URL. */
         baseUrl?: UrlResolver | undefined
         /** Headers sent to Zone indexer upstreams. */
@@ -327,7 +328,7 @@ export declare namespace getClient {
       }
     | ((context: Viem.resolveRpc.Context) => {
         /** Shared or per-chain TIDX credentials, or undefined for none. */
-        auth?: Auth.ChainCredential | undefined
+        auth?: Credential.ChainCredential | undefined
         /** TIDX base URL to use; falls back to the built-in public host when omitted. */
         baseUrl?: string | undefined
         /** Headers sent to Zone indexer upstreams. */

package/src/internal/Value.test.ts

@@ -1,5 +1,30 @@
 import * as Value from './Value.js'
 
+describe('blockToIso', () => {
+  test('prefers the millisecond timestamp on a raw header', () => {
+    expect(
+      Value.blockToIso({ timestamp: '0x6a7b5571', timestampMillis: '0x19ff1c5c312' }),
+    ).toMatchInlineSnapshot(`"2026-08-11T17:01:37.426Z"`)
+  })
+
+  test('falls back to whole seconds when the millisecond timestamp is absent', () => {
+    expect(Value.blockToIso({ timestamp: '0x6a7b5571' })).toMatchInlineSnapshot(
+      `"2026-08-11T17:01:37.000Z"`,
+    )
+  })
+
+  test('reads a viem-formatted header', () => {
+    expect(
+      Value.blockToIso({ timestamp: 1_786_467_697n, timestampMillis: '0x19ff1c5c312' }),
+    ).toMatchInlineSnapshot(`"2026-08-11T17:01:37.426Z"`)
+  })
+
+  test('returns undefined without a usable timestamp', () => {
+    expect(Value.blockToIso(undefined)).toMatchInlineSnapshot(`undefined`)
+    expect(Value.blockToIso({ timestamp: null })).toMatchInlineSnapshot(`undefined`)
+  })
+})
+
 describe('tokenAmount', () => {
   test('renders a self-contained token quantity', () => {
     expect(

package/src/internal/Value.ts

@@ -111,6 +111,35 @@ export function hexSecondsToIso(value: unknown): string | undefined {
   return seconds === undefined ? undefined : new Date(seconds * 1000).toISOString()
 }
 
+/**
+ * Read a block's timestamp as epoch milliseconds, preferring Tempo's
+ * `timestampMillis` over the second-granularity `timestamp`. Accepts hex
+ * quantities (raw RPC) and bigint/number (viem-formatted).
+ */
+function blockToMillis(block: unknown): number | undefined {
+  if (typeof block !== 'object' || block === null) return undefined
+  const { timestamp, timestampMillis } = block as {
+    timestamp?: unknown
+    timestampMillis?: unknown
+  }
+  const millis = quantity(timestampMillis)
+  if (millis !== undefined) return millis
+  const seconds = quantity(timestamp)
+  return seconds === undefined ? undefined : seconds * 1_000
+}
+
+/** Convert a block's timestamp to an ISO 8601 datetime string, preserving milliseconds. */
+export function blockToIso(block: unknown): string | undefined {
+  const millis = blockToMillis(block)
+  return millis === undefined ? undefined : new Date(millis).toISOString()
+}
+
+/** Narrows a quantity that may arrive hex-encoded (raw RPC) or decoded (viem). */
+function quantity(value: unknown): number | undefined {
+  const number = toNumber(value)
+  return number === undefined || !Number.isFinite(number) ? undefined : number
+}
+
 /**
  * Coerce a TIDX timestamp column (Date / epoch seconds / epoch ms / ISO string)
  * to an ISO 8601 datetime string. Returns undefined when the value cannot be

package/src/internal/Viem.test.ts

@@ -220,6 +220,10 @@ describe('resolveRpc', () => {
 })
 
 describe('getClient', () => {
+  test('disables CCIP-Read', () => {
+    expect(Viem.getClient({ chainId: 4217 }).ccipRead).toBe(false)
+  })
+
   test('disables multicall for Zones', () => {
     const l1Client = Viem.getClient({ chainId: 4217 })
     const zoneClient = Viem.getClient({ chainId: zone.id, zone })

package/src/internal/Viem.ts

@@ -6,7 +6,8 @@ import type { TempoActions } from 'viem/tempo'
 import { tempoMainnet, tempoTestnet } from 'viem/tempo/chains'
 import type * as z from 'zod/mini'
 
-import * as Auth from './Auth.js'
+import type * as Auth from './Auth.js'
+import * as Credential from './Credential.js'
 import type * as Schema from './Schema.js'
 
 /** Known Tempo chains keyed by id, for metadata lookups. */
@@ -79,7 +80,7 @@ export function resolveRpc(
   context: resolveRpc.Context,
 ): resolveRpc.Resolved {
   const config = typeof rpc === 'function' ? rpc(context) : rpc
-  const auth = Auth.resolveCredential({ chainId: context.chainId, value: config?.auth })
+  const auth = Credential.resolveCredential({ chainId: context.chainId, value: config?.auth })
   const publicZoneUrl = context.zone
     ? (resolveUrl(config?.publicZoneUrl, context.chainId) ?? context.zone.rpcUrls.default.http[0])
     : undefined
@@ -165,6 +166,7 @@ export function getClient(options: getClient.Options): getClient.ReturnType {
     // configure a deployed multicall3, can still serve the aggregated call.
     // Zones disable multicall entirely and issue concurrent direct `eth_call`s instead.
     batch: { multicall: zone ? false : { deployless: true } },
+    ccipRead: false,
     chain: { ...tempoMainnet, id: chainId },
     transport: http(rpcUrl, fetchOptions ? { fetchOptions } : {}),
   })
@@ -250,7 +252,7 @@ export declare namespace getClient {
   type Rpc =
     | {
         /** Shared or per-chain RPC credentials. Values containing `:` use Basic auth; others use Bearer auth. */
-        auth?: Auth.ChainCredential | undefined
+        auth?: Credential.ChainCredential | undefined
         /** Resolves the public Zone RPC URL used with caller-provided authorization. */
         publicZoneUrl?: UrlResolver | undefined
         /** Headers sent to Zone RPC upstreams. */
@@ -260,7 +262,7 @@ export declare namespace getClient {
       }
     | ((context: resolveRpc.Context) => {
         /** Shared or per-chain RPC credentials, or undefined for none. */
-        auth?: Auth.ChainCredential | undefined
+        auth?: Credential.ChainCredential | undefined
         /** Public Zone RPC URL used with caller-provided authorization. */
         publicZoneUrl?: string | undefined
         /** Headers sent to Zone RPC upstreams. */

package/src/internal/WebhookTransfer.test.ts

@@ -0,0 +1,89 @@
+import type { Hex } from 'ox'
+
+import * as WebhookTransfer from './WebhookTransfer.js'
+
+const token: Hex.Hex = '0x20c0000000000000000000000000000000000001'
+const sender: Hex.Hex = `0x${'aa'.repeat(20)}`
+const recipient: Hex.Hex = `0x${'bb'.repeat(20)}`
+const other: Hex.Hex = `0x${'cc'.repeat(20)}`
+const transactionHash = `0x${'ef'.repeat(32)}`
+const transferTopic = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
+const timestamp = '2026-01-01T00:00:00.000Z'
+
+const addressTopic = (address: string) => `0x${'0'.repeat(24)}${address.slice(2)}`
+
+function transferLog(overrides: Record<string, unknown> = {}) {
+  return {
+    address: token,
+    blockNumber: '0x7b',
+    data: `0x${(10n ** 18n).toString(16).padStart(64, '0')}`,
+    logIndex: '0x4',
+    topics: [transferTopic, addressTopic(sender), addressTopic(recipient)],
+    transactionHash,
+    transactionIndex: '0x0',
+    ...overrides,
+  } as never
+}
+
+describe('decode', () => {
+  test('decodes a strict TIP-20 Transfer log', () => {
+    expect(WebhookTransfer.decode(transferLog(), timestamp)).toMatchInlineSnapshot(`
+      {
+        "address": "0x20c0000000000000000000000000000000000001",
+        "amount": "1000000000000000000",
+        "blockNumber": 123,
+        "logIndex": 4,
+        "recipient": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+        "sender": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "timestamp": "2026-01-01T00:00:00.000Z",
+        "transactionHash": "0xefefefefefefefefefefefefefefefefefefefefefefefefefefefefefefefef",
+      }
+    `)
+  })
+
+  test('rejects non-TIP-20 addresses and malformed payloads', () => {
+    const cases: readonly Record<string, unknown>[] = [
+      // Outside the deterministic TIP-20 address range.
+      { address: other },
+      // Missing recipient topic.
+      { topics: [transferTopic, addressTopic(sender)] },
+      // Wrong event selector.
+      { topics: [`0x${'12'.repeat(32)}`, addressTopic(sender), addressTopic(recipient)] },
+      // Sender topic without the address left-padding.
+      { topics: [transferTopic, `0x${'ff'.repeat(32)}`, addressTopic(recipient)] },
+      // Amount payload is not one word.
+      { data: '0x01' },
+      // Pending-log positions cannot form a cursor.
+      { blockNumber: null },
+      { logIndex: null },
+    ]
+    for (const overrides of cases)
+      expect(
+        WebhookTransfer.decode(transferLog(overrides), timestamp),
+        JSON.stringify(overrides),
+      ).toBeUndefined()
+  })
+})
+
+describe('matches', () => {
+  const data = WebhookTransfer.decode(transferLog(), timestamp)!
+
+  test('AND-combines side, either-side address, and token filters', () => {
+    const cases: readonly [WebhookTransfer.Filters, boolean][] = [
+      [{}, true],
+      [{ sender }, true],
+      [{ sender: recipient }, false],
+      [{ recipient }, true],
+      [{ recipient: sender }, false],
+      [{ address: sender }, true],
+      [{ address: recipient }, true],
+      [{ address: other }, false],
+      [{ token }, true],
+      [{ token: '0x20c0000000000000000000000000000000000002' }, false],
+      [{ recipient, sender, token }, true],
+      [{ recipient: sender, sender, token }, false],
+    ]
+    for (const [filters, expected] of cases)
+      expect(WebhookTransfer.matches(data, filters), JSON.stringify(filters)).toBe(expected)
+  })
+})

package/src/internal/WebhookTransfer.ts

@@ -18,9 +18,11 @@ const scanChunkBlocks = 8
 const event = parseAbiItem(Transfers.signature)
 const topic = encodeEventTopics({ abi: [event] })[0]
 
-type Filters = z.output<typeof Transfers.schema.Predicates>
+/** Parsed transfer filter predicates. */
+export type Filters = z.output<typeof Transfers.schema.Predicates>
 
-type EventData = {
+/** One decoded TIP-20 Transfer row, as the read endpoint returns it. */
+export type EventData = {
   address: string
   amount: string
   blockNumber: number
@@ -303,7 +305,7 @@ function isTip20Address(address: string): boolean {
 }
 
 /** Decodes one strict TIP-20 Transfer wire payload. */
-function decode(log: RpcLog, timestamp: string): EventData | undefined {
+export function decode(log: RpcLog, timestamp: string): EventData | undefined {
   if (!isTip20Address(log.address)) return undefined
   if (
     log.topics.length !== 3 ||
@@ -343,7 +345,7 @@ function decode(log: RpcLog, timestamp: string): EventData | undefined {
 }
 
 /** Re-checks every transfer filter after RPC topic pushdown. */
-function matches(data: EventData, filters: Filters): boolean {
+export function matches(data: EventData, filters: Filters): boolean {
   if (filters.address && data.sender !== filters.address && data.recipient !== filters.address)
     return false
   if (filters.recipient && data.recipient !== filters.recipient) return false
@@ -389,13 +391,13 @@ async function scanCohort(options: {
     items: [],
     state,
   }))
-  const timestamps = new Map<number, Promise<string>>()
+  const timestamps = new Map<number, Promise<string | undefined>>()
   const timestamp = (blockNumber: number) => {
     const existing = timestamps.get(blockNumber)
     if (existing) return existing
     const pending = client
       .getBlock({ blockNumber: BigInt(blockNumber), includeTransactions: false })
-      .then((block) => new Date(Number(block.timestamp) * 1_000).toISOString())
+      .then((block) => Value.blockToIso(block))
     timestamps.set(blockNumber, pending)
     return pending
   }
@@ -412,7 +414,9 @@ async function scanCohort(options: {
       const blockNumber = Value.hexToNumber(log.blockNumber)
       const logIndex = Value.hexToNumber(log.logIndex)
       if (blockNumber === undefined || logIndex === undefined) continue
-      const data = decode(log, await timestamp(blockNumber))
+      const blockTimestamp = await timestamp(blockNumber)
+      if (blockTimestamp === undefined) continue
+      const data = decode(log, blockTimestamp)
       if (!data) continue
       for (const accumulator of accumulators) {
         if (!canMatch(accumulator, blockNumber, logIndex)) continue