tapimo 0.15.1 → 0.18.0

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

@@ -0,0 +1,566 @@
+import { AbiEvent, AbiFunction, AbiParameters, Address, Hash, Hex } from 'ox'
+import {
+  BlockNotFoundError,
+  parseEventLogs,
+  publicActions,
+  TransactionReceiptNotFoundError,
+} from 'viem'
+
+import * as Tron from '../../Tron.js'
+import * as Viem from '../../Viem.js'
+import * as Action from '../Action.js'
+import type * as Chain from '../Chain.js'
+import * as Provider from '../Provider.js'
+import * as Delivery from './legacyMeshOutboundDelivery.js'
+
+// Canonical contracts: https://docs.usdt0.to/api/deployments.
+const sourceToken = '0x20C00000000000000000000014f22CA97301EB73'
+const sourceOft = '0xaf37E8B6C9ED7f6318979f56Fc287d76c30847ff'
+const sourceEndpoint = '0x20Bb7C2E2f4e5ca2B4c57060d1aE2615245dCc9C'
+const feeWrapper = '0x0cEb237E109eE22374a567c6b09F373C73FA4cBb'
+const feePaymentToken = '0x20c0000000000000000000000000000000000000'
+const hubComposer = '0x759BA420bF1ded1765F18C2DC3Fc57A1964A2Ad1'
+const hubOft = '0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92'
+const hubAdapter = '0x77652D5aba086137b595875263FC200182919B92'
+const destinationToken = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
+const hubRpcUrls = ['https://arb1.arbitrum.io/rpc']
+const hubEid = 30_110
+const sourceEid = 30_410
+const destinationEid = 30_420
+const quoteTtlMs = 60_000
+
+const sendParam = AbiParameters.from(
+  '(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd)',
+)
+const approve = AbiFunction.from('function approve(address spender, uint256 amount) returns (bool)')
+const wrap = AbiFunction.from('function wrap(address token, address to, uint256 amount)')
+const endpointNativeToken = AbiFunction.from('function nativeToken() view returns (address)')
+const quoteOft = AbiFunction.from(
+  'function quoteOFT((uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam) view returns ((uint256 minAmountLD, uint256 maxAmountLD) limit, (int256 feeAmountLD, string description)[] fees, (uint256 amountSentLD, uint256 amountReceivedLD) receipt)',
+)
+const quoteSend = AbiFunction.from(
+  'function quoteSend((uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam, bool payInLzToken) view returns ((uint256 nativeFee, uint256 lzTokenFee) fee)',
+)
+const send = AbiFunction.from(
+  'function send((uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam, (uint256 nativeFee, uint256 lzTokenFee) fee, address refundAddress) payable',
+)
+const oftSent = AbiEvent.from(
+  'event OFTSent(bytes32 indexed guid, uint32 dstEid, address indexed fromAddress, uint256 amountSentLD, uint256 amountReceivedLD)',
+)
+const transferEvent = AbiEvent.from(
+  'event Transfer(address indexed from, address indexed to, uint256 value)',
+)
+const approvalEvent = AbiEvent.from(
+  'event Approval(address indexed owner, address indexed spender, uint256 value)',
+)
+const packetSent = AbiEvent.from(
+  'event PacketSent(bytes encodedPayload, bytes options, address sendLibrary)',
+)
+
+type Options = {
+  fetch?: Provider.Fetch | undefined
+  hubRpcUrls?: readonly string[] | undefined
+  resolveRpcUrls?: ((chain: Chain.Chain) => readonly string[]) | undefined
+}
+
+function clients(options: Options, chain: Chain.Chain, signal: AbortSignal) {
+  const fetch = options.fetch ?? globalThis.fetch
+  return {
+    hub: Viem.createEvmClient({
+      chainId: 42161,
+      fetch,
+      signal,
+      urls: options.hubRpcUrls ?? hubRpcUrls,
+    }).extend(publicActions),
+    source: Viem.createEvmClient({
+      chainId: 4217,
+      fetch,
+      signal,
+      urls: options.resolveRpcUrls?.(chain) ?? chain.rpcUrls,
+    }).extend(publicActions),
+  }
+}
+
+/** Quotes Tempo USDT0 into Tron USDT through the Arbitrum Legacy Mesh composer. */
+export async function getQuote(
+  parameters: Provider.getQuote.Parameters,
+  signal: AbortSignal,
+  options: Options = {},
+): Promise<Provider.getQuote.ReturnType> {
+  assertRoute(parameters.candidate)
+  const { hub, source } = clients(options, parameters.route.source.chain, signal)
+  try {
+    const quote = await quoteAmount({
+      amount: BigInt(parameters.candidate.sourceAmount.amount),
+      hub,
+      recipient: parameters.request.recipient ?? destinationToken,
+      source,
+    })
+    return {
+      destinationAmount: quote.destinationAmount.toString(),
+      destinationAmountMin: quote.destinationAmount.toString(),
+      quality: quality(),
+      sampledAt: new Date().toISOString(),
+      status: 'available',
+    }
+  } catch (cause) {
+    if (!(cause instanceof Provider.ProviderUnavailableError)) throw cause
+    return Provider.unavailableResult({
+      detail: 'legacy-mesh:tempo-arbitrum-tron',
+      message: 'amount-outside-liquidity-limits',
+      now: new Date(),
+      source: 'onchain',
+    })
+  }
+}
+
+/** Prepares the bounded Tempo action for a composed delivery to Tron. */
+export async function prepareTransfer(
+  parameters: Provider.prepareTransfer.Parameters,
+  signal: AbortSignal,
+  options: Options = {},
+): Promise<Provider.prepareTransfer.ReturnType> {
+  const { candidate, method, mode, recipient, sender, slippageBps } = parameters
+  assertRoute(candidate)
+  if (
+    method !== 'transaction' ||
+    mode !== 'exactSource' ||
+    !Address.validate(sender, { strict: false })
+  )
+    throw new Provider.ProviderConfigurationError()
+  Tron.toEvmAddress(recipient)
+  const { hub, source } = clients(options, candidate.route.source.chain, signal)
+  const quote = await quoteAmount({
+    amount: BigInt(candidate.sourceAmount.amount),
+    hub,
+    recipient,
+    source,
+  })
+  const quotedMinimum = (quote.destinationAmount * BigInt(10_000 - (slippageBps ?? 0))) / 10_000n
+  const minimum = quotedMinimum > 0n ? quotedMinimum : 1n
+  const onward = onwardParam({ amount: quote.hubAmount, minimum, recipient })
+  const fee = await hub.readContract({
+    abi: [quoteSend],
+    address: hubAdapter,
+    args: [onward, false],
+    functionName: 'quoteSend',
+  })
+  if (fee.lzTokenFee !== 0n) throw new Provider.ProviderPayloadError()
+  const first = firstParam({
+    amount: BigInt(candidate.sourceAmount.amount),
+    composeValue: (fee.nativeFee * 110n + 99n) / 100n,
+    minimum,
+    onward,
+  })
+  const [nativeToken, messagingFee, hubBlock, tronBlock] = await Promise.all([
+    source.readContract({
+      abi: [endpointNativeToken],
+      address: sourceEndpoint,
+      functionName: 'nativeToken',
+    }),
+    source.readContract({
+      abi: [quoteSend],
+      account: sender as Address.Address,
+      address: sourceOft,
+      args: [first, false],
+      functionName: 'quoteSend',
+    }),
+    hub.getBlockNumber(),
+    Tron.createClient({
+      fetch: options.fetch,
+      signal,
+      urls:
+        options.resolveRpcUrls?.(candidate.route.destination.chain) ??
+        candidate.route.destination.chain.rpcUrls,
+    }).getBlock(),
+  ])
+  if (!Address.isEqual(nativeToken, feeWrapper) || messagingFee.lzTokenFee !== 0n)
+    throw new Provider.ProviderUnavailableError()
+  const feeAmount = messagingFee.nativeFee
+  const action: Action.EvmCalls = {
+    calls: [
+      {
+        data: AbiFunction.encodeData(approve, [sourceOft, BigInt(candidate.sourceAmount.amount)]),
+        to: sourceToken,
+        value: '0x0',
+      },
+      {
+        data: AbiFunction.encodeData(approve, [feeWrapper, feeAmount]),
+        to: feePaymentToken,
+        value: '0x0',
+      },
+      {
+        data: AbiFunction.encodeData(wrap, [feePaymentToken, sender, feeAmount]),
+        to: feeWrapper,
+        value: '0x0',
+      },
+      {
+        data: AbiFunction.encodeData(approve, [sourceOft, feeAmount]),
+        to: feeWrapper,
+        value: '0x0',
+      },
+      {
+        data: AbiFunction.encodeData(send, [first, messagingFee, sender as Address.Address]),
+        to: sourceOft,
+        value: '0x0',
+      },
+    ],
+    type: 'evm:calls',
+  }
+  validateTransferAction({ ...parameters, action, destinationAmountMin: minimum.toString() })
+  const sampledAt = new Date()
+  return {
+    action,
+    destinationAmount: quote.destinationAmount.toString(),
+    destinationAmountMin: minimum.toString(),
+    expiresAt: new Date(sampledAt.getTime() + quoteTtlMs).toISOString(),
+    fees: [
+      {
+        amount: feeAmount.toString(),
+        side: 'source',
+        token: {
+          address: feePaymentToken,
+          currency: 'USD',
+          decimals: 6,
+          name: 'pathUSD',
+          standard: 'TIP-20',
+          symbol: 'pathUSD',
+          tokenKey: `eip155:4217/erc20:${feePaymentToken}`,
+          verified: true,
+        },
+      },
+    ],
+    providerState: {
+      hubBlockNumber: hubBlock.toString(),
+      destinationBlockNumber: tronBlock.block_header.raw_data.number.toString(),
+      quotedDestinationAmount: quote.destinationAmount.toString(),
+      sourceHopAmount: quote.hubAmount.toString(),
+      sourceDataHash: Hash.keccak256(action.calls.at(-1)!.data as Hex.Hex),
+    },
+    quality: quality(),
+    sampledAt: sampledAt.toISOString(),
+  }
+}
+
+/** Validates the exact source approvals, fee wrap, composed send, and Tron beneficiary. */
+export function validateTransferAction(
+  parameters: Provider.validateTransferAction.Parameters,
+): Provider.validateTransferAction.ReturnType {
+  try {
+    assertRoute(parameters.candidate)
+    const action = Action.schema.EvmCalls.parse(parameters.action)
+    if (action.calls.length !== 5) throw new Provider.ProviderPayloadError()
+    const [tokenApproval, paymentApproval, wrapping, feeApproval, execution] = action.calls
+    const amount = BigInt(parameters.candidate.sourceAmount.amount)
+    const [tokenSpender, tokenAmount] = AbiFunction.decodeData(
+      approve,
+      tokenApproval!.data as Hex.Hex,
+    )
+    const [paymentSpender, feeAmount] = AbiFunction.decodeData(
+      approve,
+      paymentApproval!.data as Hex.Hex,
+    )
+    const [paymentToken, feeRecipient, wrappedAmount] = AbiFunction.decodeData(
+      wrap,
+      wrapping!.data as Hex.Hex,
+    )
+    const [feeSpender, approvedFee] = AbiFunction.decodeData(approve, feeApproval!.data as Hex.Hex)
+    if (
+      !Address.isEqual(tokenApproval!.to as Address.Address, sourceToken) ||
+      !Address.isEqual(tokenSpender, sourceOft) ||
+      tokenAmount !== amount ||
+      !Address.isEqual(paymentApproval!.to as Address.Address, feePaymentToken) ||
+      !Address.isEqual(paymentSpender, feeWrapper) ||
+      !Address.isEqual(wrapping!.to as Address.Address, feeWrapper) ||
+      !Address.isEqual(paymentToken, feePaymentToken) ||
+      !Address.isEqual(feeRecipient, parameters.sender as Address.Address) ||
+      !Address.isEqual(feeApproval!.to as Address.Address, feeWrapper) ||
+      !Address.isEqual(feeSpender, sourceOft) ||
+      feeAmount !== wrappedAmount ||
+      wrappedAmount !== approvedFee ||
+      [tokenApproval, paymentApproval, wrapping, feeApproval, execution].some(
+        (call) => BigInt(call!.value) !== 0n,
+      )
+    )
+      throw new Provider.ProviderPayloadError()
+    const [first, fee, refund] = AbiFunction.decodeData(send, execution!.data as Hex.Hex)
+    const [onward] = AbiParameters.decode(sendParam, first.composeMsg)
+    if (
+      !Address.isEqual(execution!.to as Address.Address, sourceOft) ||
+      !Address.isEqual(refund, parameters.sender as Address.Address) ||
+      first.dstEid !== hubEid ||
+      !Hex.isEqual(first.to, Hex.padLeft(hubComposer, 32)) ||
+      first.amountLD !== amount ||
+      first.minAmountLD !== BigInt(parameters.destinationAmountMin) ||
+      first.oftCmd !== '0x' ||
+      onward.dstEid !== destinationEid ||
+      !Hex.isEqual(onward.to, Hex.padLeft(Tron.toEvmAddress(parameters.recipient), 32)) ||
+      onward.amountLD < BigInt(parameters.destinationAmountMin) ||
+      onward.amountLD > amount ||
+      onward.minAmountLD !== BigInt(parameters.destinationAmountMin) ||
+      onward.extraOptions !== '0x' ||
+      onward.composeMsg !== '0x' ||
+      onward.oftCmd !== '0x' ||
+      fee.lzTokenFee !== 0n ||
+      fee.nativeFee !== feeAmount ||
+      first.extraOptions.length !== composeOptions(0n).length ||
+      first.extraOptions.slice(0, -32) !== composeOptions(0n).slice(0, -32) ||
+      !Hex.isEqual(AbiFunction.encodeData(send, [first, fee, refund]), execution!.data as Hex.Hex)
+    )
+      throw new Provider.ProviderPayloadError()
+    return {
+      tokenApprovals: [
+        { amount: feeAmount.toString(), spender: feeWrapper, token: feePaymentToken },
+        { amount: feeAmount.toString(), spender: sourceOft, token: feeWrapper },
+      ],
+    }
+  } catch {
+    throw new Provider.ProviderPayloadError()
+  }
+}
+
+/** Verifies a settled Tempo send against its registered transfer and composed packet. */
+export async function verifySourceTransaction(
+  parameters: Provider.verifySourceTransaction.Parameters,
+  signal: AbortSignal,
+  options: Options = {},
+): Promise<Provider.verifySourceTransaction.ReturnType> {
+  if (!Hash.validate(parameters.transactionHash)) return { type: 'invalid' }
+  const { source } = clients(options, parameters.sourceChain, signal)
+  const hash = parameters.transactionHash as Hex.Hex
+  const [receipt, transaction] = await Promise.all([
+    source.getTransactionReceipt({ hash }).catch((cause) => {
+      if (cause instanceof TransactionReceiptNotFoundError) return undefined
+      throw cause
+    }),
+    source.getTransaction({ hash }),
+  ])
+  if (!receipt || !transaction) return { type: 'pending' }
+  const block = await source.getBlock({ blockNumber: receipt.blockNumber }).catch((cause) => {
+    if (cause instanceof BlockNotFoundError) return undefined
+    throw cause
+  })
+  if (!block || !Hex.isEqual(block.hash, receipt.blockHash)) return { type: 'pending' }
+  try {
+    const { providerState, transfer } = parameters
+    if (
+      receipt.status !== 'success' ||
+      block.timestamp < BigInt(Math.floor(Date.parse(transfer.quote.sampledAt) / 1_000)) ||
+      transfer.method !== 'transaction' ||
+      transfer.mode !== 'exactSource' ||
+      !transfer.sender ||
+      !transfer.destinationAmountMin ||
+      transfer.sourceChain.id !== 'eip155:4217' ||
+      transfer.destinationChain.id !== 'tron:0x2b6653dc' ||
+      !Address.isEqual(transfer.sourceToken.address as Address.Address, sourceToken) ||
+      transfer.destinationToken.address !== destinationToken
+    )
+      return { type: 'invalid' }
+    if (!Address.isEqual(transaction.from, transfer.sender as Address.Address))
+      return { type: 'invalid' }
+    const sent = parseEventLogs({ abi: [oftSent], logs: receipt.logs, strict: true }).filter(
+      ({ address, args }) =>
+        Address.isEqual(address, sourceOft) &&
+        args.dstEid === hubEid &&
+        Address.isEqual(args.fromAddress, transfer.sender as Address.Address) &&
+        args.amountSentLD === BigInt(transfer.sourceAmount.baseUnits) &&
+        args.amountReceivedLD >= BigInt(transfer.destinationAmountMin!.baseUnits) &&
+        args.amountReceivedLD <= BigInt(transfer.sourceAmount.baseUnits),
+    )
+    if (sent.length !== 1) {
+      const approvals = parseEventLogs({ abi: [approvalEvent], logs: receipt.logs, strict: true })
+      return approvals.some(
+        ({ address, args }) =>
+          Address.isEqual(address, sourceToken) &&
+          Address.isEqual(args.owner, transfer.sender as Address.Address) &&
+          Address.isEqual(args.spender, sourceOft),
+      )
+        ? { type: 'related' }
+        : { type: 'invalid' }
+    }
+    const event = sent[0]!
+    const transfers = parseEventLogs({
+      abi: [transferEvent],
+      logs: receipt.logs,
+      strict: true,
+    }).filter(
+      ({ address, args }) =>
+        Address.isEqual(address, sourceToken) &&
+        Address.isEqual(args.from, transfer.sender as Address.Address) &&
+        Address.isEqual(args.to, sourceOft) &&
+        args.value === BigInt(transfer.sourceAmount.baseUnits),
+    )
+    if (transfers.length !== 1) return { type: 'invalid' }
+    const sourceHopAmount = providerState?.['sourceHopAmount']
+    const quotedDestinationAmount = providerState?.['quotedDestinationAmount']
+    if (
+      typeof providerState?.['sourceDataHash'] !== 'string' ||
+      typeof sourceHopAmount !== 'string' ||
+      !/^[1-9]\d*$/.test(sourceHopAmount) ||
+      typeof quotedDestinationAmount !== 'string' ||
+      !/^[1-9]\d*$/.test(quotedDestinationAmount)
+    )
+      return { type: 'invalid' }
+    const packets = parseEventLogs({ abi: [packetSent], logs: receipt.logs, strict: true }).filter(
+      ({ address, args }) => {
+        const packet = args.encodedPayload
+        return (
+          Address.isEqual(address, sourceEndpoint) &&
+          Hex.size(packet) > 153 &&
+          Hex.toNumber(Hex.slice(packet, 0, 1)) === 1 &&
+          Hex.toNumber(Hex.slice(packet, 9, 13)) === sourceEid &&
+          Hex.isEqual(Hex.slice(packet, 13, 45), Hex.padLeft(sourceOft, 32)) &&
+          Hex.toNumber(Hex.slice(packet, 45, 49)) === hubEid &&
+          Hex.isEqual(Hex.slice(packet, 49, 81), Hex.padLeft(hubOft, 32)) &&
+          Hex.isEqual(Hex.slice(packet, 81, 113), event.args.guid) &&
+          Hex.isEqual(Hex.slice(packet, 113, 145), Hex.padLeft(hubComposer, 32)) &&
+          Hex.toBigInt(Hex.slice(packet, 145, 153)) === event.args.amountReceivedLD &&
+          Hex.isEqual(Hex.slice(packet, 153, 185), Hex.padLeft(transfer.sender! as Hex.Hex, 32)) &&
+          Hex.isEqual(
+            Hex.slice(packet, 185),
+            AbiParameters.encode(sendParam, [
+              onwardParam({
+                amount: BigInt(sourceHopAmount),
+                minimum: BigInt(transfer.destinationAmountMin!.baseUnits),
+                recipient: transfer.recipient,
+              }),
+            ]),
+          )
+        )
+      },
+    )
+    if (packets.length !== 1) return { type: 'invalid' }
+    const prior = providerState?.['legacyMeshOutbound']
+    if (
+      prior &&
+      (typeof prior !== 'object' || !('guid' in prior) || prior.guid !== event.args.guid)
+    )
+      return { type: 'invalid' }
+    return {
+      destinationAmount: quotedDestinationAmount,
+      providerState: {
+        ...providerState,
+        legacyMeshOutbound: {
+          amount: event.args.amountReceivedLD.toString(),
+          guid: event.args.guid,
+        },
+      },
+      type: 'verified',
+    }
+  } catch {
+    return { type: 'invalid' }
+  }
+}
+
+/** Verifies Arbitrum forwarding and the final solidified Tron receipt. */
+export async function verifyDestinationDelivery(
+  parameters: Provider.verifyDestinationDelivery.Parameters,
+  signal: AbortSignal,
+  options: Options = {},
+): Promise<Provider.verifyDestinationDelivery.ReturnType> {
+  return Delivery.verifyDestinationDelivery({ ...parameters, ...options, signal })
+}
+
+function onwardParam(options: { amount: bigint; minimum: bigint; recipient: string }) {
+  return {
+    amountLD: options.amount,
+    composeMsg: '0x' as const,
+    dstEid: destinationEid,
+    extraOptions: '0x' as const,
+    minAmountLD: options.minimum,
+    oftCmd: '0x' as const,
+    to: Hex.padLeft(Tron.toEvmAddress(options.recipient), 32),
+  }
+}
+
+function firstParam(options: {
+  amount: bigint
+  composeValue: bigint
+  minimum: bigint
+  onward: ReturnType<typeof onwardParam>
+}) {
+  return {
+    amountLD: options.amount,
+    composeMsg: AbiParameters.encode(sendParam, [options.onward]),
+    dstEid: hubEid,
+    extraOptions: composeOptions(options.composeValue),
+    minAmountLD: options.minimum,
+    oftCmd: '0x' as const,
+    to: Hex.padLeft(hubComposer, 32),
+  }
+}
+
+function composeOptions(value: bigint) {
+  return Hex.concat(
+    '0x0003010023030000',
+    Hex.fromNumber(500_000n, { size: 16 }),
+    Hex.fromNumber(value, { size: 16 }),
+  )
+}
+
+async function quoteAmount(options: {
+  amount: bigint
+  hub: ReturnType<typeof Viem.createEvmClient> & ReturnType<typeof publicActions>
+  recipient: string
+  source: ReturnType<typeof Viem.createEvmClient> & ReturnType<typeof publicActions>
+}) {
+  const onward = onwardParam({ amount: options.amount, minimum: 0n, recipient: options.recipient })
+  const first = firstParam({ amount: options.amount, composeValue: 0n, minimum: 0n, onward })
+  const [limit, , receipt] = await options.source.readContract({
+    abi: [quoteOft],
+    address: sourceOft,
+    args: [first],
+    functionName: 'quoteOFT',
+  })
+  if (options.amount < limit.minAmountLD || options.amount > limit.maxAmountLD)
+    throw new Provider.ProviderUnavailableError()
+  if (
+    receipt.amountSentLD !== options.amount ||
+    receipt.amountReceivedLD <= 0n ||
+    receipt.amountReceivedLD > options.amount
+  )
+    throw new Provider.ProviderPayloadError()
+  const hubParam = onwardParam({
+    amount: receipt.amountReceivedLD,
+    minimum: 0n,
+    recipient: options.recipient,
+  })
+  const [hubLimit, , hubReceipt] = await options.hub.readContract({
+    abi: [quoteOft],
+    address: hubAdapter,
+    args: [hubParam],
+    functionName: 'quoteOFT',
+  })
+  if (
+    receipt.amountReceivedLD < hubLimit.minAmountLD ||
+    receipt.amountReceivedLD > hubLimit.maxAmountLD
+  )
+    throw new Provider.ProviderUnavailableError()
+  if (
+    hubReceipt.amountSentLD !== receipt.amountReceivedLD ||
+    hubReceipt.amountReceivedLD <= 0n ||
+    hubReceipt.amountReceivedLD > receipt.amountReceivedLD
+  )
+    throw new Provider.ProviderPayloadError()
+  return { destinationAmount: hubReceipt.amountReceivedLD, hubAmount: receipt.amountReceivedLD }
+}
+
+function assertRoute(candidate: Provider.QuoteCandidate) {
+  if (
+    candidate.sourceChain.id !== 'eip155:4217' ||
+    candidate.destinationChain.id !== 'tron:0x2b6653dc' ||
+    !Address.isEqual(candidate.sourceToken.address as Address.Address, sourceToken) ||
+    candidate.destinationToken.address !== destinationToken ||
+    candidate.sourceToken.decimals !== 6 ||
+    candidate.destinationToken.decimals !== 6
+  )
+    throw new Provider.ProviderConfigurationError()
+}
+
+function quality() {
+  return {
+    liquiditySource: 'onchain',
+    sourceDetail: 'legacy-mesh:tempo-arbitrum-tron',
+    tier: 'liquid' as const,
+  }
+}