tapimo 0.15.1 → 0.18.1

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

@@ -0,0 +1,633 @@
+import { AbiEvent, AbiFunction, AbiParameters, Address, Hash, Hex } from 'ox'
+import { publicActions } from 'viem'
+import * as z from 'zod/mini'
+
+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 './legacyMeshDelivery.js'
+import * as Outbound from './legacyMeshOutbound.js'
+
+// Deployments: https://docs.usdt0.to/api/deployments. Keep the supported asset path pinned across catalog edits.
+const sourceToken = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
+const sourcePool = 'TFG4wBaDQ8sHWWP1ACeSGnoNR6RRzevLPt'
+const destinationToken = '0x20C00000000000000000000014f22CA97301EB73'
+const hubComposer = '0x759BA420bF1ded1765F18C2DC3Fc57A1964A2Ad1'
+const hubOft = '0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92'
+const hubRpcUrls = ['https://arb1.arbitrum.io/rpc']
+const hubEid = 30_110
+const destinationEid = 30_410
+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 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)',
+)
+
+/** Creates the direct Tron USDT to Tempo USDT0 Legacy Mesh provider. */
+export function legacyMesh(options: legacyMesh.Options = {}) {
+  const resolveRpcUrls = options.resolveRpcUrls ?? ((chain: Chain.Chain) => chain.rpcUrls)
+  function clients(chain: Chain.Chain, signal: AbortSignal) {
+    return {
+      hub: Viem.createEvmClient({
+        chainId: 42161,
+        fetch: options.fetch ?? globalThis.fetch,
+        signal,
+        urls: options.hubRpcUrls ?? hubRpcUrls,
+      }).extend(publicActions),
+      source: Tron.createClient({
+        fetch: options.fetch ?? globalThis.fetch,
+        signal,
+        urls: resolveRpcUrls(chain),
+      }),
+    }
+  }
+  return Provider.from({
+    id: 'legacy-mesh',
+    name: 'USDT0 Legacy Mesh',
+    async getQuote(parameters, signal) {
+      const { candidate, route } = parameters
+      if (
+        candidate.sourceChain.id === 'eip155:4217' &&
+        candidate.destinationChain.id === 'tron:0x2b6653dc'
+      )
+        return Outbound.getQuote(parameters, signal, options)
+      try {
+        assertRoute(candidate)
+        const { hub, source } = clients(route.source.chain, signal)
+        const amount = await quoteAmount({
+          amount: BigInt(candidate.sourceAmount.amount),
+          hub,
+          source,
+        })
+        return {
+          destinationAmount: amount.toString(),
+          destinationAmountMin: amount.toString(),
+          quality: quality(),
+          sampledAt: new Date().toISOString(),
+          status: 'available' as const,
+        }
+      } catch (cause) {
+        if (!(cause instanceof Provider.ProviderUnavailableError)) throw cause
+        return Provider.unavailableResult({
+          detail: 'legacy-mesh:tron-arbitrum-tempo',
+          message: 'amount-outside-liquidity-limits',
+          now: new Date(),
+          source: 'onchain',
+        })
+      }
+    },
+    async prepareTransfer(parameters, signal) {
+      if (
+        parameters.candidate.sourceChain.id === 'eip155:4217' &&
+        parameters.candidate.destinationChain.id === 'tron:0x2b6653dc'
+      )
+        return Outbound.prepareTransfer(parameters, signal, options)
+      const { candidate, method, mode, recipient, sender, slippageBps } = parameters
+      assertRoute(candidate)
+      if (
+        method !== 'transaction' ||
+        mode !== 'exactSource' ||
+        !Address.validate(recipient, { strict: false })
+      )
+        throw new Provider.ProviderConfigurationError()
+      Tron.toEvmAddress(sender)
+      const { hub, source } = clients(candidate.route.source.chain, signal)
+      const destination = Viem.createEvmClient({
+        chainId: 4217,
+        fetch: options.fetch ?? globalThis.fetch,
+        signal,
+        urls: resolveRpcUrls(candidate.route.destination.chain),
+      }).extend(publicActions)
+      const amount = await quoteAmount({
+        amount: BigInt(candidate.sourceAmount.amount),
+        hub,
+        source,
+      })
+      const quotedMinimum = (amount * BigInt(10_000 - (slippageBps ?? 0))) / 10_000n
+      const minimum = quotedMinimum > 0n ? quotedMinimum : 1n
+      const onward = onwardParam({ amount, recipient })
+      const fee = await hub.readContract({
+        abi: [quoteSend],
+        address: hubOft,
+        args: [onward, false],
+        functionName: 'quoteSend',
+      })
+      if (fee.lzTokenFee !== 0n) throw new Provider.ProviderPayloadError()
+      // The composer spends this native value on hop two; reserve 10% for fee movement before delivery.
+      const composeValue = (fee.nativeFee * 110n + 99n) / 100n
+      const first = firstParam({
+        amount: BigInt(candidate.sourceAmount.amount),
+        composeValue,
+        minimum,
+        onward,
+      })
+      const messagingFee = AbiFunction.decodeResult(
+        quoteSend,
+        await source.call({
+          data: AbiFunction.encodeData(quoteSend, [first, false]),
+          from: sender,
+          to: sourcePool,
+        }),
+      )
+      if (
+        messagingFee.lzTokenFee !== 0n ||
+        messagingFee.nativeFee > BigInt(Number.MAX_SAFE_INTEGER)
+      )
+        throw new Provider.ProviderPayloadError()
+      const [hubBlock, destinationBlock] = await Promise.all([
+        hub.getBlockNumber(),
+        destination.getBlockNumber(),
+      ])
+      const action: Action.TronCalls = {
+        calls: [
+          // Reset first so USDT approvals remain valid when the sender already has a nonzero allowance.
+          {
+            data: AbiFunction.encodeData(approve, [Tron.toEvmAddress(sourcePool), 0n]),
+            to: sourceToken,
+            value: '0x0',
+          },
+          {
+            data: AbiFunction.encodeData(approve, [
+              Tron.toEvmAddress(sourcePool),
+              BigInt(candidate.sourceAmount.amount),
+            ]),
+            to: sourceToken,
+            value: '0x0',
+          },
+          {
+            data: AbiFunction.encodeData(send, [first, messagingFee, Tron.toEvmAddress(sender)]),
+            to: sourcePool,
+            value: Hex.fromNumber(messagingFee.nativeFee),
+          },
+        ],
+        type: 'tron:calls',
+      }
+      validateAction({ ...parameters, action, destinationAmountMin: minimum.toString() })
+      const sampledAt = new Date()
+      return {
+        action,
+        destinationAmount: amount.toString(),
+        destinationAmountMin: minimum.toString(),
+        expiresAt: new Date(sampledAt.getTime() + quoteTtlMs).toISOString(),
+        fees: [
+          {
+            amount: messagingFee.nativeFee.toString(),
+            side: 'source' as const,
+            token: {
+              address: 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb',
+              currency: 'TRX',
+              decimals: 6,
+              name: 'TRON',
+              standard: 'native',
+              symbol: 'TRX',
+              tokenKey: 'tron:0x2b6653dc/slip44:195',
+              verified: true,
+            },
+          },
+        ],
+        providerState: {
+          destinationBlockNumber: destinationBlock.toString(),
+          hubBlockNumber: hubBlock.toString(),
+          quotedDestinationAmount: amount.toString(),
+          sourceDataHash: Hash.keccak256(action.calls.at(-1)!.data as Hex.Hex),
+          sourceCallValue: action.calls.at(-1)!.value,
+        },
+        quality: quality(),
+        sampledAt: sampledAt.toISOString(),
+      }
+    },
+    validateTransferAction(parameters) {
+      if (
+        parameters.candidate.sourceChain.id === 'eip155:4217' &&
+        parameters.candidate.destinationChain.id === 'tron:0x2b6653dc'
+      )
+        return Outbound.validateTransferAction(parameters)
+      return validateAction(parameters)
+    },
+    async verifyDestinationDelivery(parameters, signal) {
+      if (
+        parameters.sourceChain.id === 'eip155:4217' &&
+        parameters.destinationChain.id === 'tron:0x2b6653dc'
+      )
+        return Outbound.verifyDestinationDelivery(parameters, signal, options)
+      return Delivery.verifyDestinationDelivery({
+        ...parameters,
+        fetch: options.fetch ?? globalThis.fetch,
+        hubRpcUrls: options.hubRpcUrls ?? hubRpcUrls,
+        resolveRpcUrls,
+        signal,
+      })
+    },
+    async verifySourceTransaction(parameters, signal) {
+      if (
+        parameters.sourceChain.id === 'eip155:4217' &&
+        parameters.destinationChain.id === 'tron:0x2b6653dc'
+      )
+        return Outbound.verifySourceTransaction(parameters, signal, options)
+      const source = Tron.createClient({
+        fetch: options.fetch ?? globalThis.fetch,
+        signal,
+        urls: resolveRpcUrls(parameters.sourceChain),
+      })
+      try {
+        const receipt = await source.getTransactionReceipt({ hash: parameters.transactionHash })
+        if (!receipt) return { type: 'pending' }
+        const transaction = await source.getTransaction({ hash: parameters.transactionHash })
+        if (!transaction) return { type: 'pending' }
+        return verifySourceEvidence({ ...parameters, receipt, transaction })
+      } catch (cause) {
+        // Non-contract transactions are invalid evidence; transport failures remain retryable.
+        if (cause instanceof z.core.$ZodError) return { type: 'invalid' }
+        throw cause
+      }
+    },
+  })
+}
+
+export declare namespace legacyMesh {
+  /** Chain access for Legacy Mesh quotes and reconciliation. */
+  type Options = {
+    /** Fetch implementation for chain RPC requests. */
+    fetch?: Provider.Fetch | undefined
+    /** Arbitrum endpoints used by the intermediate composer. */
+    hubRpcUrls?: readonly string[] | undefined
+    /** Preferred endpoints for the route's source and destination chains. */
+    resolveRpcUrls?: ((chain: Chain.Chain) => readonly string[]) | undefined
+  }
+}
+
+/** Checks solidified Tron receipt and transaction evidence against the prepared transfer. */
+export function verifySourceEvidence(
+  options: verifySourceEvidence.Options,
+): Provider.verifySourceTransaction.ReturnType {
+  try {
+    const { providerState, transfer } = options
+    const receipt = Tron.schema.Receipt.parse(options.receipt)
+    const transaction = Tron.schema.Transaction.parse(options.transaction)
+    const hash = options.transactionHash.replace(/^0x/, '').toLowerCase()
+    if (receipt.id.toLowerCase() !== hash || transaction.txID.toLowerCase() !== hash)
+      return { type: 'invalid' }
+    if (
+      transfer.method !== 'transaction' ||
+      transfer.mode !== 'exactSource' ||
+      !transfer.sender ||
+      !transfer.destinationAmountMin ||
+      !transfer.destinationAmount
+    )
+      return { type: 'invalid' }
+    if (
+      transfer.sourceChain.id !== 'tron:0x2b6653dc' ||
+      transfer.destinationChain.id !== 'eip155:4217' ||
+      transfer.sourceToken.address !== sourceToken ||
+      !Address.isEqual(transfer.destinationToken.address as Address.Address, destinationToken)
+    )
+      return { type: 'invalid' }
+    if (
+      receipt.receipt.result !== 'SUCCESS' ||
+      (receipt.result && receipt.result !== 'SUCCESS') ||
+      receipt.blockTimeStamp < Date.parse(transfer.quote.sampledAt)
+    )
+      return { type: 'invalid' }
+    if (
+      transaction.raw_data.contract.length !== 1 ||
+      transaction.ret.some((entry) => entry.contractRet !== 'SUCCESS')
+    )
+      return { type: 'invalid' }
+    const call = transaction.raw_data.contract[0]!.parameter.value
+    if (
+      call.owner_address.slice(2).toLowerCase() !==
+      Tron.toEvmAddress(transfer.sender).slice(2).toLowerCase()
+    )
+      return { type: 'invalid' }
+    const target = Tron.fromEvmAddress(`0x${call.contract_address.slice(2)}`)
+    const data: Hex.Hex = `0x${call.data}`
+    if (target === sourceToken) {
+      const [spender, amount] = AbiFunction.decodeData(approve, data)
+      if (
+        !Address.isEqual(spender, Tron.toEvmAddress(sourcePool)) ||
+        amount > BigInt(transfer.sourceAmount.baseUnits) ||
+        (call.call_value ?? 0) !== 0
+      )
+        return { type: 'invalid' }
+      return { type: 'related' }
+    }
+    if (
+      providerState?.['sourceDataHash'] !== Hash.keccak256(data) ||
+      typeof providerState?.['sourceCallValue'] !== 'string' ||
+      BigInt(providerState['sourceCallValue']) !== BigInt(call.call_value ?? 0)
+    )
+      return { type: 'invalid' }
+    const decoded = validateSend({
+      data,
+      minimum: BigInt(transfer.destinationAmountMin.baseUnits),
+      recipient: transfer.recipient,
+      sender: transfer.sender,
+      sourceAmount: BigInt(transfer.sourceAmount.baseUnits),
+      to: target,
+      value: BigInt(call.call_value ?? 0),
+    })
+    if (decoded.onward.amountLD.toString() !== providerState?.['quotedDestinationAmount'])
+      return { type: 'invalid' }
+    const logs = (receipt.log ?? []).filter(
+      (log) =>
+        log.address.toLowerCase() === Tron.toEvmAddress(sourcePool).slice(2).toLowerCase() &&
+        log.topics[0]?.toLowerCase() === AbiEvent.getSelector(oftSent).slice(2).toLowerCase(),
+    )
+    if (logs.length !== 1) return { type: 'invalid' }
+    const event = AbiEvent.decode(oftSent, {
+      data: `0x${logs[0]!.data}`,
+      topics: logs[0]!.topics.map((topic) => `0x${topic}`) as [Hex.Hex, ...Hex.Hex[]],
+    })
+    if (
+      event.dstEid !== hubEid ||
+      !Address.isEqual(event.fromAddress, Tron.toEvmAddress(transfer.sender)) ||
+      event.amountSentLD !== BigInt(transfer.sourceAmount.baseUnits) ||
+      event.amountReceivedLD < BigInt(transfer.destinationAmountMin.baseUnits) ||
+      event.amountReceivedLD > BigInt(transfer.sourceAmount.baseUnits)
+    )
+      return { type: 'invalid' }
+    const prior = providerState?.['legacyMesh']
+    if (
+      prior &&
+      (typeof prior !== 'object' ||
+        !('guid' in prior) ||
+        !('amount' in prior) ||
+        prior.guid !== event.guid ||
+        prior.amount !== event.amountReceivedLD.toString())
+    )
+      return { type: 'invalid' }
+    if (
+      typeof providerState?.['hubBlockNumber'] !== 'string' ||
+      typeof providerState?.['destinationBlockNumber'] !== 'string'
+    )
+      return { type: 'invalid' }
+    return {
+      destinationAmount: event.amountReceivedLD.toString(),
+      providerState: {
+        ...providerState,
+        legacyMesh: { amount: event.amountReceivedLD.toString(), guid: event.guid },
+      },
+      type: 'verified',
+    }
+  } catch {
+    return { type: 'invalid' }
+  }
+}
+
+export declare namespace verifySourceEvidence {
+  /** Prepared transfer terms and untrusted native chain responses. */
+  type Options = Pick<
+    Provider.verifySourceTransaction.Parameters,
+    'providerState' | 'transactionHash' | 'transfer'
+  > & {
+    /** Solidified execution receipt from the native Tron API. */
+    receipt: unknown
+    /** Solidified transaction from the native Tron API. */
+    transaction: unknown
+  }
+}
+
+/** Checks the exact approvals, composed recipient, amounts, fee, and refund account. */
+export function validateAction(
+  options: Provider.validateTransferAction.Parameters,
+): Provider.validateTransferAction.ReturnType {
+  try {
+    assertRoute(options.candidate)
+    const action = Action.schema.TronCalls.parse(options.action)
+    if (action.calls.length !== 3) throw new Provider.ProviderPayloadError()
+    const [reset, approval, execution] = action.calls
+    const amount = BigInt(options.candidate.sourceAmount.amount)
+    if (
+      reset!.to !== sourceToken ||
+      BigInt(reset!.value) !== 0n ||
+      reset!.data.toLowerCase() !==
+        AbiFunction.encodeData(approve, [Tron.toEvmAddress(sourcePool), 0n]).toLowerCase()
+    )
+      throw new Provider.ProviderPayloadError()
+    if (
+      approval!.to !== sourceToken ||
+      BigInt(approval!.value) !== 0n ||
+      approval!.data.toLowerCase() !==
+        AbiFunction.encodeData(approve, [Tron.toEvmAddress(sourcePool), amount]).toLowerCase()
+    )
+      throw new Provider.ProviderPayloadError()
+    validateSend({
+      data: execution!.data as Hex.Hex,
+      minimum: BigInt(options.destinationAmountMin),
+      recipient: options.recipient,
+      sender: options.sender,
+      sourceAmount: amount,
+      to: execution!.to,
+      value: BigInt(execution!.value),
+    })
+    return { nativeValues: [{ to: sourcePool, value: execution!.value }] }
+  } catch {
+    throw new Provider.ProviderPayloadError()
+  }
+}
+
+function validateSend(options: validateSend.Options) {
+  if (options.to !== sourcePool || options.value > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new Provider.ProviderPayloadError()
+  const [first, fee, refund] = AbiFunction.decodeData(send, options.data)
+  const [onward] = AbiParameters.decode(sendParam, first.composeMsg)
+  if (
+    first.dstEid !== hubEid ||
+    !Hex.isEqual(first.to, Hex.padLeft(hubComposer, 32)) ||
+    first.amountLD !== options.sourceAmount ||
+    first.minAmountLD !== options.minimum ||
+    first.oftCmd !== '0x' ||
+    fee.lzTokenFee !== 0n ||
+    fee.nativeFee !== options.value ||
+    !Address.isEqual(refund, Tron.toEvmAddress(options.sender)) ||
+    onward.dstEid !== destinationEid ||
+    !Hex.isEqual(onward.to, Hex.padLeft(options.recipient as Hex.Hex, 32)) ||
+    onward.amountLD < options.minimum ||
+    onward.amountLD > options.sourceAmount ||
+    onward.minAmountLD !== 0n ||
+    onward.extraOptions !== '0x' ||
+    onward.composeMsg !== '0x' ||
+    onward.oftCmd !== '0x'
+  )
+    throw new Provider.ProviderPayloadError()
+  // Type 3 executor compose option: worker 1, size 35, type 3, index 0, gas 500000, native value.
+  const prefix = composeOptions(0n).slice(0, -32)
+  if (
+    first.extraOptions.length !== composeOptions(0n).length ||
+    first.extraOptions.slice(0, -32) !== prefix
+  )
+    throw new Provider.ProviderPayloadError()
+  if (!Hex.isEqual(AbiFunction.encodeData(send, [first, fee, refund]), options.data))
+    throw new Provider.ProviderPayloadError()
+  return { onward }
+}
+
+declare namespace validateSend {
+  /** Expected prepared source-call terms. */
+  type Options = {
+    /** Complete source contract calldata. */
+    data: Hex.Hex
+    /** Minimum destination amount. */
+    minimum: bigint
+    /** Final Tempo beneficiary. */
+    recipient: string
+    /** Tron account signing the source transaction. */
+    sender: string
+    /** Expected source USDT amount. */
+    sourceAmount: bigint
+    /** Target Tron contract address. */
+    to: string
+    /** Attached native value in sun. */
+    value: bigint
+  }
+}
+
+async function quoteAmount(options: quoteAmount.Options) {
+  const first = firstParam({
+    amount: options.amount,
+    composeValue: 0n,
+    minimum: 0n,
+    onward: onwardParam({
+      amount: options.amount,
+      recipient: '0x0000000000000000000000000000000000000001',
+    }),
+  })
+  const [limit, , receipt] = AbiFunction.decodeResult(
+    quoteOft,
+    await options.source.call({ data: AbiFunction.encodeData(quoteOft, [first]), to: sourcePool }),
+  )
+  // Legacy Mesh deducts fees from its receipt without necessarily populating the optional fee-details array.
+  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 onward = onwardParam({
+    amount: receipt.amountReceivedLD,
+    recipient: '0x0000000000000000000000000000000000000001',
+  })
+  const [hubLimit, , hubReceipt] = await options.hub.readContract({
+    abi: [quoteOft],
+    address: hubOft,
+    args: [onward],
+    functionName: 'quoteOFT',
+  })
+  // The composer clears minAmountLD, so accept only the native OFT's exact, fee-free onward path.
+  if (
+    receipt.amountReceivedLD < hubLimit.minAmountLD ||
+    receipt.amountReceivedLD > hubLimit.maxAmountLD
+  )
+    throw new Provider.ProviderUnavailableError()
+  if (
+    hubReceipt.amountSentLD !== receipt.amountReceivedLD ||
+    hubReceipt.amountReceivedLD !== receipt.amountReceivedLD
+  )
+    throw new Provider.ProviderPayloadError()
+  return receipt.amountReceivedLD
+}
+
+declare namespace quoteAmount {
+  /** Source amount and read-only clients for both hops. */
+  type Options = {
+    /** Source USDT amount in base units. */
+    amount: bigint
+    /** Arbitrum client used for onward liquidity checks. */
+    hub: ReturnType<typeof Viem.createEvmClient> & ReturnType<typeof publicActions>
+    /** Tron client used for source pool quotes. */
+    source: ReturnType<typeof Tron.createClient>
+  }
+}
+
+function onwardParam(options: onwardParam.Options) {
+  return {
+    amountLD: options.amount,
+    composeMsg: '0x' as const,
+    dstEid: destinationEid,
+    extraOptions: '0x' as const,
+    minAmountLD: 0n,
+    oftCmd: '0x' as const,
+    to: Hex.padLeft(options.recipient as Hex.Hex, 32),
+  }
+}
+
+declare namespace onwardParam {
+  /** Amount and final beneficiary for the Arbitrum-to-Tempo hop. */
+  type Options = {
+    /** Token amount in base units. */
+    amount: bigint
+    /** Final Tempo beneficiary. */
+    recipient: string
+  }
+}
+
+function firstParam(options: firstParam.Options) {
+  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),
+  }
+}
+
+declare namespace firstParam {
+  /** Source send and destination composition parameters. */
+  type Options = {
+    /** Source USDT amount in base units. */
+    amount: bigint
+    /** Arbitrum native value reserved for onward messaging. */
+    composeValue: bigint
+    /** Minimum accepted receipt amount. */
+    minimum: bigint
+    /** ABI parameters forwarded to the hub composer. */
+    onward: ReturnType<typeof onwardParam>
+  }
+}
+
+function composeOptions(value: bigint) {
+  // The LayerZero composition guide budgets 500000 gas for the composer; source receive gas is enforced on-chain.
+  return Hex.concat(
+    '0x0003010023030000',
+    Hex.fromNumber(500_000n, { size: 16 }),
+    Hex.fromNumber(value, { size: 16 }),
+  )
+}
+
+function assertRoute(candidate: Provider.prepareTransfer.Parameters['candidate']) {
+  if (
+    candidate.sourceChain.id !== 'tron:0x2b6653dc' ||
+    candidate.destinationChain.id !== 'eip155:4217' ||
+    candidate.sourceToken.address !== sourceToken ||
+    !Address.isEqual(candidate.destinationToken.address as Address.Address, destinationToken) ||
+    candidate.sourceToken.decimals !== 6 ||
+    candidate.destinationToken.decimals !== 6
+  )
+    throw new Provider.ProviderConfigurationError()
+}
+
+function quality() {
+  return {
+    liquiditySource: 'onchain',
+    sourceDetail: 'legacy-mesh:tron-arbitrum-tempo',
+    tier: 'liquid' as const,
+  }
+}