tapimo 0.5.0 → 0.5.1

package/src/apps/data/FundingQuoteProviders.ts

@@ -1,23 +1,166 @@
+import * as z from 'zod/mini'
+
 import * as FundingQuotes from '../../internal/FundingQuotes.js'
 
 type Fetch = typeof globalThis.fetch
 
 const defaultFetch: Fetch = (input, init) => globalThis.fetch(input, init)
 
+const defaultAcrossBaseUrl = 'https://app.across.to/api'
 const defaultRelayBaseUrl = 'https://api.relay.link'
+const defaultRhinoBaseUrl = 'https://api.rhino.fi/bridge'
+const providerOperations = {
+  across: 'swap/approval',
+  relay: 'quote/v2',
+  rhino: 'quote/bridge-swap/public',
+} as const
+
+namespace schema {
+  const IntegerString = z.string().check(z.regex(/^\d+$/))
+
+  const AcrossToken = z.object({
+    address: z.string(),
+    chainId: z.number().check(z.int(), z.nonnegative()),
+    decimals: z.number().check(z.int(), z.nonnegative()),
+  })
+
+  export const AcrossQuote = z.object({
+    amountType: z.literal('exactInput'),
+    expectedFillTime: z.number().check(z.int(), z.nonnegative()),
+    expectedOutputAmount: IntegerString,
+    inputAmount: IntegerString,
+    inputToken: AcrossToken,
+    minOutputAmount: IntegerString,
+    outputToken: AcrossToken,
+    quoteExpiryTimestamp: z.number().check(z.int(), z.nonnegative()),
+  })
+
+  export const RhinoQuote = z.object({
+    _tag: z.literal('bridge'),
+    chainIn: z.string(),
+    chainOut: z.string(),
+    estimatedDuration: z.optional(z.nullable(z.number().check(z.nonnegative()))),
+    payAmount: z.string().check(z.regex(/^\d+(\.\d+)?$/)),
+    receiveAmount: z.string().check(z.regex(/^\d+(\.\d+)?$/)),
+    token: z.string(),
+  })
+}
 
 /** Creates the live funding quote adapters configured for this deployment. */
 export function createAdapters(options: createAdapters.Options = {}) {
-  return (
-    options.relay ? { relay: relay(options.relay) } : {}
-  ) satisfies FundingQuotes.ProviderAdapters
+  return {
+    ...(options.across ? { across: across(options.across) } : {}),
+    ...(options.relay ? { relay: relay(options.relay) } : {}),
+    ...(options.rhino ? { rhino: rhino(options.rhino) } : {}),
+  } satisfies FundingQuotes.ProviderAdapters
 }
 
 export declare namespace createAdapters {
   /** Provider adapter factory options. Omit a provider to leave it unconfigured. */
   type Options = {
+    /** Across quote adapter options. */
+    across?: across.Options | false | undefined
     /** Relay quote adapter options. */
     relay?: relay.Options | false | undefined
+    /** Rhino quote adapter options. */
+    rhino?: rhino.Options | false | undefined
+  }
+}
+
+/** Resolves all-or-none Across deployment configuration. */
+export function configureAcross(options: configureAcross.Options = {}): across.Options | undefined {
+  const configured = [options.apiKey, options.integratorId, options.userAddress].filter(Boolean)
+  if (configured.length === 0) return undefined
+  if (!options.apiKey || !options.integratorId || !options.userAddress)
+    throw new ProviderConfigurationError()
+  return {
+    apiKey: options.apiKey,
+    integratorId: options.integratorId,
+    userAddress: options.userAddress,
+  }
+}
+
+export declare namespace configureAcross {
+  /** Optional deployment bindings required together to enable Across. */
+  type Options = {
+    /** Across API key binding. */
+    apiKey?: string | undefined
+    /** Across integrator id binding. */
+    integratorId?: string | undefined
+    /** Across quote-user binding. */
+    userAddress?: string | undefined
+  }
+}
+
+/** Creates an Across quote adapter backed by `/swap/approval`. */
+export function across(options: across.Options): FundingQuotes.ProviderAdapter {
+  assertAcrossConfiguration(options)
+  const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultAcrossBaseUrl)
+  const fetcher = options.fetch ?? defaultFetch
+  const now = options.now ?? (() => new Date())
+
+  return {
+    async probeQuote({ candidate }, signal) {
+      const destinationChainId = eip155ChainId(candidate.destinationChain)
+      const originChainId = providerChainId(candidate.sourceChain, 'across')
+      const url = new URL(`${baseUrl}/swap/approval`)
+      url.search = new URLSearchParams({
+        amount: candidate.sourceAmount.amount,
+        depositor: options.userAddress,
+        destinationChainId,
+        inputToken: candidate.sourceToken.address,
+        integratorId: options.integratorId,
+        originChainId,
+        outputToken: candidate.destinationToken.address,
+        recipient: options.userAddress,
+        skipOriginTxEstimation: 'true',
+        strictTradeType: 'true',
+        tradeType: 'exactInput',
+      }).toString()
+
+      try {
+        const quote = await requestJson(url, {
+          fetcher,
+          headers: { Authorization: `Bearer ${options.apiKey}` },
+          signal,
+        })
+        return formatAcrossResult(candidate, quote, now())
+      } catch (cause) {
+        const unavailable = providerUnavailable(cause, [
+          'AMOUNT_TOO_HIGH',
+          'AMOUNT_TOO_LOW',
+          'INSUFFICIENT_LIQUIDITY',
+          'NO_QUOTES',
+          'NO_ROUTE',
+          'UNSUPPORTED_ROUTE',
+        ])
+        if (!unavailable) throw cause
+        return unavailableResult({
+          detail: 'across:swap-approval',
+          message: unavailable,
+          now: now(),
+          source: 'providerQuote',
+        })
+      }
+    },
+  }
+}
+
+export declare namespace across {
+  /** Across quote adapter options. */
+  type Options = {
+    /** Across API key sent as a bearer token. */
+    apiKey: string
+    /** Override for tests or Across test environments. */
+    baseUrl?: string | undefined
+    /** Fetch implementation override for tests. */
+    fetch?: Fetch | undefined
+    /** Across integrator id sent as the required query parameter. */
+    integratorId: string
+    /** Clock override for deterministic tests. */
+    now?: (() => Date) | undefined
+    /** Probe wallet address used as the Across depositor and recipient. */
+    userAddress: string
   }
 }
 
@@ -87,6 +230,144 @@ export declare namespace relay {
   }
 }
 
+/** Creates a Rhino quote adapter backed by the public bridge-and-swap quote endpoint. */
+export function rhino(options: rhino.Options = {}): FundingQuotes.ProviderAdapter {
+  const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultRhinoBaseUrl)
+  const fetcher = options.fetch ?? defaultFetch
+  const now = options.now ?? (() => new Date())
+
+  return {
+    async probeQuote({ cache, candidate }, signal) {
+      const chainIn = providerChainReference(candidate.sourceChain, 'rhino')
+      const tokenOut = rhinoToken(candidate.destinationToken)
+      const url = new URL(`${baseUrl}/quote/bridge-swap/public`)
+      url.search = new URLSearchParams({
+        amount: candidate.sourceAmount.formatted,
+        amountNative: '0',
+        chainIn,
+        chainOut: 'TEMPO',
+        mode: 'pay',
+        tokenIn: candidate.sourceToken.symbol,
+        tokenOut,
+      }).toString()
+
+      try {
+        const quote = await requestJson(url, {
+          fetcher,
+          headers: cache.bypass ? { 'cache-control': 'no-cache' } : undefined,
+          signal,
+        })
+        return formatRhinoResult(candidate, quote, { chainIn, now: now(), tokenOut })
+      } catch (cause) {
+        const unavailable = providerUnavailable(cause, ['NoRouteFoundError'])
+        if (!unavailable) throw cause
+        return unavailableResult({
+          detail: 'rhino:bridge-swap-public',
+          message: unavailable,
+          now: now(),
+          source: 'providerQuote',
+        })
+      }
+    },
+  }
+}
+
+export declare namespace rhino {
+  /** Rhino public quote adapter options. */
+  type Options = {
+    /** Override for tests or Rhino test environments. */
+    baseUrl?: string | undefined
+    /** Fetch implementation override for tests. */
+    fetch?: Fetch | undefined
+    /** Clock override for deterministic tests. */
+    now?: (() => Date) | undefined
+  }
+}
+
+/** Returns bounded provider failure details suitable for structured request logs. */
+export function providerFailure(options: providerFailure.Options): providerFailure.Result {
+  const operation = providerOperations[options.provider]
+  if (
+    options.cause instanceof FundingQuotes.ProviderAdapterTimeoutError ||
+    (options.cause instanceof DOMException && options.cause.name === 'AbortError')
+  )
+    return { failure: 'timeout', id: options.provider, operation }
+  if (options.cause instanceof ProviderResponseError) {
+    const code = providerErrorCode(options.cause.body)
+    return {
+      ...(code === undefined ? {} : { code }),
+      failure: 'http',
+      id: options.provider,
+      operation,
+      status: options.cause.status,
+    }
+  }
+  if (options.cause instanceof ProviderPayloadError)
+    return { failure: 'payload', id: options.provider, operation }
+  if (options.cause instanceof TypeError)
+    return { failure: 'network', id: options.provider, operation }
+  return { failure: 'unknown', id: options.provider, operation }
+}
+
+export declare namespace providerFailure {
+  /** Inputs used to classify a provider failure. */
+  type Options = FundingQuotes.ProviderFailure
+
+  /** Bounded provider failure fields. */
+  type Result = {
+    /** Stable provider error code, when one is safe to retain. */
+    code?: string | undefined
+    /** Failure boundary that rejected the provider request. */
+    failure: 'http' | 'network' | 'payload' | 'timeout' | 'unknown'
+    /** Provider identifier. */
+    id: FundingQuotes.ProviderId
+    /** Provider operation identifier. */
+    operation: (typeof providerOperations)[FundingQuotes.ProviderId]
+    /** Upstream HTTP status, when a response was received. */
+    status?: number | undefined
+  }
+}
+
+function formatAcrossResult(
+  candidate: FundingQuotes.QuoteCandidate,
+  quote: unknown,
+  now: Date,
+): FundingQuotes.QuoteProbeResult {
+  const parsed = schema.AcrossQuote.safeParse(quote)
+  if (!parsed.success) throw new ProviderPayloadError()
+  const response = parsed.data
+  const expiresAt = new Date(response.quoteExpiryTimestamp * 1_000)
+  if (
+    response.inputAmount !== candidate.sourceAmount.amount ||
+    !matchesToken(response.inputToken, candidate.sourceChain, candidate.sourceToken) ||
+    !matchesToken(response.outputToken, candidate.destinationChain, candidate.destinationToken) ||
+    BigInt(response.expectedOutputAmount) <= 0n ||
+    BigInt(response.minOutputAmount) <= 0n ||
+    BigInt(response.minOutputAmount) > BigInt(response.expectedOutputAmount) ||
+    Number.isNaN(expiresAt.getTime()) ||
+    response.quoteExpiryTimestamp * 1_000 <= now.getTime()
+  )
+    throw new ProviderPayloadError()
+
+  return {
+    expiresAt: expiresAt.toISOString(),
+    minimumOutputAmount: response.minOutputAmount,
+    outputAmount: response.expectedOutputAmount,
+    outputAmountFormatted: decimalFromBaseUnits(
+      response.expectedOutputAmount,
+      candidate.destinationToken.decimals,
+    ),
+    quality: {
+      estimatedSeconds: response.expectedFillTime,
+      liquiditySource: 'providerQuote',
+      sourceDetail: 'across:swap-approval',
+      tier: 'liquid',
+    },
+    sampledAt: now.toISOString(),
+    status: 'available',
+  }
+}
+
 function formatRelayResult(
   candidate: FundingQuotes.QuoteCandidate,
   quote: unknown,
@@ -116,6 +397,45 @@ function formatRelayResult(
   }
 }
 
+function formatRhinoResult(
+  candidate: FundingQuotes.QuoteCandidate,
+  quote: unknown,
+  options: { chainIn: string; now: Date; tokenOut: string },
+): FundingQuotes.QuoteProbeResult {
+  const parsed = schema.RhinoQuote.safeParse(quote)
+  if (!parsed.success) throw new ProviderPayloadError()
+  const response = parsed.data
+  const inputAmount = baseUnitsFromDecimal(response.payAmount, candidate.sourceToken.decimals)
+  const outputAmount = baseUnitsFromDecimal(
+    response.receiveAmount,
+    candidate.destinationToken.decimals,
+  )
+  if (
+    response.chainIn !== options.chainIn ||
+    response.chainOut !== 'TEMPO' ||
+    response.token !== options.tokenOut ||
+    inputAmount !== candidate.sourceAmount.amount ||
+    outputAmount === undefined ||
+    BigInt(outputAmount) <= 0n
+  )
+    throw new ProviderPayloadError()
+
+  return {
+    outputAmount,
+    outputAmountFormatted: decimalFromBaseUnits(outputAmount, candidate.destinationToken.decimals),
+    quality: {
+      ...(response.estimatedDuration === undefined || response.estimatedDuration === null
+        ? {}
+        : { estimatedSeconds: Math.ceil(response.estimatedDuration / 1_000) }),
+      liquiditySource: 'providerQuote',
+      sourceDetail: 'rhino:bridge-swap-public',
+      tier: 'liquid',
+    },
+    sampledAt: options.now.toISOString(),
+    status: 'available',
+  }
+}
+
 function unavailableResult(options: {
   detail: string
   message: string
@@ -172,7 +492,8 @@ function providerUnavailable(cause: unknown, codes: readonly string[]) {
 
 function providerErrorCode(input: unknown) {
   const body = record(input)
-  const code = stringValue(body['code']) ?? stringValue(body['errorCode'])
+  const code =
+    stringValue(body['_tag']) ?? stringValue(body['code']) ?? stringValue(body['errorCode'])
   return code && /^[A-Za-z0-9_.:-]{1,64}$/.test(code) ? code : undefined
 }
 
@@ -186,6 +507,38 @@ function providerChainId(
   return eip155ChainId(quoteChain)
 }
 
+function providerChainReference(
+  quoteChain: FundingQuotes.QuoteCandidate['sourceChain'],
+  provider: string,
+) {
+  const providerIds = quoteChain.providerIds as Record<string, string> | undefined
+  const id = providerIds?.[provider]
+  if (!id) throw new UnsupportedProviderChainError()
+  return id
+}
+
+function rhinoToken(token: FundingQuotes.TokenRef) {
+  const tokens: Record<string, string> = {
+    '0x20c00000000000000000000014f22ca97301eb73': 'USDT',
+    '0x20c000000000000000000000b9537d11c60e8b50': 'USDC',
+  }
+  const id = tokens[token.address.toLowerCase()]
+  if (!id) throw new UnsupportedProviderTokenError()
+  return id
+}
+
+function matchesToken(
+  token: z.output<typeof schema.AcrossQuote>['inputToken'],
+  chain: FundingQuotes.ChainRef,
+  expected: FundingQuotes.TokenRef,
+) {
+  return (
+    token.address.toLowerCase() === expected.address.toLowerCase() &&
+    token.chainId === Number(eip155ChainId(chain)) &&
+    token.decimals === expected.decimals
+  )
+}
+
 function eip155ChainId(chain: { id: string; kind: string }) {
   if (chain.kind !== 'evm') throw new UnsupportedProviderChainError()
   const match = /^eip155:(\d+)$/.exec(chain.id)
@@ -235,6 +588,31 @@ function decimalFromBaseUnits(baseUnits: string, decimals: number) {
   return fraction ? `${whole}.${fraction}` : whole
 }
 
+function baseUnitsFromDecimal(value: string, decimals: number) {
+  if (!/^\d+(\.\d+)?$/.test(value)) return undefined
+  const [whole, fraction = ''] = value.split('.')
+  const significantFraction = fraction.replace(/0+$/, '')
+  if (significantFraction.length > decimals) return undefined
+  return BigInt(`${whole}${significantFraction.padEnd(decimals, '0')}`).toString()
+}
+
+function assertAcrossConfiguration(options: across.Options) {
+  if (
+    options.apiKey.length === 0 ||
+    !/^0x[\da-fA-F]{4}$/.test(options.integratorId) ||
+    !/^0x[\da-fA-F]{40}$/.test(options.userAddress)
+  )
+    throw new ProviderConfigurationError()
+}
+
+class ProviderConfigurationError extends Error {
+  override name = 'FundingQuoteProviders.ProviderConfigurationError'
+}
+
+class ProviderPayloadError extends Error {
+  override name = 'FundingQuoteProviders.ProviderPayloadError'
+}
+
 class ProviderResponseError extends Error {
   override name = 'FundingQuoteProviders.ProviderResponseError'
 
@@ -249,3 +627,7 @@ class ProviderResponseError extends Error {
 class UnsupportedProviderChainError extends Error {
   override name = 'FundingQuoteProviders.UnsupportedProviderChainError'
 }
+
+class UnsupportedProviderTokenError extends Error {
+  override name = 'FundingQuoteProviders.UnsupportedProviderTokenError'
+}

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

@@ -1,6 +1,7 @@
 import { Schema } from 'tapimo'
 
 import type * as FundingQuotes from '../../../internal/FundingQuotes.js'
+import type * as Log from '../../../internal/Log.js'
 import * as TestApp from '../../../../test/App.js'
 import * as Funding from './funding.js'
 
@@ -27,22 +28,59 @@ describe('GET /funding/quotes', () => {
   })
 
   test('queries only the requested provider', async () => {
-    let calls = 0
+    let acrossCalls = 0
+    let relayCalls = 0
     const app = TestApp.create({
       funding: {
         adapters: {
+          across: acrossAdapter(() => {
+            acrossCalls += 1
+          }),
           relay: relayAdapter(() => {
-            calls += 1
+            relayCalls += 1
           }),
         },
       },
     })
-    const response = await app.request(quoteUrl({ ...baseUsdcQuery, provider: 'relay' }), {
+    const response = await app.request(quoteUrl({ ...baseUsdcQuery, provider: 'across' }), {
       headers: TestApp.auth.headers,
     })
 
     expect(response.status).toBe(200)
-    expect(calls).toBe(1)
+    expect(acrossCalls).toBe(1)
+    expect(relayCalls).toBe(0)
+    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+    expect(body.data[0]?.quote.expiresAt).toBe('2026-01-01T00:01:00Z')
+  })
+
+  test('returns non-EVM Rhino quotes with stable chain and token ids', async () => {
+    const app = TestApp.create({ funding: { adapters: { rhino: rhinoAdapter() } } })
+    const response = await app.request(
+      quoteUrl({
+        destinationToken: 'USDC.e',
+        provider: 'rhino',
+        sourceAmount: '1000000',
+        sourceChain: 'solana',
+        sourceToken: 'USDC',
+      }),
+      { headers: TestApp.auth.headers },
+    )
+
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+    expect(body.data[0]).toMatchObject({
+      id: 'solana-usdc-tempo-usdce-rhino',
+      provider: { id: 'rhino' },
+      sourceChain: {
+        addressFormat: 'base58',
+        id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        kind: 'solana',
+      },
+      sourceToken: {
+        tokenKey:
+          'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+      },
+    })
   })
 
   test('returns an empty list when no provider is configured', async () => {
@@ -90,6 +128,72 @@ describe('GET /funding/quotes', () => {
     expect(body.error.code).toBe('upstream_error')
   })
 
+  test('logs provider quote deadlines as timeouts', async () => {
+    const entries: Log.Entry[] = []
+    const app = TestApp.create({
+      funding: {
+        adapterTimeoutMs: 1,
+        adapters: {
+          across: {
+            probeQuote() {
+              return new Promise<FundingQuotes.QuoteProbeResult>(() => {})
+            },
+          },
+        },
+      },
+      logger: (entry) => {
+        entries.push(entry)
+      },
+    })
+
+    const response = await app.request(quoteUrl({ ...baseUsdcQuery, provider: 'across' }), {
+      headers: TestApp.auth.headers,
+    })
+
+    expect(response.status).toBe(502)
+    expect(entries[0]?.provider).toEqual({
+      failure: 'timeout',
+      id: 'across',
+      operation: 'swap/approval',
+    })
+  })
+
+  test('logs every failure when multiple providers fail', async () => {
+    const entries: Log.Entry[] = []
+    const app = TestApp.create({
+      funding: {
+        adapters: {
+          across: {
+            async probeQuote() {
+              throw new TypeError('Across network failure')
+            },
+          },
+          relay: {
+            async probeQuote() {
+              throw new Error('Relay failure')
+            },
+          },
+        },
+      },
+      logger: (entry) => {
+        entries.push(entry)
+      },
+    })
+
+    const response = await app.request(quoteUrl(), { headers: TestApp.auth.headers })
+
+    expect(response.status).toBe(502)
+    expect(entries[0]?.provider).toEqual({
+      failure: 'network',
+      id: 'across',
+      operation: 'swap/approval',
+    })
+    expect(entries[0]?.providerFailures).toEqual([
+      { failure: 'network', id: 'across', operation: 'swap/approval' },
+      { failure: 'unknown', id: 'relay', operation: 'quote/v2' },
+    ])
+  })
+
   test('rejects successful provider results without output amounts', async () => {
     const app = TestApp.create({
       funding: {
@@ -126,9 +230,9 @@ describe('GET /funding/quotes', () => {
     expect(body.error.code).toBe('query_invalid')
   })
 
-  test('rejects source chains without a live quote adapter', async () => {
+  test('rejects unsupported source chains', async () => {
     const response = await TestApp.create().request(
-      quoteUrl({ ...baseUsdcQuery, sourceChain: 'solana' }),
+      quoteUrl({ ...baseUsdcQuery, sourceChain: 'bitcoin' }),
       { headers: TestApp.auth.headers },
     )
     expect(response.status).toBe(400)
@@ -151,7 +255,13 @@ describe('GET /funding/chains', () => {
     expect(response.status).toBe(200)
     const body = await TestApp.json(response, Funding.schema.listFundingChains.Response)
 
-    expect(body.data.map((chain) => chain.id)).toEqual(['eip155:1', 'eip155:8453', 'eip155:56'])
+    expect(body.data.map((chain) => chain.id)).toEqual([
+      'eip155:1',
+      'eip155:8453',
+      'eip155:56',
+      'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+      'tron:0x2b6653dc',
+    ])
     expect(body.data.flatMap((chain) => chain.tokens.map((token) => token.symbol))).toEqual(
       expect.arrayContaining(['USDC', 'USDT']),
     )
@@ -168,6 +278,13 @@ describe('GET /funding/providers', () => {
     const body = await TestApp.json(response, Funding.schema.listProviders.Response)
 
     expect(body.data).toEqual([
+      {
+        id: 'across',
+        kind: 'intentBridge',
+        name: 'Across',
+        requiresApiKey: true,
+        status: 'unconfigured',
+      },
       {
         id: 'relay',
         kind: 'solverNetwork',
@@ -175,6 +292,13 @@ describe('GET /funding/providers', () => {
         requiresApiKey: false,
         status: 'configured',
       },
+      {
+        id: 'rhino',
+        kind: 'bridge',
+        name: 'Rhino',
+        requiresApiKey: false,
+        status: 'unconfigured',
+      },
     ])
   })
 
@@ -222,3 +346,46 @@ function relayAdapter(onProbe: () => void = () => {}): FundingQuotes.ProviderAda
     },
   }
 }
+
+function acrossAdapter(onProbe: () => void = () => {}): FundingQuotes.ProviderAdapter {
+  return {
+    async probeQuote(input, signal) {
+      onProbe()
+      expect(signal.aborted).toBe(false)
+      expect(input.candidate.id).toBe('base-usdc-tempo-usdce-across')
+      return {
+        expiresAt: '2026-01-01T00:01:00Z',
+        minimumOutputAmount: '988000',
+        outputAmount: '990000',
+        outputAmountFormatted: '0.99',
+        quality: {
+          estimatedSeconds: 2,
+          liquiditySource: 'providerQuote',
+          sourceDetail: 'across:swap-approval',
+          tier: 'liquid',
+        },
+        sampledAt: '2026-01-01T00:00:00Z',
+        status: 'available',
+      }
+    },
+  }
+}
+
+function rhinoAdapter(): FundingQuotes.ProviderAdapter {
+  return {
+    async probeQuote(input, signal) {
+      expect(signal.aborted).toBe(false)
+      expect(input.candidate.id).toBe('solana-usdc-tempo-usdce-rhino')
+      return {
+        outputAmount: '983000',
+        quality: {
+          liquiditySource: 'providerQuote',
+          sourceDetail: 'rhino:bridge-swap-public',
+          tier: 'liquid',
+        },
+        sampledAt: '2026-01-01T00:00:00Z',
+        status: 'available',
+      }
+    },
+  }
+}