tapimo 0.9.0 → 0.10.0

package/src/Webhooks.memory.bench.ts

@@ -0,0 +1,250 @@
+/** @module-tag localnet */
+/**
+ * Measures retained database-factory memory and dense transfer-scan allocations.
+ * Set `WEBHOOK_MEMORY_SNAPSHOT_DIR` to write V8 heap snapshots for retained objects.
+ */
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as v8 from 'node:v8'
+import { nanoid } from 'nanoid'
+import { sendTransactionSync } from 'viem/actions'
+import { Actions, Addresses } from 'viem/tempo'
+import { Webhooks } from 'tapimo'
+import { bench } from 'vite-plus/test'
+
+import * as Db from './db/Db.js'
+import * as Cursor from './internal/Cursor.js'
+import * as Runtime from '../test/runtime.js'
+import * as TestApp from '../test/App.js'
+import * as Tempo from '../test/Tempo.js'
+import * as TestViem from '../test/Viem.js'
+
+const batchSize = 200
+const endOfBlockIndex = 2_147_483_647
+const factoryTicks = positiveInteger('WEBHOOK_MEMORY_FACTORY_TICKS', 25)
+const mebibyte = 1024 * 1024
+const runtime = Runtime.get()
+const transferCallsPerTransaction = 32
+const transferCount = positiveInteger('WEBHOOK_MEMORY_TRANSFER_COUNT', 3_600)
+
+type Memory = {
+  arrayBuffers: number
+  external: number
+  heapUsed: number
+  rss: number
+}
+
+type Report = {
+  after: Memory
+  afterOperation: Memory
+  afterOperationDelta: Memory
+  before: Memory
+  delta: Memory
+  details?: Record<string, number> | undefined
+  label: string
+}
+
+const reports: Report[] = []
+
+beforeAll(() => {
+  if (runtime.mode !== 'localnet')
+    throw new Error('Run webhook memory benchmarks with TEMPO_ENV=localnet.')
+  if (!globalThis.gc)
+    throw new Error('Run webhook memory benchmarks with NODE_OPTIONS=--expose-gc.')
+})
+
+afterAll(() => {
+  process.stdout.write(`WEBHOOK_MEMORY_REPORT ${JSON.stringify(reports)}\n`)
+})
+
+describe('webhook poller memory', () => {
+  bench(
+    `factory-created databases / ${factoryTicks} ticks`,
+    async () => {
+      reports.push(await measureFactoryRetention())
+    },
+    { iterations: 1, time: 0, warmupIterations: 0, warmupTime: 0 },
+  )
+
+  bench(
+    `transfer firehose / ${transferCount} generated transfers`,
+    async () => {
+      reports.push(await measureTransferFirehose())
+    },
+    { iterations: 1, time: 0, warmupIterations: 0, warmupTime: 0 },
+  )
+})
+
+async function measureFactoryRetention(): Promise<Report> {
+  const databases: Db.Db[] = []
+  const schema = `memory_${nanoid()}`
+  const database = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+  await database.migrate()
+  await Webhooks.createSubscription(database, {
+    chainId: runtime.chainId,
+    destination: { type: 'url', url: 'https://hooks.example.com/bench/memory/factory' },
+    eventType: 'block:created',
+    owner: { orgId: 'org_benchmark', type: 'api_key' },
+  })
+  const headBlockNumber = Number(await TestViem.getClient().getBlockNumber())
+  const poller = Webhooks.createPoller({
+    db: () => {
+      const database = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+      databases.push(database)
+      return database
+    },
+    defaultChainId: runtime.chainId,
+    dispatchBatch: async () => ({ ok: true }),
+    rpc: TestApp.rpc,
+  })
+
+  try {
+    const report = await measure('factory-retained', async () => {
+      for (let index = 0; index < factoryTicks; index++)
+        await poller.tick({
+          confirmations: 0,
+          eventTypes: ['block:created'],
+          headBlockNumber,
+          maxBlocks: 1,
+        })
+    })
+    writeHeapSnapshot('factory-retained')
+    return { ...report, details: { databases: databases.length, ticks: factoryTicks } }
+  } finally {
+    await Promise.allSettled(databases.map((database) => database.close()))
+    await database.close()
+  }
+}
+
+async function measureTransferFirehose(): Promise<Report> {
+  const database = TestApp.database()
+  const client = Tempo.getClient({ account: Tempo.accounts[0] })
+  const startBlockNumber = Number(await TestViem.getClient().getBlockNumber())
+
+  try {
+    for (let offset = 0; offset < transferCount; offset += transferCallsPerTransaction) {
+      const length = Math.min(transferCallsPerTransaction, transferCount - offset)
+      await sendTransactionSync(client, {
+        account: Tempo.accounts[0],
+        calls: Array.from({ length }, () =>
+          Actions.token.transfer.call(client, {
+            amount: 1n,
+            to: Tempo.accounts[1].address,
+            token: Addresses.pathUsd,
+          }),
+        ),
+      })
+    }
+
+    const headBlockNumber = Number(await TestViem.getClient().getBlockNumber())
+    const subscription = await Webhooks.createSubscription(database, {
+      chainId: runtime.chainId,
+      destination: { type: 'url', url: 'https://hooks.example.com/bench/memory/firehose' },
+      eventType: 'token:transfer',
+      filters: {},
+      owner: { orgId: 'org_benchmark', type: 'api_key' },
+    })
+    await Webhooks.setCursor(
+      database,
+      subscription.id,
+      Cursor.encode([startBlockNumber, endOfBlockIndex]),
+    )
+
+    let dispatched = 0
+    let serializedBytes = 0
+    const poller = Webhooks.createPoller({
+      db: database,
+      defaultChainId: runtime.chainId,
+      dispatchBatch: async (dispatchables) => {
+        dispatched += dispatchables.length
+        for (const body of dispatchables)
+          serializedBytes += new TextEncoder().encode(JSON.stringify({ body })).byteLength
+        return { ok: true }
+      },
+      rpc: TestApp.rpc,
+    })
+
+    const report = await measure('transfer-firehose', async () => {
+      const result = await poller.tick({
+        batchSize,
+        confirmations: 0,
+        eventTypes: ['token:transfer'],
+        headBlockNumber,
+        maxBlocks: 500,
+      })
+      if (result.dispatched === 0 || result.dispatched !== dispatched)
+        throw new Error(`Unexpected dispatch count: ${result.dispatched} / ${dispatched}.`)
+      if (result.dispatched > batchSize)
+        throw new Error(`Dispatch count ${result.dispatched} exceeded batch size ${batchSize}.`)
+      if (serializedBytes === 0) throw new Error('Expected serialized webhook queue messages.')
+    })
+    writeHeapSnapshot('transfer-firehose-retained')
+    return {
+      ...report,
+      details: { dispatched, serializedBytes, transferCount },
+    }
+  } finally {
+    await database.close()
+  }
+}
+
+async function measure(label: string, fn: () => Promise<void>): Promise<Report> {
+  collectGarbage()
+  const before = memoryUsage()
+  await fn()
+  const afterOperation = memoryUsage()
+  collectGarbage()
+  const after = memoryUsage()
+  return {
+    after,
+    afterOperation,
+    afterOperationDelta: subtract(afterOperation, before),
+    before,
+    delta: subtract(after, before),
+    label,
+  }
+}
+
+function collectGarbage(): void {
+  globalThis.gc?.()
+  globalThis.gc?.()
+}
+
+function memoryUsage(): Memory {
+  const usage = process.memoryUsage()
+  return {
+    arrayBuffers: mebibytes(usage.arrayBuffers),
+    external: mebibytes(usage.external),
+    heapUsed: mebibytes(usage.heapUsed),
+    rss: mebibytes(usage.rss),
+  }
+}
+
+function mebibytes(bytes: number): number {
+  return Math.round((bytes / mebibyte) * 100) / 100
+}
+
+function positiveInteger(name: string, fallback: number): number {
+  const input = process.env[name]
+  if (!input) return fallback
+  const value = Number(input)
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new Error(`${name} must be a positive integer.`)
+  return value
+}
+
+function subtract(after: Memory, before: Memory): Memory {
+  return {
+    arrayBuffers: after.arrayBuffers - before.arrayBuffers,
+    external: after.external - before.external,
+    heapUsed: after.heapUsed - before.heapUsed,
+    rss: after.rss - before.rss,
+  }
+}
+
+function writeHeapSnapshot(label: string): void {
+  const directory = process.env.WEBHOOK_MEMORY_SNAPSHOT_DIR
+  if (!directory) return
+  fs.mkdirSync(directory, { recursive: true })
+  v8.writeHeapSnapshot(path.join(directory, `${label}.heapsnapshot`))
+}

package/src/Webhooks.test.ts

@@ -1,4 +1,4 @@
-import { Webhooks } from 'tapimo'
+import { Metrics, Webhooks } from 'tapimo'
 import * as TestApp from '../test/App.js'
 
 describe('createPoller', () => {
@@ -25,9 +25,8 @@ describe('createPoller', () => {
 
     // A brand-new subscription anchors at the confirmed head on its first tick
     // (no backfill), so this exercises the createPoller → poll wiring (db
-    // binding, default chain id, injected head, result shape) without touching
-    // TIDX. Detailed poll/getIndexedHead behavior lives in
-    // src/apps/webhooks.test.ts.
+    // binding, default chain id, injected head, and result shape) without an
+    // upstream request. Detailed scanner behavior lives in the route test.
     const result = await poller.tick({ headBlockNumber: 200 })
 
     expect(result).toMatchInlineSnapshot(`
@@ -35,19 +34,70 @@ describe('createPoller', () => {
         "chainId": 42431,
         "dispatched": 0,
         "failed": 0,
-        "safeBlock": 198,
+        "safeBlock": 199,
         "scanned": 0,
         "subscriptions": 1,
       }
     `)
     expect(decodeCursor(await Webhooks.getCursor(db, subscription.id))).toMatchInlineSnapshot(`
       [
-        198,
+        199,
         2147483647,
       ]
     `)
   })
 
+  test('records active subscriptions before scanning', async () => {
+    const db = TestApp.database()
+    await Webhooks.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/x' },
+      eventType: 'block:created',
+      owner: { orgId: 'org_test', type: 'api_key' },
+    })
+    const gauges: { name: string; tags: Metrics.Tags; value: number }[] = []
+    const poller = Webhooks.createPoller({
+      db,
+      defaultChainId: 42431,
+      metrics: Metrics.from({
+        count() {},
+        flush() {},
+        gauge(name, value, tags = {}) {
+          gauges.push({ name, tags, value })
+        },
+        histogram() {},
+      }),
+    })
+
+    await poller.tick({ eventTypes: ['block:created'], headBlockNumber: 200 })
+
+    expect(gauges).toMatchInlineSnapshot(`
+      [
+        {
+          "name": "webhook_poller_active_subscription_count",
+          "tags": {
+            "chain_id": "42431",
+          },
+          "value": 1,
+        },
+        {
+          "name": "webhook_subscription_cursor_lag_blocks",
+          "tags": {
+            "chain_id": "42431",
+          },
+          "value": 0,
+        },
+        {
+          "name": "webhook_poller_safe_block",
+          "tags": {
+            "chain_id": "42431",
+          },
+          "value": 199,
+        },
+      ]
+    `)
+  })
+
   test('clamps a creation checkpoint to genesis', async () => {
     const db = TestApp.database()
     const subscription = await Webhooks.createSubscription(
@@ -72,4 +122,25 @@ describe('createPoller', () => {
 
     expect(decodeCursor(await Webhooks.getCursor(db, subscription.id))).toEqual([0, 2_147_483_647])
   })
+
+  test('keeps a factory-created database open after each tick', async () => {
+    const db = TestApp.database()
+    await Webhooks.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/x' },
+      eventType: 'block:created',
+      owner: { orgId: 'org_test', type: 'api_key' },
+    })
+    const poller = Webhooks.createPoller({
+      db: () => db,
+      defaultChainId: 42431,
+    })
+
+    await poller.tick({
+      eventTypes: ['block:created'],
+      headBlockNumber: 1,
+    })
+
+    await expect(Webhooks.maxCursorBlock(db, 42431)).resolves.toBe(0)
+  })
 })

package/src/Webhooks.ts

@@ -1,11 +1,14 @@
 import * as AppWebhooks from './apps/data/routes/webhooks.js'
 import * as Db from './db/Db.js'
+import * as core_Webhooks from './internal/Webhooks.js'
 import * as MetricSink from './internal/MetricSink.js'
 import * as Store from './internal/Store.js'
 import type * as Metrics from './Metrics.js'
-import * as Tidx from './internal/Tidx.js'
 import * as Viem from './internal/Viem.js'
 
+/** How often a poller reclaims expired rows, independent of tick cadence. */
+const pruneIntervalMs = 60_000
+
 // Re-export the runtime-agnostic primitives (subscriptions, signing, delivery,
 // `deliverAndRecord`, cursors, …) so consumers reach everything through one
 // `Webhooks` namespace. The apps-layer poller stays private behind
@@ -19,33 +22,29 @@ export * from './internal/Webhooks.js'
 export { eventTypes, schema } from './apps/data/routes/webhooks.js'
 
 /**
- * Builds a scheduled webhook poller bound to a state store and chain config.
+ * Builds a webhook poller bound to a state store and chain config.
  *
- * This is the entry point a host runtime drives on a timer (a Cloudflare
- * `scheduled` cron handler, a self-host `setInterval`, …). Each {@link
- * Poller.tick} scans active subscriptions from their cursors up to `head -
- * confirmations` and dispatches matching events.
+ * This is the entry point a host runtime drives from chain-head notifications
+ * or a timer. Each {@link Poller.tick} scans active subscriptions from their
+ * cursors up to `head - confirmations` and dispatches matching events.
  *
- * The monitoring event types (`log:emitted`, `block:created`,
- * `transaction:included`) scan a confirmed window directly over JSON-RPC, so the
- * poller builds memoized viem clients (via {@link Viem.createGetClient}); the legacy
- * `token:transfer` type still reads from TIDX, so it
- * also builds memoized TIDX clients (via {@link Tidx.createGetClient}) when a
- * `tidx` config is supplied. The poller keeps `App.create` a pure Hono app: it
- * constructs its own clients instead of reaching into app internals, and owns no
- * request state.
+ * Every onchain event type scans a confirmed window directly over JSON-RPC, so
+ * the poller builds memoized viem clients via {@link Viem.createGetClient}. The
+ * poller keeps `App.create` a pure Hono app: it constructs its own clients
+ * instead of reaching into app internals, and owns no request state.
  */
 export function createPoller(options: createPoller.Options): createPoller.Poller {
   // Persistent memoize cache for token metadata, shared across ticks (the
   // webhook state store used to double-duty as this cache).
-  const cache = Store.memory()
-  const getTidx = options.tidx
-    ? Tidx.createGetClient({ defaultChainId: options.defaultChainId, tidx: options.tidx })
-    : undefined
+  const cache = options.cache ?? Store.memory()
   const getClient = Viem.createGetClient({
     defaultChainId: options.defaultChainId,
     rpc: options.rpc,
   })
+  // Chain-head ticks run about once per block, so the janitor is throttled here
+  // rather than issuing deletes per block. Reads filter expiry at query time, so
+  // reclaiming late only costs space.
+  let prunedAt: number | undefined
 
   const metrics = options.metrics ? MetricSink.webhooks(options.metrics) : undefined
 
@@ -58,6 +57,8 @@ export function createPoller(options: createPoller.Options): createPoller.Poller
       // returns the underlying result unchanged and is a no-op when no metrics
       // backend is configured.
       const inner = input.dispatch ?? options.dispatch
+      const innerBatch =
+        input.dispatchBatch ?? (input.dispatch === undefined ? options.dispatchBatch : undefined)
       const dispatch =
         metrics && inner
           ? async (dispatchable: AppWebhooks.poll.Dispatchable) => {
@@ -73,8 +74,35 @@ export function createPoller(options: createPoller.Options): createPoller.Poller
               return result
             }
           : inner
+      const dispatchBatch =
+        metrics && innerBatch
+          ? async (dispatchables: readonly AppWebhooks.poll.Dispatchable[]) => {
+              const start = Date.now()
+              const result = await innerBatch(dispatchables)
+              const durationMs = Date.now() - start
+              for (const dispatchable of dispatchables)
+                metrics.record({
+                  chainId: dispatchable.envelope.chainId,
+                  durationMs,
+                  eventType: dispatchable.envelope.type,
+                  ok: result.ok,
+                  type: 'webhook:enqueue',
+                })
+              return result
+            }
+          : innerBatch
+
+      // Resolve per tick so Workers factories build a fresh Hyperdrive-pooled
+      // connection each run.
+      const db = Db.get(options.db)
+      const now = input.now ?? options.now
+      if (prunedAt === undefined || Date.now() - prunedAt >= pruneIntervalMs) {
+        prunedAt = Date.now()
+        await core_Webhooks.pruneExpired(db, { now }).catch(() => {})
+      }
 
       const start = Date.now()
+      let cursorLagBlocks: number | undefined
       try {
         const result = await AppWebhooks.poll({
           batchSize: input.batchSize ?? options.batchSize,
@@ -82,19 +110,37 @@ export function createPoller(options: createPoller.Options): createPoller.Poller
           chainId,
           client: getClient(chainId),
           confirmations: input.confirmations ?? options.confirmations,
-          // Resolve per tick so Workers factories build a fresh
-          // Hyperdrive-pooled connection each run.
-          db: Db.get(options.db),
+          db,
           dispatch,
+          dispatchBatch,
           eventTypes: input.eventTypes ?? options.eventTypes,
           ...(input.headBlockNumber === undefined
             ? {}
             : { headBlockNumber: input.headBlockNumber }),
           maxBlocks: input.maxBlocks ?? options.maxBlocks,
-          now: input.now ?? options.now,
-          ...(getTidx ? { tidx: getTidx(chainId) } : {}),
+          now,
+          signal: input.signal,
+          ...(metrics
+            ? {
+                onCursorLag(blocks: number) {
+                  cursorLagBlocks = blocks
+                },
+                onScanCheckpoint(checkpoint: AppWebhooks.poll.ScanCheckpoint) {
+                  metrics.record({ chainId, type: 'webhook:poll-scan', ...checkpoint })
+                  // Ship the start boundary before the RPC allocation can terminate the isolate.
+                  metrics.flush()
+                },
+                onStage(stage: AppWebhooks.poll.Stage) {
+                  metrics.record({ chainId, type: 'webhook:poll', ...stage })
+                },
+                onSubscriptions(count: number) {
+                  metrics.record({ chainId, count, type: 'webhook:poll-subscriptions' })
+                },
+              }
+            : {}),
         })
         metrics?.record({
+          cursorLagBlocks,
           meta: { durationMs: Date.now() - start, outcome: 'ok' },
           result,
           type: 'webhook:tick',
@@ -102,6 +148,7 @@ export function createPoller(options: createPoller.Options): createPoller.Poller
         return result
       } catch (error) {
         metrics?.record({
+          cursorLagBlocks,
           meta: { chainId, durationMs: Date.now() - start, outcome: 'error' },
           result: undefined,
           type: 'webhook:tick',
@@ -121,6 +168,9 @@ export declare namespace createPoller {
   /** Delivery transport: hands a matched event to a queue or delivers inline. */
   type Dispatch = NonNullable<AppWebhooks.poll.Options['dispatch']>
 
+  /** Batch delivery transport: confirms all rows together or leaves their cursor unchanged. */
+  type DispatchBatch = NonNullable<AppWebhooks.poll.Options['dispatchBatch']>
+
   /** Summary counters returned by {@link Poller.tick}. */
   type Result = AppWebhooks.poll.Result
 
@@ -128,13 +178,15 @@ export declare namespace createPoller {
   type Defaults = {
     /** Max matching rows scanned per subscription per tick (default 200). */
     batchSize?: number | undefined
-    /** Reorg-safety window: only emit blocks this far behind head (default 2). */
+    /** Reorg-safety window: only emit blocks this far behind head (default 1). */
     confirmations?: number | undefined
     /**
      * Delivery transport. Defaults to inline `deliverAndRecord` (self-host); on
      * Cloudflare pass a Queue producer so retry/backoff/DLQ are native.
      */
     dispatch?: Dispatch | undefined
+    /** Batch delivery transport used when the runtime can enqueue multiple rows atomically. */
+    dispatchBatch?: DispatchBatch | undefined
     /** Event types to poll (default all). */
     eventTypes?: AppWebhooks.poll.Options['eventTypes']
     /** Backfill cap: most blocks an RPC scanner inspects per tick (default 1000). */
@@ -145,16 +197,16 @@ export declare namespace createPoller {
 
   /** Options for {@link createPoller}. */
   type Options = Defaults & {
+    /** Cache for token metadata shared across ticks. */
+    cache?: Store.Store | undefined
     /** Database holding subscriptions + cursors, or a factory resolved per tick (Workers/Hyperdrive). */
     db: Db.Source
     /** Tempo chain id polled when a tick omits one. */
     defaultChainId?: Viem.ChainId | undefined
     /** Metrics backend; emits `webhook:tick` per tick and `webhook:enqueue` per dispatch. */
     metrics?: Metrics.Metrics | undefined
-    /** RPC options for the viem clients the monitoring scanners read from. */
+    /** RPC options for the viem clients that scan chain events. */
     rpc?: Viem.getClient.Rpc | undefined
-    /** TIDX query client options for the legacy `token:transfer` type. */
-    tidx?: Tidx.getClient.Tidx | undefined
   }
 
   /** Per-tick overrides; falls back to the {@link Options} defaults. */
@@ -163,11 +215,13 @@ export declare namespace createPoller {
     chainId?: Viem.ChainId | undefined
     /** Chain head to work back from; resolved from RPC when omitted. */
     headBlockNumber?: bigint | number | undefined
+    /** Stops scanning and dispatch when the caller loses its execution lease. */
+    signal?: AbortSignal | undefined
   }
 
-  /** A scheduled webhook poller. */
+  /** A chain-head-driven webhook poller. */
   type Poller = {
-    /** Runs one poll tick, resolving the indexed head when not supplied. */
+    /** Runs one poll tick, resolving the RPC head when not supplied. */
     tick(options?: TickOptions): Promise<Result>
   }
 }

package/src/apps/Zones.test.ts

@@ -5,13 +5,14 @@ describe('chains', () => {
     expect(Zones.chains).toMatchObject([
       {
         contracts: {
-          messenger: { address: '0x254356112cCf6f32fAd84F16CC5E0A0cCA17Beb7' },
-          portal: { address: '0x59831A17340EE14FE136d751EfbeA8b630470fD2' },
+          messenger: { address: '0xc9C88278eA934A03CE8c90793F0B903e1C63B735' },
+          portal: { address: '0xd8fDA2e3f421F272C56752cBCf5Ae0782c8B9ed2' },
         },
         id: 421_700_001,
         rpcUrls: {
-          default: { http: ['https://rpc-zone-e.testnet.tempo.xyz'] },
-          internal: { http: ['https://rpc-zone-e.testnet.tempo.xyz'] },
+          default: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },
+          internal: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },
+          tidx: { http: ['https://indexer-zone-internal.testnet.tempo.xyz'] },
         },
         sourceId: 42_431,
       },

package/src/apps/Zones.ts

@@ -1,19 +1,20 @@
 import { defineChain } from 'viem'
 import { tempoDevnet, tempoTestnet } from 'viem/tempo/chains'
 
-/** Zone E on Tempo testnet. */
-export const zoneE = defineChain({
+/** Moderato Zone on Tempo testnet. */
+export const zoneModerato = defineChain({
   ...tempoTestnet,
   contracts: {
     ...tempoTestnet.contracts,
-    messenger: { address: '0x254356112cCf6f32fAd84F16CC5E0A0cCA17Beb7' },
-    portal: { address: '0x59831A17340EE14FE136d751EfbeA8b630470fD2' },
+    messenger: { address: '0xc9C88278eA934A03CE8c90793F0B903e1C63B735' },
+    portal: { address: '0xd8fDA2e3f421F272C56752cBCf5Ae0782c8B9ed2' },
   },
   id: 421_700_001,
-  name: 'zone-e',
+  name: 'zone-moderato',
   rpcUrls: {
-    default: { http: ['https://rpc-zone-e.testnet.tempo.xyz'] },
-    internal: { http: ['https://rpc-zone-e.testnet.tempo.xyz'] },
+    default: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },
+    internal: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },
+    tidx: { http: ['https://indexer-zone-internal.testnet.tempo.xyz'] },
   },
   sourceId: tempoTestnet.id,
 })
@@ -37,4 +38,4 @@ export const zoneStable = defineChain({
 })
 
 /** Hosted Zone chains served by the API and admin. */
-export const chains = [zoneE, zoneStable] as const
+export const chains = [zoneModerato, zoneStable] as const

package/src/apps/data/FxOracle.test.ts

@@ -41,6 +41,24 @@ describe('from', () => {
 })
 
 describe('ecb', () => {
+  test('caches the daily feed for one day', () => {
+    expect(FxOracle.ecb({ url: feedUrl('1.25') }).ttl).toMatchInlineSnapshot(`86400000`)
+  })
+
+  test('rotates the cache key after the daily publication window', () => {
+    vi.useFakeTimers()
+    try {
+      const oracle = FxOracle.ecb({ url: feedUrl('1.25') })
+
+      vi.setSystemTime('2026-01-02T15:59:00.000Z')
+      expect(oracle.cacheKey?.()).toMatchInlineSnapshot(`"ecb:2026-01-01"`)
+      vi.setSystemTime('2026-01-02T16:00:00.000Z')
+      expect(oracle.cacheKey?.()).toMatchInlineSnapshot(`"ecb:2026-01-02"`)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   test('fetches and parses the daily reference rates', async () => {
     const rates = await FxOracle.ecb({ url: feedUrl('1.25') }).rates()
     expect(rates).toMatchInlineSnapshot(`