tapimo 0.19.0 → 0.20.0

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

@@ -802,12 +802,10 @@ export namespace schema {
               z.meta({ examples: ['1000000'] }),
             ),
           quote: PairToken,
-          timestamp: z.iso
-            .datetime()
-            .check(
-              z.describe('Block timestamp when the pair was created.'),
-              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-            ),
+          timestamp: Schema.dateTime().check(
+            z.describe('Block timestamp when the pair was created.'),
+            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+          ),
           transactionHash: Schema.Hash.check(
             z.describe('Transaction hash for the transaction that created the pair.'),
           ),
@@ -1004,12 +1002,10 @@ export namespace schema {
             ),
           destinationAmount: ValuedAmount,
           destinationToken: SwapSide,
-          filledAt: z.iso
-            .datetime()
-            .check(
-              z.describe('Block timestamp when the swap was filled onchain.'),
-              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-            ),
+          filledAt: Schema.dateTime().check(
+            z.describe('Block timestamp when the swap was filled onchain.'),
+            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+          ),
           fills: z
             .array(Fill)
             .check(
@@ -1230,12 +1226,10 @@ export namespace schema {
               ),
               z.meta({ examples: ['1.00000'] }),
             ),
-          timestamp: z.iso
-            .datetime()
-            .check(
-              z.describe('ISO 8601 timestamp for the start of this candle bucket.'),
-              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-            ),
+          timestamp: Schema.dateTime().check(
+            z.describe('ISO 8601 timestamp for the start of this candle bucket.'),
+            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+          ),
           volume: z
             .object({
               base: Schema.DecimalString.check(
@@ -1544,12 +1538,10 @@ export namespace schema {
         orderId: Schema.DecimalString.check(
           z.describe('On-chain order id, returned as a decimal string.'),
         ),
-        placedAt: z.iso
-          .datetime()
-          .check(
-            z.describe('Block timestamp when the order was placed.'),
-            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-          ),
+        placedAt: Schema.dateTime().check(
+          z.describe('Block timestamp when the order was placed.'),
+          z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+        ),
         price: z
           .string()
           .check(
@@ -1681,12 +1673,10 @@ export namespace schema {
               z.describe('Block number where the fill was included.'),
               z.meta({ examples: [23456789] }),
             ),
-          filledAt: z.iso
-            .datetime()
-            .check(
-              z.describe('Block timestamp when the fill landed onchain.'),
-              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-            ),
+          filledAt: Schema.dateTime().check(
+            z.describe('Block timestamp when the fill landed onchain.'),
+            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+          ),
           id: z.string().check(
             z.describe('Stable API id built from the lowercase transaction hash and log index.'),
             z.meta({

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

@@ -154,21 +154,17 @@ export namespace schema {
     export const Pool = OpenApi.component(
       z
         .object({
-          createdAt: z.iso
-            .datetime()
-            .check(
-              z.describe('Timestamp when liquidity was first minted into this pool.'),
-              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-            ),
+          createdAt: Schema.dateTime().check(
+            z.describe('Timestamp when liquidity was first minted into this pool.'),
+            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+          ),
           id: Schema.Hash.check(
             z.describe('Stable resource id for the pool; this is the same value as `poolId`.'),
           ),
-          lastMintAt: z.iso
-            .datetime()
-            .check(
-              z.describe('Timestamp when liquidity was most recently minted into this pool.'),
-              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-            ),
+          lastMintAt: Schema.dateTime().check(
+            z.describe('Timestamp when liquidity was most recently minted into this pool.'),
+            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+          ),
           mintCount: z
             .number()
             .check(
@@ -283,12 +279,10 @@ export namespace schema {
                 'Address that received the minted liquidity. Only present on current-signature mints.',
               ),
             ),
-          timestamp: z.iso
-            .datetime()
-            .check(
-              z.describe('Block timestamp when the mint occurred.'),
-              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-            ),
+          timestamp: Schema.dateTime().check(
+            z.describe('Block timestamp when the mint occurred.'),
+            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+          ),
           transactionHash: Schema.Hash.check(
             z.describe('Hash of the transaction that emitted this mint.'),
           ),

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

@@ -451,12 +451,12 @@ describe('GET /indexer/query', () => {
 
   test('routes Zone queries to the Zone TIDX with its basic auth', async () => {
     const zone = runtime.zone.chainId
-    const zoneReader = {
-      id: 'key_zone_indexer',
-      orgId: 'org_test',
-      scopes: ['data:read', 'indexer:query', `zone:${zone}:read`],
-      token: 'secret_zone_indexer',
-    } satisfies TestApp.kvStore.Key
+    const zoneReader = TestApp.zoneReader(
+      { id: 'key_zone_indexer', orgId: 'org_test', scopes: ['data:read', 'indexer:query'], token: 'secret_zone_indexer' }, // prettier-ignore
+      [zone],
+    )
+    const db = TestApp.database()
+    await TestApp.delegateZone(db, { chainIds: [zone] })
     const fetch = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
       new Response(JSON.stringify({ columns: [], ok: true, row_count: 0, rows: [] }), {
         headers: { 'content-type': 'application/json' },
@@ -465,6 +465,7 @@ describe('GET /indexer/query', () => {
     try {
       const client = TestApp.client({
         auth: { keys: [zoneReader] },
+        db,
         tidx: { auth: JSON.stringify({ [zone]: 'zone:secret' }) },
         zones: [
           TestApp.zone({
@@ -496,12 +497,12 @@ describe('GET /indexer/query', () => {
 
   test('routes Zone queries to the Zone TIDX with its bearer auth', async () => {
     const zone = runtime.zone.chainId
-    const zoneReader = {
-      id: 'key_zone_bearer_indexer',
-      orgId: 'org_test',
-      scopes: ['data:read', 'indexer:query', `zone:${zone}:read`],
-      token: 'secret_zone_bearer_indexer',
-    } satisfies TestApp.kvStore.Key
+    const zoneReader = TestApp.zoneReader(
+      { id: 'key_zone_bearer_indexer', orgId: 'org_test', scopes: ['data:read', 'indexer:query'], token: 'secret_zone_bearer_indexer' }, // prettier-ignore
+      [zone],
+    )
+    const db = TestApp.database()
+    await TestApp.delegateZone(db, { chainIds: [zone] })
     const fetch = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
       new Response(JSON.stringify({ columns: [], ok: true, row_count: 0, rows: [] }), {
         headers: { 'content-type': 'application/json' },
@@ -510,6 +511,7 @@ describe('GET /indexer/query', () => {
     try {
       const client = TestApp.client({
         auth: { keys: [zoneReader] },
+        db,
         tidx: { auth: 'zone-secret', baseUrl: 'https://zone.tidx.test' },
         zones: [TestApp.zone({ chainId: zone, rpcUrl: runtime.zone.publicZoneUrl })],
       })

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

@@ -312,7 +312,7 @@ export namespace schema {
           z.meta({ examples: ['success'] }),
         ),
       timestamp: z
-        .nullable(z.iso.datetime())
+        .nullable(Schema.dateTime())
         .check(
           z.describe('The block timestamp as ISO 8601, or `null` when it is unavailable.'),
           z.meta({ examples: ['2024-01-01T00:00:00Z'] }),

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

@@ -82,18 +82,22 @@ const zoneOptions = TestApp.zone({
   chainId: zone,
   rpcUrl: runtime.zone.internalRpcUrl,
 })
-const zoneReader = {
-  id: 'key_zone_reader',
-  orgId: 'org_test',
-  scopes: ['data:read', `zone:${zone}:read`],
-  token: 'secret_zone_reader',
-} satisfies TestApp.kvStore.Key
-const zoneReaderOtherWriter = {
-  id: 'key_zone_reader_other_writer',
-  orgId: 'org_test',
-  scopes: ['data:read', `zone:${zone}:read`, `zone:${zone + 1}:write`],
-  token: 'secret_zone_reader_other_writer',
-} satisfies TestApp.kvStore.Key
+const zoneReader = TestApp.zoneReader(
+  { id: 'key_zone_reader', orgId: 'org_test', scopes: ['data:read'], token: 'secret_zone_reader' },
+  [zone],
+)
+const zoneReaderOtherWriter = TestApp.zoneReader(
+  {
+    id: 'key_zone_reader_other_writer',
+    orgId: 'org_test',
+    scopes: ['data:read', `zone:${zone + 1}:write`],
+    token: 'secret_zone_reader_other_writer',
+  },
+  [zone],
+)
+/** Holds the readers' organization delegation for the Zone. */
+const zoneDb = TestApp.database()
+await TestApp.delegateZone(zoneDb, { chainIds: [zone] })
 const zoneWriter = {
   id: 'key_zone_writer',
   orgId: 'org_test',
@@ -1092,7 +1096,7 @@ describe('POST /rpc', () => {
 
       expect(response.status).toBe(403)
       expect(body.error.code).toBe('api_key_forbidden')
-      expect(body.error.message).toContain(`zone:${zone}:read`)
+      expect(body.error.message).toContain('`zone:read`')
       // Refused before any upstream round-trip.
       expect(fetch.calls).toHaveLength(0)
     } finally {
@@ -1101,7 +1105,7 @@ describe('POST /rpc', () => {
   })
 
   test('routes Zone-scoped reads to the internal RPC', async () => {
-    const app = TestApp.create({ auth: { keys: [zoneReader] }, zones: [zoneOptions] })
+    const app = TestApp.create({ auth: { keys: [zoneReader] }, db: zoneDb, zones: [zoneOptions] })
     const response = await app.fetch(
       new Request(`http://tempo-api.test/rpc/${zone}`, {
         body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_chainId' }),
@@ -1115,7 +1119,7 @@ describe('POST /rpc', () => {
   })
 
   test('allows Zone-scoped eth_fillTransaction calls', async () => {
-    const app = TestApp.create({ auth: { keys: [zoneReader] }, zones: [zoneOptions] })
+    const app = TestApp.create({ auth: { keys: [zoneReader] }, db: zoneDb, zones: [zoneOptions] })
     const response = await app.fetch(
       new Request(`http://tempo-api.test/rpc/${zone}`, {
         body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_fillTransaction' }),
@@ -1140,6 +1144,7 @@ describe('POST /rpc', () => {
     try {
       const app = TestApp.create({
         auth: { keys: [zoneReader] },
+        db: zoneDb,
         rpc: ({ chainId }) => (chainId === zone ? { auth: 'rpc:secret', url: server.url } : {}),
         zones: [zoneOptions],
       })
@@ -1165,7 +1170,7 @@ describe('POST /rpc', () => {
   })
 
   test('blocks caller-authenticated Zone methods for Zone read scopes', async () => {
-    const app = TestApp.create({ auth: { keys: [zoneReader] }, zones: [zoneOptions] })
+    const app = TestApp.create({ auth: { keys: [zoneReader] }, db: zoneDb, zones: [zoneOptions] })
     const response = await app.fetch(
       new Request(`http://tempo-api.test/rpc/${zone}`, {
         body: JSON.stringify({
@@ -1184,7 +1189,7 @@ describe('POST /rpc', () => {
 
   test('rejects writes without the matching Zone write scope', async () => {
     for (const key of [zoneReader, zoneReaderOtherWriter]) {
-      const app = TestApp.create({ auth: { keys: [key] }, zones: [zoneOptions] })
+      const app = TestApp.create({ auth: { keys: [key] }, db: zoneDb, zones: [zoneOptions] })
       const response = await app.fetch(
         new Request(`http://tempo-api.test/rpc/${zone}`, {
           body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_sendRawTransaction' }),
@@ -1313,7 +1318,7 @@ describe('POST /rpc', () => {
   })
 
   test('rejects a Zone-scoped batch containing a write', async () => {
-    const app = TestApp.create({ auth: { keys: [zoneReader] }, zones: [zoneOptions] })
+    const app = TestApp.create({ auth: { keys: [zoneReader] }, db: zoneDb, zones: [zoneOptions] })
     const response = await app.fetch(
       new Request(`http://tempo-api.test/rpc/${zone}`, {
         body: JSON.stringify([

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

@@ -320,33 +320,33 @@ async function handleRpc(c: Context<App.Environment>) {
   }
   if (zone) {
     const requests = Array.isArray(body) ? body : [body]
-    const check = (verb: ZoneAccess.Verb) =>
-      ZoneAccess.check(c, { chainId, verb, zoneToken: Boolean(zoneToken) }).allowed
+    // Account-scoped methods need the token itself, so the token is the grant.
+    const reads = (request: unknown) =>
+      isZoneReadMethod(request) || (Boolean(zoneToken) && isZoneTokenMethod(request))
+    const classified = requests.every((request) => reads(request) || isZoneWriteMethod(request))
+    const options_access = { accounts: zoneAccounts(requests), chainId, zoneToken: Boolean(zoneToken) } // prettier-ignore
+    // Tokenless reads reach the internal node, which trusts a caller-supplied `from`;
+    // write scopes authorize broadcasts only, never those reads. Reads are decided
+    // once for the batch's accounts; a broadcast anywhere makes the record a write.
+    const read =
+      requests.some(reads) || !requests.some(isZoneWriteMethod)
+        ? await ZoneAccess.authorize(c, { ...options_access, verb: 'read' })
+        : undefined
+    const write = requests.some(isZoneWriteMethod)
+      ? await ZoneAccess.authorize(c, { ...options_access, verb: 'write' })
+      : undefined
     const allowed =
-      requests.length > 0 &&
-      requests.every(
-        (request) =>
-          // Tokenless reads reach the internal node, which trusts a caller-supplied `from`;
-          // write scopes authorize broadcasts only, never those reads.
-          (isZoneReadMethod(request) && check('read')) ||
-          (isZoneWriteMethod(request) && check('write')) ||
-          // Account-scoped methods need the token itself, so the token is the grant.
-          (Boolean(zoneToken) && isZoneTokenMethod(request) && check('read')),
-      )
-    // One record per request: the strictest operation the batch performs,
-    // denied when any method fails the allowlist.
-    ZoneAccess.authorize(c, {
-      accounts: zoneAccounts(requests),
-      chainId,
-      verb: requests.some(isZoneWriteMethod) ? 'write' : 'read',
-      zoneToken: Boolean(zoneToken),
-    })
+      requests.length > 0 && classified && (read?.allowed ?? true) && (write?.allowed ?? true)
     if (!allowed) {
       ZoneAccess.deny(c)
+      // A failed delegation read is retriable, unlike a missing grant.
+      for (const result of [read, write])
+        if (result && !result.allowed && result.error.status === 503)
+          return Response.error(c, result.error)
       return Response.error(c, {
         code: 'api_key_forbidden',
         message:
-          'Zone RPC permits read-only methods and signed transaction broadcasts. Reads require a matching Zone read scope or a Zone token; broadcasts require a matching Zone write scope or a Zone token; account-scoped methods require a Zone token.',
+          'Zone RPC permits read-only methods and signed transaction broadcasts. Reads require a delegated `zone:read` key tagged for the Zone or a Zone token; broadcasts require a matching Zone write scope or a Zone token; account-scoped methods require a Zone token.',
         status: 403,
       })
     }

package/src/apps/data/routes/rpc.zone.test.ts

@@ -233,14 +233,20 @@ describe('POST /rpc Zone authorization', () => {
     const server = await Relay.createServer(listener)
     const internal = await Relay.createServer(listener)
     try {
-      const key = {
-        ...TestApp.key,
-        id: 'key_zone_reader',
-        scopes: ['data:read', `zone:${chainId}:read`],
-        token: 'secret_zone_reader',
-      }
+      const key = TestApp.zoneReader(
+        {
+          ...TestApp.key,
+          id: 'key_zone_reader',
+          scopes: ['data:read'],
+          token: 'secret_zone_reader',
+        },
+        [chainId],
+      )
+      const db = TestApp.database()
+      await TestApp.delegateZone(db, { chainIds: [chainId] })
       const app = TestApp.create({
         auth: { keys: [key, TestApp.key] },
+        db,
         rpc: {
           auth: 'internal:secret',
           publicZoneUrl: { [chainId]: `${server.url}/public` },
@@ -308,6 +314,54 @@ describe('POST /rpc Zone authorization', () => {
     }
   })
 
+  test('broadcasts through the generic write scope only to tagged Zones, and never reads', async () => {
+    const calls: string[] = []
+    const server = await Relay.createServer(
+      RequestListener.fromFetchHandler(async (request) => {
+        calls.push((JSON.parse(await request.text()) as { method: string }).method)
+        return Response.json({ id: 1, jsonrpc: '2.0', result: null })
+      }),
+    )
+    try {
+      const tagged = { ...TestApp.key, id: 'key_tagged', scopes: ['data:read', 'zone:write'], token: 'secret_tagged', zoneTags: [chainId] } // prettier-ignore
+      const elsewhere = { ...tagged, id: 'key_elsewhere', token: 'secret_elsewhere', zoneTags: [chainId + 1] } // prettier-ignore
+      const untagged = { ...TestApp.key, id: 'key_untagged', scopes: ['data:read', 'zone:write'], token: 'secret_untagged' } // prettier-ignore
+      const db = TestApp.database()
+      await TestApp.delegateZone(db, { chainIds: [chainId] })
+      const app = TestApp.create({
+        auth: { keys: [tagged, elsewhere, untagged] },
+        db,
+        rpc: { url: server.url },
+        zones: [TestApp.zone({ chainId, rpcUrl: server.url })],
+      })
+      const send = (token: string, method: string) =>
+        app.fetch(
+          new Request(`http://tempo-api.test/rpc/${chainId}`, {
+            body: JSON.stringify({ id: 1, jsonrpc: '2.0', method, params: [] }),
+            headers: { 'tempo-api-key': token },
+            method: 'POST',
+          }),
+        )
+      expect((await send(tagged.token, 'eth_sendRawTransaction')).status).toBe(200)
+      const refused = await Promise.all([
+        send(tagged.token, 'eth_chainId'),
+        send(elsewhere.token, 'eth_sendRawTransaction'),
+        send(untagged.token, 'eth_sendRawTransaction'),
+      ])
+      expect(refused.map((response) => response.status)).toEqual([403, 403, 403])
+      const { requestId: _requestId, ...error } = (await refused[2].json()).error
+      expect(error).toMatchInlineSnapshot(`
+        {
+          "code": "api_key_forbidden",
+          "message": "Chain ID 421700001 is a Zone. Use an API key granting \`zone:read\` and tagged for Zone 421700001, issued to an organization delegated that Zone (or \`zone:write\` with a tag for Zone 421700001 for broadcasts), or pass a Zone token via \`X-Authorization-Token\`.",
+        }
+      `)
+      expect(calls).toEqual(['eth_sendRawTransaction'])
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
   test('does not fall back when a public URL map only contains a legacy Zone alias', async () => {
     const calls: string[] = []
     const server = await Relay.createServer(

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

@@ -114,12 +114,10 @@ export namespace schema {
               z.describe('The human-readable name of this token list.'),
               z.meta({ examples: ['Tempo Verified Tokens'] }),
             ),
-          timestamp: z.iso
-            .datetime()
-            .check(
-              z.describe('The ISO 8601 timestamp when this token list was last updated.'),
-              z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-            ),
+          timestamp: Schema.dateTime().check(
+            z.describe('The ISO 8601 timestamp when this token list was last updated.'),
+            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+          ),
           version: z
             .union([Version])
             .check(

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

@@ -1100,6 +1100,26 @@ describe('GET /tokens?addresses=', () => {
 })
 
 describe('GET /tokens/:token', () => {
+  test('returns the 404 envelope for an unknown token', async () => {
+    const client = app()
+    const response = await client.v1.tokens[':token'].$get(
+      { param: { token: '0x20c00000000000000000000000000000000000ff' }, query: {} },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+    const { requestId: _, ...stable } = body
+
+    expect(response.status).toMatchInlineSnapshot(`404`)
+    expect(stable).toMatchInlineSnapshot(`
+      {
+        "error": {
+          "code": "token_not_found",
+          "message": "Token not found",
+        },
+      }
+    `)
+  })
+
   test('returns token metadata for a small token', async () => {
     const client = app()
     const response = await client.v1.tokens[':token'].$get(

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

@@ -1,7 +1,7 @@
 import { Hono, type Context, type TypedResponse } from 'hono'
 import type { JSONParsed } from 'hono/utils/types'
 import { AbiEvent, AbiParameters, Hash } from 'ox'
-import { type Address, ContractFunctionExecutionError } from 'viem'
+import { type Address, BaseError, ContractFunctionExecutionError } from 'viem'
 import { Abis, Addresses } from 'viem/tempo'
 import * as z from 'zod/mini'
 
@@ -134,7 +134,7 @@ export namespace schema {
               z.meta({ examples: [tokenExample.currency] }),
             ),
           createdAt: z
-            .optional(z.iso.datetime())
+            .optional(Schema.dateTime())
             .check(
               z.describe(
                 'Token creation timestamp, present when requested via `include=createdAt` ' +
@@ -212,7 +212,7 @@ export namespace schema {
                     z.meta({ examples: [12345] }),
                   ),
                 firstAt: z
-                  .nullable(z.iso.datetime())
+                  .nullable(Schema.dateTime())
                   .check(
                     z.describe(
                       'The time of this token’s first `Transfer` event, or `null` if no transfers exist.',
@@ -220,7 +220,7 @@ export namespace schema {
                     z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
                   ),
                 lastAt: z
-                  .nullable(z.iso.datetime())
+                  .nullable(Schema.dateTime())
                   .check(
                     z.describe(
                       'The time of this token’s most recent `Transfer` event, or `null` if no transfers exist.',
@@ -2591,7 +2591,12 @@ declare namespace getTokens {
 
 /** Matches metadata-read failures for addresses that are not TIP-20 tokens. */
 export function isTokenNotFound(cause: unknown) {
-  if (cause instanceof ContractFunctionExecutionError) return true
+  // Tempo actions rethrow decoded reverts as `TempoExecutionError`, keeping the contract error as a cause.
+  if (
+    cause instanceof BaseError &&
+    cause.walk((error) => error instanceof ContractFunctionExecutionError)
+  )
+    return true
   if (cause instanceof Error && cause.message.includes('invalid tip20 address')) return true
   return false
 }

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

@@ -450,7 +450,7 @@ export namespace schema {
         z.describe('The address that submitted or authorized the transaction.'),
       ),
       timestamp: z
-        .nullable(z.iso.datetime())
+        .nullable(Schema.dateTime())
         .check(
           z.describe(
             'The block timestamp as ISO 8601, or `null` while the transaction is pending.',
@@ -465,13 +465,13 @@ export namespace schema {
         ),
       type: TransactionType,
       validAfter: z
-        .nullish(z.iso.datetime())
+        .nullish(Schema.dateTime())
         .check(
           z.describe('Earliest ISO 8601 time when this Tempo transaction may be included.'),
           z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
         ),
       validBefore: z
-        .nullish(z.iso.datetime())
+        .nullish(Schema.dateTime())
         .check(
           z.describe('Latest ISO 8601 time when this Tempo transaction may be included.'),
           z.meta({ examples: ['2024-01-01T00:00:00Z'] }),

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

@@ -284,12 +284,10 @@ export namespace schema {
         sender: Schema.Address.check(z.describe('The account address that sent the tokens.')),
         sourceAmount: valuedTokenAmount,
         sourceToken: transferToken.check(z.describe('The token that moved.')),
-        timestamp: z.iso
-          .datetime()
-          .check(
-            z.describe('The block timestamp when this transfer was recorded.'),
-            z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-          ),
+        timestamp: Schema.dateTime().check(
+          z.describe('The block timestamp when this transfer was recorded.'),
+          z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+        ),
         transactionHash: Schema.Hash.check(
           z.describe('The hash of the transaction that emitted this transfer event.'),
         ),

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

@@ -255,10 +255,8 @@ describe('GET /addresses/:address/valuation', () => {
       // Zone TIP-20 `balanceOf` reverts unless the `eth_call` caller is the queried account.
       const zoneDb = TestApp.database()
       await TestApp.verifiedSeed(zoneDb, runtime.zone.chainId, { tokens: usdTokens })
-      const key = {
-        ...TestApp.key,
-        scopes: ['data:read', `zone:${runtime.zone.chainId}:read`],
-      } satisfies TestApp.kvStore.Key
+      await TestApp.delegateZone(zoneDb, { chainIds: [runtime.zone.chainId] })
+      const key = TestApp.zoneReader({ ...TestApp.key, scopes: ['data:read'] }, [runtime.zone.chainId]) // prettier-ignore
       const client = app({
         auth: { keys: [key] },
         db: zoneDb,

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

@@ -57,12 +57,10 @@ export namespace schema {
   export const Pricing = OpenApi.component(
     z
       .object({
-        asOf: z.iso
-          .datetime()
-          .check(
-            z.describe('Publication date of the rate set as an ISO 8601 timestamp.'),
-            z.meta({ examples: ['2026-07-20T00:00:00.000Z'] }),
-          ),
+        asOf: Schema.dateTime().check(
+          z.describe('Publication date of the rate set as an ISO 8601 timestamp.'),
+          z.meta({ examples: ['2026-07-20T00:00:00.000Z'] }),
+        ),
         basis: z
           .literal('nominal')
           .check(

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

@@ -366,11 +366,7 @@ describe('access matrix', () => {
 
   test('rejects a sandbox key selecting a mainnet Zone', async () => {
     const zone = 421_700_001
-    const sandbox = {
-      ...writer,
-      environment: 'sandbox',
-      scopes: [...writer.scopes, `zone:${zone}:read`],
-    } satisfies TestApp.kvStore.Key
+    const sandbox = TestApp.zoneReader({ ...writer, environment: 'sandbox' }, [zone])
     const app = TestApp.create({
       auth: { keys: [sandbox] },
       webhook: { supportedChainIds: [4217, 42431, zone] },