tapimo 0.13.0 → 0.15.0

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

@@ -0,0 +1,165 @@
+import { App } from 'tapimo/server'
+
+import * as Store from '../../internal/Store.js'
+import * as Viem from '../../internal/Viem.js'
+import * as TestApp from '../../../test/App.js'
+import { routes } from './App.js'
+
+const sandbox = {
+  environment: 'sandbox',
+  id: 'key_sandbox_routes',
+  orgId: 'org_test',
+  scopes: ['data:read', 'routes:write'],
+  token: 'secret_sandbox_routes',
+} satisfies TestApp.kvStore.Key
+
+function as(key: { token: string }) {
+  return { headers: { authorization: `Bearer ${key.token}` } } as const
+}
+
+describe('routes access', () => {
+  test.each([
+    { method: 'GET', path: '/v1/routes/chains' },
+    { method: 'POST', path: '/v1/routes/transfers' },
+    { method: 'POST', path: '/v1/routes/transfers/rtr_test/source-transactions' },
+  ])('rejects sandbox keys on mainnet: $method $path', async ({ method, path }) => {
+    const app = App.create({
+      auth: {},
+      db: TestApp.database(),
+      defaultChainId: Viem.chainId.mainnet,
+      kv: { store: TestApp.kvStore({ keys: [sandbox] }) },
+    }).route('/', routes())
+
+    const response = await app.request(path, { ...as(sandbox), method })
+
+    expect(response.status).toBe(403)
+    expect(await response.json()).toMatchObject({
+      error: {
+        code: 'api_key_forbidden',
+        message: 'Sandbox API keys only support testnet. Pass a testnet `chainId`.',
+      },
+    })
+  })
+
+  test('rejects sandbox keys on a mainnet-backed default Zone', async () => {
+    const chainId = 421_700_001
+    const key = {
+      ...sandbox,
+      scopes: [...sandbox.scopes, `zone:${chainId}:read`],
+    } satisfies TestApp.kvStore.Key
+    const app = App.create({
+      auth: {},
+      db: TestApp.database(),
+      defaultChainId: chainId,
+      kv: { store: TestApp.kvStore({ keys: [key] }) },
+      zones: [
+        TestApp.zone({
+          chainId,
+          rpcUrl: `https://${chainId}.rpc.test`,
+          sourceChainId: Viem.chainId.mainnet,
+        }),
+      ],
+    }).route('/', routes())
+
+    const response = await app.request('/v1/routes/chains', as(key))
+
+    expect(response.status).toBe(403)
+    expect((await response.json()).error.code).toBe('api_key_forbidden')
+  })
+
+  test.each(['', '?chainId=42431'])(
+    'rejects sandbox source claims and subsidized transfers on mainnet with query %j',
+    async (query) => {
+      const writer = {
+        ...sandbox,
+        scopes: ['routes:write'],
+      } satisfies TestApp.kvStore.Key
+      const db = TestApp.database()
+      const app = App.create({
+        auth: {},
+        db,
+        defaultChainId: Viem.chainId.mainnet,
+        kv: { store: TestApp.kvStore({ keys: [writer] }) },
+      }).route('/', routes())
+      const requests = [
+        {
+          body: {
+            amount: '1',
+            destinationChain: 'base',
+            destinationToken: 'usdc',
+            mode: 'exactSource',
+            recipient: `0x${'aa'.repeat(20)}`,
+            sender: `0x${'bb'.repeat(20)}`,
+            sourceChain: 'tempo',
+            sourceToken: 'usdce',
+            subsidize: true,
+          },
+          path: '/v1/routes/transfers',
+        },
+        {
+          body: { transactionHash: `0x${'cc'.repeat(32)}` },
+          path: `/v1/routes/transfers/rtr_${'0'.repeat(15)}_${'a'.repeat(24)}/source-transactions`,
+        },
+      ]
+      for (const request of requests) {
+        const response = await app.request(`${request.path}${query}`, {
+          body: JSON.stringify(request.body),
+          headers: {
+            ...as(writer).headers,
+            'content-type': 'application/json',
+            'idempotency-key': 'sandbox-mainnet-claim',
+          },
+          method: 'POST',
+        })
+        expect(response.status).toMatchInlineSnapshot(`403`)
+        expect((await response.json()).error.code).toMatchInlineSnapshot(`"api_key_forbidden"`)
+      }
+      expect(await db.kysely.selectFrom('routes_transfers').select('id').execute()).toEqual([])
+      expect(
+        await db.kysely.selectFrom('routes_transfer_transactions').select('transferId').execute(),
+      ).toEqual([])
+    },
+  )
+
+  test('requires a matching Zone scope and bypasses the edge cache', async () => {
+    const chainId = 421_700_001
+    const reader = {
+      id: 'key_zone_routes',
+      orgId: 'org_test',
+      scopes: ['data:read', `zone:${chainId}:read`],
+      token: 'secret_zone_routes',
+    } satisfies TestApp.kvStore.Key
+    const app = App.create({
+      auth: {},
+      cache: { store: Store.memory() },
+      db: TestApp.database(),
+      defaultChainId: chainId,
+      kv: { store: TestApp.kvStore({ keys: [reader] }) },
+      zones: [TestApp.zone({ chainId, rpcUrl: `https://${chainId}.rpc.test` })],
+    }).route('/', routes())
+
+    const allowed = await app.request('/v1/routes/chains', as(reader))
+    const anonymous = await app.request('/v1/routes/chains')
+
+    expect(allowed.status).toBe(200)
+    expect(allowed.headers.get('cache-control')).toContain('private')
+    expect(anonymous.status).toBe(403)
+  })
+
+  test('keeps public-chain inventory edge-cacheable on a Zone deployment', async () => {
+    const chainId = 421_700_001
+    const app = App.create({
+      auth: false,
+      cache: { store: Store.memory() },
+      db: TestApp.database(),
+      zones: [TestApp.zone({ chainId, rpcUrl: `https://${chainId}.rpc.test` })],
+    }).route('/', routes())
+
+    const first = await app.request('/v1/routes/chains')
+    const second = await app.request('/v1/routes/chains')
+
+    expect(first.status).toBe(200)
+    expect(second.status).toBe(200)
+    expect(second.headers.get('cache-control')).toContain('public')
+  })
+})

package/src/apps/routes/App.ts

@@ -0,0 +1,96 @@
+import { Hono } from 'hono'
+
+import type * as App from '../../App.js'
+import type * as RoutesDepositAddress from '../../internal/routes/DepositAddress.js'
+import type * as RoutesObservability from '../../internal/routes/Observability.js'
+import type * as RoutesProvider from '../../internal/routes/Provider.js'
+import type * as RoutesTransferReconciliation from '../../internal/routes/TransferReconciliation.js'
+import type * as RoutesTransferSubsidy from '../../internal/routes/TransferSubsidy.js'
+import type * as Webhooks from '../../internal/Webhooks.js'
+import * as Metadata from '../metadata.js'
+import { chains } from './routes/chains.js'
+import { depositAddresses } from './routes/deposit-addresses.js'
+import { providers } from './routes/providers.js'
+import { quotes } from './routes/quotes.js'
+import { transfers } from './routes/transfers.js'
+
+/**
+ * Mounts the Routes API, including quotes, inventory, reusable
+ * deposit addresses, detected deposits, and transfers.
+ *
+ * ```ts
+ * App.create(options).route('/', data()).route('/', routes())
+ * ```
+ */
+export function routes(options: routes.Options = {}) {
+  const app = new Hono<App.Environment>()
+    .route('/', quotes())
+    .route('/', chains())
+    .route('/', providers())
+    .route('/', depositAddresses(options))
+    .route('/', transfers(options))
+  return Metadata.defaultChain(Metadata.attach(app, openapi))
+}
+
+export declare namespace routes {
+  /** Routes group configuration. */
+  type Options = {
+    /** Enqueues one deposit address for asynchronous reconciliation. */
+    dispatchDepositReconciliation?:
+      | ((message: RoutesProvider.Webhook.receive.Dispatchable) => Promise<void>)
+      | undefined
+    /** Enqueues one registered transfer for destination reconciliation. */
+    dispatchTransferReconciliation?:
+      | ((message: RoutesTransferReconciliation.Message) => Promise<void>)
+      | undefined
+    /** Enqueues webhook updates staged with transfer mutations. */
+    dispatchTransferUpdates?:
+      | ((references: readonly Webhooks.QueueReference[]) => Promise<number>)
+      | undefined
+    /** Records completed route lifecycle intervals. */
+    recordLifecycleInterval?:
+      | ((interval: RoutesObservability.LifecycleInterval) => Promise<void>)
+      | undefined
+    /** Read-only destination subsidy inventory, when settlement is configured. */
+    transferSubsidy?: RoutesTransferSubsidy.Inventory | undefined
+    /** Registers a created address with a source-chain observer. */
+    registerDepositAddress?: ((address: RoutesDepositAddress.Public) => Promise<void>) | undefined
+  }
+}
+
+const openapi = {
+  tags: [
+    {
+      name: 'Chains',
+      description: 'Source chains and stablecoins supported by Routes.',
+      'x-pagePath': 'routes/chains',
+    },
+    {
+      name: 'Deposit Addresses',
+      description: 'Reusable route addresses and deposits detected at those addresses.',
+      'x-pagePath': 'routes/deposit-addresses',
+    },
+    {
+      name: 'Providers',
+      description: 'Providers available through Routes.',
+      'x-pagePath': 'routes/providers',
+    },
+    {
+      name: 'Quotes',
+      description: 'Live quotes for routing assets between supported chains.',
+      'x-pagePath': 'routes/quotes',
+    },
+    {
+      name: 'Route Transfers',
+      description: 'Transfers routed between supported chains.',
+      'x-displayName': 'Transfers',
+      'x-pagePath': 'routes/transfers',
+    },
+  ],
+  'x-tagGroups': [
+    {
+      name: 'Routes API',
+      tags: ['Chains', 'Deposit Addresses', 'Providers', 'Quotes', 'Route Transfers'],
+    },
+  ],
+} satisfies App.create.Metadata

package/src/apps/{funding → routes}/Inventory.ts

@@ -2,7 +2,7 @@ import type { Context } from 'hono'
 
 import type * as App from '../../App.js'
 import type * as Db from '../../db/Db.js'
-import * as FundingProvider from '../../internal/funding/Provider.js'
+import * as RoutesProvider from '../../internal/routes/Provider.js'
 
 const sourceScopes = new WeakMap<Db.Source, number>()
 let nextSourceScope = 0
@@ -12,7 +12,7 @@ export function key(c: Context<App.Environment>) {
   const url = new URL(c.req.url)
   const providers = c
     .get('providers')
-    .filter(FundingProvider.is)
+    .filter(RoutesProvider.is)
     .map((provider) => provider.id)
     .sort()
   url.searchParams.set('__tempo_database', String(sourceScope(c.get('dbCached'))))

package/src/apps/routes/index.ts

@@ -0,0 +1 @@
+export { routes } from './App.js'

package/src/apps/{funding → routes}/routes/chains.test.ts

@@ -1,18 +1,18 @@
-import * as Across from '../../../internal/funding/providers/across.js'
+import * as Across from '../../../internal/routes/providers/across.js'
 
-import * as Relay from '../../../internal/funding/providers/relay.js'
+import * as Relay from '../../../internal/routes/providers/relay.js'
 
-import * as Rhino from '../../../internal/funding/providers/rhino.js'
+import * as Rhino from '../../../internal/routes/providers/rhino.js'
 
-import * as Squid from '../../../internal/funding/providers/squid.js'
+import * as Squid from '../../../internal/routes/providers/squid.js'
 
-import * as Symbiosis from '../../../internal/funding/providers/symbiosis.js'
+import * as Symbiosis from '../../../internal/routes/providers/symbiosis.js'
 
 import * as TestApp from '../../../../test/App.js'
 
-import * as TestFunding from '../../../../test/Funding.js'
+import * as TestRoutes from '../../../../test/Routes.js'
 
-import * as Funding from './chains.js'
+import * as Routes from './chains.js'
 
 const db = TestApp.database()
 
@@ -22,7 +22,7 @@ const providers = [
     integratorId: '0xdead',
     userAddress: '0x1111111111111111111111111111111111111111',
   }),
-  Relay.relay({ userAddresses: TestFunding.relayQuoteUsers }),
+  Relay.relay({ userAddresses: TestRoutes.relayQuoteUsers }),
   Rhino.rhino(),
   Squid.squid({
     integratorId: 'squid-integrator-id',
@@ -31,20 +31,20 @@ const providers = [
   Symbiosis.symbiosis({ userAddress: '0x1111111111111111111111111111111111111111' }),
 ] as const
 
-beforeAll(() => TestFunding.publish(db))
+beforeAll(() => TestRoutes.publish(db))
 
 function create(options: TestApp.create.Options = {}) {
   return TestApp.create({ ...options, db })
 }
 
-describe('funding OpenAPI', () => {
+describe('routes OpenAPI', () => {
   test('publishes generator-ready discovery contracts', async () => {
     const app = create({ auth: false })
     const spec = await (await app.request('/openapi.json')).json()
     const operations = {
-      chains: spec.paths['/v1/funding/chains'].get,
-      providers: spec.paths['/v1/funding/providers'].get,
-      quotes: spec.paths['/v1/funding/quotes'].get,
+      chains: spec.paths['/v1/routes/chains'].get,
+      providers: spec.paths['/v1/routes/providers'].get,
+      quotes: spec.paths['/v1/routes/quotes'].get,
     }
     const summarize = (operation: (typeof operations)[keyof typeof operations]) => ({
       errors: Object.fromEntries(
@@ -60,35 +60,35 @@ describe('funding OpenAPI', () => {
 
     expect({
       components: [
-        'FundingChain',
-        'FundingChainInventory',
-        'FundingChainList',
-        'FundingProvider',
-        'FundingProviderList',
-        'FundingQuote',
-        'FundingQuoteDetails',
-        'FundingQuoteList',
-        'FundingQuoteQuality',
-        'FundingToken',
+        'RoutesChain',
+        'RoutesChainInventory',
+        'RoutesChainList',
+        'RoutesProvider',
+        'RoutesProviderList',
+        'RoutesQuote',
+        'RoutesQuoteDetails',
+        'RoutesQuoteList',
+        'RoutesQuoteQuality',
+        'RoutesToken',
       ].filter((name) => spec.components.schemas[name]),
       formats: {
-        quoteExpiresAt: spec.components.schemas.FundingQuoteDetails.properties.expiresAt.format,
-        quoteSampledAt: spec.components.schemas.FundingQuoteDetails.properties.sampledAt.format,
+        quoteExpiresAt: spec.components.schemas.RoutesQuoteDetails.properties.expiresAt.format,
+        quoteSampledAt: spec.components.schemas.RoutesQuoteDetails.properties.sampledAt.format,
       },
       models: {
-        chainInventoryToken: spec.components.schemas.FundingChainInventory.properties.tokens.items,
-        chainList: spec.components.schemas.FundingChainList.properties.data.items,
-        providerList: spec.components.schemas.FundingProviderList.properties.data.items,
+        chainInventoryToken: spec.components.schemas.RoutesChainInventory.properties.tokens.items,
+        chainList: spec.components.schemas.RoutesChainList.properties.data.items,
+        providerList: spec.components.schemas.RoutesProviderList.properties.data.items,
         quote: {
-          destinationChain: spec.components.schemas.FundingQuote.properties.destinationChain,
-          destinationToken: spec.components.schemas.FundingQuote.properties.destinationToken,
-          provider: spec.components.schemas.FundingQuote.properties.provider,
-          quality: spec.components.schemas.FundingQuote.properties.quality,
-          quote: spec.components.schemas.FundingQuote.properties.quote,
-          sourceChain: spec.components.schemas.FundingQuote.properties.sourceChain,
-          sourceToken: spec.components.schemas.FundingQuote.properties.sourceToken,
+          destinationChain: spec.components.schemas.RoutesQuote.properties.destinationChain,
+          destinationToken: spec.components.schemas.RoutesQuote.properties.destinationToken,
+          provider: spec.components.schemas.RoutesQuote.properties.provider,
+          quality: spec.components.schemas.RoutesQuote.properties.quality,
+          quote: spec.components.schemas.RoutesQuote.properties.quote,
+          sourceChain: spec.components.schemas.RoutesQuote.properties.sourceChain,
+          sourceToken: spec.components.schemas.RoutesQuote.properties.sourceToken,
         },
-        quoteList: spec.components.schemas.FundingQuoteList.properties.data.items,
+        quoteList: spec.components.schemas.RoutesQuoteList.properties.data.items,
       },
       operations: {
         chains: summarize(operations.chains),
@@ -109,16 +109,16 @@ describe('funding OpenAPI', () => {
     }).toMatchInlineSnapshot(`
       {
         "components": [
-          "FundingChain",
-          "FundingChainInventory",
-          "FundingChainList",
-          "FundingProvider",
-          "FundingProviderList",
-          "FundingQuote",
-          "FundingQuoteDetails",
-          "FundingQuoteList",
-          "FundingQuoteQuality",
-          "FundingToken",
+          "RoutesChain",
+          "RoutesChainInventory",
+          "RoutesChainList",
+          "RoutesProvider",
+          "RoutesProviderList",
+          "RoutesQuote",
+          "RoutesQuoteDetails",
+          "RoutesQuoteList",
+          "RoutesQuoteQuality",
+          "RoutesToken",
         ],
         "formats": {
           "quoteExpiresAt": "date-time",
@@ -126,39 +126,39 @@ describe('funding OpenAPI', () => {
         },
         "models": {
           "chainInventoryToken": {
-            "$ref": "#/components/schemas/FundingToken",
+            "$ref": "#/components/schemas/RoutesToken",
           },
           "chainList": {
-            "$ref": "#/components/schemas/FundingChainInventory",
+            "$ref": "#/components/schemas/RoutesChainInventory",
           },
           "providerList": {
-            "$ref": "#/components/schemas/FundingProvider",
+            "$ref": "#/components/schemas/RoutesProvider",
           },
           "quote": {
             "destinationChain": {
-              "$ref": "#/components/schemas/FundingChain",
+              "$ref": "#/components/schemas/RoutesChain",
             },
             "destinationToken": {
-              "$ref": "#/components/schemas/FundingToken",
+              "$ref": "#/components/schemas/RoutesToken",
             },
             "provider": {
-              "$ref": "#/components/schemas/FundingProvider",
+              "$ref": "#/components/schemas/RoutesProvider",
             },
             "quality": {
-              "$ref": "#/components/schemas/FundingQuoteQuality",
+              "$ref": "#/components/schemas/RoutesQuoteQuality",
             },
             "quote": {
-              "$ref": "#/components/schemas/FundingQuoteDetails",
+              "$ref": "#/components/schemas/RoutesQuoteDetails",
             },
             "sourceChain": {
-              "$ref": "#/components/schemas/FundingChain",
+              "$ref": "#/components/schemas/RoutesChain",
             },
             "sourceToken": {
-              "$ref": "#/components/schemas/FundingToken",
+              "$ref": "#/components/schemas/RoutesToken",
             },
           },
           "quoteList": {
-            "$ref": "#/components/schemas/FundingQuote",
+            "$ref": "#/components/schemas/RoutesQuote",
           },
         },
         "operations": {
@@ -179,9 +179,9 @@ describe('funding OpenAPI', () => {
                 "$ref": "#/components/schemas/UpstreamError",
               },
             },
-            "operationId": "getFundingChains",
+            "operationId": "getRoutesChains",
             "response": {
-              "$ref": "#/components/schemas/FundingChainList",
+              "$ref": "#/components/schemas/RoutesChainList",
             },
           },
           "providers": {
@@ -201,9 +201,9 @@ describe('funding OpenAPI', () => {
                 "$ref": "#/components/schemas/UpstreamError",
               },
             },
-            "operationId": "getFundingProviders",
+            "operationId": "getRoutesProviders",
             "response": {
-              "$ref": "#/components/schemas/FundingProviderList",
+              "$ref": "#/components/schemas/RoutesProviderList",
             },
           },
           "quotes": {
@@ -223,9 +223,9 @@ describe('funding OpenAPI', () => {
                 "$ref": "#/components/schemas/UpstreamError",
               },
             },
-            "operationId": "quoteFunding",
+            "operationId": "quoteRoutes",
             "response": {
-              "$ref": "#/components/schemas/FundingQuoteList",
+              "$ref": "#/components/schemas/RoutesQuoteList",
             },
           },
         },
@@ -256,13 +256,13 @@ describe('funding OpenAPI', () => {
   })
 })
 
-describe('GET /funding/chains', () => {
+describe('GET /routes/chains', () => {
   test('lists only inputs supported by quote providers', async () => {
-    const response = await create({ providers }).request('/v1/funding/chains', {
+    const response = await create({ providers }).request('/v1/routes/chains', {
       headers: TestApp.auth.headers,
     })
     expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.getFundingChains.Response)
+    const body = await TestApp.json(response, Routes.schema.getRoutesChains.Response)
 
     expect(body.data.map((chain) => chain.id)).toEqual([
       'eip155:1',

package/src/apps/{funding → routes}/routes/chains.ts

@@ -4,22 +4,22 @@ 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 FundingCatalog from '../../../internal/funding/Catalog.js'
-import * as FundingProvider from '../../../internal/funding/Provider.js'
+import * as RoutesCatalog from '../../../internal/routes/Catalog.js'
+import * as RoutesProvider from '../../../internal/routes/Provider.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
 import * as Inventory from '../Inventory.js'
 
-/** Zod schemas owned by funding chain resources. */
+/** Zod schemas owned by route chain resources. */
 export namespace schema {
   /** Source chain reference. */
-  export const Chain = FundingProvider.schema.ChainRef
+  export const Chain = RoutesProvider.schema.ChainRef
 
   /** Source token reference. */
-  export const Token = FundingProvider.schema.TokenRef
+  export const Token = RoutesProvider.schema.TokenRef
 
-  /** Chain inventory entry returned by the funding chains endpoint. */
+  /** Chain inventory entry returned by the route chains endpoint. */
   export const ChainInventory = OpenApi.component(
     Schema.describe(
       z.extend(Chain, {
@@ -27,22 +27,22 @@ export namespace schema {
       }),
       'One source chain and its known stablecoin inventory.',
     ),
-    'FundingChainInventory',
+    'RoutesChainInventory',
   )
 
-  /** Schemas for the getFundingChains operation. */
-  export namespace getFundingChains {
+  /** Schemas for the getRoutesChains operation. */
+  export namespace getRoutesChains {
     /** Non-paginated source-chain inventory. */
     export const Response = OpenApi.component(
       Schema.describe(
         z.object({
           data: z
             .array(ChainInventory)
-            .check(z.describe('Source chains and stablecoins supported by funding quotes.')),
+            .check(z.describe('Source chains and stablecoins supported by route quotes.')),
         }),
         'A non-paginated list of source chains and stablecoin inventory.',
       ),
-      'FundingChainList',
+      'RoutesChainList',
     )
   }
 }
@@ -65,24 +65,24 @@ const baseUsdcExample = {
   verified: true,
 } as const
 
-const fundingChainsResponseExample = {
+const routesChainsResponseExample = {
   data: [{ ...baseChainExample, tokens: [baseUsdcExample] }],
-} satisfies z.output<typeof schema.getFundingChains.Response>
+} satisfies z.output<typeof schema.getRoutesChains.Response>
 
-/** Mounts funding chain inventory routes. */
+/** Mounts route chain inventory routes. */
 export function chains() {
   return new Hono<App.Environment>().get(
-    '/v1/funding/chains',
+    '/v1/routes/chains',
     Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
     OpenApi.describeRoute({
       description: 'Lists supported source chains and tokens.',
-      operationId: 'getFundingChains',
+      operationId: 'getRoutesChains',
       responses: OpenApi.responses({
         errors: { 400: { codes: [] } },
         success: {
           description: 'Supported source chains and stablecoins.',
-          example: fundingChainsResponseExample,
-          schema: schema.getFundingChains.Response,
+          example: routesChainsResponseExample,
+          schema: schema.getRoutesChains.Response,
         },
       }),
       summary: 'Get chains',
@@ -91,15 +91,15 @@ export function chains() {
     Cache.response<App.Environment>({
       cacheControl: Cache.policies.stable,
       key: Inventory.key,
-      name: 'tempo-api:funding-chains:v5',
+      name: 'tempo-api:routes-chains:v5',
     }),
     async (c) => {
       if (Auth.narrowAccess) return Auth.paidAccessError(c)
-      const catalog = await FundingCatalog.snapshot(c)
-      const providers = c.get('providers').filter(FundingProvider.is)
+      const catalog = await RoutesCatalog.snapshot(c)
+      const providers = c.get('providers').filter(RoutesProvider.is)
       return c.json(
-        Response.validated(schema.getFundingChains.Response, {
-          data: FundingProvider.getChains({ catalog, providers }),
+        Response.validated(schema.getRoutesChains.Response, {
+          data: RoutesProvider.getChains({ catalog, providers }),
         }),
         200,
       )