tapimo 0.7.0 → 0.7.2

package/src/internal/exchange/providers/uniswap.ts

@@ -0,0 +1,682 @@
+import { Base64, Hash, Hex } from 'ox'
+import { decodeAbiParameters, decodeFunctionData, parseAbi, parseAbiParameters } from 'viem'
+import * as z from 'zod/mini'
+
+import * as Provider from '../Provider.js'
+
+const defaultBaseUrl = 'https://trade-api.gateway.uniswap.org/v1'
+const tempoMainnetChainId = 4217
+const permit2 = '0x000000000022d473030f116ddee9f6b43ac78ba3'
+const universalRouter = '0x1febb76be10aaf3a1402f04e8e835f2c382f7914'
+const universalRouterVersion = '2.0'
+const continuationTtl = 30
+const approveAbi = parseAbi(['function approve(address spender, uint256 amount) returns (bool)'])
+const universalRouterAbi = parseAbi([
+  'function execute(bytes commands, bytes[] inputs)',
+  'function execute(bytes commands, bytes[] inputs, uint256 deadline)',
+])
+const bytesAndInputs = parseAbiParameters('bytes, bytes[]')
+const allowedRouterCommands = new Set([0x00, 0x01, 0x02, 0x04, 0x05, 0x08, 0x09, 0x0a, 0x0e])
+const allowedV4Actions = new Set([0x06, 0x07, 0x08, 0x09, 0x0b, 0x0c, 0x0e, 0x0f])
+const executeSubPlan = 0x21
+const v4Swap = 0x10
+const maximumSubPlanDepth = 8
+const maxUint48 = 2n ** 48n - 1n
+const maxUint160 = 2n ** 160n - 1n
+const maxUint256 = 2n ** 256n - 1n
+
+const schema = {
+  Address: z.templateLiteral(['0x', z.string()]).check(z.regex(/^0x[\da-fA-F]{40}$/)),
+  Amount: z.string().check(z.regex(/^\d+$/)),
+  Hex: z.templateLiteral(['0x', z.string()]).check(z.regex(/^0x[\da-fA-F]+$/)),
+  Quantity: z.union([
+    z.string().check(z.regex(/^\d+$/)),
+    z.templateLiteral(['0x', z.string()]).check(z.regex(/^0x[\da-fA-F]+$/)),
+  ]),
+  Uint48: uint(maxUint48),
+  Uint160: uint(maxUint160),
+  Uint256: uint(maxUint256),
+}
+
+const Transaction = z.object({
+  chainId: z.number().check(z.int(), z.positive()),
+  data: schema.Hex,
+  from: schema.Address,
+  gasLimit: z.optional(schema.Amount),
+  to: schema.Address,
+  value: schema.Quantity,
+})
+
+const PermitDetailsTypes = z.tuple([
+  z.strictObject({ name: z.literal('token'), type: z.literal('address') }),
+  z.strictObject({ name: z.literal('amount'), type: z.literal('uint160') }),
+  z.strictObject({ name: z.literal('expiration'), type: z.literal('uint48') }),
+  z.strictObject({ name: z.literal('nonce'), type: z.literal('uint48') }),
+])
+
+const PermitSingleTypes = z.tuple([
+  z.strictObject({ name: z.literal('details'), type: z.literal('PermitDetails') }),
+  z.strictObject({ name: z.literal('spender'), type: z.literal('address') }),
+  z.strictObject({ name: z.literal('sigDeadline'), type: z.literal('uint256') }),
+])
+
+const Permit = z.strictObject({
+  domain: z.strictObject({
+    chainId: z.number().check(z.int(), z.positive()),
+    name: z.literal('Permit2'),
+    verifyingContract: schema.Address,
+  }),
+  types: z.strictObject({
+    PermitDetails: PermitDetailsTypes,
+    PermitSingle: PermitSingleTypes,
+  }),
+  values: z.strictObject({
+    details: z.strictObject({
+      amount: schema.Uint160,
+      expiration: schema.Uint48,
+      nonce: schema.Uint48,
+      token: schema.Address,
+    }),
+    sigDeadline: schema.Uint256,
+    spender: schema.Address,
+  }),
+})
+
+const ClassicQuote = z.looseObject({
+  chainId: z.number().check(z.int(), z.positive()),
+  gasUseEstimate: schema.Amount,
+  input: z.object({
+    amount: schema.Amount,
+    maximumAmount: z.optional(schema.Amount),
+    token: schema.Address,
+  }),
+  output: z.object({
+    amount: schema.Amount,
+    minimumAmount: z.optional(schema.Amount),
+    recipient: schema.Address,
+    token: schema.Address,
+  }),
+  priceImpact: z.optional(z.number().check(z.nonnegative())),
+  swapper: schema.Address,
+  tradeType: z.enum(['EXACT_INPUT', 'EXACT_OUTPUT']),
+})
+
+const QuoteResponse = z.object({
+  permitData: z.nullable(Permit),
+  quote: ClassicQuote,
+  routing: z.literal('CLASSIC'),
+})
+
+const ApprovalResponse = z.object({
+  approval: z.nullable(Transaction),
+  cancel: z.nullable(Transaction),
+})
+
+const SwapResponse = z.object({ swap: Transaction })
+
+const Continuation = z.object({
+  account: schema.Address,
+  chainId: z.number().check(z.int(), z.positive()),
+  expiresAt: z.number().check(z.int(), z.positive()),
+  permitData: Permit,
+  quote: ClassicQuote,
+})
+
+/** Creates a Uniswap Trading API provider restricted to executable AMM routes. */
+export function uniswap(options: uniswap.Options) {
+  if (!options.apiKey.trim()) throw new Provider.ProviderConfigurationError()
+
+  return Provider.from({
+    id: 'uniswap',
+    async finalizeQuote(input, signal) {
+      if (input.chainId !== tempoMainnetChainId) throw new Provider.RouteUnavailableError()
+      const continuation = decodeContinuation(input.continuation, {
+        account: input.account,
+        chainId: input.chainId,
+        secret: options.apiKey,
+      })
+      const response = await requestJson(new URL(`${defaultBaseUrl}/swap`), {
+        apiKey: options.apiKey,
+        body: {
+          permitData: continuation.permitData,
+          quote: continuation.quote,
+          refreshGasPrice: true,
+          signature: input.signature,
+        },
+        operation: 'swap',
+        signal,
+      })
+      const parsed = SwapResponse.safeParse(response)
+      if (!parsed.success)
+        throw new Provider.ProviderPayloadError({
+          code: Error.getCode({ path: parsed.error.issues[0]?.path, prefix: 'swap.response' }),
+        })
+      Error.boundary({
+        code: 'swap.transaction',
+        fn: () =>
+          assertSwapTransaction(parsed.data.swap, {
+            account: input.account,
+            chainId: input.chainId,
+          }),
+      })
+      return {
+        calls: [call(parsed.data.swap)],
+        execution: execution(continuation.quote),
+      }
+    },
+    async quote(input, signal) {
+      if (input.chainId !== tempoMainnetChainId) throw new Provider.RouteUnavailableError()
+      const response = await requestJson(new URL(`${defaultBaseUrl}/quote`), {
+        apiKey: options.apiKey,
+        body: {
+          amount: input.amount,
+          permitAmount: 'EXACT',
+          protocols: ['V2', 'V3', 'V4'],
+          slippageTolerance: input.slippageBps / 100,
+          swapper: input.account,
+          tokenIn: input.sourceToken,
+          tokenInChainId: input.chainId,
+          tokenOut: input.destinationToken,
+          tokenOutChainId: input.chainId,
+          type: input.mode === 'exactSource' ? 'EXACT_INPUT' : 'EXACT_OUTPUT',
+        },
+        operation: 'quote',
+        signal,
+      })
+      const parsed = QuoteResponse.safeParse(response)
+      if (!parsed.success)
+        throw new Provider.ProviderPayloadError({
+          code: Error.getCode({ path: parsed.error.issues[0]?.path, prefix: 'quote.response' }),
+        })
+      const quote = parsed.data.quote
+      Error.boundary({ code: 'quote.invariants', fn: () => assertQuote(quote, input) })
+      const approvalAmount =
+        input.mode === 'exactSource' ? quote.input.amount : quote.input.maximumAmount!
+      const approvalResponse = await requestJson(new URL(`${defaultBaseUrl}/check_approval`), {
+        apiKey: options.apiKey,
+        body: {
+          amount: approvalAmount,
+          chainId: input.chainId,
+          // Tempo estimates returned approval calls locally, so upstream gas-fee estimation is unnecessary.
+          includeGasInfo: false,
+          token: input.sourceToken,
+          walletAddress: input.account,
+        },
+        operation: 'check_approval',
+        signal,
+      })
+      const approval = validateApprovalResponse(approvalResponse)
+      const calls = [
+        ...(approval.cancel
+          ? [
+              Error.boundary({
+                code: 'check_approval.cancel',
+                fn: () =>
+                  approvalCall(approval.cancel!, {
+                    account: input.account,
+                    amount: { exact: 0n },
+                    chainId: input.chainId,
+                    token: input.sourceToken,
+                  }),
+              }),
+            ]
+          : []),
+        ...(approval.approval
+          ? [
+              Error.boundary({
+                code: 'check_approval.approval',
+                fn: () =>
+                  approvalCall(approval.approval!, {
+                    account: input.account,
+                    amount: { minimum: BigInt(approvalAmount) },
+                    chainId: input.chainId,
+                    token: input.sourceToken,
+                  }),
+              }),
+            ]
+          : []),
+      ]
+
+      const result = {
+        destinationAmount: quote.output.amount,
+        ...(quote.output.minimumAmount
+          ? { minimumDestinationAmount: quote.output.minimumAmount }
+          : {}),
+        ...(quote.input.maximumAmount ? { maximumSourceAmount: quote.input.maximumAmount } : {}),
+        sourceAmount: quote.input.amount,
+      } as const
+
+      if (calls.length > 0)
+        return {
+          ...result,
+          approval: { calls },
+          gasUnits: callsGas(approval),
+          status: 'approvalRequired',
+        }
+
+      const permitData = parsed.data.permitData
+      if (permitData)
+        Error.boundary({
+          code: 'quote.permit',
+          fn: () =>
+            assertPermit(permitData, {
+              input,
+              requiredAmount: BigInt(approvalAmount),
+            }),
+        })
+
+      if (permitData)
+        return {
+          ...result,
+          continuation: encodeContinuation(
+            {
+              account: input.account,
+              chainId: input.chainId,
+              expiresAt: continuationExpiry(permitData),
+              permitData,
+              quote,
+            },
+            { secret: options.apiKey },
+          ),
+          gasUnits: quote.gasUseEstimate,
+          status: 'signatureRequired',
+          typedData: typedData(permitData),
+        }
+
+      const swapResponse = await requestJson(new URL(`${defaultBaseUrl}/swap`), {
+        apiKey: options.apiKey,
+        body: { quote, refreshGasPrice: true },
+        operation: 'swap',
+        signal,
+      })
+      const swap = SwapResponse.safeParse(swapResponse)
+      if (!swap.success)
+        throw new Provider.ProviderPayloadError({
+          code: Error.getCode({ path: swap.error.issues[0]?.path, prefix: 'swap.response' }),
+        })
+      Error.boundary({
+        code: 'swap.transaction',
+        fn: () =>
+          assertSwapTransaction(swap.data.swap, {
+            account: input.account,
+            chainId: input.chainId,
+          }),
+      })
+      return {
+        ...result,
+        gasUnits: quote.gasUseEstimate,
+        status: 'ready',
+        transaction: { calls: [call(swap.data.swap)] },
+      }
+    },
+    name: 'Uniswap',
+  })
+}
+
+export declare namespace uniswap {
+  /** Uniswap Trading API provider options. */
+  type Options = {
+    /** Uniswap Trading API key. */
+    apiKey: string
+  }
+}
+
+/** Validates a Uniswap approval response before its calls are returned to a wallet. */
+export function validateApprovalResponse(response: unknown) {
+  const parsed = ApprovalResponse.safeParse(response)
+  if (!parsed.success)
+    throw new Provider.ProviderPayloadError({
+      code: Error.getCode({
+        path: parsed.error.issues[0]?.path,
+        prefix: 'check_approval.response',
+      }),
+    })
+  return parsed.data
+}
+
+namespace Error {
+  export function boundary<const result>(options: boundary.Options<result>): result {
+    try {
+      return options.fn()
+    } catch (cause) {
+      if (cause instanceof Provider.ProviderPayloadError && !cause.code)
+        throw new Provider.ProviderPayloadError({ code: options.code })
+      throw cause
+    }
+  }
+
+  export declare namespace boundary {
+    /** Bounded validation context for one provider payload boundary. */
+    type Options<result> = {
+      /** Stable validation code safe for operational reporting. */
+      code: string
+      /** Provider payload validation to execute. */
+      fn: () => result
+    }
+  }
+
+  export function getCode(options: getCode.Options) {
+    if (!options.path || options.path.length === 0) return options.prefix
+    return `${options.prefix}.${options.path.map((part) => (typeof part === 'number' ? '*' : String(part))).join('.')}`
+  }
+
+  export declare namespace getCode {
+    /** Schema issue context used to build a bounded validation code. */
+    type Options = {
+      /** First invalid schema path, when Zod returned one. */
+      path: readonly PropertyKey[] | undefined
+      /** Stable provider operation and response prefix. */
+      prefix: string
+    }
+  }
+}
+
+function uint(maximum: bigint) {
+  return z.string().check(
+    z.regex(/^\d+$/),
+    z.refine((value) => BigInt(value) <= maximum),
+  )
+}
+
+/** Provider-neutral EIP-712 payload accepted by Privy and common wallet clients. */
+type TypedData = {
+  /** EIP-712 signing domain. */
+  domain: z.output<typeof Permit>['domain']
+  /** Permit message values. */
+  message: z.output<typeof Permit>['values']
+  /** Root EIP-712 type. */
+  primaryType: 'PermitSingle'
+  /** EIP-712 type definitions. */
+  types: z.output<typeof Permit>['types']
+}
+
+function assertQuote(quote: z.output<typeof ClassicQuote>, input: Provider.QuoteInput) {
+  const denominator = 10_000n
+  const maximum = quote.input.maximumAmount ? BigInt(quote.input.maximumAmount) : undefined
+  const slippage = BigInt(input.slippageBps)
+  const source = BigInt(quote.input.amount)
+  if (input.mode === 'exactSource') {
+    validateExactSourceMaximum({ amount: input.amount, maximumAmount: quote.input.maximumAmount })
+    validateExactSourceMinimum({
+      amount: quote.output.amount,
+      minimumAmount: quote.output.minimumAmount,
+      slippageBps: input.slippageBps,
+    })
+  }
+  if (
+    quote.chainId !== input.chainId ||
+    quote.input.token.toLowerCase() !== input.sourceToken.toLowerCase() ||
+    quote.output.token.toLowerCase() !== input.destinationToken.toLowerCase() ||
+    quote.output.recipient.toLowerCase() !== input.account.toLowerCase() ||
+    quote.swapper.toLowerCase() !== input.account.toLowerCase() ||
+    quote.tradeType !== (input.mode === 'exactSource' ? 'EXACT_INPUT' : 'EXACT_OUTPUT') ||
+    (input.mode === 'exactSource' && quote.input.amount !== input.amount) ||
+    (input.mode === 'exactDestination' &&
+      (quote.output.amount !== input.amount ||
+        maximum === undefined ||
+        maximum < source ||
+        maximum > (source * (denominator + slippage) + denominator - 1n) / denominator))
+  )
+    throw new Provider.ProviderPayloadError()
+}
+
+/** Accepts exact-source minimums that preserve the requested slippage after integer rounding. */
+export function validateExactSourceMinimum(options: validateExactSourceMinimum.Options): void {
+  if (!options.minimumAmount) throw new Provider.ProviderPayloadError()
+  const amount = BigInt(options.amount)
+  const denominator = 10_000n
+  const minimumAmount = BigInt(options.minimumAmount)
+  const slippage = BigInt(options.slippageBps)
+  if (minimumAmount < (amount * (denominator - slippage)) / denominator || minimumAmount > amount)
+    throw new Provider.ProviderPayloadError()
+}
+
+export declare namespace validateExactSourceMinimum {
+  /** Upstream destination amounts and requested slippage to compare. */
+  type Options = {
+    /** Quoted destination amount in base units. */
+    amount: string
+    /** Minimum destination amount in base units. */
+    minimumAmount?: string | undefined
+    /** Requested slippage in basis points. */
+    slippageBps: number
+  }
+}
+
+/** Rejects exact-source quotes that expand the wallet authorization amount. */
+export function validateExactSourceMaximum(options: validateExactSourceMaximum.Options): void {
+  if (options.maximumAmount !== undefined && options.maximumAmount !== options.amount)
+    throw new Provider.ProviderPayloadError()
+}
+
+export declare namespace validateExactSourceMaximum {
+  /** Requested and upstream source bounds to compare. */
+  type Options = {
+    /** Exact source amount requested by the caller. */
+    amount: string
+    /** Optional maximum source amount returned upstream. */
+    maximumAmount?: string | undefined
+  }
+}
+
+function execution(quote: z.output<typeof ClassicQuote>): Provider.Execution {
+  return {
+    destinationAmount: quote.output.amount,
+    destinationToken: quote.output.token,
+    gasUnits: quote.gasUseEstimate,
+    ...(quote.input.maximumAmount ? { maximumSourceAmount: quote.input.maximumAmount } : {}),
+    ...(quote.output.minimumAmount ? { minimumDestinationAmount: quote.output.minimumAmount } : {}),
+    mode: quote.tradeType === 'EXACT_INPUT' ? 'exactSource' : 'exactDestination',
+    sourceAmount: quote.input.amount,
+    sourceToken: quote.input.token,
+  }
+}
+
+function assertSwapTransaction(
+  transaction: z.output<typeof Transaction>,
+  options: { account: string; chainId: number },
+) {
+  if (
+    transaction.chainId !== options.chainId ||
+    transaction.from.toLowerCase() !== options.account.toLowerCase() ||
+    transaction.to.toLowerCase() !== universalRouter ||
+    BigInt(transaction.value) !== 0n
+  )
+    throw new Provider.ProviderPayloadError()
+  validateRouterCalldata(transaction.data as Hex.Hex)
+}
+
+/** Rejects Universal Router calldata with capabilities outside token swaps and payments. */
+export function validateRouterCalldata(data: Hex.Hex): void {
+  try {
+    const decoded = decodeFunctionData({ abi: universalRouterAbi, data })
+    const [commands, inputs] = decoded.args
+    validateRouterPlan(commands, inputs, 0)
+  } catch (cause) {
+    if (cause instanceof Provider.ProviderPayloadError) throw cause
+    throw new Provider.ProviderPayloadError()
+  }
+}
+
+function validateRouterPlan(commands: Hex.Hex, inputs: readonly Hex.Hex[], depth: number): void {
+  if (depth > maximumSubPlanDepth) throw new Provider.ProviderPayloadError()
+  const bytes = Hex.toBytes(commands)
+  if (bytes.length !== inputs.length) throw new Provider.ProviderPayloadError()
+
+  for (const [index, byte] of bytes.entries()) {
+    if ((byte & 0x40) !== 0) throw new Provider.ProviderPayloadError()
+    const command = byte & 0x3f
+    if (allowedRouterCommands.has(command)) continue
+    if (command === executeSubPlan) {
+      const [nestedCommands, nestedInputs] = decodeAbiParameters(bytesAndInputs, inputs[index]!)
+      validateRouterPlan(nestedCommands, nestedInputs, depth + 1)
+      continue
+    }
+    if (command === v4Swap) {
+      validateV4Plan(inputs[index]!)
+      continue
+    }
+    throw new Provider.ProviderPayloadError()
+  }
+}
+
+function validateV4Plan(input: Hex.Hex): void {
+  const [actions, parameters] = decodeAbiParameters(bytesAndInputs, input)
+  const bytes = Hex.toBytes(actions)
+  if (bytes.length !== parameters.length || bytes.some((action) => !allowedV4Actions.has(action)))
+    throw new Provider.ProviderPayloadError()
+}
+
+function approvalCall(
+  transaction: z.output<typeof Transaction>,
+  options: {
+    account: string
+    amount: { exact: bigint } | { minimum: bigint }
+    chainId: number
+    token: string
+  },
+): Provider.Call {
+  if (
+    transaction.chainId !== options.chainId ||
+    transaction.from.toLowerCase() !== options.account.toLowerCase() ||
+    transaction.to.toLowerCase() !== options.token.toLowerCase() ||
+    BigInt(transaction.value) !== 0n
+  )
+    throw new Provider.ProviderPayloadError()
+
+  try {
+    const decoded = decodeFunctionData({ abi: approveAbi, data: transaction.data as Hex.Hex })
+    if (
+      decoded.functionName !== 'approve' ||
+      decoded.args[0].toLowerCase() !== permit2 ||
+      ('exact' in options.amount
+        ? decoded.args[1] !== options.amount.exact
+        : decoded.args[1] < options.amount.minimum)
+    )
+      throw new Provider.ProviderPayloadError()
+  } catch (cause) {
+    if (cause instanceof Provider.ProviderPayloadError) throw cause
+    throw new Provider.ProviderPayloadError()
+  }
+  return call(transaction)
+}
+
+function callsGas(approval: z.output<typeof ApprovalResponse>): string {
+  return (
+    BigInt(approval.cancel?.gasLimit ?? 0) + BigInt(approval.approval?.gasLimit ?? 0)
+  ).toString()
+}
+
+function assertPermit(
+  permit: z.output<typeof Permit>,
+  options: { input: Provider.QuoteInput; requiredAmount: bigint },
+) {
+  const { input, requiredAmount } = options
+  if (
+    permit.domain.chainId !== input.chainId ||
+    permit.domain.verifyingContract.toLowerCase() !== permit2 ||
+    permit.values.details.token.toLowerCase() !== input.sourceToken.toLowerCase() ||
+    permit.values.spender.toLowerCase() !== universalRouter ||
+    BigInt(permit.values.details.amount) !== requiredAmount ||
+    BigInt(permit.values.details.expiration) <= Math.floor(Date.now() / 1_000) ||
+    BigInt(permit.values.sigDeadline) <= Math.floor(Date.now() / 1_000)
+  )
+    throw new Provider.ProviderPayloadError()
+}
+
+function continuationExpiry(permit: z.output<typeof Permit>): number {
+  const now = Math.floor(Date.now() / 1_000)
+  return Number(
+    [
+      BigInt(now + continuationTtl),
+      BigInt(permit.values.details.expiration),
+      BigInt(permit.values.sigDeadline),
+    ].reduce((minimum, value) => (value < minimum ? value : minimum)),
+  )
+}
+
+function typedData(permit: z.output<typeof Permit>): TypedData {
+  return {
+    domain: permit.domain,
+    message: permit.values,
+    primaryType: 'PermitSingle',
+    types: permit.types,
+  }
+}
+
+function call(transaction: z.output<typeof Transaction>): Provider.Call {
+  return {
+    data: transaction.data as Hex.Hex,
+    to: transaction.to as `0x${string}`,
+    value: Hex.fromNumber(BigInt(transaction.value)),
+  }
+}
+
+function encodeContinuation(value: z.output<typeof Continuation>, options: { secret: string }) {
+  const body = Base64.fromString(JSON.stringify(value), { pad: false, url: true })
+  const signature = Hash.hmac256(Hex.fromString(options.secret), Hex.fromString(body)).slice(2)
+  return `${body}.${signature}`
+}
+
+function decodeContinuation(
+  value: string,
+  options: { account: string; chainId: number; secret: string },
+) {
+  try {
+    const [body, signature, extra] = value.split('.')
+    if (!body || !signature || extra) throw new Provider.ProviderContinuationError()
+    const expected = Hash.hmac256(Hex.fromString(options.secret), Hex.fromString(body)).slice(2)
+    if (!ContinuationSignature.timingSafeEqual(expected, signature))
+      throw new Provider.ProviderContinuationError()
+    const parsed = Continuation.safeParse(JSON.parse(Base64.toString(body)))
+    if (
+      parsed.success &&
+      parsed.data.account.toLowerCase() === options.account.toLowerCase() &&
+      parsed.data.chainId === options.chainId &&
+      parsed.data.quote.chainId === options.chainId &&
+      parsed.data.quote.swapper.toLowerCase() === options.account.toLowerCase() &&
+      parsed.data.expiresAt >= Math.floor(Date.now() / 1_000)
+    )
+      return parsed.data
+  } catch {}
+  throw new Provider.ProviderContinuationError()
+}
+
+namespace ContinuationSignature {
+  export 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
+  }
+}
+
+async function requestJson(
+  url: URL,
+  options: { apiKey: string; body: unknown; operation: string; signal: AbortSignal },
+) {
+  const response = await fetch(url, {
+    body: JSON.stringify(options.body),
+    headers: {
+      accept: 'application/json',
+      'content-type': 'application/json',
+      'x-api-key': options.apiKey,
+      'x-universal-router-version': universalRouterVersion,
+    },
+    method: 'POST',
+    signal: options.signal,
+  }).catch((cause) => {
+    if (cause instanceof TypeError)
+      throw new Provider.ProviderNetworkError({ cause, operation: options.operation })
+    throw cause
+  })
+  const body = await response.json().catch(() => undefined)
+  if (response.status === 404) throw new Provider.RouteUnavailableError()
+  if (!response.ok)
+    throw new Provider.ProviderResponseError({
+      operation: options.operation,
+      status: response.status,
+    })
+  return body
+}