tapimo 0.12.0 → 0.14.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'] },
@@ -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',

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'] },
@@ -25,9 +25,9 @@ export const zoneMainnetInternal = defineChain({
   ...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',

package/src/apps/composition.test.ts

@@ -197,7 +197,7 @@ describe('data()', () => {
           42431,
           421700001,
           421700006,
-          1424310001,
+          1424310003,
         ],
       }
     `)
@@ -309,6 +309,7 @@ describe('funding()', () => {
         '/v1/funding/transfers/vault',
         '/v1/funding/transfers/zone',
         '/v1/funding/transfers/{id}',
+        '/v1/funding/transfers/{id}/source-transactions',
       ].sort(),
     )
     expect(Object.keys(spec.paths).some((path) => path.startsWith('/v1/tokens'))).toBe(false)

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

@@ -23,7 +23,7 @@ import { transactions as transactionActivities } from './routes/activities.js'
 import { addresses } from './routes/addresses.js'
 import { blocks, blocksByTimestampCompat } from './routes/blocks.js'
 import { coingecko } from './routes/coingecko.js'
-import { earn } from './routes/earn.js'
+import * as Earn from './routes/earn.js'
 import { exchanges } from './routes/exchanges.js'
 import { feeAmm } from './routes/fee-amm.js'
 import { indexer } from './routes/indexer.js'
@@ -60,7 +60,7 @@ export function data(options: data.Options = {}) {
 
   const getTidx = Tidx.createGetClient({ tidx })
   const addresses_routes = addresses({ fx: options.fx })
-  const earn_routes = earn({ fx: options.fx })
+  const earn_routes = Earn.earn({ fx: options.fx })
   const indexer_routes = indexer()
   const transactionActivities_routes = transactionActivities({ fx: options.fx })
   const indexerRouteHandlers = new Set(indexer_routes.routes.map((route) => route.handler))
@@ -130,6 +130,30 @@ export function data(options: data.Options = {}) {
       const rpc_config = c.get('rpc')
       const tidx_config = c.get('tidx')
       const zones = c.get('zones')
+      const query = Earn.schema.getEarnVaultPosition.Query.safeParse(
+        Object.fromEntries(
+          Object.entries(c.req.queries()).map(([key, values]) => [
+            key,
+            values.length === 1 ? values[0] : values,
+          ]),
+        ),
+      )
+      const requiresTidx = selection.rpcOnly && query.success && query.data.asOf !== undefined
+      // Raw passthroughs and current RPC-only reads need RPC. Historical
+      // position reads and composed data routes require both upstreams.
+      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 && !requiresTidx)) 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 +174,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 +210,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,
         })
 
@@ -500,7 +509,7 @@ function webhooksBlock() {
             'tempo-event-id',
             'A unique, stable id for this event (`evt_…`). The same event may be delivered more than once, so use this id to skip duplicates.',
           ),
-          header('tempo-event-type', 'What happened: `token:transfer`, `transaction:included`, `log:emitted`, `block:created`, `funding:deposit.updated`, or `ping`.'), // prettier-ignore
+          header('tempo-event-type', 'What happened: `token:transfer`, `transaction:included`, `log:emitted`, `block:created`, `funding:deposit.updated`, `funding:transfer.updated`, or `ping`.'), // prettier-ignore
         ],
         requestBody: {
           content: { 'application/json': { schema: envelope } },

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'