tapimo 0.15.1 → 0.18.1

package/src/internal/routes/TransferReconciliation.test.ts

@@ -324,7 +324,7 @@ describe.skipIf(!Anvil.available)('createTracker', () => {
       }),
     })
     const snapshot = TestRoutes.transferSnapshot()
-    const account = Anvil.getAccount(5)
+    const account = Anvil.getSubsidyAccount(5)
     const recipient = '0x10a3097afe2c7ebc8f1c621bc9bb371c4dff76a8'
     const sourceTransactionHash =
       '0x9664a5b8dff87c44181abb174b295fd91b2eedae5cff6dacfbd83ab3d8350e88'
@@ -359,7 +359,7 @@ describe.skipIf(!Anvil.available)('createTracker', () => {
       policy: { maxAmount: '5' },
     })
     const rotatedSubsidies = TransferSubsidy.create({
-      account: Anvil.getAccount(6),
+      account: Anvil.getSubsidyAccount(6),
       fetch: globalThis.fetch,
       policy: { maxAmount: '5' },
     })
@@ -445,8 +445,30 @@ describe.skipIf(!Anvil.available)('createTracker', () => {
     await expect(
       tracker.reconcile({ transferId: transfer.id, type: 'routes:transfer:reconcile' }),
     ).resolves.toEqual({ type: 'pending' })
-    // Bound each mining RPC while preserving all 64 confirmations.
-    for (let i = 0; i < 8; i++) await source.client.mine({ blocks: 8 })
+    const pending = await RoutesTransfers.get(database, transfer.id)
+    const transaction = TransferSubsidy.read(pending?.providerState?.['transferSubsidy'])
+    expect(transaction).toBeDefined()
+    if (!transaction) throw new Error('The destination subsidy was not prepared.')
+    const subsidyReceipt = await source.client.waitForTransactionReceipt({
+      hash: transaction.hash,
+      timeout: 10_000,
+    })
+    expect(subsidyReceipt.status).toBe('success')
+
+    const deadline = Date.now() + 20_000
+    let finalized = await source.client.getBlock({ blockTag: 'finalized' })
+    for (
+      let i = 0;
+      i < 32 && finalized.number < subsidyReceipt.blockNumber && Date.now() < deadline;
+      i++
+    ) {
+      await source.client.mine({ blocks: 8 })
+      finalized = await source.client.getBlock({ blockTag: 'finalized' })
+    }
+    expect(
+      finalized.number,
+      `Subsidy receipt block ${subsidyReceipt.blockNumber} was not finalized; finalized block is ${finalized.number}.`,
+    ).toBeGreaterThanOrEqual(subsidyReceipt.blockNumber)
     await expect(tracker.reconcile(dispatches[0]!)).resolves.toEqual({ type: 'completed' })
     const completed = await RoutesTransfers.get(database, transfer.id)
     expect(completed).toMatchObject({

package/src/internal/routes/TransferReconciliation.ts

@@ -1,5 +1,3 @@
-import { getAddress } from 'viem'
-
 import * as Db from '../../db/Db.js'
 import * as RoutesTransferTransactions from '../../db/tables/routesTransferTransactions.js'
 import * as RoutesTransfers from '../../db/tables/routesTransfers.js'
@@ -8,10 +6,15 @@ import * as MetricSink from '../MetricSink.js'
 import * as Value from '../Value.js'
 import type * as Webhooks from '../Webhooks.js'
 import * as Catalog from './Catalog.js'
+import * as EvmTransferSettlement from './EvmTransferSettlement.js'
 import * as Observability from './Observability.js'
 import * as Provider from './Provider.js'
+import * as SolanaTransferSubsidy from './SolanaTransferSubsidy.js'
+import * as SolanaTransferSettlement from './SolanaTransferSettlement.js'
 import * as Transfer from './Transfer.js'
 import * as TransferSubsidy from './TransferSubsidy.js'
+import * as TronTransferSubsidy from './TronTransferSubsidy.js'
+import * as TronTransferSettlement from './TronTransferSettlement.js'
 
 const followUpDelaySeconds = 2
 const maximumFollowUpAttempts = 900
@@ -97,9 +100,32 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
           ),
         { onAttempt: recordProviderOperation, operation: 'verifyDestinationDelivery' },
       )
+      if (delivery.type === 'action-required')
+        return actionRequired(transfer, options, delivery.statusReason)
       if (delivery.type === 'invalid')
         throw new EvidenceError('Tempo delivery conflicts with registered transfer terms.')
       if (delivery.type === 'pending') {
+        const cursor = delivery.providerState?.['tronEventCursor']
+        if (cursor !== undefined) {
+          const packet = transfer.providerState?.['legacyMeshOutbound']
+          const guid =
+            packet && typeof packet === 'object' && 'guid' in packet ? packet.guid : undefined
+          const previousCursor = transfer.providerState?.['tronEventCursor'] ?? null
+          if (
+            transfer.providerId !== 'legacy-mesh' ||
+            typeof guid !== 'string' ||
+            !isTronEventCursor(cursor) ||
+            !isTronEventCursor(previousCursor)
+          )
+            throw new EvidenceError('Destination scan cursor conflicts with provider evidence.')
+          if (cursor !== null || previousCursor !== null)
+            await RoutesTransfers.recordTronEventCursor(db, {
+              cursor,
+              guid,
+              id: transfer.id,
+              previousCursor,
+            })
+        }
         const verified = await Provider.observe(
           provider,
           () =>
@@ -141,6 +167,12 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
         return followUp(message, options, recordOutcome)
       }
 
+      const verifiedAmount = Value.tokenAmount({
+        baseUnits: delivery.destinationAmount ?? destinationAmount.baseUnits,
+        currency: destinationAmount.currency,
+        decimals: destinationAmount.decimals,
+      })
+
       const providerDelivery = await Transfer.recordProviderDelivery(db, { id: transfer.id })
       if (providerDelivery.type === 'invalid' || providerDelivery.type === 'not_found') {
         recordOutcome('invalid_state')
@@ -154,173 +186,54 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
       }
       let current = providerDelivery.record
       const transactionHashes: [string, ...string[]] = [delivery.transactionHash]
-      let deliveredAmount = destinationAmount
+      let deliveredAmount = verifiedAmount
       if (transfer.snapshot.subsidize) {
         const required = transfer.snapshot.destinationAmountRequired
         if (!required) throw new EvidenceError('Normalized destination amount is missing.')
-        const deficit = BigInt(required.baseUnits) - BigInt(destinationAmount.baseUnits)
-        // A fully covered quote may have no subsidy signer commitment.
+        const deficit = BigInt(required.baseUnits) - BigInt(verifiedAmount.baseUnits)
         if (deficit > 0n) {
-          let transaction = TransferSubsidy.read(current.providerState?.['transferSubsidy'])
-          const settler = transaction
-            ? options.subsidies?.[0]
-            : options.subsidies?.find(
-                ({ account }) => account.toLowerCase() === current.subsidyAccount?.toLowerCase(),
-              )
-          if (!settler) {
-            recordSubsidy('unavailable')
-            return actionRequired(current, options, {
-              code: 'subsidy_failed',
-              message: 'Destination subsidy settlement is unavailable.',
-            })
-          }
-          if (!transaction) {
-            const commitment = current.subsidyCommitmentAmount
-            if (!commitment || deficit > BigInt(commitment.baseUnits)) {
-              recordSubsidy('routes_subsidy_limit_exceeded')
-              return actionRequired(current, options, {
-                code: 'routes_subsidy_limit_exceeded',
-                message: 'The required destination subsidy exceeds its approved commitment.',
-              })
-            }
-            const pendingNonce = await settler.pendingNonce({ chain: destinationChain })
-            const subsidyAmount = Value.tokenAmount({
-              baseUnits: deficit,
-              currency: transfer.snapshot.destinationToken.currency,
-              decimals: transfer.snapshot.destinationToken.decimals,
-            })
-            const reserved = await Transfer.reserveSubsidy(db, {
-              account: settler.account,
-              chainId: destinationChain.id,
-              id: current.id,
-              orgId: current.orgId,
-              pendingNonce,
-              prepare: ({ nonce, reservations }) =>
-                settler.prepare({
-                  amount: deficit,
-                  chain: destinationChain,
-                  nonce,
-                  recipient: getAddress(transfer.snapshot.recipient),
-                  reservations,
-                  token: getAddress(transfer.snapshot.destinationToken.address),
-                }),
-              subsidyAmount,
-              tokenAddress: transfer.snapshot.destinationToken.address,
-            }).catch((cause) => {
-              if (cause instanceof Transfer.SubsidyEvidenceError) {
-                recordSubsidy('evidence_conflict')
-                throw cause
-              }
-              if (cause instanceof TransferSubsidy.BalanceUnavailableError) return undefined
-              if (cause instanceof Transfer.SubsidySignerBlockedError) return 'blocked' as const
-              if (TransferSubsidy.isPermanentPreparationError(cause)) return 'rejected' as const
-              throw cause
-            })
-            if (reserved === 'blocked') {
-              recordSubsidy('signer_blocked')
-              return actionRequired(current, options, {
-                code: 'subsidy_failed',
-                message: 'Destination subsidy settlement requires operator recovery.',
-              })
-            }
-            if (reserved === 'rejected') {
-              recordSubsidy('prepare_rejected')
-              return actionRequired(current, options, {
-                code: 'subsidy_failed',
-                message: 'The destination subsidy transaction could not be prepared.',
-              })
-            }
-            if (!reserved) {
-              recordSubsidy('balance_unavailable')
-              return actionRequired(current, options, {
-                code: 'subsidy_balance_unavailable',
-                message: 'Tempo lacks enough destination token inventory or native gas.',
-              })
-            }
-            if (reserved.type === 'invalid' || reserved.type === 'not_found') {
-              recordOutcome('invalid_state')
-              return { type: 'ignored' }
-            }
-            transaction = reserved.transaction
-            current = reserved.record
-            if (
-              (reserved.type === 'reserved' || reserved.type === 'shared') &&
-              options.dispatchTransferUpdates &&
-              reserved.references.length > 0
-            )
-              await options.dispatchTransferUpdates(reserved.references)
-            if (reserved.type === 'reserved') recordSubsidy('prepared')
-            if (reserved.type === 'shared') recordSubsidy('shared')
-          }
-          const status = await settler.status({
-            chain: destinationChain,
-            recipient: getAddress(transfer.snapshot.recipient),
-            token: getAddress(transfer.snapshot.destinationToken.address),
-            transaction,
-          })
-          if (status.type === 'reverted') {
-            recordSubsidy('reverted')
-            return actionRequired(
-              current,
-              options,
-              {
-                code: 'subsidy_failed',
-                message: 'The destination subsidy transaction reverted.',
-              },
-              {
-                subsidyAmount: Value.tokenAmount({
-                  baseUnits: 0n,
-                  currency: transfer.snapshot.destinationToken.currency,
-                  decimals: transfer.snapshot.destinationToken.decimals,
-                }),
-              },
-            )
+          const settlementOptions = {
+            current,
+            db,
+            deficit,
+            destinationChain,
+            dispatchTransferUpdates: options.dispatchTransferUpdates,
+            recordSubsidy,
           }
-          if (status.type === 'pending') {
-            if (status.broadcast) {
-              const rejected = await settler
-                .broadcast({ chain: destinationChain, transaction })
-                .then(() => false)
-                .catch((cause) => {
-                  if (alreadyKnown(cause)) return false
-                  if (
-                    cause instanceof TransferSubsidy.TransactionHashMismatchError ||
-                    TransferSubsidy.isPermanentBroadcastError(cause)
-                  )
-                    return true
-                  recordSubsidy('broadcast_failed')
-                  throw cause
+          const settlement = await (async () => {
+            switch (destinationChain.kind) {
+              case 'evm':
+                return EvmTransferSettlement.settle({
+                  ...settlementOptions,
+                  metrics: options.metrics,
+                  recordOutcome,
+                  settlers: options.subsidies,
                 })
-              if (rejected) {
-                recordSubsidy('broadcast_rejected')
-                const blocked = await Transfer.blockSubsidy(db, {
-                  id: current.id,
-                  statusReason: {
-                    code: 'subsidy_failed',
-                    message: 'The destination subsidy transaction was rejected.',
-                  },
+              case 'solana':
+                return SolanaTransferSettlement.settle({
+                  ...settlementOptions,
+                  settlers: options.solanaSubsidies,
                 })
-                if (blocked.type === 'applied') {
-                  Observability.recordTransfer(options.metrics, {
-                    previous: current,
-                    record: blocked.record,
-                  })
-                  if (options.dispatchTransferUpdates && blocked.references.length > 0)
-                    await options.dispatchTransferUpdates(blocked.references)
-                }
-                return { type: 'ignored' }
-              }
-              recordSubsidy('broadcast')
+              case 'tron':
+                return TronTransferSettlement.settle({
+                  ...settlementOptions,
+                  settlers: options.tronSubsidies,
+                })
+              default:
+                throw new EvidenceError('Unsupported destination subsidy chain.')
             }
-            return followUp(message, options, recordOutcome)
-          }
+          })()
+          if (settlement.type === 'action-required')
+            return actionRequired(settlement.record, options, settlement.reason, settlement.state)
+          if (settlement.type === 'pending') return followUp(message, options, recordOutcome)
+          if (settlement.type === 'ignored') return { type: 'ignored' }
+          current = settlement.record
           deliveredAmount = Value.tokenAmount({
-            baseUnits: BigInt(destinationAmount.baseUnits) + BigInt(transaction.amount),
-            currency: destinationAmount.currency,
-            decimals: destinationAmount.decimals,
+            baseUnits: BigInt(verifiedAmount.baseUnits) + settlement.amount,
+            currency: verifiedAmount.currency,
+            decimals: verifiedAmount.decimals,
           })
-          transactionHashes.push(transaction.hash)
-          recordSubsidy('completed')
+          transactionHashes.push(settlement.hash)
         }
       }
 
@@ -449,6 +362,10 @@ export declare namespace createTracker {
     providers: readonly Provider.Provider[]
     /** Destination-chain subsidy settlers, active first with retained rotation keys after it. */
     subsidies?: readonly TransferSubsidy.Settler[] | undefined
+    /** Solana destination subsidy wallets, active first with retained rotation wallets. */
+    solanaSubsidies?: readonly SolanaTransferSubsidy.Settler[] | undefined
+    /** Tron destination subsidy wallets, active first with retained rotation wallets. */
+    tronSubsidies?: readonly TronTransferSubsidy.Settler[] | undefined
   }
 
   /** Reconciles one registered route transfer. */
@@ -467,6 +384,21 @@ export declare namespace createTracker {
     | { type: 'reopened' }
 }
 
+function isTronEventCursor(
+  value: unknown,
+): value is NonNullable<RoutesTransfers.recordTronEventCursor.Options['cursor']> | null {
+  if (value === null) return true
+  if (typeof value !== 'object' || Array.isArray(value)) return false
+  const cursor = value as Record<string, unknown>
+  return (
+    typeof cursor['offset'] === 'number' &&
+    Number.isSafeInteger(cursor['offset']) &&
+    cursor['offset'] >= 0 &&
+    (cursor['fingerprint'] === undefined ||
+      (typeof cursor['fingerprint'] === 'string' && cursor['fingerprint'].length <= 2_048))
+  )
+}
+
 async function actionRequired(
   transfer: RoutesTransfers.Record,
   options: createTracker.Options,
@@ -515,13 +447,6 @@ class EvidenceError extends Error {
   override name = 'Routes.TransferReconciliation.EvidenceError'
 }
 
-function alreadyKnown(cause: unknown): boolean {
-  if (!(cause instanceof Error)) return false
-  const message =
-    `${cause.message} ${'details' in cause ? String(cause.details) : ''}`.toLowerCase()
-  return message.includes('already known') || message.includes('known transaction')
-}
-
 class ExhaustedError extends Error {
   override name = 'Routes.TransferReconciliation.ExhaustedError'
 }

package/src/internal/routes/TransferSettlement.ts

@@ -0,0 +1,48 @@
+import type * as Db from '../../db/Db.js'
+import type * as RoutesTransfers from '../../db/tables/routesTransfers.js'
+import type * as Webhooks from '../Webhooks.js'
+import type * as Chain from './Chain.js'
+import type * as Transfer from './Transfer.js'
+
+/** Dependencies shared by destination-chain settlement attempts. */
+export type Options = {
+  /** Current persisted transfer. */
+  current: RoutesTransfers.Record
+  /** Authoritative database. */
+  db: Db.Db
+  /** Verified destination shortfall in token base units. */
+  deficit: bigint
+  /** Chain receiving the subsidy. */
+  destinationChain: Chain.Chain
+  /** Dispatches transfer updates staged with mutations. */
+  dispatchTransferUpdates?:
+    | ((references: readonly Webhooks.QueueReference[]) => Promise<number>)
+    | undefined
+  /** Records a bounded subsidy outcome. */
+  recordSubsidy: (outcome: string) => void
+}
+
+/** Outcome of one destination-chain settlement attempt. */
+export type Result =
+  | {
+      /** Operator-facing reason. */
+      reason: Transfer.StatusReason
+      /** Latest persisted transfer. */
+      record: RoutesTransfers.Record
+      /** Optional correction to the recorded subsidy amount. */
+      state?: Pick<Transfer.transition.Options, 'subsidyAmount'> | undefined
+      /** Settlement requires operator recovery. */
+      type: 'action-required'
+    }
+  | { /** No settlement work remains for this attempt. */ type: 'ignored' }
+  | { /** Settlement remains in progress. */ type: 'pending' }
+  | {
+      /** Settled subsidy quantity in base units. */
+      amount: bigint
+      /** Destination transaction hash. */
+      hash: string
+      /** Latest persisted transfer. */
+      record: RoutesTransfers.Record
+      /** Destination subsidy is finalized. */
+      type: 'success'
+    }

package/src/internal/routes/TransferSubsidy.local.test.ts

@@ -0,0 +1,143 @@
+/** @module-tag localnet */
+
+import { mnemonicToAccount } from 'viem/accounts'
+import { waitForTransactionReceipt } from 'viem/actions'
+import { Actions, Addresses } from 'viem/tempo'
+import { inject } from 'vite-plus/test'
+
+import * as Runtime from '../../../test/runtime.js'
+import * as TestTempo from '../../../test/Tempo.js'
+import * as Fees from '../Fees.js'
+import * as Chain from './Chain.js'
+import * as TransferSubsidy from './TransferSubsidy.js'
+
+const runtime = Runtime.get()
+const account = mnemonicToAccount(inject('tempoTestMnemonic'), { addressIndex: 15 })
+const recipient = TestTempo.accounts[7]!.address
+const client = TestTempo.getClient({ account })
+const chain = Chain.from({
+  id: `eip155:${runtime.chainId}`,
+  name: 'Tempo',
+  rpcUrls: [TestTempo.rpcUrl],
+  slug: 'tempo',
+})
+const inventory = TransferSubsidy.createInventory({
+  account: account.address,
+  fetch: globalThis.fetch,
+  policy: { maxAmount: '5' },
+})
+const settler = TransferSubsidy.create({
+  account,
+  fetch: globalThis.fetch,
+  policy: { maxAmount: '5' },
+})
+
+describe.skipIf(runtime.mode !== 'localnet')('create', () => {
+  beforeAll(async () => {
+    await Actions.faucet.fundSync(client, { account: account.address, timeout: 60_000 })
+    const preferred = await Actions.fee.getUserToken(client, { account: account.address })
+    if (preferred?.address.toLowerCase() !== Addresses.pathUsd.toLowerCase())
+      await Actions.fee.setUserTokenSync(client, { token: Addresses.pathUsd })
+  })
+
+  test('reserves Tempo fees and settles a signed destination top-up', async () => {
+    const token = Addresses.pathUsd
+    const parameters = {
+      amount: 3_001n,
+      chain,
+      recipient,
+      reservations: { nativeAmount: 0n, tokenAmount: 0n, tokenAmounts: {} },
+      token,
+    } as const
+    const balance = await Actions.token.getBalance(client, { account: account.address, token })
+    const checked = await inventory.check(parameters)
+    expect(BigInt(checked.nativeAmount) > 0n).toBe(true)
+    expect(BigInt(checked.nativeAmount) % Fees.scalingFactor).toBe(0n)
+    // Delivery alone fits, but this commitment leaves no room for the current transaction's fee.
+    await expect(
+      inventory.check({
+        ...parameters,
+        reservations: {
+          nativeAmount: (balance.amount - parameters.amount) * Fees.scalingFactor,
+          tokenAmount: 0n,
+          tokenAmounts: {},
+        },
+      }),
+    ).rejects.toThrow(TransferSubsidy.BalanceUnavailableError)
+
+    const before = await Actions.token.getBalance(client, { account: recipient, token })
+    const transaction = await settler.prepare({
+      ...parameters,
+      nonce: await settler.pendingNonce({ chain }),
+    })
+    await settler.broadcast({ chain, transaction })
+    await waitForTransactionReceipt(client, { hash: transaction.hash })
+    // The dev node's finalized head trails receipt inclusion beyond Vitest's default polling timeout.
+    await expect
+      .poll(() => settler.status({ chain, recipient, token, transaction }), { timeout: 60_000 })
+      .toEqual({
+        type: 'success',
+      })
+    const after = await Actions.token.getBalance(client, { account: recipient, token })
+    expect(after.amount - before.amount).toBe(parameters.amount)
+  })
+
+  test('counts delivery commitments in a separately configured fee token', async () => {
+    const token = '0x20c0000000000000000000000000000000000001'
+    const balance = await Actions.token.getBalance(client, {
+      account: account.address,
+      token: Addresses.pathUsd,
+    })
+    const parameters = {
+      amount: 1n,
+      chain,
+      recipient,
+      reservations: { nativeAmount: 0n, tokenAmount: 0n, tokenAmounts: {} },
+      token,
+    } as const
+    await inventory.check(parameters)
+    const deliveryBalance = await Actions.token.getBalance(client, {
+      account: account.address,
+      token,
+    })
+    await expect(
+      inventory.check({ ...parameters, amount: deliveryBalance.amount }),
+    ).rejects.toThrow(TransferSubsidy.BalanceUnavailableError)
+    await expect(
+      inventory.check({
+        ...parameters,
+        reservations: {
+          ...parameters.reservations,
+          tokenAmounts: { [Addresses.pathUsd.toLowerCase()]: balance.amount },
+        },
+      }),
+    ).rejects.toThrow(TransferSubsidy.BalanceUnavailableError)
+  })
+
+  test('reserves a new fee against other committed delivery tokens', async () => {
+    const otherToken = '0x20c0000000000000000000000000000000000001'
+    const balance = await Actions.token.getBalance(client, {
+      account: account.address,
+      token: otherToken,
+    })
+    const parameters = {
+      amount: 1n,
+      chain,
+      recipient,
+      reservations: { nativeAmount: 0n, tokenAmount: 0n, tokenAmounts: {} },
+      token: Addresses.pathUsd,
+    } as const
+    const feeAmount = BigInt((await inventory.check(parameters)).nativeAmount) / Fees.scalingFactor
+    expect(balance.amount > feeAmount).toBe(true)
+    await expect(
+      inventory.check({
+        ...parameters,
+        reservations: {
+          nativeAmount: feeAmount * Fees.scalingFactor,
+          tokenAmount: 0n,
+          tokenAmounts: { [otherToken.toLowerCase()]: balance.amount - feeAmount },
+        },
+      }),
+    ).rejects.toThrow(TransferSubsidy.BalanceUnavailableError)
+  })
+})

package/src/internal/routes/TransferSubsidy.test.ts

@@ -13,6 +13,35 @@ import * as TestRoutes from '../../../test/Routes.js'
 import * as Chain from './Chain.js'
 import * as TransferSubsidy from './TransferSubsidy.js'
 
+describe('supportsRoute', () => {
+  test.each([
+    ['tron:0x2b6653dc', 'eip155:4217', true],
+    ['eip155:8453', 'eip155:4217', true],
+    ['eip155:1', 'eip155:4217', true],
+    ['solana:mainnet', 'eip155:4217', true],
+    ['eip155:4217', 'eip155:8453', true],
+    ['eip155:4217', 'eip155:1', true],
+    ['eip155:4217', 'tron:0x2b6653dc', true],
+    ['eip155:4217', 'eip155:137', false],
+    ['eip155:4217', 'eip155:4217', false],
+    ['eip155:1', 'eip155:8453', false],
+  ])('%s to %s: %s', (sourceChainId, destinationChainId, supported) => {
+    expect(
+      TransferSubsidy.supportsRoute({ destinationChainId, sourceChainId, tempoChainId: 4217 }),
+    ).toBe(supported)
+  })
+
+  test('uses the configured Tempo chain', () => {
+    expect(
+      TransferSubsidy.supportsRoute({
+        destinationChainId: 'eip155:42431',
+        sourceChainId: 'eip155:8453',
+        tempoChainId: 42431,
+      }),
+    ).toBe(true)
+  })
+})
+
 describe('requiredAmount', () => {
   test('normalizes USD stablecoins across decimal precisions', () => {
     const snapshot = TestRoutes.transferSnapshot()
@@ -101,7 +130,7 @@ describe.skipIf(!Anvil.available)('create', () => {
   test('signs, broadcasts, and verifies a Base USDC subsidy', async () => {
     const anvil = await Anvil.start({ chain: base, forkUrl: base.rpcUrls.default.http[0]! })
     try {
-      const account = Anvil.getAccount(3)
+      const account = Anvil.getSubsidyAccount(3)
       const recipient = Anvil.getAccount(4).address
       const token = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
       await Anvil.setErc20Balance(anvil.client, {
@@ -128,7 +157,7 @@ describe.skipIf(!Anvil.available)('create', () => {
           chain,
           nonce,
           recipient,
-          reservations: { nativeAmount: 0n, tokenAmount: 0n },
+          reservations: { nativeAmount: 0n, tokenAmount: 0n, tokenAmounts: {} },
           token,
         }),
       ).rejects.toThrow(TransferSubsidy.BalanceUnavailableError)
@@ -137,10 +166,11 @@ describe.skipIf(!Anvil.available)('create', () => {
         chain,
         nonce,
         recipient,
-        reservations: { nativeAmount: 0n, tokenAmount: 0n },
+        reservations: { nativeAmount: 0n, tokenAmount: 0n, tokenAmounts: {} },
         token,
       })
       await settler.broadcast({ chain, transaction })
+      await anvil.client.waitForTransactionReceipt({ hash: transaction.hash })
       await expect(settler.status({ chain, recipient, token, transaction })).resolves.toEqual({
         broadcast: false,
         type: 'pending',
@@ -158,7 +188,7 @@ describe.skipIf(!Anvil.available)('create', () => {
         }),
       ).resolves.toBe(3_001n)
       const rotated = TransferSubsidy.create({
-        account: Anvil.getAccount(5),
+        account: Anvil.getSubsidyAccount(5),
         fetch: globalThis.fetch,
         policy: { maxAmount: '5' },
       })