tapimo 0.12.0 → 0.13.0

package/src/apps/Zones.test.ts

@@ -5,11 +5,11 @@ describe('chains', () => {
     expect(Zones.chains).toMatchObject([
       {
         contracts: {
-          messenger: { address: '0x2fB7Aba18510622cd88F5f45B3AC0E7Dd70606a5' },
-          portal: { address: '0x5765e8B9003054e479df44D12D3dEeaADEfa8b7c' },
-          verifier: { address: '0xfa16b9C6A356a096F0e7ceF0135C393A81d4a355' },
+          messenger: { address: '0x5A4d000000000000000000000000000000000000' },
+          portal: { address: '0x5Ad0000000000000000000000000000000000003' },
+          verifier: { address: '0x5a56000000000000000000000000000000000000' },
         },
-        id: 1_424_310_001,
+        id: 1_424_310_003,
         name: 'zone-moderato-internal',
         rpcUrls: {
           default: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },

package/src/apps/Zones.ts

@@ -6,11 +6,11 @@ export const zoneModeratoInternal = defineChain({
   ...tempoTestnet,
   contracts: {
     ...tempoTestnet.contracts,
-    messenger: { address: '0x2fB7Aba18510622cd88F5f45B3AC0E7Dd70606a5' },
-    portal: { address: '0x5765e8B9003054e479df44D12D3dEeaADEfa8b7c' },
-    verifier: { address: '0xfa16b9C6A356a096F0e7ceF0135C393A81d4a355' },
+    messenger: { address: '0x5A4d000000000000000000000000000000000000' },
+    portal: { address: '0x5Ad0000000000000000000000000000000000003' },
+    verifier: { address: '0x5a56000000000000000000000000000000000000' },
   },
-  id: 1_424_310_001,
+  id: 1_424_310_003,
   name: 'zone-moderato-internal',
   rpcUrls: {
     default: { http: ['https://zone-internal-rpc.testnet.tempo.xyz'] },

package/src/apps/composition.test.ts

@@ -197,7 +197,7 @@ describe('data()', () => {
           42431,
           421700001,
           421700006,
-          1424310001,
+          1424310003,
         ],
       }
     `)

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

@@ -183,11 +183,20 @@ describe('MPP session management', () => {
 })
 
 describe('zone chain gate', () => {
+  const legacyModerato = 1_424_310_001
+  const moderato = 1_424_310_003
   /** A consumer-supplied zone chain id (the API never derives these). */
   const zone = 421_700_001
   /** A second zone, isolating per-zone grants. */
   const zoneB = 4_217_000_002
 
+  const legacyModeratoReader = {
+    id: 'key_legacy_moderato',
+    orgId: 'org_test',
+    scopes: ['data:read', 'indexer:query', `zone:${legacyModerato}:read`],
+    token: 'secret_legacy_moderato',
+  } satisfies TestApp.kvStore.Key
+
   function zoneOptions(chainId: number) {
     return TestApp.zone({
       chainId,
@@ -292,6 +301,38 @@ describe('zone chain gate', () => {
     expect(response.status).toBe(200)
   })
 
+  test('the legacy Moderato id and read scope route to current upstreams', async () => {
+    const fetch = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValueOnce(Response.json({ id: 1, jsonrpc: '2.0', result: '0x54e89ac3' }))
+      .mockResolvedValueOnce(Response.json({ columns: [], ok: true, row_count: 0, rows: [] }))
+    try {
+      const app = TestApp.create({
+        auth: { keys: [legacyModeratoReader] },
+        rpc: { url: (chainId) => `https://${chainId}.rpc.test` },
+        tidx: { baseUrl: (chainId) => `https://${chainId}.tidx.test` },
+        zones: true,
+      })
+      const rpc = await app.request(`/rpc/${legacyModerato}`, {
+        body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_chainId' }),
+        headers: as(legacyModeratoReader).headers,
+        method: 'POST',
+      })
+      const tidx = await app.request(
+        `/v1/indexer/query?chainId=${legacyModerato}&sql=select%201`,
+        as(legacyModeratoReader),
+      )
+      const tidxUpstream = new URL((fetch.mock.calls[1]![0] as Request).url)
+
+      expect([rpc.status, tidx.status]).toEqual([200, 200])
+      expect((fetch.mock.calls[0]![0] as Request).url).toBe(`https://${moderato}.rpc.test/`)
+      expect(tidxUpstream.origin).toBe(`https://${moderato}.tidx.test`)
+      expect(tidxUpstream.searchParams.get('chainId')).toBe(String(moderato))
+    } finally {
+      fetch.mockRestore()
+    }
+  })
+
   test('a Zone write scope reads Zone data', async () => {
     const response = await zoneApp().request(`/v1/tokenlist?chainId=${zone}`, as(zoneWriter))
     expect(response.status).toBe(200)

package/src/apps/data/App.ts

@@ -130,6 +130,21 @@ export function data(options: data.Options = {}) {
       const rpc_config = c.get('rpc')
       const tidx_config = c.get('tidx')
       const zones = c.get('zones')
+      // Raw passthroughs and RPC-only reads need only RPC; composed data routes
+      // require both upstreams to avoid falling through to unrelated defaults.
+      const narrowedChainIds = new Set(
+        [...supportedChainIds].filter((chainId) => {
+          const context = { chainId, principal, zone: zones.get(chainId) }
+          const hasRpc = Viem.resolveRpc(rpc_config, context).url !== undefined
+          const hasTidx = Tidx.resolve(tidx_config, context).baseUrl !== undefined
+          if (selection.rpc || selection.rpcOnly) return hasRpc
+          if (selection.indexer) return hasTidx
+          return hasRpc && hasTidx
+        }),
+      )
+      c.set('supportedChainIds', narrowedChainIds)
+      if (!narrowedChainIds.has(selection.chainId))
+        return Response.unsupportedChainId(c, selection.chainId, narrowedChainIds)
       if (selection.inferredZones) {
         if (principal?.type !== 'api_key')
           return Response.error(c, {
@@ -150,25 +165,10 @@ export function data(options: data.Options = {}) {
             message: 'The API key has no readable configured Zones.',
             status: 403,
           })
-        c.set('supportedChainIds', new Set(zoneChainIds))
+        c.set('supportedChainIds', new Set([selection.chainId, ...zoneChainIds]))
         c.set('zoneChainIds', zoneChainIds)
         return next()
       }
-      // Raw passthroughs and RPC-only reads need only RPC; composed data routes
-      // require both upstreams to avoid falling through to unrelated defaults.
-      const narrowedChainIds = new Set(
-        [...supportedChainIds].filter((chainId) => {
-          const context = { chainId, principal, zone: zones.get(chainId) }
-          const hasRpc = Viem.resolveRpc(rpc_config, context).url !== undefined
-          const hasTidx = Tidx.resolve(tidx_config, context).baseUrl !== undefined
-          if (selection.rpc || selection.rpcOnly) return hasRpc
-          if (selection.indexer) return hasTidx
-          return hasRpc && hasTidx
-        }),
-      )
-      c.set('supportedChainIds', narrowedChainIds)
-      if (!narrowedChainIds.has(selection.chainId))
-        return Response.unsupportedChainId(c, selection.chainId, narrowedChainIds)
       c.set('chainId', selection.chainId)
       return next()
     })
@@ -201,8 +201,8 @@ export function data(options: data.Options = {}) {
         return Response.error(c, {
           code: 'api_key_forbidden',
           message: selection.rpc
-            ? `Chain id ${chainId} is a zone. Use an API key granting \`zone:${chainId}:read\` or \`zone:${chainId}:write\`, or pass a Zone token via \`X-Authorization-Token\`.`
-            : `Chain id ${chainId} is a zone. Use an API key granting \`zone:${chainId}:read\` or \`zone:${chainId}:write\`.`,
+            ? `Chain ID ${chainId} is a Zone. Use an API key granting \`zone:${chainId}:read\` or \`zone:${chainId}:write\`, or pass a Zone token via \`X-Authorization-Token\`.`
+            : `Chain ID ${chainId} is a Zone. Use an API key granting \`zone:${chainId}:read\` or \`zone:${chainId}:write\`.`,
           status: 403,
         })
 

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

@@ -138,7 +138,7 @@ describe('readableChainIds', () => {
 })
 
 describe('uniqueMatch', () => {
-  test('selects one match after every Zone completes', () => {
+  test('selects one match after every chain completes', () => {
     expect(
       ZoneSelection.uniqueMatch([
         { chainId: 1, value: null },
@@ -159,7 +159,7 @@ describe('uniqueMatch', () => {
     ).toStrictEqual({ kind: 'ambiguous' })
   })
 
-  test('fails the selection when any Zone lookup fails', () => {
+  test('fails the selection when any chain lookup fails', () => {
     const cause = new Error('unavailable')
     expect(
       ZoneSelection.uniqueMatch([

package/src/apps/data/ZoneSelection.ts

@@ -48,7 +48,7 @@ export declare namespace readableChainIds {
   }
 }
 
-/** Resolves receipt probes without treating partial upstream results as complete. */
+/** Resolves chain receipt probes without treating partial upstream results as complete. */
 export function uniqueMatch<const value>(
   probes: readonly uniqueMatch.Probe<value>[],
 ): uniqueMatch.Result<value> {
@@ -66,25 +66,25 @@ export function uniqueMatch<const value>(
 }
 
 export declare namespace uniqueMatch {
-  /** One completed Zone lookup. */
+  /** One completed chain lookup. */
   type Probe<value> =
     | {
-        /** Zone that completed the lookup. */
+        /** Chain that completed the lookup. */
         chainId: number
-        /** Matching value, or null when the Zone did not contain the resource. */
+        /** Matching value, or null when the chain did not contain the resource. */
         value: value | null
       }
     | {
-        /** Upstream failure from this Zone. */
+        /** Upstream failure from this chain. */
         cause: unknown
-        /** Zone that failed the lookup. */
+        /** Chain that failed the lookup. */
         chainId: number
       }
 
-  /** Unique-match decision across every requested Zone. */
+  /** Unique-match decision across every requested chain. */
   type Result<value> =
     | {
-        /** Zone containing the unique match. */
+        /** Chain containing the unique match. */
         chainId: number
         /** Unique match result. */
         kind: 'selected'