tapimo 0.5.0 → 0.5.2

package/src/apps/composition.test.ts

@@ -25,6 +25,46 @@ async function paths(app: { request: (path: string) => Promise<Response> | Respo
   return Object.keys((await document(app)).paths)
 }
 
+describe('App.create()', () => {
+  test('publishes shared chain context without data routes', async () => {
+    const rpc = { url: () => 'https://rpc.example' }
+    const group = new Hono<App.Environment>().get('/context', (c) => {
+      const client = c.get('getClient')()
+      return c.json({
+        chainId: c.get('chainId'),
+        clientChainId: client.chain.id,
+        memoized: client === c.get('getClient')(),
+        rpc: c.get('rpc') === rpc,
+        supportedChainIds: [...c.get('supportedChainIds')].sort((a, b) => a - b),
+      })
+    })
+    const app = App.create({
+      auth: false,
+      db: TestApp.database(),
+      defaultChainId: 1337,
+      rpc,
+      supportedChainIds: [999],
+    }).route('/', group)
+
+    const response = await app.request('/context')
+
+    expect(await response.json()).toMatchInlineSnapshot(`
+      {
+        "chainId": 1337,
+        "clientChainId": 1337,
+        "memoized": true,
+        "rpc": true,
+        "supportedChainIds": [
+          999,
+          1337,
+          4217,
+          42431,
+        ],
+      }
+    `)
+  })
+})
+
 describe('App.from()', () => {
   test('contributes external route-group metadata', async () => {
     const group = new Hono().get(
@@ -110,6 +150,43 @@ describe('data()', () => {
     const orgs = await app.request('/v1/orgs')
     expect(orgs.status).toBe(404)
   })
+
+  test('inherits shared chain context', async () => {
+    const rpc = { url: () => 'https://rpc.example' }
+    const context = new Hono<App.Environment>().get('/context', (c) =>
+      c.json({
+        chainId: c.get('chainId'),
+        clientChainId: c.get('getClient')().chain.id,
+        rpc: c.get('rpc') === rpc,
+        supportedChainIds: [...c.get('supportedChainIds')].sort((a, b) => a - b),
+      }),
+    )
+    const app = App.create({
+      auth: false,
+      db: TestApp.database(),
+      defaultChainId: 333,
+      rpc,
+      supportedChainIds: [444],
+    })
+      .route('/', data())
+      .route('/', context)
+
+    const response = await app.request('/context')
+
+    expect(await response.json()).toMatchInlineSnapshot(`
+      {
+        "chainId": 333,
+        "clientChainId": 333,
+        "rpc": true,
+        "supportedChainIds": [
+          333,
+          444,
+          4217,
+          42431,
+        ],
+      }
+    `)
+  })
 })
 
 describe('relay()', () => {

package/src/apps/data/App.ts

@@ -33,59 +33,36 @@ import { verifiedTokens } from './routes/verified-tokens.js'
 import { schema as webhookSchema, webhooks } from './routes/webhooks.js'
 
 /**
- * The chain-data route group: read endpoints over blocks, transactions, tokens,
- * the exchange/fee-AMM, and the RPC/indexer passthroughs. It owns all chain
- * configuration and publishes the chain clients on request context.
+ * The chain-data route group extends app context with TIDX, assets, zones,
+ * verified tokens, and webhooks, and exposes indexed and RPC-backed reads.
  *
  * ```ts
  * App.create(options).route('/', data())
  * ```
  */
 export function data(options: data.Options = {}) {
-  const { assets, defaultChainId = Viem.defaultChainId, rpc: rpc_option, tidx } = options
+  const { assets, tidx } = options
 
   // Zone endpoints are explicit trust boundaries; the API never derives them.
   const zones = new Map((options.zones ?? []).map((zone) => [zone.chainId, zone]))
   const dataRouteHandlers = new Set<unknown>()
 
-  // The chain ids this deployment serves (built-in public chains plus
-  // `defaultChainId` and any explicit `supportedChainIds`). Published on context
-  // so handlers with a path `chainId` can guard it too.
-  const supportedChainIds = new Set<number>([
-    ...Object.keys(Viem.url).map(Number),
-    ...Object.keys(Tidx.url).map(Number),
-    defaultChainId,
-    ...(options.supportedChainIds ?? []),
-    ...zones.keys(),
-  ])
-
-  // Memoize one viem client per resolved upstream (stateless HTTP transports).
-  // Keying on the resolved output (`url`+`basicAuth`+`chainId`), not the
-  // principal, bounds cardinality by the number of distinct upstreams.
-  const clients = new Map<string, ReturnType<typeof Viem.getClient>>()
-  const getClient = (chainId = defaultChainId, principal: Auth.Principal | null = null) => {
-    const { url, basicAuth } = Viem.resolve(rpc_option, { chainId, principal })
-    const cacheKey = `${url}|${basicAuth ?? ''}|${chainId}`
-    const existing = clients.get(cacheKey)
-    if (existing) return existing
-    const client = Viem.getClient({ chainId, principal, rpc: rpc_option })
-    clients.set(cacheKey, client)
-    return client
-  }
-
-  // Memoize TIDX clients per resolved upstream.
-  const getTidx = Tidx.createGetClient({ defaultChainId, tidx })
+  const getTidx = Tidx.createGetClient({ tidx })
 
   const app = new Hono<App.Environment>()
     // Publish the chain-data context vars for this group's handlers. Runs after
     // `App.create`'s middleware, so `getClient`/`getTidx` can key on the
     // resolved principal and `getAsset` can read `basePath` off context.
     .use('*', async (c, next) => {
-      c.set('chainId', defaultChainId)
+      const getClient = c.get('getClient')
+      const supportedChainIds = new Set<number>([
+        ...c.get('supportedChainIds'),
+        ...Object.keys(Tidx.url).map(Number),
+        ...zones.keys(),
+      ])
       c.set('getAsset', createGetAsset({ assets, basePath: c.get('basePath'), origin: new URL(c.req.url).origin })) // prettier-ignore
-      c.set('getClient', (chainId) => getClient(chainId, Auth.getPrincipal(c)))
-      c.set('getTidx', (chainId) => getTidx(chainId, Auth.getPrincipal(c)))
-      c.set('rpc', rpc_option)
+      c.set('getClient', (chainId) => getClient(chainId ?? c.get('chainId')))
+      c.set('getTidx', (chainId) => getTidx(chainId ?? c.get('chainId'), Auth.getPrincipal(c)))
       c.set('supportedChainIds', supportedChainIds)
       c.set('tidx', tidx)
       c.set('verifiedTokens', options.verifiedTokens === false ? undefined : (options.verifiedTokens ?? {})) // prettier-ignore
@@ -95,6 +72,8 @@ export function data(options: data.Options = {}) {
     })
     // Resolve one chain for every data route before auth and handlers use it.
     .use('*', async (c, next) => {
+      const defaultChainId = c.get('chainId')
+      const supportedChainIds = c.get('supportedChainIds')
       const selection = resolveChainSelector({
         c,
         defaultChainId,
@@ -118,7 +97,7 @@ export function data(options: data.Options = {}) {
       if (zones.size === 0) return next()
       const selection = resolveChainSelector({
         c,
-        defaultChainId,
+        defaultChainId: c.get('chainId'),
         handlers: dataRouteHandlers,
       })
       if (!selection.matched) return next()
@@ -155,7 +134,7 @@ export function data(options: data.Options = {}) {
 
       const selection = resolveChainSelector({
         c,
-        defaultChainId,
+        defaultChainId: c.get('chainId'),
         handlers: dataRouteHandlers,
       })
       if (!selection.matched || !Viem.isMainnet(c.get('chainId'))) return next()
@@ -197,7 +176,11 @@ export function data(options: data.Options = {}) {
     .route('/', coingecko())
     .route('/', blocksByTimestampCompat())
   const edgeCacheEligible = (c: Context<App.Environment>) => {
-    const selection = resolveChainSelector({ c, defaultChainId, handlers: dataRouteHandlers })
+    const selection = resolveChainSelector({
+      c,
+      defaultChainId: c.get('chainId'),
+      handlers: dataRouteHandlers,
+    })
     return (
       selection.matched &&
       !selection.conflict &&
@@ -210,7 +193,10 @@ export function data(options: data.Options = {}) {
     dataRouteHandlers.add(route.handler)
     if (zones.size > 0) EdgeCache.setEligibility(route.handler, edgeCacheEligible)
   }
-  return Metadata.attach(app, openapi)
+  return Metadata.attach(app, {
+    ...openapi,
+    supportedChainIds: [...Object.keys(Tidx.url).map(Number), ...zones.keys()],
+  })
 }
 
 export declare namespace data {
@@ -218,14 +204,8 @@ export declare namespace data {
   type Options = {
     /** Static API asset store for the current runtime (e.g. `Assets.cloudflareR2(...)`). Omit to skip static assets — token logo URIs go unresolved. */
     assets?: Assets.Assets | undefined
-    /** Default Tempo chain id for requests that omit `chainId`. */
-    defaultChainId?: Viem.ChainId | undefined
     /** Funding quote provider configuration. */
     funding?: funding.Options | undefined
-    /** Tempo RPC options: a static config, or a per-request resolver that routes by request principal to a separate (e.g. public, no-auth) RPC. */
-    rpc?: Viem.getClient.Rpc | undefined
-    /** Extra chain ids this deployment serves, beyond the built-in public chains and `defaultChainId`. A `chainId` outside this set is rejected with a 400. */
-    supportedChainIds?: readonly number[] | undefined
     /** TIDX query client options. */
     tidx?: Tidx.getClient.Tidx | undefined
     /** Verified-token feature configuration. Enabled by default (token rows live in `db`; empty until published); pass `false` to always serve an empty verified list. */