tapimo 0.1.0 → 0.3.0

package/src/apps/data/App.ts

@@ -0,0 +1,330 @@
+import { Hono } from 'hono'
+import * as z from 'zod/mini'
+
+import type * as Assets from '../../Assets.js'
+import type * as App from '../../App.js'
+import * as Metadata from '../metadata.js'
+import * as Auth from '../../internal/Auth.js'
+import * as Path from '../../internal/Path.js'
+import * as Response from '../../internal/Response.js'
+import * as Schema from '../../internal/Schema.js'
+import * as Tidx from '../../internal/Tidx.js'
+import * as Viem from '../../internal/Viem.js'
+
+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 { exchanges } from './routes/exchanges.js'
+import { feeAmm } from './routes/fee-amm.js'
+import { funding } from './routes/funding.js'
+import { indexer } from './routes/indexer.js'
+import { receipts } from './routes/receipts.js'
+import { rpc } from './routes/rpc.js'
+import { tokenlist } from './routes/tokenlist.js'
+import { tokens } from './routes/tokens.js'
+import { transactions } from './routes/transactions.js'
+import { transfers } from './routes/transfers.js'
+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.
+ *
+ * ```ts
+ * App.create(options).route('/', data())
+ * ```
+ */
+export function data(options: data.Options = {}) {
+  const { assets, defaultChainId = Viem.defaultChainId, rpc: rpc_option, tidx } = options
+
+  // 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 ?? []),
+  ])
+
+  // 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 `chainId` so the base URL resolver runs once per
+  // chain instead of on every request.
+  const getTidx = Tidx.createGetClient({ defaultChainId, 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)
+      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('supportedChainIds', supportedChainIds)
+      c.set('tidx', tidx)
+      c.set('verifiedTokens', options.verifiedTokens === false ? undefined : (options.verifiedTokens ?? {})) // prettier-ignore
+      c.set('webhook', options.webhook === false ? undefined : (options.webhook ?? {}))
+      await next()
+    })
+    // Reject a well-formed but unsupported `chainId` before it reaches an
+    // upstream, which would otherwise return an opaque `upstream_error`.
+    .use('*', async (c, next) => {
+      const raw = c.req.query('chainId') ?? c.req.query('chain_id')
+      if (raw === undefined) return next()
+      // Only reject a well-formed-but-unsupported chain here; malformed values
+      // (e.g. `abc`, `0`) fall through to the route's own query validation.
+      const parsed = Schema.ChainId.safeParse(raw)
+      if (!parsed.success || supportedChainIds.has(parsed.data)) return next()
+      return Response.unsupportedChainId(c, parsed.data, supportedChainIds)
+    })
+    // Sandbox keys are testnet-only. A chain-scoped data route defaults to
+    // mainnet, so a sandbox key that omits `chainId` (or targets mainnet) is
+    // refused with a clear message telling the caller to pass a testnet
+    // `chainId`. The relay resolves its chain from the request body, not the
+    // query, so it is skipped and enforces the rule in its sponsor validation.
+    .use('*', async (c, next) => {
+      const relay = Path.join(c.get('basePath') ?? '', 'rpc/relay')
+      if (c.req.path === relay || c.req.path.startsWith(`${relay}/`)) return next()
+
+      const principal = Auth.getPrincipal(c)
+      if (principal?.type !== 'api_key' || principal.environment !== 'sandbox') return next()
+
+      const raw = c.req.query('chainId') ?? c.req.query('chain_id')
+      // Absent falls back to the group default (mainnet); a malformed value
+      // stays with the route's own validator rather than the sandbox message.
+      const chainId = (() => {
+        if (raw === undefined) return defaultChainId
+        const parsed = Schema.ChainId.safeParse(raw)
+        return parsed.success ? parsed.data : undefined
+      })()
+      if (chainId === undefined || !Viem.isMainnet(chainId)) return next()
+
+      return Response.error(c, {
+        code: 'api_key_forbidden',
+        message: 'Sandbox API keys only support testnet. Pass a testnet `chainId`.',
+        status: 403,
+      })
+    })
+    // Serve static API assets (e.g. verified-token icons) from the configured
+    // store; a no-op fall-through when no store is configured (logo URIs simply
+    // go unresolved).
+    .use('/assets/*', async (c, next) => {
+      if (!assets) return next()
+      const key = stripAssetPath(c.req.path, c.get('basePath')).replace(/^\/+/, '')
+      const asset = key ? await assets.get(key) : undefined
+      if (!asset) return next()
+      return c.body(asset.body, 200, {
+        'Cache-Control': 'public, max-age=86400',
+        'Content-Type': asset.contentType,
+      })
+    })
+    .route('/', addresses())
+    .route('/', blocks())
+    .route('/', exchanges())
+    .route('/', feeAmm())
+    .route('/', funding())
+    .route('/', indexer())
+    .route('/', receipts())
+    .route('/', tokenlist())
+    .route('/', tokens())
+    .route('/', transactions())
+    .route('/', transactionActivities())
+    .route('/', transfers())
+    .route('/', verifiedTokens())
+    .route('/', webhooks({ enabled: options.webhook !== false }))
+    .route('/', rpc())
+    .route('/', coingecko())
+    .route('/', blocksByTimestampCompat())
+  return Metadata.attach(app, openapi)
+}
+
+export declare namespace data {
+  /** Options for the data route group. */
+  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
+    /** 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. */
+    verifiedTokens?: VerifiedTokens | false | undefined
+    /** Webhook feature configuration. Enabled by default (rows live in `db`); pass `false` to disable, leaving `/webhooks` mounted but returning `404` and hidden from the OpenAPI document. */
+    webhook?: Webhook | false | undefined
+  }
+
+  /** Verified-token feature configuration. */
+  type VerifiedTokens = {
+    /**
+     * Per-isolate soft-refresh window (ms). Lookups serve from the in-memory
+     * snapshot within it; after it, the next lookup re-checks the head version
+     * and recompiles only on change. Defaults to 10_000.
+     */
+    refreshMs?: number | undefined
+  }
+
+  /** Webhook feature configuration. */
+  type Webhook = {
+    /**
+     * Maximum active subscriptions per owner; creation is rejected with
+     * `403 limit_exceeded` once reached. Defaults to 100, bounding the spam/SSRF
+     * and delivery-cost surface per owner.
+     */
+    maxPerOwner?: number | undefined
+  }
+}
+
+/**
+ * The OpenAPI metadata this group owns: its operation tags and the outbound
+ * `webhooks` block. Tagged onto the {@link data} instance so `App.create`
+ * collects it; the webhooks block emits only when webhook routes are mounted.
+ */
+const openapi = {
+  tags: [
+    { name: 'Activities', description: 'A readable feed of what an account did onchain.' },
+    { name: 'Balances', description: 'How much of each token an account holds.' },
+    { name: 'Blocks', description: 'The ordered batches of transactions making up the chain.' },
+    { name: 'Exchange', description: "Tempo's built-in stablecoin exchange: pairs, swaps, orders, prices." }, // prettier-ignore
+    { name: 'Fee AMM', description: 'Pools that convert stablecoins to pay fees.' },
+    { name: 'Funding', description: 'Routes and inventory for moving stablecoins into Tempo.' },
+    { name: 'Providers', description: 'Provider metadata, capabilities, and integration status.' },
+    { name: 'Tokens', description: 'TIP-20 token details, supply, and holders.' },
+    { name: 'Transactions', description: 'Transactions submitted to Tempo, and their receipts.' },
+    { name: 'Transfers', description: 'Token movements from executing transactions.' },
+    { name: 'Verified Tokens', description: 'A curated, trusted list of TIP-20 tokens.' },
+    { name: 'Webhooks', description: 'Get signed callbacks when onchain events happen.' },
+    { name: 'Indexer', description: "Run read-only SQL queries against Tempo's indexed data." },
+    { name: 'RPC', description: 'Direct access to the chain over Ethereum JSON-RPC. Not part of the stable API contract; best-effort support only. No compatibility, latency, availability, or data-freshness guarantees. Breaking changes may happen with limited notice.' }, // prettier-ignore
+    { name: 'CoinGecko', description: "Exchange data in CoinGecko's GeckoTerminal format." },
+  ],
+  'x-tagGroups': [
+    {
+      name: 'Data API',
+      tags: [
+        'Activities',
+        'Balances',
+        'Blocks',
+        'Exchange',
+        'Fee AMM',
+        'Funding',
+        'Providers',
+        'Tokens',
+        'Transactions',
+        'Transfers',
+        'Verified Tokens',
+        'Webhooks',
+        'Indexer',
+        'RPC',
+        'MCP',
+        'CoinGecko',
+      ],
+    },
+  ],
+  webhooks: webhooksBlock,
+} satisfies App.create.Metadata
+
+// Builds the outbound-delivery `webhooks` block. `io: 'output'` documents the
+// serialized shape; `unrepresentable: 'any'` emits `{}` for payload transforms
+// (e.g. lazy fee-token metadata) that have no JSON-Schema form.
+function webhooksBlock() {
+  const envelope = z.toJSONSchema(webhookSchema.Envelope, {
+    io: 'output',
+    target: 'draft-2020-12',
+    unrepresentable: 'any',
+  })
+  delete envelope.$schema
+  const header = (name: string, description: string) => ({
+    description,
+    in: 'header' as const,
+    name,
+    required: true,
+    schema: { type: 'string' as const },
+  })
+  return {
+    event: {
+      post: {
+        description:
+          'When an event you subscribed to happens, Tempo sends this signed message to your webhook URL as an HTTP POST (the same shape is used by `POST /webhooks/:id/ping` so you can test your endpoint). Always verify the `tempo-signature` header before trusting the body, then reply with any 2xx status to confirm you received it. If your endpoint returns a non-2xx status, times out, or redirects, Tempo retries with increasing delays; an endpoint that keeps failing is eventually disabled.',
+        parameters: [
+          header(
+            'tempo-signature',
+            'Signature proving the message really came from Tempo. An HMAC-SHA256 of the body using your webhook secret, formatted `t=<unix>,v1=<hex>`. Verify this before trusting the payload.',
+          ),
+          header(
+            '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`, or `ping`.'), // prettier-ignore
+        ],
+        requestBody: {
+          content: { 'application/json': { schema: envelope } },
+          required: true,
+        },
+        responses: { '2xx': { description: 'Delivery acknowledged.' } },
+        summary: 'Webhook event delivery',
+        tags: ['Webhooks'],
+      },
+    },
+  }
+}
+
+// Builds the per-request static-asset resolver. The store is keyed by
+// `:chainId/:path` (decoupled from the public `/assets/:chainId` URL) and
+// returns absolute URLs against the request origin. Without a store, every
+// lookup misses and callers fall back to undefined logo URIs.
+function createGetAsset(options: createGetAsset.Options): App.GetAsset {
+  const { assets, basePath, origin } = options
+  if (!assets) return () => undefined
+  return async (chainId, path) => {
+    const pathname = Path.join(basePath, 'assets', String(chainId), path)
+    // `path` may be absolute (`Path.join` returns a leading slash); strip it so
+    // the key is `:chainId/:path`, not `:chainId//:path`.
+    const key = `${chainId}/${path.replace(/^\/+/, '')}`
+    const asset = await assets.get(key)
+    if (!asset) return undefined
+    return {
+      response: new globalThis.Response(asset.body, {
+        headers: { 'Content-Type': asset.contentType },
+      }),
+      uri: new URL(pathname, origin).toString(),
+    }
+  }
+}
+
+declare namespace createGetAsset {
+  type Options = {
+    assets?: Assets.Assets | undefined
+    basePath: string
+    origin: string
+  }
+}
+
+// Strips the (possibly base-path-prefixed) `/assets/` segment so the remainder
+// is the store key path.
+function stripAssetPath(path: string, basePath: string) {
+  for (const prefix of [`${Path.join(basePath, 'assets')}/`, '/assets/'])
+    if (path.startsWith(prefix)) return `/${path.slice(prefix.length)}`
+  return path
+}

package/src/apps/data/index.ts

@@ -0,0 +1,2 @@
+export { data } from './App.js'
+export * as Sponsorships from '../relay/Sponsorships.js'

package/src/apps/{activities.test.ts → data/routes/activities.test.ts}

@@ -2,9 +2,9 @@ import { Address, Hex } from 'ox'
 import { encodeAbiParameters, encodeEventTopics } from 'viem'
 import { Abis } from 'viem/tempo'
 
-import * as TestApp from '../../test/App.js'
-import * as Runtime from '../../test/runtime.js'
-import * as Store from '../internal/Store.js'
+import * as TestApp from '../../../../test/App.js'
+import * as Runtime from '../../../../test/runtime.js'
+import * as Store from '../../../internal/Store.js'
 import * as Activities from './activities.js'
 
 /**

package/src/apps/{activities.ts → data/routes/activities.ts}

@@ -4,19 +4,19 @@ import { type Log, parseEventLogs, zeroAddress } from 'viem'
 import { Abis, Addresses } from 'viem/tempo'
 import * as z from 'zod/mini'
 
-import type * as App from '../App.js'
-import * as Auth from '../internal/Auth.js'
-import * as Cache from '../internal/Cache.js'
-import * as Cursor from '../internal/Cursor.js'
-import * as Mpp from '../internal/Mpp.js'
-import * as OpenApi from '../internal/OpenApi.js'
-import * as Response from '../internal/Response.js'
-import * as Schema from '../internal/Schema.js'
-import * as Store from '../internal/Store.js'
-import type * as Tidx from '../internal/Tidx.js'
-import * as Timing from '../internal/Timing.js'
-import * as Ttl from '../internal/Ttl.js'
-import * as Value from '../internal/Value.js'
+import type * as App from '../../../App.js'
+import * as Auth from '../../../internal/Auth.js'
+import * as Cache from '../../../internal/Cache.js'
+import * as Cursor from '../../../internal/Cursor.js'
+import * as Mpp from '../../../internal/Mpp.js'
+import * as OpenApi from '../../../internal/OpenApi.js'
+import * as Response from '../../../internal/Response.js'
+import * as Schema from '../../../internal/Schema.js'
+import * as Store from '../../../internal/Store.js'
+import type * as Tidx from '../../../internal/Tidx.js'
+import * as Timing from '../../../internal/Timing.js'
+import * as Ttl from '../../../internal/Ttl.js'
+import * as Value from '../../../internal/Value.js'
 import * as Tokens from './tokens.js'
 import * as Transfers from './transfers.js'
 
@@ -1667,7 +1667,7 @@ type TxGroup = {
  */
 export function addresses() {
   return new Hono<App.Environment>().get(
-    '/:address/activities',
+    '/v1/addresses/:address/activities',
     Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
     OpenApi.validate('param', schema.getAddressActivities.Params, {
       code: 'address_invalid',
@@ -1775,7 +1775,7 @@ export function addresses() {
  */
 export function transactions() {
   return new Hono<App.Environment>().get(
-    '/:transactionHash/activities',
+    '/v1/transactions/:transactionHash/activities',
     Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
     OpenApi.validate('param', schema.getTransactionActivities.Params, {
       code: 'transaction_invalid',

package/src/apps/{addresses.ts → data/routes/addresses.ts}

@@ -1,15 +1,15 @@
 import { Hono } from 'hono'
 
-import type * as App from '../App.js'
+import type * as App from '../../../App.js'
 import * as Activities from './activities.js'
 import * as Balances from './balances.js'
 
 /**
- * Composes the `/addresses/:address/*` route surface from the address-scoped
- * sub-routers exported by each resource module. The handlers and schemas live
- * with the resource they describe (activities, balances); this composer only
- * owns the `/addresses` mount path so docs grouping stays by tag while URLs
- * stay nested under the parent resource.
+ * Composes the `/v1/addresses/:address/*` route surface from the
+ * address-scoped sub-routers exported by each resource module. The handlers,
+ * schemas, and paths live with the resource they describe (activities,
+ * balances); this composer only aggregates them so docs grouping stays by tag
+ * while URLs stay nested under the parent resource.
  *
  * Only subject-relative resources live here — rows that cannot be interpreted
  * without the path address (activity classification, held-token balances).

package/src/apps/{balances.test.ts → data/routes/balances.test.ts}

@@ -1,8 +1,8 @@
 import { Schema } from 'tapimo'
 import { Value as core_Value } from 'ox'
 
-import * as TestApp from '../../test/App.js'
-import * as Runtime from '../../test/runtime.js'
+import * as TestApp from '../../../../test/App.js'
+import * as Runtime from '../../../../test/runtime.js'
 import * as Balances from './balances.js'
 import * as Tokens from './tokens.js'
 

package/src/apps/{balances.ts → data/routes/balances.ts}

@@ -1,17 +1,18 @@
 import { Hono, type Context } from 'hono'
 import { Hex, Value as core_Value } from 'ox'
+import { Actions } from 'viem/tempo'
 import * as z from 'zod/mini'
 
-import type * as App from '../App.js'
-import * as Auth from '../internal/Auth.js'
-import * as Cache from '../internal/Cache.js'
-import * as Cursor from '../internal/Cursor.js'
-import * as OpenApi from '../internal/OpenApi.js'
-import * as Response from '../internal/Response.js'
-import * as Schema from '../internal/Schema.js'
-import * as Timing from '../internal/Timing.js'
-import * as Value from '../internal/Value.js'
-import * as VerifiedTokens from '../internal/VerifiedTokens.js'
+import type * as App from '../../../App.js'
+import * as Auth from '../../../internal/Auth.js'
+import * as Cache from '../../../internal/Cache.js'
+import * as Cursor from '../../../internal/Cursor.js'
+import * as OpenApi from '../../../internal/OpenApi.js'
+import * as Response from '../../../internal/Response.js'
+import * as Schema from '../../../internal/Schema.js'
+import * as Timing from '../../../internal/Timing.js'
+import * as Value from '../../../internal/Value.js'
+import * as VerifiedTokens from '../../../internal/VerifiedTokens.js'
 import * as FeeAmm from './fee-amm.js'
 import * as Tokens from './tokens.js'
 
@@ -150,7 +151,7 @@ export namespace schema {
  */
 export function addresses() {
   return new Hono<App.Environment>().get(
-    '/:address/balances',
+    '/v1/addresses/:address/balances',
     Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
     OpenApi.validate('param', schema.getAddressBalances.Params, {
       code: 'address_invalid',
@@ -353,6 +354,39 @@ async function getAddressBalances(
 
   if (holdings.data.length === 0) return { data: [], nextCursor: holdings.nextCursor }
 
+  const client = c.get('getClient')(chainId)
+  // TODO: remove once https://github.com/tempoxyz/tidx/commit/2f37b44172d381fd00234ef23f79ed1e1d69c470 deployed.
+  const corrected = await Timing.time(c, 'balances_rpc', async () => {
+    const results = await client
+      .multicall({
+        allowFailure: true,
+        contracts: holdings.data.map((holding) =>
+          Actions.token.getBalance.call(client, { account: address, token: holding.address }),
+        ),
+      })
+      .catch(() => undefined)
+
+    const rows: { address: Hex.Hex; amount: string }[] = []
+    for (const [index, holding] of holdings.data.entries()) {
+      const result = results?.[index]
+      if (!result || result.status !== 'success' || typeof result.result !== 'bigint') {
+        rows.push(holding)
+        continue
+      }
+      if (result.result === 0n) continue
+      rows.push({ address: holding.address, amount: result.result.toString() })
+    }
+
+    rows.sort((a, b) => {
+      const delta = BigInt(b.amount) - BigInt(a.amount)
+      if (delta !== 0n) return delta > 0n ? 1 : -1
+      return a.address < b.address ? -1 : a.address > b.address ? 1 : 0
+    })
+    return rows
+  })
+
+  if (corrected.length === 0) return { data: [], nextCursor: holdings.nextCursor }
+
   // Resolve token metadata for each balance. The endpoint's contract is a
   // balance with its `token` reference inlined per row (and `formatted` needs
   // the token `decimals`), so a row whose metadata cannot be resolved is
@@ -365,7 +399,7 @@ async function getAddressBalances(
   // so it is never fetched here.
   const resolved = await Timing.time(c, 'tokens', () =>
     Promise.all(
-      holdings.data.map((holding) =>
+      corrected.map((holding) =>
         Tokens.resolveToken(c, {
           address: holding.address,
           chainId,

package/src/apps/{blocks.test.ts → data/routes/blocks.test.ts}

@@ -2,9 +2,9 @@ import { Schema } from 'tapimo'
 import { Hex } from 'ox'
 import { zeroHash } from 'viem'
 
-import * as TestApp from '../../test/App.js'
-import * as Runtime from '../../test/runtime.js'
-import * as Viem from '../../test/Viem.js'
+import * as TestApp from '../../../../test/App.js'
+import * as Runtime from '../../../../test/runtime.js'
+import * as Viem from '../../../../test/Viem.js'
 import * as Blocks from './blocks.js'
 import * as Transactions from './transactions.js'
 

package/src/apps/{blocks.ts → data/routes/blocks.ts}

@@ -2,17 +2,17 @@ import { Hono, type Context, type MiddlewareHandler } from 'hono'
 import { Hex } from 'ox'
 import * as z from 'zod/mini'
 
-import type * as App from '../App.js'
-import * as Auth from '../internal/Auth.js'
-import * as Cache from '../internal/Cache.js'
-import * as Cursor from '../internal/Cursor.js'
-import * as OpenApi from '../internal/OpenApi.js'
-import * as Response from '../internal/Response.js'
-import * as Schema from '../internal/Schema.js'
-import * as Store from '../internal/Store.js'
-import * as Timing from '../internal/Timing.js'
-import * as Ttl from '../internal/Ttl.js'
-import * as Value from '../internal/Value.js'
+import type * as App from '../../../App.js'
+import * as Auth from '../../../internal/Auth.js'
+import * as Cache from '../../../internal/Cache.js'
+import * as Cursor from '../../../internal/Cursor.js'
+import * as OpenApi from '../../../internal/OpenApi.js'
+import * as Response from '../../../internal/Response.js'
+import * as Schema from '../../../internal/Schema.js'
+import * as Store from '../../../internal/Store.js'
+import * as Timing from '../../../internal/Timing.js'
+import * as Ttl from '../../../internal/Ttl.js'
+import * as Value from '../../../internal/Value.js'
 
 /** Example block number surfaced in OpenAPI docs. */
 const exampleBlockNumber = '1000000'
@@ -382,7 +382,7 @@ export function blocks() {
 
   return new Hono<App.Environment>()
     .get(
-      '/',
+      '/v1/blocks',
       Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
       OpenApi.validate('query', schema.getBlocks.Query, {
         code: 'query_invalid',
@@ -425,7 +425,7 @@ export function blocks() {
       },
     )
     .get(
-      '/:block',
+      '/v1/blocks/:block',
       Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
       OpenApi.validate('param', schema.getBlock.Params, {
         code: 'block_invalid',
@@ -590,7 +590,7 @@ export function blocks() {
  */
 export function blocksByTimestampCompat() {
   return new Hono<App.Environment>().get(
-    '/:chainId/blocks/by-timestamp',
+    '/chains/:chainId/blocks/by-timestamp',
     Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
     OpenApi.validate('param', schema.getBlockByTimestamp.Params, {
       code: 'chain_id_invalid',

package/src/apps/{coingecko.test.ts → data/routes/coingecko.test.ts}

@@ -1,7 +1,7 @@
 import { Address, Hash } from 'ox'
 
-import * as TestApp from '../../test/App.js'
-import * as Runtime from '../../test/runtime.js'
+import * as TestApp from '../../../../test/App.js'
+import * as Runtime from '../../../../test/runtime.js'
 import * as Coingecko from './coingecko.js'
 
 // The adapter addresses the chain positionally, mirroring the legacy `/gecko`