tapimo 0.13.0 → 0.15.0

package/src/analytics/Analytics.test.ts

@@ -50,7 +50,26 @@ const row = {
   timings: { transactions: 42.7, transactions_count: 7.1 },
 } satisfies Analytics.Event
 
-afterEach(() => vi.unstubAllGlobals())
+const lifecycleEvent = {
+  data: {
+    ended_at: '2026-01-01 00:01:00.000',
+    environment: 'production',
+    routes_environment: 'production',
+    method: 'transaction',
+    provider: 'stargate',
+    recorded_at: '2026-01-01 00:01:01.000',
+    resource_id: 'rtr_1',
+    service: 'cadent-api',
+    stage: 'source_routes',
+    started_at: '2026-01-01 00:00:00.000',
+  },
+  type: 'routes:lifecycle:interval',
+} satisfies Analytics.Event
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+  vi.useRealTimers()
+})
 
 describe('clickhouse', () => {
   test('insert posts NDJSON rows scoped to the database', async () => {
@@ -200,7 +219,9 @@ describe('migrations', () => {
 
   test('the migrations declare the endpoint latency view', () => {
     const sql = Analytics.migrations.map((migration) => migration.sql).join('\n')
-    const latest = Analytics.migrations[Analytics.migrations.length - 1]!
+    const view = Analytics.migrations.find(
+      (migration) => migration.name === '0011_endpoint_latency_query',
+    )!
     expect(sql).toContain('CREATE OR REPLACE VIEW endpoint_latency_results')
     expect(sql).toContain("'production' AS source")
     expect(sql).toContain("'benchmark' AS source")
@@ -208,10 +229,23 @@ describe('migrations', () => {
     expect(sql).toContain("if(status >= 200 AND status < 300, 'success', 'error') AS outcome")
     expect(sql).toContain("WHERE result.metric != 'request'")
     expect(sql).toContain('arrayZip(mapKeys(timings), mapValues(timings))')
-    expect(latest.name).toBe('0011_endpoint_latency_query')
-    expect(latest.sql).toContain("environment = 'production' AND service = 'cadent-api'")
-    expect(latest.sql).toContain("coalesce(request_id, '') AS request_id")
-    expect(latest.sql).toContain('query AS variant')
+    expect(view.sql).toContain("environment = 'production' AND service = 'cadent-api'")
+    expect(view.sql).toContain("coalesce(request_id, '') AS request_id")
+    expect(view.sql).toContain('query AS variant')
+  })
+
+  test('the migrations declare route lifecycle history', () => {
+    const migration = Analytics.migrations.find(
+      (candidate) => candidate.name === '0012_routes_lifecycle_intervals',
+    )!
+
+    expect(migration.sql).toContain('CREATE TABLE IF NOT EXISTS routes_lifecycle_intervals')
+    expect(migration.sql).toContain('ENGINE = ReplacingMergeTree(recorded_at)')
+    expect(migration.sql).toContain('PARTITION BY toYYYYMM(ended_at)')
+    expect(migration.sql).toContain('stage LowCardinality(String)')
+    expect(migration.sql).toContain(
+      'ORDER BY (service, environment, routes_environment, stage, provider, method, resource_id)',
+    )
   })
 })
 
@@ -225,7 +259,9 @@ describe('get', () => {
 
 describe('createQueueSink', () => {
   test('enqueues one row per entry', async () => {
-    const send = vi.fn<(message: Analytics.Event) => Promise<void>>().mockResolvedValue(undefined)
+    const send = vi
+      .fn<(message: RequestEvents.Table) => Promise<void>>()
+      .mockResolvedValue(undefined)
     const sink = Analytics.createQueueSink({ send })(context)
 
     await sink(entry)
@@ -287,7 +323,9 @@ describe('createQueueSink', () => {
   })
 
   test('stores an empty timing map when the request has no operation timings', async () => {
-    const send = vi.fn<(message: Analytics.Event) => Promise<void>>().mockResolvedValue(undefined)
+    const send = vi
+      .fn<(message: RequestEvents.Table) => Promise<void>>()
+      .mockResolvedValue(undefined)
     const sink = Analytics.createQueueSink({ send })(context)
 
     await sink({ ...entry, timings: undefined })
@@ -296,7 +334,9 @@ describe('createQueueSink', () => {
   })
 
   test('stores an empty query when the request has no query string', async () => {
-    const send = vi.fn<(message: Analytics.Event) => Promise<void>>().mockResolvedValue(undefined)
+    const send = vi
+      .fn<(message: RequestEvents.Table) => Promise<void>>()
+      .mockResolvedValue(undefined)
     const sink = Analytics.createQueueSink({ send })(context)
 
     await sink({ ...entry, query: undefined })
@@ -306,7 +346,7 @@ describe('createQueueSink', () => {
 
   test('retries a failed send once with the same row', async () => {
     const send = vi
-      .fn<(message: Analytics.Event) => Promise<void>>()
+      .fn<(message: RequestEvents.Table) => Promise<void>>()
       .mockRejectedValueOnce(new Error('Unknown Internal Error (15000)'))
       .mockResolvedValueOnce(undefined)
     const sink = Analytics.createQueueSink({ send })(context)
@@ -318,7 +358,9 @@ describe('createQueueSink', () => {
   })
 
   test('records API-key attribution for API-key principals', async () => {
-    const send = vi.fn<(message: Analytics.Event) => Promise<void>>().mockResolvedValue(undefined)
+    const send = vi
+      .fn<(message: RequestEvents.Table) => Promise<void>>()
+      .mockResolvedValue(undefined)
     const sink = Analytics.createQueueSink({ send })(context)
 
     await sink({
@@ -341,7 +383,9 @@ describe('createQueueSink', () => {
   })
 
   test('records JSON-RPC error metadata', async () => {
-    const send = vi.fn<(message: Analytics.Event) => Promise<void>>().mockResolvedValue(undefined)
+    const send = vi
+      .fn<(message: RequestEvents.Table) => Promise<void>>()
+      .mockResolvedValue(undefined)
     const sink = Analytics.createQueueSink({ send })(context)
 
     await sink({
@@ -360,7 +404,7 @@ describe('createQueueSink', () => {
 
   test('rethrows when the retry also fails', async () => {
     const send = vi
-      .fn<(message: Analytics.Event) => Promise<void>>()
+      .fn<(message: RequestEvents.Table) => Promise<void>>()
       .mockRejectedValue(new Error('Unknown Internal Error (15000)'))
     const sink = Analytics.createQueueSink({ send })(context)
 
@@ -371,7 +415,7 @@ describe('createQueueSink', () => {
   })
 
   test('drops entries when disabled', async () => {
-    const send = vi.fn<(message: Analytics.Event) => Promise<void>>()
+    const send = vi.fn<(message: RequestEvents.Table) => Promise<void>>()
     const sink = Analytics.createQueueSink({ send })({ ...context, enabled: false })
 
     await sink(entry)
@@ -380,13 +424,42 @@ describe('createQueueSink', () => {
   })
 })
 
+describe('createRoutesLifecycleSink', () => {
+  test('enqueues one normalized interval event', async () => {
+    vi.useFakeTimers({ now: new Date('2026-01-01T00:01:01.000Z'), toFake: ['Date'] })
+    const events: Analytics.Event[] = []
+    const sink = Analytics.createRoutesLifecycleSink(
+      {
+        async send(message) {
+          events.push(message)
+        },
+      },
+      { environment: 'production', service: 'cadent-api' },
+    )
+
+    await sink({
+      endedAt: '2026-01-01T00:01:00.000Z',
+      routesEnvironment: 'production',
+      method: 'transaction',
+      provider: 'stargate',
+      resourceId: 'rtr_1',
+      stage: 'source_routes',
+      startedAt: '2026-01-01T00:00:00.000Z',
+    })
+
+    expect(events).toEqual([lifecycleEvent])
+  })
+})
+
 describe('handleQueue', () => {
   /** Fake store and one queued message with ack/retry spies. */
   function fixture() {
-    const insert = vi.fn((_table: 'request_events', _rows: readonly Analytics.Event[]) =>
-      Promise.resolve(),
-    )
-    const store = { insert, migrate: () => Promise.resolve(), query: () => Promise.resolve([]) }
+    const insert = vi.fn<Analytics.Analytics['insert']>().mockResolvedValue(undefined)
+    const store: Analytics.Analytics = {
+      insert,
+      migrate: () => Promise.resolve(),
+      query: () => Promise.resolve([]),
+    }
     const message = { ack: vi.fn(), body: row, retry: vi.fn() }
     return { insert, message, store }
   }
@@ -446,6 +519,23 @@ describe('handleQueue', () => {
     expect(onResult).toHaveBeenCalledWith({ messages: 1, outcome: 'acked' })
   })
 
+  test('routes lifecycle events and request rows to separate tables', async () => {
+    const { insert, message, store } = fixture()
+    const interval = { ack: vi.fn(), body: lifecycleEvent, retry: vi.fn() }
+
+    await Analytics.handleQueue(store, {
+      messages: [message, interval],
+      queue: Analytics.queueName,
+    })
+
+    expect(insert.mock.calls).toEqual([
+      ['routes_lifecycle_intervals', [lifecycleEvent.data]],
+      ['request_events', [row]],
+    ])
+    expect(message.ack).toHaveBeenCalledTimes(1)
+    expect(interval.ack).toHaveBeenCalledTimes(1)
+  })
+
   test('retries every message when the insert fails', async () => {
     vi.spyOn(console, 'error').mockImplementation(() => {})
     const { insert, message, store } = fixture()

package/src/analytics/Analytics.ts

@@ -1,6 +1,8 @@
+import * as RoutesLifecycleIntervals from './tables/routesLifecycleIntervals.js'
 import * as RequestEvents from './tables/requestEvents.js'
 
 export { createQueueSink } from './tables/requestEvents.js'
+export { createQueueSink as createRoutesLifecycleSink } from './tables/routesLifecycleIntervals.js'
 
 /** One org's deduped billable request count for a UTC hour; the reporter's source row. */
 export type BillableCount = RequestEvents.BillableCount
@@ -54,6 +56,7 @@ export function readBillableRequestCounts(
  * through it.
  */
 export type Database = {
+  routes_lifecycle_intervals: RoutesLifecycleIntervals.Table
   request_events: RequestEvents.Table
 }
 
@@ -76,8 +79,8 @@ export type Analytics = {
  */
 export type Source = Analytics | (() => Analytics)
 
-/** One stored request row (`request_events`); hosts use it in their queue-body union. */
-export type Event = RequestEvents.Table
+/** One analytics queue event; hosts use it in their queue-body union. */
+export type Event = RoutesLifecycleIntervals.Event | RequestEvents.Table
 
 /** Queue name {@link handleQueue} consumes; the host's queue producer/consumer bindings must reference it. */
 export const queueName = 'api-request-analytics'
@@ -424,6 +427,26 @@ export const migrations: readonly Migration[] = [
       WHERE result.metric != 'request'
     `,
   },
+  {
+    name: '0012_routes_lifecycle_intervals',
+    sql: `
+      CREATE TABLE IF NOT EXISTS routes_lifecycle_intervals (
+        recorded_at DateTime64(3, 'UTC'),
+        service LowCardinality(String),
+        environment LowCardinality(String),
+        routes_environment LowCardinality(String),
+        stage LowCardinality(String),
+        provider LowCardinality(String),
+        method LowCardinality(String),
+        resource_id String,
+        started_at DateTime64(3, 'UTC'),
+        ended_at DateTime64(3, 'UTC')
+      )
+      ENGINE = ReplacingMergeTree(recorded_at)
+      PARTITION BY toYYYYMM(ended_at)
+      ORDER BY (service, environment, routes_environment, stage, provider, method, resource_id)
+    `,
+  },
 ]
 
 /**
@@ -537,11 +560,20 @@ export async function handleQueue(
   options: handleQueue.Options = {},
 ): Promise<boolean> {
   if (batch.queue !== (options.queue ?? queueName)) return false
-  await RequestEvents.insertMessages(
-    get(source),
-    batch.messages as readonly RequestEvents.insertMessages.Message[],
-    { onResult: options.onResult },
+  const analytics = get(source)
+  const intervals = batch.messages.filter(
+    (message): message is RoutesLifecycleIntervals.insertMessages.Message =>
+      RoutesLifecycleIntervals.isEvent(message.body),
   )
+  const requests = batch.messages.filter(
+    (message) => !RoutesLifecycleIntervals.isEvent(message.body),
+  ) as readonly RequestEvents.insertMessages.Message[]
+  await Promise.all([
+    RoutesLifecycleIntervals.insertMessages(analytics, intervals, {
+      onResult: options.onResult,
+    }),
+    RequestEvents.insertMessages(analytics, requests, { onResult: options.onResult }),
+  ])
   return true
 }
 

package/src/analytics/tables/requestEvents.test.ts

@@ -0,0 +1,100 @@
+import * as TestApp from '../../../test/App.js'
+import * as Containers from '../../../test/containers.js'
+import * as Metrics from '../../Metrics.js'
+import * as Analytics from '../Analytics.js'
+import * as RequestEvents from './requestEvents.js'
+
+describe('readBillableCounts', () => {
+  test('counts separate requests and deduplicates redelivered analytics rows', async () => {
+    const stack = await Containers.start()
+    try {
+      const analytics = Analytics.clickhouse({
+        database: 'tempo_api',
+        password: 'clickhouse',
+        url: `http://${stack.endpoints.clickhouse.host}:${stack.endpoints.clickhouse.port}`,
+        user: 'clickhouse',
+      })
+      await analytics.migrate()
+
+      const rows: RequestEvents.Table[] = []
+      const app = TestApp.create({
+        auth: {
+          keys: [{ ...TestApp.key, environment: 'production', scopes: ['data:read'] }],
+        },
+        metrics: Metrics.cloudflare({
+          analytics: RequestEvents.createQueueSink({
+            async send(row) {
+              rows.push(row)
+            },
+          }),
+        }),
+      })
+      const responses = await Promise.all(
+        [
+          '/v1/tokenlist',
+          '/v1/tokenlist',
+          '/v1/tokens/not-an-address',
+          '/v1/indexer/query?query=SELECT%201',
+        ].map(async (path) =>
+          app.request(path, {
+            headers: {
+              ...TestApp.auth.headers,
+              'tempo-request-id': 'client-controlled',
+              'X-Request-Id': 'client-controlled',
+            },
+          }),
+        ),
+      )
+
+      expect(responses.map((response) => response.status)).toMatchInlineSnapshot(`
+        [
+          200,
+          200,
+          400,
+          403,
+        ]
+      `)
+      expect(rows).toHaveLength(4)
+      expect(new Set(rows.map((row) => row.request_id))).toEqual(
+        new Set(responses.map((response) => response.headers.get('tempo-request-id'))),
+      )
+      rows.push(
+        {
+          ...rows[0]!,
+          error_code: null,
+          request_id: 'request-payment-challenge',
+          status: 402,
+        },
+        {
+          ...rows[0]!,
+          error_code: 'payment_required',
+          request_id: 'request-payment-unavailable',
+          status: 429,
+        },
+      )
+
+      const options = {
+        environment: 'production',
+        from: '2020-01-01T00:00:00.000Z',
+        to: '2100-01-01T00:00:00.000Z',
+      } as const
+      await analytics.insert('request_events', rows)
+      const counts = await RequestEvents.readBillableCounts(analytics, options)
+      expect(counts.reduce((sum, row) => sum + row.count, 0)).toMatchInlineSnapshot(`3`)
+
+      // Queue redelivery repeats the original rows, including their trusted request identities.
+      await analytics.insert('request_events', rows)
+      expect(await RequestEvents.readBillableCounts(analytics, options)).toEqual(counts)
+      expect(await analytics.query('SELECT count() AS count FROM request_events'))
+        .toMatchInlineSnapshot(`
+          [
+            {
+              "count": 12,
+            },
+          ]
+        `)
+    } finally {
+      await stack.stop()
+    }
+  })
+})

package/src/analytics/tables/requestEvents.ts

@@ -471,7 +471,8 @@ export type BillableCountsOptions = {
  * Reads deduped billable request counts grouped by `(org, UTC hour)` for the
  * request-metered billing reporter. Counts dedupe on `request_id` via
  * `uniqExact` (the queue → ClickHouse path can duplicate rows); production rows
- * always bill, sandbox rows only when `billing_active = 1` at request time.
+ * exclude authentication and quota denials, while sandbox rows also require
+ * `billing_active = 1` at request time.
  *
  * @param analytics - The analytics store.
  * @param options - The read options.
@@ -492,6 +493,14 @@ export async function readBillableCounts(
       WHERE principal_type = 'api_key'
         AND org_id IS NOT NULL
         AND request_id IS NOT NULL
+        AND status != 402
+        AND coalesce(error_code, '') NOT IN (
+          'api_key_forbidden',
+          'api_key_ip_forbidden',
+          'forbidden',
+          'payment_required',
+          'rate_limit_exceeded'
+        )
         AND key_environment = ${ClickHouseValue.literal(options.environment)}
         ${sandboxGate}
         AND timestamp >= parseDateTime64BestEffort(${ClickHouseValue.literal(options.from)}, 3, 'UTC')

package/src/analytics/tables/routesLifecycleIntervals.ts

@@ -0,0 +1,140 @@
+import type * as RoutesObservability from '../../internal/routes/Observability.js'
+import type * as Analytics from '../Analytics.js'
+import type * as RequestEvents from './requestEvents.js'
+
+/** Columns of `routes_lifecycle_intervals`: one completed routes stage interval. */
+export type Table = {
+  /** UTC time when the stage ended. */
+  ended_at: string
+  /** Deployment environment that recorded the interval. */
+  environment: string
+  /** API-key environment that owns the route journey. */
+  routes_environment: 'production' | 'sandbox'
+  /** Route method used by the journey. */
+  method: 'deposit_address' | 'transaction'
+  /** Route provider that owns the journey. */
+  provider: string
+  /** UTC time when the interval was recorded. */
+  recorded_at: string
+  /** Stable route resource id. */
+  resource_id: string
+  /** Service that recorded the interval. */
+  service: string
+  /** Completed lifecycle stage. */
+  stage: RoutesObservability.LifecycleInterval['stage']
+  /** UTC time when the stage began. */
+  started_at: string
+}
+
+/** Discriminated queue event carrying one route lifecycle interval. */
+export type Event = {
+  /** Stored interval row. */
+  data: Table
+  /** Queue event discriminator. */
+  type: 'routes:lifecycle:interval'
+}
+
+/** Builds a queue sink for completed route lifecycle intervals. */
+export function createQueueSink(
+  queue: createQueueSink.Queue,
+  options: createQueueSink.Options,
+): createQueueSink.Sink {
+  return async (interval) => {
+    await queue.send({
+      data: {
+        ended_at: timestamp(interval.endedAt),
+        environment: options.environment,
+        routes_environment: interval.routesEnvironment,
+        method: interval.method,
+        provider: interval.provider,
+        recorded_at: timestamp(new Date().toISOString()),
+        resource_id: interval.resourceId,
+        service: options.service,
+        stage: interval.stage,
+        started_at: timestamp(interval.startedAt),
+      },
+      type: 'routes:lifecycle:interval',
+    })
+  }
+}
+
+export declare namespace createQueueSink {
+  /** Context added to every stored interval. */
+  type Options = {
+    /** Deployment environment that records intervals. */
+    environment: string
+    /** Service that records intervals. */
+    service: string
+  }
+
+  /** Minimal queue producer used by the interval sink. */
+  type Queue = {
+    /** Enqueues one lifecycle interval. */
+    send(message: Event): Promise<unknown>
+  }
+
+  /** Records one completed route lifecycle interval. */
+  type Sink = (interval: RoutesObservability.LifecycleInterval) => Promise<void>
+}
+
+/** Returns whether a queue body is a route lifecycle interval event. */
+export function isEvent(value: unknown): value is Event {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'type' in value &&
+    value.type === 'routes:lifecycle:interval'
+  )
+}
+
+/** Inserts queued interval rows and applies per-message queue disposition. */
+export async function insertMessages(
+  analytics: Analytics.Analytics,
+  messages: readonly insertMessages.Message[],
+  options: insertMessages.Options = {},
+): Promise<void> {
+  if (messages.length === 0) return
+
+  try {
+    await analytics.insert(
+      'routes_lifecycle_intervals',
+      messages.map((message) => message.body.data),
+    )
+    for (const message of messages) message.ack()
+    report({ messages: messages.length, outcome: 'acked' })
+  } catch (cause) {
+    console.error('ClickHouse route lifecycle insert failed', cause)
+    for (const message of messages) message.retry()
+    report({ cause, messages: messages.length, outcome: 'retried' })
+  }
+
+  function report(result: RequestEvents.insertMessages.Result) {
+    try {
+      options.onResult?.(result)
+    } catch (cause) {
+      console.error('Analytics queue result callback failed', cause)
+    }
+  }
+}
+
+export declare namespace insertMessages {
+  /** Minimal queue message carrying one lifecycle event. */
+  type Message = {
+    /** Acknowledges the message. */
+    ack(): void
+    /** Queued lifecycle event. */
+    body: Event
+    /** Marks the message for redelivery. */
+    retry(): void
+  }
+
+  /** Queue insert observability options. */
+  type Options = {
+    /** Receives the final insert disposition. */
+    onResult?: ((result: RequestEvents.insertMessages.Result) => void) | undefined
+  }
+}
+
+function timestamp(value: string) {
+  return new Date(value).toISOString().replace('T', ' ').replace('Z', '')
+}

package/src/apps/Zones.test.ts

@@ -20,9 +20,9 @@ describe('chains', () => {
       },
       {
         contracts: {
-          messenger: { address: '0x171699d2B5211414C23E5Cd306d05046b78FdD16' },
-          portal: { address: '0xe5208b9604972CA6a2E1EF656a9d2bDF2e530B9A' },
-          verifier: { address: '0x3E7C1cC9C049052eb061116A4Ee7a7C281fa1F30' },
+          messenger: { address: '0x5A4d000000000000000000000000000000000000' },
+          portal: { address: '0x5ad0000000000000000000000000000000000001' },
+          verifier: { address: '0x5a56000000000000000000000000000000000000' },
         },
         id: 421_700_001,
         name: 'zone-mainnet-internal',
@@ -33,6 +33,21 @@ describe('chains', () => {
         },
         sourceId: 4_217,
       },
+      {
+        contracts: {
+          messenger: { address: '0x5A4d000000000000000000000000000000000000' },
+          portal: { address: '0x5Ad0000000000000000000000000000000000002' },
+          verifier: { address: '0x5a56000000000000000000000000000000000000' },
+        },
+        id: 421_700_002,
+        name: 'zone-deel',
+        rpcUrls: {
+          default: { http: ['https://zone-2-rpc.tempo.xyz'] },
+          internal: { http: ['https://zone-2-rpc.tempo.xyz'] },
+          tidx: { http: ['https://indexer-zone-2.tempo.xyz'] },
+        },
+        sourceId: 4_217,
+      },
       {
         contracts: {
           messenger: { address: '0x5A4d000000000000000000000000000000000000' },

package/src/apps/Zones.ts

@@ -1,8 +1,31 @@
-import { defineChain } from 'viem'
+import type { Chain } from 'viem'
+import { Zone } from 'viem/tempo'
 import { tempo, tempoDevnet, tempoTestnet } from 'viem/tempo/chains'
 
+type HostedZone = Zone.from.ReturnValue<Chain & Zone.from.Parameters>
+
+/** Returns a parent chain and its configured Zones for shared sponsorship accounting. */
+export function chainIds(options: chainIds.Options): number[] {
+  return [
+    options.sourceId,
+    ...[...options.zones]
+      .filter((zone) => zone.sourceId === options.sourceId)
+      .map((zone) => zone.id),
+  ]
+}
+
+export declare namespace chainIds {
+  /** Chains included in the accounting scope. */
+  type Options = {
+    /** Parent Tempo chain id. */
+    sourceId: number
+    /** Configured Zone chains. */
+    zones: Iterable<Chain>
+  }
+}
+
 /** Internal Moderato Zone on Tempo testnet. */
-export const zoneModeratoInternal = defineChain({
+export const zoneModeratoInternal: HostedZone = Zone.from({
   ...tempoTestnet,
   contracts: {
     ...tempoTestnet.contracts,
@@ -21,13 +44,13 @@ export const zoneModeratoInternal = defineChain({
 })
 
 /** Internal Zone on Tempo mainnet. */
-export const zoneMainnetInternal = defineChain({
+export const zoneMainnetInternal: HostedZone = Zone.from({
   ...tempo,
   contracts: {
     ...tempo.contracts,
-    messenger: { address: '0x171699d2B5211414C23E5Cd306d05046b78FdD16' },
-    portal: { address: '0xe5208b9604972CA6a2E1EF656a9d2bDF2e530B9A' },
-    verifier: { address: '0x3E7C1cC9C049052eb061116A4Ee7a7C281fa1F30' },
+    messenger: { address: '0x5A4d000000000000000000000000000000000000' },
+    portal: { address: '0x5ad0000000000000000000000000000000000001' },
+    verifier: { address: '0x5a56000000000000000000000000000000000000' },
   },
   id: 421_700_001,
   name: 'zone-mainnet-internal',
@@ -39,8 +62,27 @@ export const zoneMainnetInternal = defineChain({
   sourceId: tempo.id,
 })
 
+/** Deel Zone on Tempo mainnet. */
+export const zoneDeel: HostedZone = Zone.from({
+  ...tempo,
+  contracts: {
+    ...tempo.contracts,
+    messenger: { address: '0x5A4d000000000000000000000000000000000000' },
+    portal: { address: '0x5Ad0000000000000000000000000000000000002' },
+    verifier: { address: '0x5a56000000000000000000000000000000000000' },
+  },
+  id: 421_700_002,
+  name: 'zone-deel',
+  rpcUrls: {
+    default: { http: ['https://zone-2-rpc.tempo.xyz'] },
+    internal: { http: ['https://zone-2-rpc.tempo.xyz'] },
+    tidx: { http: ['https://indexer-zone-2.tempo.xyz'] },
+  },
+  sourceId: tempo.id,
+})
+
 /** Stable hosted Zone on Tempo devnet. */
-export const zoneStable = defineChain({
+export const zoneStable: HostedZone = Zone.from({
   ...tempoDevnet,
   contracts: {
     ...tempoDevnet.contracts,
@@ -58,4 +100,9 @@ export const zoneStable = defineChain({
 })
 
 /** Hosted Zone chains served by the API and admin. */
-export const chains = [zoneModeratoInternal, zoneMainnetInternal, zoneStable] as const
+export const chains: readonly HostedZone[] = [
+  zoneModeratoInternal,
+  zoneMainnetInternal,
+  zoneDeel,
+  zoneStable,
+]