tapimo 0.7.0 → 0.7.2

package/src/internal/funding/providers/relay.ts

@@ -0,0 +1,559 @@
+import { Address, Hash, Hex } from 'ox'
+import * as z from 'zod/mini'
+
+import * as Db from '../../../db/Db.js'
+import * as FundingDepositAddresses from '../../../db/tables/fundingDepositAddresses.js'
+import * as FundingChain from '../Chain.js'
+import * as FundingProvider from '../Provider.js'
+import * as Subsidy from '../Subsidy.js'
+
+const defaultBaseUrl = 'https://api.relay.link'
+const defaultFetch: FundingProvider.Fetch = (input, init) => globalThis.fetch(input, init)
+const webhookSignatureToleranceSeconds = 300
+
+namespace schema {
+  const Decimal = z.union([
+    z.string().check(z.regex(/^\d+(\.\d+)?$/)),
+    z.pipe(
+      z.number().check(z.nonnegative()),
+      z.transform((value) => String(value)),
+    ),
+  ])
+
+  const Integer = z.union([
+    z.number().check(z.int(), z.nonnegative()),
+    z.pipe(
+      z.pipe(
+        z.string().check(z.regex(/^\d+$/)),
+        z.transform((value) => Number(value)),
+      ),
+      z.number().check(z.int(), z.nonnegative()),
+    ),
+  ])
+
+  export const Quote = z.object({
+    details: z.optional(
+      z.object({
+        currencyOut: z.optional(
+          z.object({
+            amount: z.optional(Decimal),
+            minimumAmount: z.optional(Decimal),
+          }),
+        ),
+        timeEstimate: z.optional(Integer),
+      }),
+    ),
+  })
+
+  const StepCall = z.object({
+    chainId: Integer,
+    data: z.string().check(z.regex(/^0x[0-9a-fA-F]*$/)),
+    from: z.string(),
+    to: z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/)),
+    value: z.optional(z.string().check(z.regex(/^\d+$/))),
+  })
+
+  const StepItem = z.object({
+    check: z.optional(z.object({ endpoint: z.string() })),
+    data: StepCall,
+  })
+
+  const Step = z.object({
+    depositAddress: z.optional(z.string()),
+    id: z.string(),
+    items: z.optional(z.array(StepItem)),
+    kind: z.string(),
+    requestId: z.optional(z.string()),
+  })
+
+  export const PreparedQuote = z.object({
+    details: z.object({
+      currencyIn: z.object({ amount: Decimal }),
+      currencyOut: z.object({ amount: Decimal, minimumAmount: Decimal }),
+      timeEstimate: z.optional(Integer),
+    }),
+    fees: z.optional(
+      z.object({
+        relayer: z.optional(z.object({ amount: Decimal })),
+      }),
+    ),
+    steps: z.array(Step),
+  })
+
+  export const DepositAddress = z.object({
+    details: PreparedQuote.shape.details,
+    fees: PreparedQuote.shape.fees,
+    steps: z.array(
+      z.object({
+        depositAddress: z.optional(z.string()),
+        items: z.optional(
+          z.array(
+            z.object({
+              check: z.optional(z.object({ endpoint: z.string() })),
+            }),
+          ),
+        ),
+        requestId: z.optional(z.string()),
+      }),
+    ),
+  })
+
+  const RequestTransaction = z.object({
+    hash: z.string().check(z.minLength(1)),
+  })
+
+  export const Requests = z.object({
+    continuation: z.optional(z.string().check(z.minLength(1))),
+    requests: z.array(
+      z.object({
+        createdAt: z.iso.datetime(),
+        data: z.optional(
+          z.object({
+            outTxs: z.optional(z.array(RequestTransaction)),
+          }),
+        ),
+        depositAddress: z.optional(
+          z.object({
+            depositTxHash: z.optional(z.string().check(z.minLength(1))),
+          }),
+        ),
+        id: z.string().check(z.minLength(1)),
+        status: z.string().check(z.minLength(1)),
+        updatedAt: z.iso.datetime(),
+      }),
+    ),
+  })
+
+  export const WebhookPayload = z.object({
+    data: z.object({
+      depositAddress: z.nullable(z.object({ address: z.string().check(z.minLength(1)) })),
+      requestId: z.optional(z.string().check(z.minLength(1))),
+    }),
+    event: z.literal('request.status.updated'),
+  })
+}
+
+/** Creates a Relay funding provider backed by `/quote/v2`. */
+export function relay(options: relay.Options = {}): FundingProvider.Provider<'relay'> {
+  if (
+    (options.userAddress !== undefined &&
+      !Address.validate(options.userAddress, { strict: false })) ||
+    (options.recipientAddress !== undefined &&
+      !Address.validate(options.recipientAddress, { strict: false }))
+  )
+    throw new FundingProvider.ProviderConfigurationError()
+
+  const endpoint = quoteEndpoint(options)
+  const fetch = options.fetch ?? defaultFetch
+  const now = options.now ?? (() => new Date())
+  const webhook = (() => {
+    if (!options.apiKey || !options.webhook) return undefined
+    const { apiKey, webhook } = options
+    const verify = (input: FundingProvider.Webhook.verify.Parameters) =>
+      verifyWebhook(webhookOptions(input, apiKey))
+    return {
+      async receive(input: FundingProvider.Webhook.receive.Parameters) {
+        const hint = (() => {
+          try {
+            return verify(input)
+          } catch (cause) {
+            webhook.onResult?.(
+              cause instanceof FundingProvider.WebhookAuthenticationError
+                ? 'authentication_failed'
+                : 'payload_invalid',
+            )
+            throw cause
+          }
+        })()
+        if (!hint.address) {
+          webhook.onResult?.('ignored')
+          return { type: 'ignored' as const }
+        }
+        const address = await FundingDepositAddresses.getByProviderAddress(Db.get(webhook.db), {
+          address: hint.address,
+          providerId: 'relay',
+        })
+        if (!address) {
+          webhook.onResult?.('unknown_address')
+          return { type: 'unknown_address' as const }
+        }
+        try {
+          await webhook.dispatch({
+            addressId: address.id,
+            ...(hint.requestId ? { requestId: hint.requestId } : {}),
+            type: 'funding:deposit-address:reconcile',
+          })
+        } catch (cause) {
+          webhook.onResult?.('enqueue_failed')
+          throw cause
+        }
+        webhook.onResult?.('queued')
+        return { addressId: address.id, type: 'queued' as const }
+      },
+      verify,
+    }
+  })()
+
+  return FundingProvider.from({
+    id: 'relay',
+    name: 'Relay',
+    ...(webhook ? { webhook } : {}),
+    async createDepositAddress({ amount, candidate, recipient, refundAddress, subsidize }, signal) {
+      if (
+        subsidize &&
+        (!options.subsidies ||
+          !Subsidy.supports(options.subsidies, {
+            amount,
+            destinationToken: candidate.destinationToken,
+            sourceToken: candidate.sourceToken,
+          }))
+      )
+        throw new FundingProvider.ProviderUnavailableError()
+      const quote = await (async () => {
+        try {
+          return await FundingProvider.requestJson(endpoint, {
+            body: {
+              amount,
+              destinationChainId: relayChainId(candidate.route.destination.chain),
+              destinationCurrency: candidate.destinationToken.address,
+              originChainId: relayChainId(candidate.route.source.chain),
+              originCurrency: candidate.sourceToken.address,
+              recipient,
+              refundTo: refundAddress,
+              subsidizeFees: subsidize,
+              tradeType: 'EXACT_INPUT',
+              useDepositAddress: true,
+              user: refundAddress,
+            },
+            fetch,
+            headers: options.apiKey ? { 'x-api-key': options.apiKey } : undefined,
+            method: 'POST',
+            signal,
+          })
+        } catch (cause) {
+          if (FundingProvider.unavailable(cause, ['NO_QUOTES', 'NO_ROUTE', 'UNSUPPORTED_ROUTE']))
+            throw new FundingProvider.ProviderUnavailableError()
+          throw cause
+        }
+      })()
+      const parsed = schema.DepositAddress.safeParse(quote)
+      if (!parsed.success) throw new FundingProvider.ProviderPayloadError()
+      if (parsed.data.details.currencyIn.amount !== amount)
+        throw new FundingProvider.ProviderPayloadError()
+      const step = parsed.data.steps.find(
+        (candidate) => candidate.depositAddress && candidate.requestId,
+      )
+      if (!step?.depositAddress || !step.requestId) throw new FundingProvider.ProviderPayloadError()
+      const checkEndpoint = step.items?.find((item) => item.check)?.check?.endpoint
+      const providerFee = parsed.data.fees?.relayer?.amount
+      return {
+        address: step.depositAddress,
+        correlation: {
+          ...(checkEndpoint ? { checkEndpoint } : {}),
+          requestId: step.requestId,
+        },
+        destinationAmount: parsed.data.details.currencyOut.amount,
+        destinationAmountMin: parsed.data.details.currencyOut.minimumAmount,
+        fees:
+          providerFee && BigInt(providerFee) > 0n ? [{ amount: providerFee, side: 'source' }] : [],
+        sampledAt: now().toISOString(),
+      }
+    },
+    async getQuote({ candidate, route }, signal) {
+      if (options.userAddress === undefined)
+        return FundingProvider.unavailableResult({
+          detail: 'relay:quote-v2',
+          message: 'QUOTE_USER_NOT_CONFIGURED',
+          now: now(),
+          source: 'providerQuote',
+        })
+      const destinationChainId = relayChainId(route.destination.chain)
+      const sourceChainId = relayChainId(route.source.chain)
+      try {
+        const quote = await FundingProvider.requestJson(endpoint, {
+          body: {
+            amount: candidate.sourceAmount.amount,
+            destinationChainId,
+            destinationCurrency: candidate.destinationToken.address,
+            originChainId: sourceChainId,
+            originCurrency: candidate.sourceToken.address,
+            recipient: options.recipientAddress ?? options.userAddress,
+            tradeType: 'EXACT_INPUT',
+            user: options.userAddress,
+          },
+          fetch,
+          headers: options.apiKey ? { 'x-api-key': options.apiKey } : undefined,
+          method: 'POST',
+          signal,
+        })
+        const parsed = schema.Quote.safeParse(quote)
+        if (!parsed.success) throw new FundingProvider.ProviderPayloadError()
+        const destinationAmount = parsed.data.details?.currencyOut?.amount
+        const status = destinationAmount
+          ? { status: 'available' as const, tier: 'liquid' as const }
+          : { status: 'unknown' as const, tier: 'unknown' as const }
+
+        return {
+          destinationAmountMin: parsed.data.details?.currencyOut?.minimumAmount,
+          destinationAmount,
+          quality: {
+            estimatedSeconds: parsed.data.details?.timeEstimate,
+            liquiditySource: 'providerQuote',
+            sourceDetail: 'relay:quote-v2',
+            tier: status.tier,
+          },
+          sampledAt: now().toISOString(),
+          status: status.status,
+        }
+      } catch (cause) {
+        const unavailable = FundingProvider.unavailable(cause, [
+          'NO_QUOTES',
+          'NO_ROUTE',
+          'UNSUPPORTED_ROUTE',
+        ])
+        if (!unavailable) throw cause
+        return FundingProvider.unavailableResult({
+          detail: 'relay:quote-v2',
+          message: unavailable,
+          now: now(),
+          source: 'providerQuote',
+        })
+      }
+    },
+    async listDepositAddressRequests({ address, continuation, requestId }, signal) {
+      const requestUrl = requestsEndpoint(options)
+      if (requestId) requestUrl.searchParams.set('id', requestId)
+      else {
+        requestUrl.searchParams.set('depositAddress', address)
+        requestUrl.searchParams.set('includeChildRequests', 'true')
+      }
+      requestUrl.searchParams.set('limit', '50')
+      requestUrl.searchParams.set('sortBy', 'updatedAt')
+      requestUrl.searchParams.set('sortDirection', 'desc')
+      if (continuation) requestUrl.searchParams.set('continuation', continuation)
+      const response = await FundingProvider.requestJson(requestUrl, {
+        fetch,
+        headers: options.apiKey ? { 'x-api-key': options.apiKey } : undefined,
+        method: 'GET',
+        signal,
+      })
+      const parsed = schema.Requests.safeParse(response)
+      if (!parsed.success) throw new FundingProvider.ProviderPayloadError()
+      return {
+        ...(parsed.data.continuation ? { continuation: parsed.data.continuation } : {}),
+        requests: parsed.data.requests.map((request) => ({
+          createdAt: new Date(request.createdAt).toISOString(),
+          destinationTransactionHashes: request.data?.outTxs?.map((tx) => tx.hash) ?? [],
+          id: request.id,
+          sourceTransactionHashes: request.depositAddress?.depositTxHash
+            ? [request.depositAddress.depositTxHash]
+            : [],
+          status: request.status,
+          updatedAt: new Date(request.updatedAt).toISOString(),
+        })),
+      }
+    },
+    async prepareTransfer({ candidate, method, mode, recipient, sender, slippageBps }, signal) {
+      // Catalog capabilities gate deposit addresses and exact destination
+      // off this adapter; refuse them defensively if one slips through.
+      if (method !== 'transaction' || mode !== 'exactSource')
+        throw new FundingProvider.ProviderConfigurationError()
+      const quote = await (async () => {
+        try {
+          return await FundingProvider.requestJson(endpoint, {
+            body: {
+              amount: candidate.sourceAmount.amount,
+              destinationChainId: Number(FundingChain.eip155Id(candidate.route.destination.chain)),
+              destinationCurrency: candidate.destinationToken.address,
+              originChainId: Number(FundingChain.eip155Id(candidate.route.source.chain)),
+              originCurrency: candidate.sourceToken.address,
+              recipient,
+              ...(slippageBps !== undefined ? { slippageTolerance: String(slippageBps) } : {}),
+              tradeType: 'EXACT_INPUT',
+              user: sender,
+            },
+            fetch,
+            headers: options.apiKey ? { 'x-api-key': options.apiKey } : undefined,
+            method: 'POST',
+            signal,
+          })
+        } catch (cause) {
+          if (FundingProvider.unavailable(cause, ['NO_QUOTES', 'NO_ROUTE', 'UNSUPPORTED_ROUTE']))
+            throw new FundingProvider.ProviderUnavailableError()
+          throw cause
+        }
+      })()
+      const parsed = schema.PreparedQuote.safeParse(quote)
+      if (!parsed.success) throw new FundingProvider.ProviderPayloadError()
+      const { details, fees, steps } = parsed.data
+      // The quoted input must match the request exactly; a drifted amount
+      // would desynchronize the stored terms from the prepared calls.
+      if (details.currencyIn.amount !== candidate.sourceAmount.amount)
+        throw new FundingProvider.ProviderPayloadError()
+
+      const items = steps
+        .filter((step) => step.kind === 'transaction')
+        .flatMap((step) => step.items ?? [])
+      const requestId = steps.find((step) => step.requestId)?.requestId
+      if (items.length === 0 || !requestId) throw new FundingProvider.ProviderPayloadError()
+      const sourceChainId = Number(FundingChain.eip155Id(candidate.route.source.chain))
+      for (const item of items)
+        if (
+          item.data.chainId !== sourceChainId ||
+          item.data.from.toLowerCase() !== sender.toLowerCase()
+        )
+          throw new FundingProvider.ProviderPayloadError()
+
+      const checkEndpoint = items.find((item) => item.check)?.check?.endpoint
+      // Relay's `relayer` fee is the solver's total source-side charge (gas
+      // plus service); it surfaces as the transfer's provider fee.
+      const providerFee = fees?.relayer?.amount
+      return {
+        action: {
+          calls: items.map((item) => ({
+            data: item.data.data,
+            to: item.data.to,
+            value: Hex.fromNumber(BigInt(item.data.value ?? '0')),
+          })),
+          type: 'evm:calls',
+        },
+        correlation: { ...(checkEndpoint ? { checkEndpoint } : {}), requestId },
+        fees:
+          providerFee && BigInt(providerFee) > 0n ? [{ amount: providerFee, side: 'source' }] : [],
+        destinationAmountMin: details.currencyOut.minimumAmount,
+        destinationAmount: details.currencyOut.amount,
+        quality: {
+          ...(details.timeEstimate !== undefined ? { estimatedSeconds: details.timeEstimate } : {}),
+          liquiditySource: 'providerQuote',
+          sourceDetail: 'relay:quote-v2',
+          tier: 'liquid',
+        },
+        sampledAt: now().toISOString(),
+      }
+    },
+  })
+}
+
+export declare namespace relay {
+  /** Relay provider options. */
+  type Options = {
+    /** Optional Relay API key for higher rate limits. */
+    apiKey?: string | undefined
+    /** Override for tests or Relay test environments. */
+    baseUrl?: string | undefined
+    /** Fetch implementation override for tests. */
+    fetch?: FundingProvider.Fetch | undefined
+    /** Clock override for deterministic tests. */
+    now?: (() => Date) | undefined
+    /** Optional recipient override; defaults to `userAddress`. */
+    recipientAddress?: string | undefined
+    /** Deposit subsidy policy enabled for this integration. */
+    subsidies?: Subsidy.Policy | undefined
+    /** Optional wallet address for indicative quotes. */
+    userAddress?: string | undefined
+    /** Tempo infrastructure used to receive authenticated Relay webhooks. */
+    webhook?: Webhook | undefined
+  }
+
+  /** Authenticated Relay webhook integration attached to a provider instance. */
+  type Webhook = {
+    /** Authoritative funding database or per-request database factory. */
+    db: Db.Source
+    /** Enqueues one bounded reconciliation hint. */
+    dispatch: (message: FundingProvider.Webhook.receive.Dispatchable) => Promise<void>
+    /** Observes one bounded webhook disposition. */
+    onResult?: ((result: WebhookResult) => void) | undefined
+  }
+
+  /** Bounded operational result emitted while receiving a Relay webhook. */
+  type WebhookResult =
+    | 'authentication_failed'
+    | 'enqueue_failed'
+    | 'ignored'
+    | 'payload_invalid'
+    | 'queued'
+    | 'unknown_address'
+}
+
+type VerifyWebhookOptions = {
+  body: string
+  secret: string
+  signature: string
+  timestamp: string
+}
+
+function verifyWebhook(options: VerifyWebhookOptions): FundingProvider.Webhook.verify.ReturnType {
+  const timestamp = Number(options.timestamp)
+  if (!Number.isSafeInteger(timestamp)) throw new WebhookSignatureError()
+  const now = Math.floor(Date.now() / 1_000)
+  if (Math.abs(now - timestamp) > webhookSignatureToleranceSeconds)
+    throw new WebhookSignatureError()
+  if (!/^[0-9a-fA-F]{64}$/.test(options.signature)) throw new WebhookSignatureError()
+  const expected = Hash.hmac256(
+    Hex.fromString(options.secret),
+    Hex.fromString(`${options.timestamp}.${options.body}`),
+  ).slice(2)
+  if (!timingSafeEqual(expected, options.signature)) throw new WebhookSignatureError()
+
+  const payload = (() => {
+    try {
+      return JSON.parse(options.body) as unknown
+    } catch {
+      throw new WebhookPayloadError()
+    }
+  })()
+  const parsed = schema.WebhookPayload.safeParse(payload)
+  if (!parsed.success) throw new WebhookPayloadError()
+  return {
+    address: parsed.data.data.depositAddress?.address,
+    requestId: parsed.data.data.requestId,
+  }
+}
+
+function webhookOptions(
+  input: FundingProvider.Webhook.verify.Parameters,
+  secret: string,
+): VerifyWebhookOptions {
+  const signature = input.headers.get('x-signature-sha256')
+  const timestamp = input.headers.get('x-signature-timestamp')
+  if (!signature || !timestamp) throw new WebhookSignatureError()
+  return { body: input.body, secret, signature, timestamp }
+}
+
+function quoteEndpoint(options: relay.Options): URL {
+  const endpoint = new URL(options.baseUrl ?? defaultBaseUrl)
+  endpoint.pathname = `${endpoint.pathname.replace(/\/+$/, '')}/quote/v2`
+  return endpoint
+}
+
+function requestsEndpoint(options: relay.Options): URL {
+  const endpoint = new URL(options.baseUrl ?? defaultBaseUrl)
+  endpoint.pathname = `${endpoint.pathname.replace(/\/+$/, '')}/requests/v2`
+  return endpoint
+}
+
+function timingSafeEqual(left: string, right: string): boolean {
+  if (left.length !== right.length) return false
+  let mismatch = 0
+  for (let index = 0; index < left.length; index++)
+    mismatch |= left.charCodeAt(index) ^ right.charCodeAt(index)
+  return mismatch === 0
+}
+
+function relayChainId(chain: FundingProvider.Chain): number {
+  if (chain.id.startsWith('eip155:')) return Number(FundingChain.eip155Id(chain))
+  // Relay uses a numeric chain ID for Solana instead of its CAIP-2 reference.
+  if (chain.id === 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp') return 792_703_809
+  if (chain.id.startsWith('tron:')) return Number(chain.id.slice('tron:'.length))
+  throw new FundingProvider.ProviderConfigurationError()
+}
+
+/** Relay webhook signature is missing, stale, or invalid. */
+export class WebhookSignatureError extends FundingProvider.WebhookAuthenticationError {
+  override name = 'Funding.Provider.Relay.WebhookSignatureError'
+}
+
+/** Relay webhook body does not match the expected status event shape. */
+export class WebhookPayloadError extends FundingProvider.WebhookPayloadError {
+  override name = 'Funding.Provider.Relay.WebhookPayloadError'
+}

package/src/internal/funding/providers/rhino.ts

@@ -0,0 +1,139 @@
+import { Value as core_Value } from 'ox'
+import * as z from 'zod/mini'
+
+import type * as FundingChain from '../Chain.js'
+import type * as FundingToken from '../Token.js'
+import * as FundingProvider from '../Provider.js'
+
+const defaultBaseUrl = 'https://api.rhino.fi/bridge'
+const defaultFetch: FundingProvider.Fetch = (input, init) => globalThis.fetch(input, init)
+
+const chainIds = {
+  'eip155:4217': 'TEMPO',
+  'eip155:8453': 'BASE',
+  'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': 'SOLANA',
+  'tron:0x2b6653dc': 'TRON',
+} as const satisfies Record<string, string>
+
+const tokenIds = {
+  usdce: 'USDC',
+  usdt0: 'USDT',
+} as const satisfies Record<string, string>
+
+namespace schema {
+  export const Quote = 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 a Rhino funding provider backed by its public bridge-and-swap quote endpoint. */
+export function rhino(options: rhino.Options = {}) {
+  const endpoint = new URL(options.baseUrl ?? defaultBaseUrl)
+  endpoint.pathname = `${endpoint.pathname.replace(/\/+$/, '')}/quote/bridge-swap/public`
+  const fetch = options.fetch ?? defaultFetch
+  const now = options.now ?? (() => new Date())
+
+  return FundingProvider.from({
+    id: 'rhino',
+    name: 'Rhino',
+    async getQuote({ cache, candidate, route }, signal) {
+      const chainIn = chainId(route.source.chain)
+      const chainOut = chainId(route.destination.chain)
+      const tokenOut = tokenId(route.destination)
+      const url = new URL(endpoint)
+      url.search = new URLSearchParams({
+        amount: candidate.sourceAmount.formatted,
+        amountNative: '0',
+        chainIn,
+        chainOut,
+        mode: 'pay',
+        tokenIn: candidate.sourceToken.symbol,
+        tokenOut,
+      }).toString()
+
+      try {
+        const quote = await FundingProvider.requestJson(url, {
+          fetch,
+          headers: cache.bypass ? { 'cache-control': 'no-cache' } : undefined,
+          signal,
+        })
+        const parsed = schema.Quote.safeParse(quote)
+        if (!parsed.success) throw new FundingProvider.ProviderPayloadError()
+        const response = parsed.data
+        const inputAmount = parseAmount(response.payAmount, candidate.sourceToken.decimals)
+        const destinationAmount = parseAmount(
+          response.receiveAmount,
+          candidate.destinationToken.decimals,
+        )
+        if (
+          response.chainIn !== chainIn ||
+          response.chainOut !== chainOut ||
+          response.token !== tokenOut ||
+          inputAmount !== candidate.sourceAmount.amount ||
+          destinationAmount === undefined ||
+          BigInt(destinationAmount) <= 0n
+        )
+          throw new FundingProvider.ProviderPayloadError()
+
+        return {
+          destinationAmount,
+          quality: {
+            ...(response.estimatedDuration === undefined || response.estimatedDuration === null
+              ? {}
+              : { estimatedSeconds: Math.ceil(response.estimatedDuration / 1_000) }),
+            liquiditySource: 'providerQuote',
+            sourceDetail: 'rhino:bridge-swap-public',
+            tier: 'liquid',
+          },
+          sampledAt: now().toISOString(),
+          status: 'available',
+        }
+      } catch (cause) {
+        const unavailable = FundingProvider.unavailable(cause, ['NoRouteFoundError'])
+        if (!unavailable) throw cause
+        return FundingProvider.unavailableResult({
+          detail: 'rhino:bridge-swap-public',
+          message: unavailable,
+          now: now(),
+          source: 'providerQuote',
+        })
+      }
+    },
+  })
+}
+
+export declare namespace rhino {
+  /** Rhino provider options. */
+  type Options = {
+    /** Override for tests or Rhino test environments. */
+    baseUrl?: string | undefined
+    /** Fetch implementation override for tests. */
+    fetch?: FundingProvider.Fetch | undefined
+    /** Clock override for deterministic tests. */
+    now?: (() => Date) | undefined
+  }
+}
+
+function parseAmount(value: string, decimals: number) {
+  const fraction = value.split('.')[1]?.replace(/0+$/, '') ?? ''
+  if (fraction.length > decimals) return undefined
+  return core_Value.from(value, decimals).toString()
+}
+
+function chainId(chain: FundingChain.Chain) {
+  const id = chainIds[chain.id as keyof typeof chainIds]
+  if (!id) throw new FundingProvider.ProviderConfigurationError()
+  return id
+}
+
+function tokenId(token: FundingToken.Resolved) {
+  const id = tokenIds[token.slug as keyof typeof tokenIds]
+  if (!id) throw new FundingProvider.ProviderConfigurationError()
+  return id
+}