tapimo 0.15.1 → 0.18.1

package/src/internal/routes/providers/propAmm.ts

@@ -0,0 +1,640 @@
+import { Address, Hash, Hex } from 'ox'
+import {
+  BaseError,
+  BlockNotFoundError,
+  ContractFunctionRevertedError,
+  decodeFunctionData,
+  parseEventLogs,
+  TransactionReceiptNotFoundError,
+} from 'viem'
+import { getBlock, getChainId, getTransactionReceipt, readContract } from 'viem/actions'
+import { Abis, Actions, Formatters, type Transaction } from 'viem/tempo'
+import * as z from 'zod/mini'
+
+import * as Schema from '../../Schema.js'
+import * as Store from '../../Store.js'
+import * as Viem from '../../Viem.js'
+import * as Chain from '../Chain.js'
+import * as RoutesProvider from '../Provider.js'
+
+/** PropAMM route schemas. */
+export namespace schema {
+  /** Pool selected by the route catalog. */
+  export const Configuration = z
+    .strictObject({
+      poolAddress: z
+        .string()
+        .check(z.regex(/^0x[0-9a-fA-F]{40}$/), z.describe('PropAMM pool on the route chain.')),
+    })
+    .check(z.describe('PropAMM configuration for one same-chain route.'))
+
+  /** Swap terms retained across registration and reconciliation. */
+  export const Preparation = z
+    .object({
+      amountIn: RoutesProvider.schema.PositiveInteger,
+      baseToQuote: z.boolean().check(z.describe('Whether input is the pool base token.')),
+      customerId: Schema.Hash,
+      deadline: RoutesProvider.schema.PositiveInteger,
+      expectedOraclePrice: RoutesProvider.schema.PositiveInteger,
+      minAmountOut: RoutesProvider.schema.PositiveInteger,
+      minimumOracleUpdatedAt: RoutesProvider.schema.PositiveInteger,
+      oraclePriceToleranceBps: z.literal('0').check(z.describe('Exact oracle price binding.')),
+      pool: Schema.Address,
+      recipient: Schema.Address,
+      sender: Schema.Address,
+      tokenIn: Schema.Address,
+      tokenOut: Schema.Address,
+      tradeId: Schema.Hash,
+    })
+    .check(z.describe('Persisted exact-input PropAMM swap preparation.'))
+
+  /** Prepared terms and optional canonical execution evidence. */
+  export const ProviderState = z
+    .object({
+      propAmm: Preparation,
+      propAmmEvidence: z.optional(
+        z
+          .object({
+            amountOut: RoutesProvider.schema.PositiveInteger,
+            blockHash: Schema.Hash,
+            blockNumber: Schema.DecimalString,
+            transactionHash: Schema.Hash,
+          })
+          .check(z.describe('Previously verified canonical swap execution.')),
+      ),
+      routeConfiguration: Configuration,
+    })
+    .check(z.describe('Private PropAMM preparation and execution state.'))
+}
+
+/** Creates a same-chain PropAMM provider for quotes and unsigned swap preparation. */
+export function propAmm(options: propAmm.Options = {}) {
+  const { rpc } = options
+  const cache = Store.memory()
+  const fetch = options.fetch ?? globalThis.fetch
+  const resolveRpcUrls = options.resolveRpcUrls ?? ((chain: Chain.Chain) => chain.rpcUrls)
+
+  return RoutesProvider.from({
+    id: 'propamm',
+    name: 'PropAMM',
+    async getQuote({ candidate, request }, signal) {
+      try {
+        const result = await quote({
+          cache,
+          candidate,
+          fetch,
+          recipient: request.recipient,
+          resolveRpcUrls,
+          rpc,
+          sender: request.sender,
+          signal,
+        })
+        return result.quote
+      } catch (cause) {
+        if (cause instanceof RoutesProvider.ProviderUnavailableError)
+          return RoutesProvider.unavailableResult({
+            detail: 'propamm',
+            message: cause.message,
+            now: new Date(),
+            reason: unavailableReason(cause.message),
+            source: 'onchain',
+          })
+
+        throw cause
+      }
+    },
+    async prepareTransfer({ candidate, method, mode, recipient, sender, slippageBps }, signal) {
+      if (method !== 'transaction' || mode !== 'exactSource')
+        throw new RoutesProvider.ProviderConfigurationError()
+
+      const result = await quote({
+        cache,
+        candidate,
+        fetch,
+        recipient,
+        resolveRpcUrls,
+        rpc,
+        sender,
+        signal,
+      })
+      const minimum =
+        (BigInt(result.quote.destinationAmount) * BigInt(10_000 - (slippageBps ?? 0))) / 10_000n
+      // Route amounts require a positive minimum, including at 100% slippage.
+      const minAmountOut = minimum > 0n ? minimum : 1n
+      const deadline = BigInt(Math.floor(Date.parse(result.quote.expiresAt) / 1000))
+      const request = {
+        ...result.request,
+        deadline,
+        minAmountOut,
+        tradeId: Hex.random(32),
+      }
+      const approval = Actions.token.approve.call(result.client, {
+        amount: request.amountIn,
+        spender: request.pool,
+        token: candidate.sourceToken.address as Address.Address,
+      })
+      const swap = Actions.propAmm.swap.call(request)
+
+      return {
+        action: {
+          calls: [approval, swap].map(({ data, to }) => ({ data, to, value: '0x0' })),
+          type: 'evm:calls',
+        },
+        destinationAmount: result.quote.destinationAmount,
+        destinationAmountMin: minAmountOut.toString(),
+        expiresAt: new Date(Number(deadline) * 1000).toISOString(),
+        fees: [],
+        providerState: {
+          propAmm: {
+            amountIn: request.amountIn.toString(),
+            baseToQuote: request.baseToQuote,
+            customerId: request.customerId,
+            deadline: deadline.toString(),
+            expectedOraclePrice: request.expectedOraclePrice.toString(),
+            minAmountOut: minAmountOut.toString(),
+            minimumOracleUpdatedAt: request.minimumOracleUpdatedAt.toString(),
+            oraclePriceToleranceBps: request.oraclePriceToleranceBps.toString(),
+            pool: request.pool,
+            recipient: request.recipient,
+            sender,
+            tokenIn: candidate.sourceToken.address,
+            tokenOut: candidate.destinationToken.address,
+            tradeId: request.tradeId,
+          },
+          routeConfiguration: candidate.configuration,
+        },
+        quality: result.quote.quality,
+        sampledAt: result.quote.sampledAt,
+      }
+    },
+    validateTransferAction(parameters) {
+      try {
+        const { action, candidate, destinationAmountMin, method, mode, recipient, sender } =
+          parameters
+        const configuration = schema.Configuration.parse(candidate.configuration)
+        if (
+          action.type !== 'evm:calls' ||
+          action.calls.length !== 2 ||
+          method !== 'transaction' ||
+          mode !== 'exactSource' ||
+          candidate.sourceChain.kind !== 'evm' ||
+          candidate.sourceChain.id !== candidate.destinationChain.id
+        )
+          throw new RoutesProvider.ProviderPayloadError()
+
+        const [approval, swap] = action.calls
+        const decoded = decodeFunctionData({ abi: Abis.directPropAmm, data: swap!.data as Hex.Hex })
+        if (decoded.functionName !== 'swapExactInput')
+          throw new RoutesProvider.ProviderPayloadError()
+        const [
+          baseToQuote,
+          amountIn,
+          minAmountOut,
+          beneficiary,
+          customerId,
+          tradeId,
+          deadline,
+          expectedOraclePrice,
+          oraclePriceToleranceBps,
+          minimumOracleUpdatedAt,
+        ] = decoded.args
+        if (
+          amountIn !== BigInt(candidate.sourceAmount.amount) ||
+          minAmountOut !== BigInt(destinationAmountMin) ||
+          !Address.isEqual(beneficiary, recipient as Address.Address) ||
+          !Hex.isEqual(customerId, Hex.padLeft(sender as Address.Address, 32)) ||
+          BigInt(tradeId) === 0n ||
+          deadline <= BigInt(Math.floor(Date.now() / 1000)) ||
+          deadline > BigInt(Math.floor(Date.now() / 1000) + 60) ||
+          expectedOraclePrice === 0n ||
+          oraclePriceToleranceBps !== 0n ||
+          minimumOracleUpdatedAt === 0n
+        )
+          throw new RoutesProvider.ProviderPayloadError()
+
+        const expected = [
+          Actions.token.approve.call({
+            amount: amountIn,
+            spender: configuration.poolAddress as Address.Address,
+            token: candidate.sourceToken.address as Address.Address,
+          }),
+          Actions.propAmm.swap.call({
+            amountIn,
+            baseToQuote,
+            customerId,
+            deadline,
+            expectedOraclePrice,
+            minAmountOut,
+            minimumOracleUpdatedAt,
+            mode: 'exactInput',
+            oraclePriceToleranceBps,
+            pool: configuration.poolAddress as Address.Address,
+            recipient: beneficiary,
+            tradeId,
+          }),
+        ]
+        if (
+          ![approval!, swap!].every(
+            (call, index) =>
+              Address.isEqual(call.to as Address.Address, expected[index]!.to) &&
+              Hex.isEqual(call.data as Hex.Hex, expected[index]!.data) &&
+              BigInt(call.value) === 0n,
+          )
+        )
+          throw new RoutesProvider.ProviderPayloadError()
+
+        return {}
+      } catch (cause) {
+        throw new RoutesProvider.ProviderPayloadError('Invalid PropAMM swap batch.', { cause })
+      }
+    },
+    async verifySourceTransaction(parameters, signal) {
+      const { destinationChain, providerState, sourceChain, transactionHash, transfer } = parameters
+      const parsed = schema.ProviderState.safeParse(providerState)
+      if (
+        !parsed.success ||
+        !Hash.validate(transactionHash) ||
+        sourceChain.kind !== 'evm' ||
+        sourceChain.id !== destinationChain.id ||
+        sourceChain.id !== transfer.sourceChain.id ||
+        destinationChain.id !== transfer.destinationChain.id ||
+        transfer.method !== 'transaction' ||
+        transfer.mode !== 'exactSource' ||
+        !transfer.sender ||
+        !transfer.destinationAmountMin
+      )
+        return { type: 'invalid' }
+
+      const { propAmm: state, propAmmEvidence: evidence, routeConfiguration } = parsed.data
+      if (
+        !Address.isEqual(state.pool, routeConfiguration.poolAddress as Address.Address) ||
+        !Address.isEqual(state.sender, transfer.sender as Address.Address) ||
+        !Address.isEqual(state.recipient, transfer.recipient as Address.Address) ||
+        !Address.isEqual(state.tokenIn, transfer.sourceToken.address as Address.Address) ||
+        !Address.isEqual(state.tokenOut, transfer.destinationToken.address as Address.Address) ||
+        state.amountIn !== transfer.sourceAmount.baseUnits ||
+        state.minAmountOut !== transfer.destinationAmountMin.baseUnits ||
+        Number(state.deadline) * 1000 !== Date.parse(transfer.quote.expiresAt) ||
+        !Hex.isEqual(state.customerId, Hex.padLeft(state.sender, 32)) ||
+        (evidence && !Hex.isEqual(evidence.transactionHash, transactionHash))
+      )
+        return { type: 'invalid' }
+
+      const chainId = Number(Chain.eip155Id(sourceChain))
+      const urls = resolveRpcUrls(sourceChain)
+      if (!urls.length) throw new RoutesProvider.ProviderConfigurationError()
+      const client = Viem.createEvmClient({ chainId, fetch, rpc, signal, urls })
+      const [actualChainId, receipt, head] = await Promise.all([
+        getChainId(client),
+        getTransactionReceipt(client, { hash: transactionHash }).catch((cause) => {
+          if (cause instanceof TransactionReceiptNotFoundError) return undefined
+          throw cause
+        }),
+        getBlock(client, { blockTag: Chain.settlementBlockTag(sourceChain) }),
+      ])
+      if (actualChainId !== chainId) return { type: 'invalid' }
+
+      const block = receipt
+        ? await getBlock(client, { blockNumber: receipt.blockNumber }).catch((cause) => {
+            if (cause instanceof BlockNotFoundError) return undefined
+            throw cause
+          })
+        : undefined
+      if (!receipt || !block || !Hex.isEqual(block.hash, receipt.blockHash)) {
+        if (!evidence || head.number < BigInt(evidence.blockNumber)) return { type: 'pending' }
+        const canonical = await getBlock(client, {
+          blockNumber: BigInt(evidence.blockNumber),
+        }).catch((cause) => {
+          if (cause instanceof BlockNotFoundError) return undefined
+          throw cause
+        })
+        if (!canonical || Hex.isEqual(canonical.hash, evidence.blockHash))
+          return { type: 'pending' }
+        const { propAmmEvidence: _, ...retained } = providerState!
+        return { providerState: retained, type: 'reorged' }
+      }
+      if (block.number > head.number) return { type: 'pending' }
+      if (
+        receipt.status !== 'success' ||
+        !Address.isEqual(receipt.from, state.sender) ||
+        block.timestamp < BigInt(Math.floor(Date.parse(transfer.quote.sampledAt) / 1000)) ||
+        block.timestamp > BigInt(state.deadline)
+      )
+        return { type: 'invalid' }
+
+      const raw = await client.request({
+        method: 'eth_getTransactionByHash',
+        params: [transactionHash],
+      })
+      if (!raw) return { type: 'pending' }
+      const transaction = Formatters.formatTransaction(raw as Transaction.TransactionRpc)
+      if (
+        transaction.type !== 'tempo' ||
+        transaction.chainId !== chainId ||
+        !Address.isEqual(transaction.from, state.sender) ||
+        !transaction.blockHash ||
+        !Hex.isEqual(transaction.blockHash, block.hash) ||
+        !Hex.isEqual(transaction.hash, transactionHash)
+      )
+        return { type: 'invalid' }
+
+      const expected = [
+        Actions.token.approve.call({
+          amount: BigInt(state.amountIn),
+          spender: state.pool,
+          token: state.tokenIn,
+        }),
+        Actions.propAmm.swap.call({
+          amountIn: BigInt(state.amountIn),
+          baseToQuote: state.baseToQuote,
+          customerId: state.customerId,
+          deadline: BigInt(state.deadline),
+          expectedOraclePrice: BigInt(state.expectedOraclePrice),
+          minAmountOut: BigInt(state.minAmountOut),
+          minimumOracleUpdatedAt: BigInt(state.minimumOracleUpdatedAt),
+          mode: 'exactInput',
+          oraclePriceToleranceBps: 0n,
+          pool: state.pool,
+          recipient: state.recipient,
+          tradeId: state.tradeId,
+        }),
+      ]
+      if (
+        transaction.calls.length !== expected.length ||
+        !transaction.calls.every(
+          (call, index) =>
+            call.to &&
+            Address.isEqual(call.to, expected[index]!.to) &&
+            Hex.isEqual(call.data ?? '0x', expected[index]!.data) &&
+            (call.value ?? 0n) === 0n,
+        )
+      )
+        return { type: 'invalid' }
+
+      const trades = parseEventLogs({
+        abi: Abis.directPropAmm,
+        eventName: 'TradeExecuted',
+        logs: receipt.logs,
+        strict: true,
+      }).filter((event) => Address.isEqual(event.address, state.pool))
+      const trade = trades[0]?.args
+      if (
+        trades.length !== 1 ||
+        !trade ||
+        !Hex.isEqual(trade.tradeId, state.tradeId) ||
+        !Hex.isEqual(trade.customerId, state.customerId) ||
+        !Address.isEqual(trade.taker, state.sender) ||
+        !Address.isEqual(trade.recipient, state.recipient) ||
+        !Address.isEqual(trade.tokenIn, state.tokenIn) ||
+        !Address.isEqual(trade.tokenOut, state.tokenOut) ||
+        trade.amountIn !== BigInt(state.amountIn) ||
+        trade.amountOut < BigInt(state.minAmountOut) ||
+        trade.oraclePrice !== BigInt(state.expectedOraclePrice) ||
+        trade.oracleUpdatedAt < BigInt(state.minimumOracleUpdatedAt) ||
+        (evidence && trade.amountOut !== BigInt(evidence.amountOut))
+      )
+        return { type: 'invalid' }
+
+      const transfers = parseEventLogs({
+        abi: Abis.tip20,
+        eventName: 'Transfer',
+        logs: receipt.logs,
+        strict: true,
+      })
+      for (const movement of [
+        { amount: trade.amountIn, from: state.sender, to: state.pool, token: state.tokenIn },
+        { amount: trade.amountOut, from: state.pool, to: state.recipient, token: state.tokenOut },
+      ])
+        if (
+          transfers.filter(
+            (event) =>
+              Address.isEqual(event.address, movement.token) &&
+              Address.isEqual(event.args.from, movement.from) &&
+              Address.isEqual(event.args.to, movement.to) &&
+              event.args.amount === movement.amount,
+          ).length !== 1
+        )
+          return { type: 'invalid' }
+
+      return {
+        destinationAmount: trade.amountOut.toString(),
+        providerState: {
+          ...providerState,
+          propAmmEvidence: {
+            amountOut: trade.amountOut.toString(),
+            blockHash: block.hash,
+            blockNumber: block.number.toString(),
+            transactionHash,
+          },
+        },
+        type: 'verified',
+      }
+    },
+    async verifyDestinationDelivery(parameters, signal) {
+      const transactionHash = parameters.transfer.sourceTransactionHashes?.[0]
+      if (!transactionHash || parameters.transfer.sourceTransactionHashes?.length !== 1)
+        return { type: 'invalid' }
+
+      const result = await this.verifySourceTransaction!({ ...parameters, transactionHash }, signal)
+      // Reconciliation rechecks source evidence and reopens transfers after a reorg.
+      if (result.type === 'reorged') return { type: 'pending' }
+      if (result.type === 'related') return { type: 'invalid' }
+      if (result.type !== 'verified') return result
+      if (result.destinationAmount !== parameters.transfer.destinationAmount?.baseUnits)
+        return { type: 'invalid' }
+
+      return { transactionHash, type: 'verified' }
+    },
+  })
+}
+
+export declare namespace propAmm {
+  /** RPC dependencies for PropAMM quotes and preparation. */
+  type Options = {
+    /** Fetch implementation used for chain RPC requests. */
+    fetch?: RoutesProvider.Fetch | undefined
+    /** Resolves RPC endpoints for the configured route chain. */
+    resolveRpcUrls?: ((chain: Chain.Chain) => readonly string[]) | undefined
+    /** Trusted Tempo RPC endpoints and authentication. */
+    rpc?: Viem.getClient.Rpc | undefined
+  }
+}
+
+async function quote(options: quote.Options) {
+  const { cache, candidate, fetch, recipient, resolveRpcUrls, rpc, sender, signal } = options
+  const { route } = candidate
+  const configuration = schema.Configuration.safeParse(candidate.configuration)
+  if (
+    !configuration.success ||
+    route.source.chain.kind !== 'evm' ||
+    route.source.chain.id !== route.destination.chain.id
+  )
+    throw new RoutesProvider.ProviderUnavailableError('ROUTE_NOT_CONFIGURED')
+
+  if (!sender || !recipient) throw new RoutesProvider.ProviderUnavailableError('IDENTITY_REQUIRED')
+  if (
+    !Address.validate(sender, { strict: false }) ||
+    !Address.validate(recipient, { strict: false })
+  )
+    throw new RoutesProvider.ProviderUnavailableError('INVALID_IDENTITY')
+
+  const urls = resolveRpcUrls(route.source.chain)
+  if (!urls.length) throw new RoutesProvider.ProviderConfigurationError()
+
+  const chainId = Number(Chain.eip155Id(route.source.chain))
+  const client = Viem.createEvmClient({
+    batch: { multicall: { deployless: true } },
+    chainId,
+    fetch,
+    rpc,
+    signal,
+    urls,
+  })
+  const pool = configuration.data.poolAddress as Address.Address
+  const [base, quote] = await Store.memoize(
+    () =>
+      Promise.all([
+        Actions.propAmm.baseToken(client, { pool }),
+        Actions.propAmm.quoteToken(client, { pool }),
+      ]),
+    {
+      key: `propamm:v1:${chainId}:${pool.toLowerCase()}:tokens`,
+      // Share immutable values, keeping pending RPC work inside its originating Worker request.
+      store: { ...cache },
+      ttl: 86_400_000,
+    },
+  )
+
+  const baseToQuote = Address.isEqual(route.source.address as Address.Address, base)
+  if (
+    !Address.isEqual(route.source.address as Address.Address, baseToQuote ? base : quote) ||
+    !Address.isEqual(route.destination.address as Address.Address, baseToQuote ? quote : base)
+  )
+    throw new RoutesProvider.ProviderUnavailableError('TOKEN_PAIR_MISMATCH')
+
+  try {
+    // Batch mutable state into one call so the quote and eligibility checks share a block.
+    const [result, paused, takerAllowed, resolved, recipientAllowed, balance, maxOracleAge] =
+      await Promise.all([
+        Actions.propAmm.getSwapQuote(client, {
+          amountIn: BigInt(candidate.sourceAmount.amount),
+          baseToQuote,
+          mode: 'exactInput',
+          pool,
+          recipient,
+          taker: sender,
+        }),
+        Actions.propAmm.paused(client, { pool }),
+        Actions.propAmm.takerAllowed(client, { pool, taker: sender }),
+        Actions.propAmm.resolveRecipient(client, { pool, recipient }),
+        Actions.propAmm.recipientAllowed(client, { pool, recipient }),
+        Actions.token.getBalance(client, {
+          account: pool,
+          decimals: candidate.destinationToken.decimals,
+          token: candidate.destinationToken.address as Address.Address,
+        }),
+        readContract(client, {
+          abi: Abis.directPropAmm,
+          address: pool,
+          functionName: 'maxOracleAge',
+        }),
+      ])
+    if (paused) throw new RoutesProvider.ProviderUnavailableError('POOL_PAUSED')
+    if (!takerAllowed) throw new RoutesProvider.ProviderUnavailableError('TAKER_NOT_ALLOWED')
+    if (!Address.isEqual(recipient, resolved))
+      throw new RoutesProvider.ProviderUnavailableError('RECIPIENT_REDIRECTED')
+    if (!recipientAllowed)
+      throw new RoutesProvider.ProviderUnavailableError('RECIPIENT_NOT_ALLOWED')
+    if (result.amountOut === 0n || balance.amount < result.amountOut)
+      throw new RoutesProvider.ProviderUnavailableError('INSUFFICIENT_INVENTORY')
+
+    const now = new Date()
+    const expiresAt = Math.min(
+      now.getTime() + 60_000,
+      Number(result.updatedAt + maxOracleAge) * 1000,
+    )
+    if (expiresAt <= now.getTime())
+      throw new RoutesProvider.ProviderUnavailableError('ORACLE_EXPIRED')
+
+    return {
+      client,
+      quote: {
+        destinationAmount: result.amountOut.toString(),
+        expiresAt: new Date(expiresAt).toISOString(),
+        quality: { liquiditySource: 'onchain', sourceDetail: 'propamm', tier: 'liquid' as const },
+        sampledAt: now.toISOString(),
+        status: 'available' as const,
+      },
+      request: result.request,
+    }
+  } catch (cause) {
+    const error =
+      cause instanceof BaseError
+        ? cause.walk((error) => error instanceof ContractFunctionRevertedError)
+        : undefined
+    if (
+      error instanceof ContractFunctionRevertedError &&
+      error.data &&
+      [
+        'StaleOraclePrice',
+        'FutureOracleTimestamp',
+        'PriceDeviationExceeded',
+        'InvalidPrice',
+        'InsufficientInventory',
+      ].includes(error.data.errorName)
+    )
+      throw new RoutesProvider.ProviderUnavailableError(error.data.errorName)
+
+    throw cause
+  }
+}
+
+function unavailableReason(
+  message: string,
+): z.output<typeof RoutesProvider.schema.UnavailableReason> {
+  switch (message) {
+    case 'IDENTITY_REQUIRED':
+      return 'identity_required'
+    case 'INVALID_IDENTITY':
+      return 'invalid_identity'
+    case 'TAKER_NOT_ALLOWED':
+      return 'sender_not_allowed'
+    case 'RECIPIENT_NOT_ALLOWED':
+      return 'recipient_not_allowed'
+    case 'RECIPIENT_REDIRECTED':
+      return 'recipient_unsupported'
+    case 'INSUFFICIENT_INVENTORY':
+    case 'InsufficientInventory':
+      return 'insufficient_liquidity'
+    case 'ORACLE_EXPIRED':
+    case 'StaleOraclePrice':
+    case 'FutureOracleTimestamp':
+    case 'PriceDeviationExceeded':
+    case 'InvalidPrice':
+      return 'price_unavailable'
+    default:
+      return 'route_unavailable'
+  }
+}
+
+declare namespace quote {
+  /** Inputs for a fresh caller-specific pool quote. */
+  type Options = {
+    /** Immutable pool token pair cache. */
+    cache: Store.Store
+    /** Catalog route selected for quoting. */
+    candidate: RoutesProvider.QuoteCandidate
+    /** RPC fetch implementation. */
+    fetch: RoutesProvider.Fetch
+    /** Beneficiary checked against pool permissions. */
+    recipient: string | undefined
+    /** RPC endpoints for the selected chain. */
+    resolveRpcUrls: (chain: Chain.Chain) => readonly string[]
+    /** Trusted Tempo RPC endpoints and authentication. */
+    rpc: Viem.getClient.Rpc | undefined
+    /** Account that will execute the swap. */
+    sender: string | undefined
+    /** Cancellation for provider RPC calls. */
+    signal: AbortSignal
+  }
+}