tapimo 0.15.0 → 0.18.0

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

@@ -1,11 +1,15 @@
 import { Address } from 'ox'
 import * as z from 'zod/mini'
 
+import * as Store from '../../Store.js'
 import * as RoutesChain from '../Chain.js'
 import * as RoutesProvider from '../Provider.js'
+import * as ProviderQuota from '../Quota.js'
 
 const defaultBaseUrl = 'https://app.across.to/api'
 const defaultFetch: RoutesProvider.Fetch = (input, init) => globalThis.fetch(input, init)
+const rateLimitWindowMs = 1_000
+const quotaStoreKey = 'routes:across:swap-approval'
 
 namespace schema {
   const IntegerString = z.string().check(z.regex(/^\d+$/))
@@ -39,6 +43,7 @@ export function across(options: across.Options) {
   endpoint.pathname = `${endpoint.pathname.replace(/\/+$/, '')}/swap/approval`
   const fetch = options.fetch ?? defaultFetch
   const now = options.now ?? (() => new Date())
+  const rateLimitStore = options.rateLimitStore ?? Store.memory()
 
   return RoutesProvider.from({
     id: 'across',
@@ -62,6 +67,7 @@ export function across(options: across.Options) {
       }).toString()
 
       try {
+        await ProviderQuota.check(rateLimitStore, { key: quotaStoreKey, now: now() })
         const quote = await RoutesProvider.requestJson(url, {
           fetch,
           headers: { Authorization: `Bearer ${options.apiKey}` },
@@ -98,6 +104,11 @@ export function across(options: across.Options) {
           status: 'available',
         }
       } catch (cause) {
+        await ProviderQuota.blockOnRateLimit(rateLimitStore, cause, {
+          key: quotaStoreKey,
+          now: now(),
+          windowMs: rateLimitWindowMs,
+        })
         const unavailable = RoutesProvider.unavailable(cause, [
           'AMOUNT_TOO_HIGH',
           'AMOUNT_TOO_LOW',
@@ -131,6 +142,8 @@ export declare namespace across {
     integratorId: string
     /** Clock override for deterministic tests. */
     now?: (() => Date) | undefined
+    /** Store used to coordinate provider-reported cooldowns. */
+    rateLimitStore?: Store.Store | undefined
     /** Quote wallet address used as the Across depositor and recipient. */
     userAddress: string
   }

package/src/internal/routes/providers/index.test.ts

@@ -311,6 +311,147 @@ describe('route providers', () => {
     })
   })
 
+  test('enforces the Squid integrator-wide quota', async () => {
+    const candidate = quoteCandidate('squid')
+    const rateLimitStore = Store.memory()
+    await rateLimitStore.put(
+      'routes:squid:integrator',
+      JSON.stringify({
+        bucket: Math.floor(now().getTime() / 1_000),
+        count: 10,
+        tenants: [],
+      }),
+    )
+    const requests: RecordedRequest[] = []
+    const provider = Squid.squid({
+      fetch: recordingFetch(requests, async () => jsonResponse(squidQuote(candidate))),
+      integratorId: 'squid-integrator-id',
+      now,
+      rateLimitStore,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    await expect(
+      provider.getQuote(getQuoteInput(candidate), new AbortController().signal),
+    ).rejects.toBeInstanceOf(RoutesProvider.ProviderRateLimitError)
+    expect(requests).toHaveLength(0)
+  })
+
+  test('honors Squid Retry-After cooldowns after an upstream 429', async () => {
+    const candidate = quoteCandidate('squid')
+    const rateLimitStore = Store.memory()
+    const requests: RecordedRequest[] = []
+    let time = now()
+    const provider = Squid.squid({
+      fetch: recordingFetch(requests, async () =>
+        requests.length === 1
+          ? new Response(JSON.stringify({ message: 'rate limited' }), {
+              headers: { 'content-type': 'application/json', 'retry-after': '2' },
+              status: 429,
+            })
+          : jsonResponse(squidQuote(candidate)),
+      ),
+      integratorId: 'squid-integrator-id',
+      now: () => time,
+      rateLimitStore,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+    const input = getQuoteInput(candidate)
+    const signal = new AbortController().signal
+
+    await expect(provider.getQuote(input, signal)).rejects.toMatchObject({
+      retryAfterMs: 2_000,
+      status: 429,
+    })
+    await expect(provider.getQuote(input, signal)).rejects.toBeInstanceOf(
+      RoutesProvider.ProviderRateLimitError,
+    )
+    expect(requests).toHaveLength(1)
+
+    time = new Date(time.getTime() + 1_001)
+    await expect(provider.getQuote(input, signal)).rejects.toBeInstanceOf(
+      RoutesProvider.ProviderRateLimitError,
+    )
+    expect(requests).toHaveLength(1)
+
+    time = new Date(time.getTime() + 1_000)
+    await expect(provider.getQuote(input, signal)).resolves.toMatchObject({ status: 'available' })
+    expect(requests).toHaveLength(2)
+  })
+
+  const adaptiveCooldownProviders: readonly {
+    create: (
+      fetch: RoutesProvider.Fetch,
+      rateLimitStore: Store.Store,
+      clock: () => Date,
+    ) => RoutesProvider.Provider
+    id: 'across' | 'rhino' | 'symbiosis'
+  }[] = [
+    {
+      create: (fetch, rateLimitStore, clock) =>
+        Across.across({
+          apiKey: 'across-api-key',
+          fetch,
+          integratorId: '0xdead',
+          now: clock,
+          rateLimitStore,
+          userAddress: '0x1111111111111111111111111111111111111111',
+        }),
+      id: 'across',
+    },
+    {
+      create: (fetch, rateLimitStore, clock) => Rhino.rhino({ fetch, now: clock, rateLimitStore }),
+      id: 'rhino',
+    },
+    {
+      create: (fetch, rateLimitStore, clock) =>
+        Symbiosis.symbiosis({
+          fetch,
+          now: clock,
+          rateLimitStore,
+          userAddress: '0x1111111111111111111111111111111111111111',
+        }),
+      id: 'symbiosis',
+    },
+  ]
+
+  for (const scenario of adaptiveCooldownProviders)
+    test(`honors ${scenario.id} Retry-After cooldowns after an upstream 429`, async () => {
+      const candidate = quoteCandidate(scenario.id)
+      const rateLimitStore = Store.memory()
+      const requests: RecordedRequest[] = []
+      let time = now()
+      const provider = scenario.create(
+        recordingFetch(
+          requests,
+          async () =>
+            new Response(JSON.stringify({ message: 'rate limited' }), {
+              headers: { 'content-type': 'application/json', 'retry-after': '2' },
+              status: 429,
+            }),
+        ),
+        rateLimitStore,
+        () => time,
+      )
+      const input = getQuoteInput(candidate)
+      const signal = new AbortController().signal
+
+      await expect(provider.getQuote(input, signal)).rejects.toMatchObject({
+        cooldownMs: 2_000,
+        retryAfterMs: 2_000,
+        status: 429,
+      })
+      time = new Date(time.getTime() + 1_001)
+      await expect(provider.getQuote(input, signal)).rejects.toBeInstanceOf(
+        RoutesProvider.ProviderRateLimitError,
+      )
+      expect(requests).toHaveLength(1)
+
+      time = new Date(time.getTime() + 1_000)
+      await expect(provider.getQuote(input, signal)).rejects.toMatchObject({ status: 429 })
+      expect(requests).toHaveLength(2)
+    })
+
   test('maps unavailable Squid routes to unavailable quote results', async () => {
     const candidate = quoteCandidate('squid')
     const provider = Squid.squid({

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

@@ -0,0 +1,484 @@
+import { AbiEvent, AbiFunction, AbiParameters, Hash, Hex } from 'ox'
+import { describe, expect, test } from 'vitest'
+
+import * as TestRoutes from '../../../../test/Routes.js'
+import * as Tron from '../../Tron.js'
+import type * as Action from '../Action.js'
+import * as Provider from '../Provider.js'
+import * as LegacyMesh from './legacyMesh.js'
+
+const amount = 10_000_000n
+const minimum = 9_900_000n
+const nativeFee = 100_000n
+const pool = 'TFG4wBaDQ8sHWWP1ACeSGnoNR6RRzevLPt'
+const recipient = '0x1111111111111111111111111111111111111111'
+const sender = Tron.fromEvmAddress('0x2222222222222222222222222222222222222222')
+const other = '0x3333333333333333333333333333333333333333'
+const sourceToken = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
+const approve = AbiFunction.from('function approve(address spender, uint256 amount) returns (bool)')
+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 sendParam = AbiParameters.from(
+  '(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd)',
+)
+const candidate = Provider.getQuoteCandidates({
+  catalog: TestRoutes.snapshot,
+  destinationToken: 'USDT0',
+  providers: [LegacyMesh.legacyMesh()],
+  sourceAmount: amount.toString(),
+  sourceAmountUnits: 'baseUnits',
+  sourceChain: 'tron',
+  sourceToken: 'USDT',
+})[0]!
+
+describe('validateAction', () => {
+  test('accepts the Tron approval and two-hop compose send from the curated route', () => {
+    expect(candidate.provider.id).toMatchInlineSnapshot('"legacy-mesh"')
+    expect(validate(action())).toMatchInlineSnapshot(`
+      {
+        "nativeValues": [
+          {
+            "to": "TFG4wBaDQ8sHWWP1ACeSGnoNR6RRzevLPt",
+            "value": "0x186a0",
+          },
+        ],
+      }
+    `)
+  })
+
+  test.each([
+    ['source amount', { first: { amountLD: amount + 1n } }],
+    ['minimum amount', { first: { minAmountLD: minimum - 1n } }],
+    ['hub endpoint', { first: { dstEid: 30_101 } }],
+    ['hub composer', { first: { to: Hex.padLeft(other, 32) } }],
+    ['first-hop command', { first: { oftCmd: '0x01' } }],
+    ['destination endpoint', { onward: { dstEid: 30_101 } }],
+    ['recipient', { onward: { to: Hex.padLeft(other, 32) } }],
+    ['onward amount below minimum', { onward: { amountLD: minimum - 1n } }],
+    ['onward amount above source', { onward: { amountLD: amount + 1n } }],
+    ['onward minimum overwritten by composer', { onward: { minAmountLD: 1n } }],
+    ['onward options', { onward: { extraOptions: '0x0003' } }],
+    ['recursive composition', { onward: { composeMsg: '0x01' } }],
+    ['onward command', { onward: { oftCmd: '0x01' } }],
+    ['refund address', { refund: other }],
+    ['LZ token fee', { fee: { lzTokenFee: 1n } }],
+    ['native fee mismatching value', { fee: { nativeFee: nativeFee + 1n } }],
+    ['malformed composed ABI', { first: { composeMsg: '0x1234' } }],
+    ['missing executor compose options', { first: { extraOptions: '0x' } }],
+    [
+      'wrong executor option type',
+      {
+        first: {
+          extraOptions: Hex.concat(
+            '0x0003010023020000',
+            Hex.fromNumber(500_000n, { size: 16 }),
+            Hex.fromNumber(1n, { size: 16 }),
+          ),
+        },
+      },
+    ],
+  ] satisfies readonly (readonly [string, action.Options])[])(
+    'rejects changed %s',
+    (_, options) => {
+      expect(() => validate(action(options))).toThrowError(Provider.ProviderPayloadError)
+    },
+  )
+
+  test('rejects excess approvals, wrong spender, and attached TRX', () => {
+    for (const approval of [
+      {
+        data: AbiFunction.encodeData(approve, [Tron.toEvmAddress(pool), amount + 1n]),
+        to: sourceToken,
+        value: '0x0',
+      },
+      { data: AbiFunction.encodeData(approve, [other, amount]), to: sourceToken, value: '0x0' },
+      { ...action().calls[0]!, to: sender },
+      { ...action().calls[0]!, value: '0x1' },
+    ]) {
+      const value = action()
+      value.calls[1] = approval
+      expect(() => validate(value)).toThrowError(Provider.ProviderPayloadError)
+    }
+  })
+
+  test('rejects a nonzero approval reset', () => {
+    const value = action()
+    value.calls[0]!.data = AbiFunction.encodeData(approve, [Tron.toEvmAddress(pool), 1n])
+    expect(() => validate(value)).toThrowError(Provider.ProviderPayloadError)
+  })
+
+  test('rejects malformed calldata, extra calls, and unsupported action type', () => {
+    const malformed = action()
+    malformed.calls[2]!.data = '0x1234'
+    const trailing = action()
+    trailing.calls[2]!.data += '00'
+    const extra = action()
+    extra.calls.push(extra.calls[0]!)
+    const target = action()
+    target.calls[2]!.to = sourceToken
+    for (const value of [
+      malformed,
+      trailing,
+      extra,
+      target,
+      { ...action(), type: 'evm:calls' as const },
+    ])
+      expect(() => validate(value)).toThrowError(Provider.ProviderPayloadError)
+  })
+
+  test('rejects a catalog candidate with the wrong asset', () => {
+    expect(() =>
+      LegacyMesh.validateAction({
+        action: action(),
+        candidate: { ...candidate, sourceToken: { ...candidate.sourceToken, address: pool } },
+        destinationAmountMin: minimum.toString(),
+        method: 'transaction',
+        mode: 'exactSource',
+        recipient,
+        sender,
+      }),
+    ).toThrowError(Provider.ProviderPayloadError)
+  })
+})
+
+function validate(action: Action.Action) {
+  return LegacyMesh.validateAction({
+    action,
+    candidate,
+    destinationAmountMin: minimum.toString(),
+    method: 'transaction',
+    mode: 'exactSource',
+    recipient,
+    sender,
+  })
+}
+
+function action(options: action.Options = {}): Action.TronCalls {
+  const onward = {
+    amountLD: 9_950_000n,
+    composeMsg: '0x',
+    dstEid: 30_410,
+    extraOptions: '0x',
+    minAmountLD: 0n,
+    oftCmd: '0x',
+    to: Hex.padLeft(recipient, 32),
+    ...options.onward,
+  } as const
+  const first = {
+    amountLD: amount,
+    composeMsg: AbiParameters.encode(sendParam, [onward]),
+    dstEid: 30_110,
+    extraOptions: Hex.concat(
+      '0x0003010023030000',
+      Hex.fromNumber(500_000n, { size: 16 }),
+      Hex.fromNumber(100_000_000_000_000n, { size: 16 }),
+    ),
+    minAmountLD: minimum,
+    oftCmd: '0x',
+    to: Hex.padLeft('0x759BA420bF1ded1765F18C2DC3Fc57A1964A2Ad1', 32),
+    ...options.first,
+  } as const
+  return {
+    calls: [
+      {
+        data: AbiFunction.encodeData(approve, [Tron.toEvmAddress(pool), 0n]),
+        to: sourceToken,
+        value: '0x0',
+      },
+      {
+        data: AbiFunction.encodeData(approve, [Tron.toEvmAddress(pool), amount]),
+        to: sourceToken,
+        value: '0x0',
+      },
+      {
+        data: AbiFunction.encodeData(send, [
+          first,
+          { lzTokenFee: 0n, nativeFee, ...options.fee },
+          options.refund ?? Tron.toEvmAddress(sender),
+        ]),
+        to: pool,
+        value: Hex.fromNumber(nativeFee),
+      },
+    ],
+    type: 'tron:calls',
+  }
+}
+
+declare namespace action {
+  type SendParam = ReturnType<typeof AbiFunction.decodeData<typeof send>>[0]
+  type Options = {
+    fee?: Partial<ReturnType<typeof AbiFunction.decodeData<typeof send>>[1]> | undefined
+    first?: Partial<SendParam> | undefined
+    onward?: Partial<SendParam> | undefined
+    refund?: Hex.Hex | undefined
+  }
+}
+
+describe('verifySourceEvidence', () => {
+  test('verifies a successful source send and pins its GUID and actual amount', () => {
+    const input = evidence()
+    const result = LegacyMesh.verifySourceEvidence(input)
+    expect(result.type).toMatchInlineSnapshot('"verified"')
+    if (result.type !== 'verified') throw new Error('Expected verified source evidence.')
+    expect(result.destinationAmount).toMatchInlineSnapshot('"9950000"')
+    expect(result.providerState?.['legacyMesh']).toMatchInlineSnapshot(`
+      {
+        "amount": "9950000",
+        "guid": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      }
+    `)
+    expect(
+      LegacyMesh.verifySourceEvidence({ ...input, providerState: result.providerState }).type,
+    ).toMatchInlineSnapshot('"verified"')
+  })
+
+  test.each([9_900_000n, 9_925_000n, 10_000_000n])(
+    'accepts actual received amount %s inside the slippage bounds',
+    (received) => {
+      const result = LegacyMesh.verifySourceEvidence(evidence({ received }))
+      expect(result.type).toMatchInlineSnapshot('"verified"')
+      if (result.type !== 'verified') throw new Error('Expected verified source evidence.')
+      expect(result.destinationAmount).toBe(received.toString())
+    },
+  )
+
+  test.each([0n, amount])(
+    'recognizes approval %s as related rather than the bridging send',
+    (approvalAmount) => {
+      const input = evidence()
+      const call = input.transaction.raw_data.contract[0]!.parameter.value
+      call.contract_address = `41${Tron.toEvmAddress(sourceToken).slice(2)}`
+      call.call_value = 0
+      call.data = AbiFunction.encodeData(approve, [Tron.toEvmAddress(pool), approvalAmount]).slice(
+        2,
+      )
+      expect(LegacyMesh.verifySourceEvidence(input)).toMatchInlineSnapshot(`
+      {
+        "type": "related",
+      }
+    `)
+    },
+  )
+
+  test.each([
+    [
+      'receipt failure',
+      (input: ReturnType<typeof evidence>) => {
+        input.receipt.receipt.result = 'REVERT'
+      },
+    ],
+    [
+      'transaction failure',
+      (input: ReturnType<typeof evidence>) => {
+        input.transaction.ret[0]!.contractRet = 'REVERT'
+      },
+    ],
+    [
+      'old receipt',
+      (input: ReturnType<typeof evidence>) => {
+        input.receipt.blockTimeStamp = 1
+      },
+    ],
+    [
+      'receipt hash',
+      (input: ReturnType<typeof evidence>) => {
+        input.receipt.id = 'bb'.repeat(32)
+      },
+    ],
+    [
+      'transaction hash',
+      (input: ReturnType<typeof evidence>) => {
+        input.transaction.txID = 'bb'.repeat(32)
+      },
+    ],
+    [
+      'sender',
+      (input: ReturnType<typeof evidence>) => {
+        input.transaction.raw_data.contract[0]!.parameter.value.owner_address = `41${other.slice(2)}`
+      },
+    ],
+    [
+      'source pool',
+      (input: ReturnType<typeof evidence>) => {
+        input.transaction.raw_data.contract[0]!.parameter.value.contract_address = `41${other.slice(2)}`
+      },
+    ],
+    [
+      'call value',
+      (input: ReturnType<typeof evidence>) => {
+        input.transaction.raw_data.contract[0]!.parameter.value.call_value += 1
+      },
+    ],
+    [
+      'prepared hash',
+      (input: ReturnType<typeof evidence>) => {
+        input.providerState.sourceDataHash = Hex.fromString('different')
+      },
+    ],
+    [
+      'changed calldata',
+      (input: ReturnType<typeof evidence>) => {
+        input.transaction.raw_data.contract[0]!.parameter.value.data = action({
+          onward: { to: Hex.padLeft(other, 32) },
+        }).calls[2]!.data.slice(2)
+      },
+    ],
+    [
+      'quoted amount',
+      (input: ReturnType<typeof evidence>) => {
+        input.providerState.quotedDestinationAmount = '1'
+      },
+    ],
+    [
+      'event emitter',
+      (input: ReturnType<typeof evidence>) => {
+        input.receipt.log[0]!.address = other.slice(2)
+      },
+    ],
+    [
+      'missing event',
+      (input: ReturnType<typeof evidence>) => {
+        input.receipt.log = []
+      },
+    ],
+    [
+      'duplicate event',
+      (input: ReturnType<typeof evidence>) => {
+        input.receipt.log.push(input.receipt.log[0]!)
+      },
+    ],
+  ])('rejects changed %s', (_, mutate) => {
+    const input = evidence()
+    mutate(input)
+    expect(LegacyMesh.verifySourceEvidence(input)).toMatchInlineSnapshot(`
+      {
+        "type": "invalid",
+      }
+    `)
+  })
+
+  test.each([
+    { received: minimum - 1n },
+    { received: amount + 1n },
+    { sent: amount + 1n },
+    { eventSender: other },
+    { eid: 30_410 },
+  ] satisfies readonly evidence.Options[])('rejects inconsistent source event %#', (options) => {
+    expect(LegacyMesh.verifySourceEvidence(evidence(options)).type).toMatchInlineSnapshot(
+      '"invalid"',
+    )
+  })
+
+  test('rejects conflicting prior GUID or previously verified amount', () => {
+    const input = evidence()
+    for (const legacyMesh of [
+      { amount: '9950000', guid: `0x${'bb'.repeat(32)}` },
+      { amount: '9900000', guid: `0x${'aa'.repeat(32)}` },
+    ])
+      expect(
+        LegacyMesh.verifySourceEvidence({
+          ...input,
+          providerState: { ...input.providerState, legacyMesh },
+        }).type,
+      ).toMatchInlineSnapshot('"invalid"')
+  })
+
+  test('rejects malformed receipts and unrelated transaction types', () => {
+    const input = evidence()
+    expect(LegacyMesh.verifySourceEvidence({ ...input, receipt: {} }).type).toMatchInlineSnapshot(
+      '"invalid"',
+    )
+    expect(
+      LegacyMesh.verifySourceEvidence({
+        ...input,
+        transaction: {
+          ...input.transaction,
+          raw_data: { contract: [{ type: 'TransferContract' }] },
+        },
+      }).type,
+    ).toMatchInlineSnapshot('"invalid"')
+  })
+})
+
+function evidence(options: evidence.Options = {}) {
+  const execution = action().calls[2]!
+  const event = AbiEvent.from(
+    'event OFTSent(bytes32 indexed guid, uint32 dstEid, address indexed fromAddress, uint256 amountSentLD, uint256 amountReceivedLD)',
+  )
+  const topics = AbiEvent.encode(event, {
+    fromAddress: options.eventSender ?? Tron.toEvmAddress(sender),
+    guid: `0x${'aa'.repeat(32)}`,
+  }).topics
+  return {
+    providerState: {
+      destinationBlockNumber: '1',
+      hubBlockNumber: '1',
+      quotedDestinationAmount: '9950000',
+      sourceCallValue: nativeFee.toString(),
+      sourceDataHash: Hash.keccak256(execution.data as Hex.Hex),
+    },
+    receipt: {
+      blockNumber: 100,
+      blockTimeStamp: Date.parse('2026-01-01T00:00:05.000Z'),
+      id: 'cc'.repeat(32),
+      log: [
+        {
+          address: Tron.toEvmAddress(pool).slice(2),
+          data: AbiParameters.encode(AbiParameters.from('uint32,uint256,uint256'), [
+            options.eid ?? 30_110,
+            options.sent ?? amount,
+            options.received ?? 9_950_000n,
+          ]).slice(2),
+          topics: topics.map((topic) => topic!.slice(2)),
+        },
+      ],
+      receipt: { result: 'SUCCESS' },
+    },
+    transaction: {
+      raw_data: {
+        contract: [
+          {
+            parameter: {
+              value: {
+                call_value: Number(nativeFee),
+                contract_address: `41${Tron.toEvmAddress(pool).slice(2)}`,
+                data: execution.data.slice(2),
+                owner_address: `41${Tron.toEvmAddress(sender).slice(2)}`,
+              },
+            },
+            type: 'TriggerSmartContract',
+          },
+        ],
+      },
+      ret: [{ contractRet: 'SUCCESS' }],
+      txID: 'cc'.repeat(32),
+    },
+    transactionHash: 'cc'.repeat(32),
+    transfer: TestRoutes.transferSnapshot({
+      destinationAmount: { baseUnits: '9950000', currency: 'USD', decimals: 6, formatted: '9.95' },
+      destinationAmountMin: {
+        baseUnits: minimum.toString(),
+        currency: 'USD',
+        decimals: 6,
+        formatted: '9.9',
+      },
+      destinationToken: TestRoutes.providerOutputToken(),
+      provider: { id: 'legacy-mesh', name: 'USDT0 Legacy Mesh' },
+      recipient,
+      sender,
+      sourceAmount: { baseUnits: amount.toString(), currency: 'USD', decimals: 6, formatted: '10' },
+      sourceChain: candidate.sourceChain,
+      sourceToken: candidate.sourceToken,
+    }),
+  }
+}
+
+declare namespace evidence {
+  type Options = {
+    eid?: number | undefined
+    eventSender?: Hex.Hex | undefined
+    received?: bigint | undefined
+    sent?: bigint | undefined
+  }
+}