tapimo 0.4.1 → 0.4.4

package/src/analytics/Analytics.ts

@@ -8,6 +8,31 @@ export type BillableCount = RequestEvents.BillableCount
 /** Options for {@link readBillableRequestCounts}. */
 export type BillableCountsOptions = RequestEvents.BillableCountsOptions
 
+/** One organization's request usage and error breakdown. */
+export type ProjectUsage = RequestEvents.ProjectUsage
+
+/** Options for reading one organization's request usage. */
+export type ProjectUsageOptions = RequestEvents.ProjectUsageOptions
+
+/** API errors grouped by their stable error code. */
+export type ErrorBreakdown = RequestEvents.ErrorBreakdown
+
+/** Reads stable API error-code counts for one organization attribution window. */
+export function readErrorBreakdown(
+  source: Source,
+  options: ProjectUsageOptions,
+): Promise<ErrorBreakdown[]> {
+  return RequestEvents.readErrorBreakdown(get(source), options)
+}
+
+/** Reads request usage for an organization and optional attribution terms. */
+export function readProjectUsage(
+  source: Source,
+  options: ProjectUsageOptions,
+): Promise<ProjectUsage> {
+  return RequestEvents.readProjectUsage(get(source), options)
+}
+
 /**
  * Reads deduped billable request counts grouped by `(org, UTC hour)` from
  * `request_events` — the request-metered billing source. Resolves the source

package/src/analytics/tables/requestEvents.ts

@@ -59,6 +59,14 @@ export type Attribution = {
 /** API-key environment for request usage. */
 export type Environment = 'production' | 'sandbox'
 
+/** API errors grouped by their stable error code. */
+export type ErrorBreakdown = {
+  /** Stable API error code, or `unknown` when none was recorded. */
+  code: string
+  /** Requests returning this error. */
+  requests: number
+}
+
 /** API key usage grouped for one project. */
 export type KeyBreakdown = {
   /** API key id (`key_…`). */
@@ -331,6 +339,26 @@ export async function readProjectUsage(
   }
 }
 
+/** Reads stable API error-code counts for one organization attribution window. */
+export async function readErrorBreakdown(
+  analytics: Analytics.Analytics,
+  options: ProjectUsageOptions,
+): Promise<ErrorBreakdown[]> {
+  const rows = await analytics.query<ErrorRow>(
+    `
+      SELECT
+        coalesce(error_code, 'unknown') AS code,
+        count() AS requests
+      FROM ${table}
+      WHERE ${usageWhere(options)} AND status >= 400
+      GROUP BY error_code
+      ORDER BY requests DESC, code ASC
+      LIMIT 25
+    `,
+  )
+  return rows.map((row) => ({ code: String(row.code), requests: number(row.requests) }))
+}
+
 /** One org's deduped billable request count for a single UTC hour. */
 export type BillableCount = {
   /** UTC hour start (ISO 8601). */
@@ -406,6 +434,11 @@ type KeyRow = {
   requests: number | string
 }
 
+type ErrorRow = {
+  code: string
+  requests: number | string
+}
+
 type RouteRow = {
   averageDurationMs: number | string
   errors: number | string

package/src/apps/composition.test.ts

@@ -1,5 +1,7 @@
 import { App, Store } from 'tapimo'
 import { data, management, relay } from 'tapimo/apps'
+import { Hono } from 'hono'
+import { describeRoute } from 'hono-openapi'
 import * as TestApp from '../../test/App.js'
 
 // Each test mounts one group and asserts its routes exist while omitted groups
@@ -10,7 +12,10 @@ import * as TestApp from '../../test/App.js'
 async function document(app: { request: (path: string) => Promise<Response> | Response }) {
   const res = await app.request('/openapi.json')
   return (await res.json()) as {
+    components: { securitySchemes: Record<string, unknown> }
     paths: Record<string, unknown>
+    tags: readonly { description: string; name: string }[]
+    webhooks?: Record<string, unknown> | undefined
     'x-tagGroups'?: readonly { name: string; tags: readonly string[] }[] | undefined
   }
 }
@@ -20,6 +25,77 @@ async function paths(app: { request: (path: string) => Promise<Response> | Respo
   return Object.keys((await document(app)).paths)
 }
 
+describe('App.from()', () => {
+  test('contributes external route-group metadata', async () => {
+    const group = new Hono().get(
+      '/v1/external/webhooks',
+      describeRoute({
+        responses: { 200: { description: 'External webhook status.' } },
+        summary: 'Get webhook status',
+        tags: ['External'],
+      }),
+      (c) => c.json({ status: 'ok' }, 200),
+    )
+    const external = App.from(group, {
+      docs: ({ spec }) =>
+        new Hono().get('/external-docs', async (c) => c.json({ paths: (await spec()).paths })),
+      securitySchemes: {
+        externalKey: { in: 'header', name: 'external-key', type: 'apiKey' },
+      },
+      tags: [{ description: 'Externally defined routes.', name: 'External' }],
+      webhooks: () => ({ externalEvent: { post: { responses: { 200: { description: 'OK' } } } } }),
+      'x-tagGroups': [{ name: 'External API', tags: ['External'] }],
+    })
+    expectTypeOf(external).toEqualTypeOf<typeof group>()
+
+    const app = App.create({ auth: false, db: TestApp.database() }).route('/', external)
+    const spec = await document(app)
+
+    expect({
+      securityScheme: spec.components.securitySchemes['externalKey'],
+      tags: spec.tags,
+      tagGroups: spec['x-tagGroups'],
+      webhooks: spec.webhooks,
+    }).toMatchInlineSnapshot(`
+      {
+        "securityScheme": {
+          "in": "header",
+          "name": "external-key",
+          "type": "apiKey",
+        },
+        "tagGroups": [
+          {
+            "name": "External API",
+            "tags": [
+              "External",
+            ],
+          },
+        ],
+        "tags": [
+          {
+            "description": "Externally defined routes.",
+            "name": "External",
+          },
+        ],
+        "webhooks": {
+          "externalEvent": {
+            "post": {
+              "responses": {
+                "200": {
+                  "description": "OK",
+                },
+              },
+            },
+          },
+        },
+      }
+    `)
+
+    const docs = await app.request('/external-docs')
+    expect((await docs.json()).paths['/v1/external/webhooks']).toBeDefined()
+  })
+})
+
 describe('data()', () => {
   test('mounts data routes and omits management routes', async () => {
     const app = App.create({ db: TestApp.database() }).route('/', data())
@@ -42,13 +118,17 @@ describe('relay()', () => {
 
     // Mounted but default-closed and hidden: unauthenticated requests are
     // refused, and the path never appears in the OpenAPI document.
-    const mounted = await composed.request('/rpc/relay')
-    expect(mounted.status).toBe(401)
+    const relayMounted = await composed.request('/rpc/relay')
+    const sponsorMounted = await composed.request('/rpc/sponsor')
+    expect(relayMounted.status).toBe(401)
+    expect(sponsorMounted.status).toBe(401)
     expect((await paths(composed)).some((path) => path.startsWith('/rpc/relay'))).toBe(false)
+    expect((await paths(composed)).some((path) => path.startsWith('/rpc/sponsor'))).toBe(false)
 
     // Without the relay group, the data group no longer serves the path.
     const dataOnly = App.create({ db: TestApp.database() }).route('/', data())
     expect((await dataOnly.request('/rpc/relay')).status).toBe(404)
+    expect((await dataOnly.request('/rpc/sponsor')).status).toBe(404)
   })
 })
 

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

@@ -4,95 +4,6 @@ import * as FundingRouteProviders from './FundingRouteProviders.js'
 const now = () => new Date('2026-01-01T00:00:00.000Z')
 
 describe('FundingRouteProviders', () => {
-  test('maps Across suggested-fees responses into quote probes', async () => {
-    const requests: RecordedRequest[] = []
-    const fetch = recordingFetch(requests, async () =>
-      jsonResponse({
-        estimatedFillTimeSec: 2,
-        limits: {
-          maxDeposit: '2000000',
-          maxDepositInstant: '1500000',
-          minDeposit: '500000',
-        },
-        outputAmount: '990000',
-        relayFeePct: '1200000000000000',
-        timestamp: '1767225600',
-      }),
-    )
-    const adapter = FundingRouteProviders.across({
-      apiKey: 'across-api-key',
-      baseUrl: 'https://across.test/api/',
-      fetch,
-      integratorId: 'tempo',
-      now,
-    })
-
-    const result = await adapter.probeQuote(
-      await probeInput('across'),
-      new AbortController().signal,
-    )
-
-    expect(requests).toHaveLength(1)
-    expect(requests[0]?.url.pathname).toBe('/api/suggested-fees')
-    expect(requests[0]?.url.searchParams.get('originChainId')).toBe('8453')
-    expect(requests[0]?.url.searchParams.get('destinationChainId')).toBe('4217')
-    expect(requests[0]?.url.searchParams.get('amount')).toBe('1000000')
-    expect(requests[0]?.url.searchParams.get('integratorId')).toBe('tempo')
-    expect(requests[0]?.url.searchParams.get('allowUnmatchedDecimals')).toBe('true')
-    expect(new Headers(requests[0]?.init?.headers).get('authorization')).toBe(
-      'Bearer across-api-key',
-    )
-    expect(result).toMatchObject({
-      expiresAt: '2026-01-01T00:10:00.000Z',
-      limits: {
-        instantSourceAmount: '1500000',
-        maxSourceAmount: '2000000',
-        minSourceAmount: '500000',
-      },
-      outputAmount: '990000',
-      outputAmountFormatted: '0.99',
-      quality: {
-        availableVolumeUsd: '2',
-        estimatedSeconds: 2,
-        feeBps: 12,
-        instantVolumeUsd: '1.5',
-        liquiditySource: 'providerLimit',
-        sourceDetail: 'across:suggested-fees',
-        tier: 'liquid',
-      },
-      sampledAt: '2026-01-01T00:00:00.000Z',
-      status: 'available',
-    })
-  })
-
-  test('maps recognized Across quote errors to unavailable probes', async () => {
-    const fetch = recordingFetch([], async () =>
-      jsonResponse({ code: 'AMOUNT_TOO_HIGH', message: 'Amount exceeds max deposit' }, 400),
-    )
-    const adapter = FundingRouteProviders.across({
-      apiKey: 'across-api-key',
-      fetch,
-      integratorId: 'tempo',
-      now,
-    })
-
-    const result = await adapter.probeQuote(
-      await probeInput('across'),
-      new AbortController().signal,
-    )
-
-    expect(result).toMatchObject({
-      quality: {
-        liquiditySource: 'providerLimit',
-        score: 0,
-        sourceDetail: 'across:suggested-fees:AMOUNT_TOO_HIGH',
-        tier: 'unavailable',
-      },
-      sampledAt: '2026-01-01T00:00:00.000Z',
-      status: 'unavailable',
-    })
-  })
-
   test('maps Relay liquidity and quote responses into quote probes', async () => {
     const requests: RecordedRequest[] = []
     const route = await staticRoute('relay')
@@ -165,6 +76,43 @@ describe('FundingRouteProviders', () => {
     })
   })
 
+  test('calls the runtime fetch method with its global receiver', async () => {
+    const route = await staticRoute('relay')
+    const fetch = vi.fn(function (this: unknown, input: Parameters<typeof globalThis.fetch>[0]) {
+      expect(this).toBe(globalThis)
+      const url = toUrl(input)
+      return Promise.resolve(
+        jsonResponse(
+          url.pathname === '/quote/v2'
+            ? {
+                details: {
+                  currencyOut: { amount: '990000', minimumAmount: '980000' },
+                  timeEstimate: 15,
+                },
+              }
+            : { liquidity: [] },
+        ),
+      )
+    })
+    vi.stubGlobal('fetch', fetch)
+
+    try {
+      const adapter = FundingRouteProviders.relay({
+        now,
+        userAddress: '0x1111111111111111111111111111111111111111',
+      })
+      const result = await adapter.probeQuote(
+        probeInputFromRoute(route),
+        new AbortController().signal,
+      )
+
+      expect(result.outputAmount).toBe('990000')
+      expect(fetch).toHaveBeenCalledTimes(2)
+    } finally {
+      vi.unstubAllGlobals()
+    }
+  })
+
   test('keeps Relay quotes when the liquidity probe fails', async () => {
     const route = await staticRoute('relay')
     const fetch = recordingFetch([], async (request) => {
@@ -224,10 +172,6 @@ async function staticRoute(
   return route as FundingRoutes.QuoteProbeInput['route']
 }
 
-async function probeInput(provider: FundingRoutes.ProviderId) {
-  return probeInputFromRoute(await staticRoute(provider))
-}
-
 function probeInputFromRoute(
   route: FundingRoutes.QuoteProbeInput['route'],
 ): FundingRoutes.QuoteProbeInput {

package/src/apps/data/FundingRouteProviders.ts

@@ -1,90 +1,30 @@
-import type * as FundingRoutes from '../../internal/FundingRoutes.js'
+import * as FundingRoutes from '../../internal/FundingRoutes.js'
 
 type Fetch = typeof globalThis.fetch
 
-const defaultAcrossBaseUrl = 'https://app.across.to/api'
+const defaultFetch: Fetch = (input, init) => globalThis.fetch(input, init)
+
 const defaultRelayBaseUrl = 'https://api.relay.link'
 
 /** Creates the live funding route adapters configured for this deployment. */
 export function createAdapters(options: createAdapters.Options = {}) {
-  return {
-    ...(options.across ? { across: across(options.across) } : {}),
-    ...(options.relay ? { relay: relay(options.relay) } : {}),
-  } satisfies FundingRoutes.ProviderAdapters
+  return (
+    options.relay ? { relay: relay(options.relay) } : {}
+  ) satisfies FundingRoutes.ProviderAdapters
 }
 
 export declare namespace createAdapters {
   /** Provider adapter factory options. Omit a provider to keep its routes static. */
   type Options = {
-    /** Across quote adapter options. */
-    across?: across.Options | false | undefined
     /** Relay quote adapter options. */
     relay?: relay.Options | false | undefined
   }
 }
 
-/** Creates an Across quote adapter backed by `/suggested-fees`. */
-export function across(options: across.Options): FundingRoutes.ProviderAdapter {
-  const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultAcrossBaseUrl)
-  const fetcher = options.fetch ?? globalThis.fetch
-  const now = options.now ?? (() => new Date())
-
-  return {
-    async probeQuote({ route }, signal) {
-      const sourceChainId = providerChainId(route.sourceChain, 'across')
-      const destinationChainId = eip155ChainId(route.destinationChain)
-      const url = new URL(`${baseUrl}/suggested-fees`)
-      url.search = new URLSearchParams({
-        allowUnmatchedDecimals: 'true',
-        amount: route.sourceAmount.amount,
-        destinationChainId,
-        inputToken: route.sourceToken.address,
-        integratorId: options.integratorId,
-        originChainId: sourceChainId,
-        outputToken: route.destinationToken.address,
-      }).toString()
-
-      try {
-        const body = await requestJson(url, {
-          fetcher,
-          headers: { Authorization: `Bearer ${options.apiKey}` },
-          signal,
-        })
-        return formatAcrossResult(route, body, now())
-      } catch (cause) {
-        const unavailable = providerUnavailable(cause, ['AMOUNT_TOO_HIGH', 'AMOUNT_TOO_LOW'])
-        if (!unavailable) throw cause
-        return unavailableResult({
-          detail: 'across:suggested-fees',
-          message: unavailable,
-          now: now(),
-          source: 'providerLimit',
-        })
-      }
-    },
-  }
-}
-
-export declare namespace across {
-  /** Across quote adapter options. */
-  type Options = {
-    /** Across API key sent as a bearer token. */
-    apiKey: string
-    /** Across integrator id sent as the required query parameter. */
-    integratorId: string
-    /** Override for tests or non-production Across environments. */
-    baseUrl?: string | undefined
-    /** Fetch implementation override for tests. */
-    fetch?: Fetch | undefined
-    /** Clock override for deterministic tests. */
-    now?: (() => Date) | undefined
-  }
-}
-
 /** Creates a Relay quote adapter backed by `/chains/liquidity` and `/quote/v2`. */
 export function relay(options: relay.Options): FundingRoutes.ProviderAdapter {
   const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultRelayBaseUrl)
-  const fetcher = options.fetch ?? globalThis.fetch
+  const fetcher = options.fetch ?? defaultFetch
   const now = options.now ?? (() => new Date())
 
   return {
@@ -152,45 +92,6 @@ export declare namespace relay {
   }
 }
 
-function formatAcrossResult(
-  route: FundingRoutes.RouteCandidate,
-  body: unknown,
-  now: Date,
-): FundingRoutes.QuoteProbeResult {
-  const response = record(body)
-  const timestamp = integerString(response['timestamp'])
-  const sampledAt = timestamp ? isoFromUnixSeconds(timestamp) : now.toISOString()
-  const limits = acrossLimits(response['limits'])
-  const amountStatus = statusFromLimits(route.sourceAmount.amount, limits)
-  const status = response['isAmountTooLow'] === true ? 'unavailable' : amountStatus.status
-  const tier = response['isAmountTooLow'] === true ? 'unavailable' : amountStatus.tier
-  const outputAmount = decimalString(response['outputAmount'])
-
-  return {
-    expiresAt: timestamp ? isoFromUnixSeconds((BigInt(timestamp) + 600n).toString()) : null,
-    limits,
-    outputAmount,
-    outputAmountFormatted: outputAmount
-      ? decimalFromBaseUnits(outputAmount, route.destinationToken.decimals)
-      : null,
-    quality: {
-      availableVolumeUsd: stablecoinUsdCapacity(route, limits?.maxSourceAmount),
-      estimatedSeconds: nonnegativeInteger(response['estimatedFillTimeSec']),
-      feeBps: scaledPctToBps(
-        nestedString(response['totalRelayFee'], 'pct') ?? decimalString(response['relayFeePct']),
-      ),
-      historicalVolumeUsd24h: null,
-      instantVolumeUsd: stablecoinUsdCapacity(route, limits?.instantSourceAmount),
-      liquiditySource: 'providerLimit',
-      score: scoreFor(tier),
-      sourceDetail: 'across:suggested-fees',
-      tier,
-    },
-    sampledAt,
-    status,
-  }
-}
-
 function formatRelayResult(
   route: FundingRoutes.RouteCandidate,
   quote: unknown,
@@ -262,31 +163,6 @@ function unavailableResult(options: {
   }
 }
 
-function acrossLimits(input: unknown): FundingRoutes.QuoteProbeLimits | null {
-  const limits = record(input)
-  const minSourceAmount = decimalString(limits['minDeposit'])
-  const maxSourceAmount = decimalString(limits['maxDeposit'])
-  const instantSourceAmount =
-    decimalString(limits['maxDepositInstant']) ?? decimalString(limits['recommendedDepositInstant'])
-  return minSourceAmount || maxSourceAmount || instantSourceAmount
-    ? { instantSourceAmount, maxSourceAmount, minSourceAmount }
-    : null
-}
-
-function statusFromLimits(
-  amount: string,
-  limits: FundingRoutes.QuoteProbeLimits | null,
-): { status: FundingRoutes.RouteStatus; tier: FundingRoutes.QualityTier } {
-  if (!limits) return { status: 'available', tier: 'liquid' }
-  if (limits.minSourceAmount && compareIntegerStrings(amount, limits.minSourceAmount) < 0)
-    return { status: 'unavailable', tier: 'unavailable' }
-  if (limits.maxSourceAmount && compareIntegerStrings(amount, limits.maxSourceAmount) > 0)
-    return { status: 'unavailable', tier: 'unavailable' }
-  if (limits.instantSourceAmount && compareIntegerStrings(amount, limits.instantSourceAmount) > 0)
-    return { status: 'thin', tier: 'thin' }
-  return { status: 'available', tier: 'liquid' }
-}
-
 function relayLiquidity(input: unknown, route: FundingRoutes.RouteCandidate) {
   const response = record(input)
   const rows = Array.isArray(response['liquidity']) ? response['liquidity'] : []
@@ -333,12 +209,17 @@ function relayHeaders(apiKey: string | undefined): Record<string, string> | unde
 function providerUnavailable(cause: unknown, codes: readonly string[]) {
   if (!(cause instanceof ProviderResponseError) || cause.status < 400 || cause.status >= 500)
     return undefined
-  const body = record(cause.body)
-  const code = stringValue(body['code']) ?? stringValue(body['errorCode'])
+  const code = providerErrorCode(cause.body)
   if (code && codes.includes(code)) return code
   return undefined
 }
 
+function providerErrorCode(input: unknown) {
+  const body = record(input)
+  const code = stringValue(body['code']) ?? stringValue(body['errorCode'])
+  return code && /^[A-Za-z0-9_.:-]{1,64}$/.test(code) ? code : undefined
+}
+
 class ProviderResponseError extends Error {
   override name = 'FundingRouteProviders.ProviderResponseError'
 
@@ -406,10 +287,6 @@ function integerString(input: unknown) {
   return undefined
 }
 
-function nestedString(input: unknown, key: string) {
-  return decimalString(record(input)[key])
-}
-
 function nonnegativeInteger(input: unknown) {
   if (typeof input === 'number' && Number.isSafeInteger(input) && input >= 0) return input
   if (typeof input === 'string' && /^\d+$/.test(input)) return Number(input)
@@ -427,30 +304,6 @@ function compareIntegerStrings(left: string, right: string) {
   return BigInt(left) === BigInt(right) ? 0 : BigInt(left) > BigInt(right) ? 1 : -1
 }
 
-function isoFromUnixSeconds(input: string) {
-  return new Date(Number(input) * 1_000).toISOString()
-}
-
-function stablecoinUsdCapacity(
-  route: FundingRoutes.RouteCandidate,
-  baseUnits: string | null | undefined,
-) {
-  if (!baseUnits || !isDollarStablecoin(route.sourceToken.symbol)) return null
-  return decimalFromBaseUnits(baseUnits, route.sourceToken.decimals)
-}
-
-function isDollarStablecoin(symbol: string) {
-  return ['DAI', 'FRXUSD', 'PYUSD', 'USDC', 'USDC.E', 'USDT', 'USDT0'].includes(
-    symbol.toUpperCase(),
-  )
-}
-
-function scaledPctToBps(input: string | undefined) {
-  if (!input || !/^\d+$/.test(input)) return null
-  const denominator = 1_000_000_000_000_000_000n
-  return Number((BigInt(input) * 10_000n + denominator / 2n) / denominator)
-}
-
 function scoreFor(tier: FundingRoutes.QualityTier) {
   if (tier === 'liquid') return 90
   if (tier === 'thin') return 65

package/src/apps/data/routes/funding.test.ts

@@ -19,16 +19,11 @@ describe('GET /funding/routes', () => {
     expect(response.status).toBe(200)
     const body = await TestApp.json(response, Funding.schema.listFundingRoutes.Response)
 
-    expect(body.data.map((route) => route.provider.id)).toEqual([
-      'across',
-      'relay',
-      'bridge',
-      'bungee',
-    ])
+    expect(body.data.map((route) => route.provider.id)).toEqual(['relay', 'bridge', 'bungee'])
     expect(body.data[0]).toMatchObject({
       destinationChain: { id: 'eip155:4217', name: 'Tempo' },
       destinationToken: { symbol: 'USDC.e' },
-      id: 'base-usdc-tempo-usdce-across',
+      id: 'base-usdc-tempo-usdce-relay',
       quality: { liquiditySource: 'staticInventory', tier: 'unknown' },
       sourceAmount: { amount: '1000000', formatted: '1' },
       sourceChain: { id: 'eip155:8453', name: 'Base' },
@@ -41,12 +36,12 @@ describe('GET /funding/routes', () => {
     const app = TestApp.create({
       fundingRoutes: {
         adapters: {
-          across: {
+          relay: {
             async probeQuote(input, signal) {
               expect(signal.aborted).toBe(false)
               expect(input.cache.bypass).toBe(true)
               expect(input.include).toEqual(['quotes'])
-              expect(input.route.id).toBe('base-usdc-tempo-usdce-across')
+              expect(input.route.id).toBe('base-usdc-tempo-usdce-relay')
               expect(input.sourceAmount.amount).toBe('1000000')
               expect(input.sourceChain.id).toBe('eip155:8453')
               expect(input.sourceToken.symbol).toBe('USDC')
@@ -81,7 +76,7 @@ describe('GET /funding/routes', () => {
     })
 
     const response = await app.request(
-      '/v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000&provider=across&include=quotes',
+      '/v1/funding/routes?sourceChain=base&sourceToken=USDC&sourceAmount=1000000&provider=relay&include=quotes',
       { headers: { ...TestApp.auth.headers, 'Cache-Control': 'no-cache' } },
     )
     expect(response.status).toBe(200)
@@ -90,7 +85,7 @@ describe('GET /funding/routes', () => {
     expect(body.data).toHaveLength(1)
     expect(body.data[0]).toMatchObject({
       errorCode: null,
-      id: 'base-usdc-tempo-usdce-across',
+      id: 'base-usdc-tempo-usdce-relay',
       quality: {
         availableVolumeUsd: '1000.00',
         liquiditySource: 'providerQuote',
@@ -261,13 +256,7 @@ describe('GET /providers', () => {
     expect(response.status).toBe(200)
     const body = await TestApp.json(response, Funding.schema.listProviders.Response)
 
-    expect(body.data.map((provider) => provider.id)).toEqual([
-      'across',
-      'relay',
-      'bridge',
-      'bungee',
-      'lifi',
-    ])
+    expect(body.data.map((provider) => provider.id)).toEqual(['relay', 'bridge', 'bungee', 'lifi'])
     expect(body.data.every((provider) => provider.capabilities.includes('fundingRoutes'))).toBe(
       true,
     )
@@ -275,34 +264,10 @@ describe('GET /providers', () => {
       'inventoryOnly',
       'inventoryOnly',
       'inventoryOnly',
-      'inventoryOnly',
       'planned',
     ])
   })
 
-  test('marks configured live provider adapters', async () => {
-    const app = TestApp.create({
-      fundingRoutes: {
-        adapters: {
-          across: {
-            async probeQuote() {
-              throw new Error('not used')
-            },
-          },
-        },
-      },
-    })
-
-    const response = await app.request('/v1/providers?capability=fundingRoutes', {
-      headers: TestApp.auth.headers,
-    })
-    expect(response.status).toBe(200)
-    const body = await TestApp.json(response, Funding.schema.listProviders.Response)
-
-    expect(body.data.find((provider) => provider.id === 'across')?.status).toBe('configured')
-    expect(body.data.find((provider) => provider.id === 'relay')?.status).toBe('inventoryOnly')
-  })
-
   test('rejects unsupported provider capabilities', async () => {
     const response = await TestApp.create().request('/v1/providers?capability=settlement', {
       headers: TestApp.auth.headers,