tapimo 0.5.0 → 0.5.1

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. */

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

@@ -4,6 +4,124 @@ import * as FundingQuoteProviders from './FundingQuoteProviders.js'
 const now = () => new Date('2026-01-01T00:00:00.000Z')
 
 describe('FundingQuoteProviders', () => {
+  test('requires every Across deployment binding when any is configured', () => {
+    expect(FundingQuoteProviders.configureAcross()).toBeUndefined()
+    expect(() =>
+      FundingQuoteProviders.configureAcross({ apiKey: 'across-api-key' }),
+    ).toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderConfigurationError]`)
+    expect(
+      FundingQuoteProviders.configureAcross({
+        apiKey: 'across-api-key',
+        integratorId: '0xdead',
+        userAddress: '0x1111111111111111111111111111111111111111',
+      }),
+    ).toEqual({
+      apiKey: 'across-api-key',
+      integratorId: '0xdead',
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+  })
+
+  test('maps successful Across quotes to available quote probes', async () => {
+    const requests: RecordedRequest[] = []
+    const candidate = quoteCandidate('across')
+    const fetch = recordingFetch(requests, async () => jsonResponse(acrossQuote(candidate)))
+    const adapter = FundingQuoteProviders.across({
+      apiKey: 'across-api-key',
+      baseUrl: 'https://across.test/api/',
+      fetch,
+      integratorId: '0xdead',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    const result = await adapter.probeQuote(probeInput(candidate), new AbortController().signal)
+
+    expect(requests).toHaveLength(1)
+    expect(requests[0]?.url.pathname).toBe('/api/swap/approval')
+    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('0xdead')
+    expect(requests[0]?.url.searchParams.get('tradeType')).toBe('exactInput')
+    expect(requests[0]?.url.searchParams.get('skipOriginTxEstimation')).toBe('true')
+    expect(requests[0]?.url.searchParams.get('strictTradeType')).toBe('true')
+    expect(requests[0]?.url.searchParams.get('depositor')).toBe(
+      '0x1111111111111111111111111111111111111111',
+    )
+    expect(requests[0]?.url.searchParams.get('recipient')).toBe(
+      '0x1111111111111111111111111111111111111111',
+    )
+    expect(new Headers(requests[0]?.init?.headers).get('authorization')).toBe(
+      'Bearer across-api-key',
+    )
+    expect(result).toMatchObject({
+      expiresAt: '2026-01-01T00:01:00.000Z',
+      minimumOutputAmount: '988000',
+      outputAmount: '990000',
+      outputAmountFormatted: '0.99',
+      quality: {
+        estimatedSeconds: 2,
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'across:swap-approval',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00.000Z',
+      status: 'available',
+    })
+  })
+
+  test('maps recognized Across quote errors to unavailable probes', async () => {
+    const candidate = quoteCandidate('across')
+    const fetch = recordingFetch([], async () => jsonResponse({ code: 'NO_ROUTE' }, 400))
+    const adapter = FundingQuoteProviders.across({
+      apiKey: 'across-api-key',
+      fetch,
+      integratorId: '0xdead',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).resolves.toMatchObject({
+      quality: {
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'across:swap-approval:NO_ROUTE',
+        tier: 'unavailable',
+      },
+      status: 'unavailable',
+    })
+  })
+
+  test('rejects malformed Across quote payloads', async () => {
+    const candidate = quoteCandidate('across')
+    const fetch = recordingFetch([], async () =>
+      jsonResponse({ ...acrossQuote(candidate), expectedOutputAmount: '0' }),
+    )
+    const adapter = FundingQuoteProviders.across({
+      apiKey: 'across-api-key',
+      fetch,
+      integratorId: '0xdead',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderPayloadError]`)
+  })
+
+  test('rejects invalid Across configuration', () => {
+    expect(() =>
+      FundingQuoteProviders.across({
+        apiKey: 'across-api-key',
+        integratorId: 'tempo',
+        userAddress: '0x1111111111111111111111111111111111111111',
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderConfigurationError]`)
+  })
+
   test('maps successful Relay quotes to available quote probes', async () => {
     const requests: RecordedRequest[] = []
     const candidate = quoteCandidate()
@@ -54,6 +172,191 @@ describe('FundingQuoteProviders', () => {
     })
   })
 
+  test('maps successful Rhino quotes to available quote probes', async () => {
+    const requests: RecordedRequest[] = []
+    const candidate = quoteCandidate('rhino')
+    const fetch = recordingFetch(requests, async () =>
+      jsonResponse({
+        _tag: 'bridge',
+        chainIn: 'BASE',
+        chainOut: 'TEMPO',
+        estimatedDuration: 1_500,
+        payAmount: '1.0000000',
+        receiveAmount: '0.9830000',
+        token: 'USDC',
+      }),
+    )
+    const adapter = FundingQuoteProviders.rhino({
+      baseUrl: 'https://rhino.test/bridge/',
+      fetch,
+      now,
+    })
+
+    const result = await adapter.probeQuote(probeInput(candidate), new AbortController().signal)
+
+    expect(requests).toHaveLength(1)
+    expect(requests[0]?.url.pathname).toBe('/bridge/quote/bridge-swap/public')
+    expect(Object.fromEntries(requests[0]!.url.searchParams)).toEqual({
+      amount: '1',
+      amountNative: '0',
+      chainIn: 'BASE',
+      chainOut: 'TEMPO',
+      mode: 'pay',
+      tokenIn: 'USDC',
+      tokenOut: 'USDC',
+    })
+    expect(result).toEqual({
+      outputAmount: '983000',
+      outputAmountFormatted: '0.983',
+      quality: {
+        estimatedSeconds: 2,
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'rhino:bridge-swap-public',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00.000Z',
+      status: 'available',
+    })
+  })
+
+  test('maps unavailable Rhino routes to unavailable quote probes', async () => {
+    const candidate = quoteCandidate('rhino')
+    const adapter = FundingQuoteProviders.rhino({
+      fetch: recordingFetch([], async () => jsonResponse({ _tag: 'NoRouteFoundError' }, 404)),
+      now,
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).resolves.toMatchObject({
+      quality: {
+        sourceDetail: 'rhino:bridge-swap-public:NoRouteFoundError',
+        tier: 'unavailable',
+      },
+      status: 'unavailable',
+    })
+  })
+
+  test('maps Solana and Tron identifiers into Rhino quote requests', async () => {
+    const cases = [
+      {
+        candidate: quoteCandidate('rhino', { sourceChain: 'solana' }),
+        chainIn: 'SOLANA',
+        tokenOut: 'USDC',
+      },
+      {
+        candidate: quoteCandidate('rhino', {
+          destinationToken: 'USDT0',
+          sourceChain: 'tron',
+          sourceToken: 'USDT',
+        }),
+        chainIn: 'TRON',
+        tokenOut: 'USDT',
+      },
+    ] as const
+
+    for (const testCase of cases) {
+      const requests: RecordedRequest[] = []
+      const adapter = FundingQuoteProviders.rhino({
+        fetch: recordingFetch(requests, async () =>
+          jsonResponse({
+            _tag: 'bridge',
+            chainIn: testCase.chainIn,
+            chainOut: 'TEMPO',
+            payAmount: '1',
+            receiveAmount: '0.983',
+            token: testCase.tokenOut,
+          }),
+        ),
+        now,
+      })
+
+      await expect(
+        adapter.probeQuote(probeInput(testCase.candidate), new AbortController().signal),
+      ).resolves.toMatchObject({ outputAmount: '983000', status: 'available' })
+      expect(requests[0]?.url.searchParams.get('chainIn')).toBe(testCase.chainIn)
+      expect(requests[0]?.url.searchParams.get('tokenOut')).toBe(testCase.tokenOut)
+    }
+  })
+
+  test('surfaces Rhino request decoding failures', async () => {
+    const candidate = quoteCandidate('rhino')
+    const adapter = FundingQuoteProviders.rhino({
+      fetch: recordingFetch([], async () => jsonResponse({ _tag: 'HttpApiDecodeError' }, 400)),
+      now,
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[FundingQuoteProviders.ProviderResponseError: Provider request failed with status 400]`,
+    )
+  })
+
+  test('surfaces unrecognized Rhino route errors', async () => {
+    const candidate = quoteCandidate('rhino')
+    const failures = [
+      { body: null, status: 404 },
+      { body: { _tag: 'InvalidRequest' }, status: 422 },
+    ] as const
+
+    for (const failure of failures) {
+      const adapter = FundingQuoteProviders.rhino({
+        fetch: recordingFetch([], async () => jsonResponse(failure.body, failure.status)),
+        now,
+      })
+      const cause = await adapter
+        .probeQuote(probeInput(candidate), new AbortController().signal)
+        .catch((error: unknown) => error)
+      expect(cause).toMatchObject({
+        name: 'FundingQuoteProviders.ProviderResponseError',
+        status: failure.status,
+      })
+    }
+  })
+
+  test('rejects mismatched Rhino quote payloads', async () => {
+    const candidate = quoteCandidate('rhino')
+    const adapter = FundingQuoteProviders.rhino({
+      fetch: recordingFetch([], async () =>
+        jsonResponse({
+          _tag: 'bridge',
+          chainIn: 'SOLANA',
+          chainOut: 'TEMPO',
+          payAmount: '1',
+          receiveAmount: '0.983',
+          token: 'USDC',
+        }),
+      ),
+      now,
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderPayloadError]`)
+  })
+
+  test('rejects non-representable Rhino output precision', async () => {
+    const candidate = quoteCandidate('rhino')
+    const adapter = FundingQuoteProviders.rhino({
+      fetch: recordingFetch([], async () =>
+        jsonResponse({
+          _tag: 'bridge',
+          chainIn: 'BASE',
+          chainOut: 'TEMPO',
+          payAmount: '1',
+          receiveAmount: '0.9830001',
+          token: 'USDC',
+        }),
+      ),
+      now,
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderPayloadError]`)
+  })
+
   test('calls the runtime fetch method with its global receiver', async () => {
     const candidate = quoteCandidate()
     const fetch = vi.fn(function (this: unknown) {
@@ -82,6 +385,94 @@ describe('FundingQuoteProviders', () => {
       vi.unstubAllGlobals()
     }
   })
+
+  const invalidAcrossQuotes = [
+    [
+      'mismatched input amounts',
+      (body: ReturnType<typeof acrossQuote>) => (body.inputAmount = '1'),
+    ],
+    [
+      'mismatched token addresses',
+      (body: ReturnType<typeof acrossQuote>) =>
+        (body.inputToken.address = '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2'),
+    ],
+    [
+      'mismatched token chains',
+      (body: ReturnType<typeof acrossQuote>) => (body.inputToken.chainId = 1),
+    ],
+    [
+      'mismatched token decimals',
+      (body: ReturnType<typeof acrossQuote>) => (body.inputToken.decimals = 18),
+    ],
+    [
+      'expired quotes',
+      (body: ReturnType<typeof acrossQuote>) => (body.quoteExpiryTimestamp = 1767225600),
+    ],
+    [
+      'out-of-range expiries',
+      (body: ReturnType<typeof acrossQuote>) =>
+        (body.quoteExpiryTimestamp = Number.MAX_SAFE_INTEGER),
+    ],
+    [
+      'invalid output bounds',
+      (body: ReturnType<typeof acrossQuote>) => (body.minOutputAmount = '990001'),
+    ],
+  ] as const
+
+  for (const [name, mutate] of invalidAcrossQuotes)
+    test(`rejects Across quotes with ${name}`, async () => {
+      const candidate = quoteCandidate('across')
+      const body = acrossQuote(candidate)
+      mutate(body)
+      const adapter = FundingQuoteProviders.across({
+        apiKey: 'across-api-key',
+        fetch: recordingFetch([], async () => jsonResponse(body)),
+        integratorId: '0xdead',
+        now,
+        userAddress: '0x1111111111111111111111111111111111111111',
+      })
+
+      await expect(
+        adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderPayloadError]`)
+    })
+
+  test('returns bounded Across failure diagnostics', async () => {
+    const candidate = quoteCandidate('across')
+    const adapter = FundingQuoteProviders.across({
+      apiKey: 'across-api-key',
+      fetch: recordingFetch([], async () =>
+        jsonResponse({ apiKey: 'secret', code: 'UNAUTHORIZED' }, 401),
+      ),
+      integratorId: '0xdead',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+    const cause = await adapter
+      .probeQuote(probeInput(candidate), new AbortController().signal)
+      .catch((error: unknown) => error)
+
+    expect(FundingQuoteProviders.providerFailure({ cause, provider: 'across' })).toEqual({
+      code: 'UNAUTHORIZED',
+      failure: 'http',
+      id: 'across',
+      operation: 'swap/approval',
+      status: 401,
+    })
+  })
+
+  test('returns explicit timeout failure diagnostics', () => {
+    expect(
+      FundingQuoteProviders.providerFailure({
+        cause: new FundingQuotes.ProviderAdapterTimeoutError(),
+        provider: 'across',
+      }),
+    ).toEqual({
+      failure: 'timeout',
+      id: 'across',
+      operation: 'swap/approval',
+    })
+  })
 })
 
 type RecordedRequest = {
@@ -89,18 +480,53 @@ type RecordedRequest = {
   url: URL
 }
 
-function quoteCandidate(): FundingQuotes.QuoteProbeInput['candidate'] {
+function quoteCandidate(
+  provider: FundingQuotes.ProviderId = 'relay',
+  options: quoteCandidate.Options = {},
+): FundingQuotes.QuoteProbeInput['candidate'] {
   const [candidate] = FundingQuotes.listQuoteCandidates({
-    provider: 'relay',
+    destinationToken: options.destinationToken,
+    provider,
     sourceAmount: '1000000',
     sourceAmountUnits: 'baseUnits',
-    sourceToken: 'USDC',
-    sourceChain: 'base',
+    sourceChain: options.sourceChain ?? 'base',
+    sourceToken: options.sourceToken ?? 'USDC',
   })
-  if (!candidate) throw new Error('Missing Relay quote candidate')
+  if (!candidate) throw new Error(`Missing ${provider} quote candidate`)
   return candidate
 }
 
+declare namespace quoteCandidate {
+  type Options = {
+    destinationToken?: string | undefined
+    sourceChain?: string | undefined
+    sourceToken?: string | undefined
+  }
+}
+
+function acrossQuote(candidate: FundingQuotes.QuoteProbeInput['candidate']) {
+  return {
+    amountType: 'exactInput',
+    expectedFillTime: 2,
+    expectedOutputAmount: '990000',
+    inputAmount: candidate.sourceAmount.amount,
+    inputToken: {
+      address: candidate.sourceToken.address,
+      chainId: 8453,
+      decimals: candidate.sourceToken.decimals,
+      symbol: candidate.sourceToken.symbol,
+    },
+    minOutputAmount: '988000',
+    outputToken: {
+      address: candidate.destinationToken.address,
+      chainId: 4217,
+      decimals: candidate.destinationToken.decimals,
+      symbol: candidate.destinationToken.symbol,
+    },
+    quoteExpiryTimestamp: 1767225660,
+  }
+}
+
 function probeInput(
   candidate: FundingQuotes.QuoteProbeInput['candidate'],
 ): FundingQuotes.QuoteProbeInput {