tapimo 0.14.0 → 0.15.0

package/src/internal/routes/TransferReconciliation.ts

@@ -0,0 +1,527 @@
+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'
+import type * as Metrics from '../../Metrics.js'
+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 Observability from './Observability.js'
+import * as Provider from './Provider.js'
+import * as Transfer from './Transfer.js'
+import * as TransferSubsidy from './TransferSubsidy.js'
+
+const followUpDelaySeconds = 2
+const maximumFollowUpAttempts = 900
+const sweepLimit = 25
+
+/** Queue message that advances one registered route transfer. */
+export type Message = {
+  /** Zero-based destination reconciliation attempt. */
+  attempt?: number | undefined
+  /** Route transfer id (`rtr_…`). */
+  transferId: string
+  /** Route transfer reconciliation discriminator. */
+  type: 'routes:transfer:reconcile'
+}
+
+/** Creates a tracker that verifies and completes registered route transfers. */
+export function createTracker(options: createTracker.Options): createTracker.Tracker {
+  const providers = options.providers.filter(Provider.canReconcileTransfer)
+  const providersById = new Map(providers.map((provider) => [provider.id, provider]))
+  const recordProviderOperation = MetricSink.routesProviderOperations(options.metrics)
+  const sweepCursors = new Map<string, string>()
+  const record = (outcome: string, providerId: string, count = 1) => {
+    options.metrics?.count('routes_transfer_reconciliation_count', count, {
+      outcome,
+      provider: providerId,
+    })
+  }
+
+  const tracker: createTracker.Tracker = {
+    async reconcile(message) {
+      const db = Db.get(options.db)
+      const transfer = await RoutesTransfers.get(db, message.transferId)
+      if (!transfer || transfer.status === 'completed') {
+        record(transfer ? 'already_completed' : 'not_found', transfer?.providerId ?? 'unresolved')
+        return { type: 'ignored' }
+      }
+      const provider = providersById.get(transfer.providerId)
+      const recordOutcome = (outcome: string) => record(outcome, transfer.providerId)
+      const recordSubsidy = (outcome: string) =>
+        options.metrics?.count('routes_transfer_subsidy_count', 1, {
+          outcome,
+          provider: transfer.providerId,
+        })
+      if (transfer.status !== 'processing' || !provider) {
+        recordOutcome('invalid_state')
+        return { type: 'ignored' }
+      }
+
+      const sourceTransactionRef = transfer.snapshot.sourceTransactionHashes?.[0]
+      const source = sourceTransactionRef
+        ? await RoutesTransferTransactions.getSource(db, {
+            chainId: transfer.snapshot.sourceChain.id,
+            transactionRef: sourceTransactionRef,
+            transferId: transfer.id,
+          })
+        : undefined
+      const catalog = await Catalog.read(db)
+      const destinationChain = catalog.chainsByKey.get(transfer.snapshot.destinationChain.id)
+      const sourceChain = catalog.chainsByKey.get(transfer.snapshot.sourceChain.id)
+      const destinationAmount = transfer.snapshot.destinationAmount
+      if (
+        !source ||
+        source.transferId !== transfer.id ||
+        !destinationChain ||
+        !destinationAmount ||
+        !sourceChain
+      )
+        throw new EvidenceError('Registered route transfer evidence is incomplete.')
+
+      const signal = new AbortController().signal
+
+      const delivery = await Provider.observe(
+        provider,
+        () =>
+          provider.verifyDestinationDelivery(
+            {
+              destinationChain,
+              providerState: transfer.providerState ?? undefined,
+              sourceChain,
+              transfer: transfer.snapshot,
+            },
+            signal,
+          ),
+        { onAttempt: recordProviderOperation, operation: 'verifyDestinationDelivery' },
+      )
+      if (delivery.type === 'invalid')
+        throw new EvidenceError('Tempo delivery conflicts with registered transfer terms.')
+      if (delivery.type === 'pending') {
+        const verified = await Provider.observe(
+          provider,
+          () =>
+            provider.verifySourceTransaction(
+              {
+                destinationChain,
+                providerState: transfer.providerState ?? undefined,
+                sourceChain,
+                transactionHash: source.transactionRef,
+                transfer: transfer.snapshot,
+              },
+              signal,
+            ),
+          { onAttempt: recordProviderOperation, operation: 'verifySourceTransaction' },
+        )
+        if (verified.type === 'reorged') {
+          const reopened = await Transfer.reopenSourceTransaction(db, {
+            chainId: transfer.snapshot.sourceChain.id,
+            id: transfer.id,
+            providerState: verified.providerState,
+            transactionHash: source.transactionRef,
+          })
+          if (reopened.type !== 'reopened') {
+            recordOutcome('invalid_state')
+            return { type: 'ignored' }
+          }
+          Observability.recordTransfer(options.metrics, {
+            previous: transfer,
+            record: reopened.record,
+          })
+          if (options.dispatchTransferUpdates && reopened.references.length > 0)
+            await options.dispatchTransferUpdates(reopened.references)
+          recordOutcome('reopened')
+          return { type: 'reopened' }
+        }
+        if (verified.type === 'pending') return followUp(message, options, recordOutcome)
+        if (verified.type === 'invalid' || verified.type === 'related')
+          throw new EvidenceError('Source transaction conflicts with registered provider evidence.')
+        return followUp(message, options, recordOutcome)
+      }
+
+      const providerDelivery = await Transfer.recordProviderDelivery(db, { id: transfer.id })
+      if (providerDelivery.type === 'invalid' || providerDelivery.type === 'not_found') {
+        recordOutcome('invalid_state')
+        return { type: 'ignored' }
+      }
+      if (providerDelivery.type === 'recorded') {
+        Observability.recordTransfer(options.metrics, {
+          previous: transfer,
+          record: providerDelivery.record,
+        })
+      }
+      let current = providerDelivery.record
+      const transactionHashes: [string, ...string[]] = [delivery.transactionHash]
+      let deliveredAmount = destinationAmount
+      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.
+        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,
+                }),
+              },
+            )
+          }
+          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
+                })
+              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.',
+                  },
+                })
+                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')
+            }
+            return followUp(message, options, recordOutcome)
+          }
+          deliveredAmount = Value.tokenAmount({
+            baseUnits: BigInt(destinationAmount.baseUnits) + BigInt(transaction.amount),
+            currency: destinationAmount.currency,
+            decimals: destinationAmount.decimals,
+          })
+          transactionHashes.push(transaction.hash)
+          recordSubsidy('completed')
+        }
+      }
+
+      const completed = await Transfer.complete(db, {
+        chainId: current.snapshot.destinationChain.id,
+        destinationAmount: deliveredAmount,
+        id: current.id,
+        transactionHashes,
+      })
+      if (completed.type === 'invalid')
+        throw new EvidenceError('Route transfer cannot accept destination evidence.')
+      if (completed.type === 'not_found') {
+        recordOutcome('not_found')
+        return { type: 'ignored' }
+      }
+      if (completed.type === 'completed')
+        Observability.recordTransfer(options.metrics, {
+          previous: current,
+          record: completed.record,
+        })
+      if (
+        completed.type === 'completed' &&
+        options.dispatchTransferUpdates &&
+        completed.references.length > 0
+      )
+        await options.dispatchTransferUpdates(completed.references)
+      recordOutcome(completed.type)
+      return { type: 'completed' }
+    },
+    async tick() {
+      if (!options.dispatch) throw new DispatchError()
+      const db = Db.get(options.db)
+      let checked = 0
+      const abandoned = await RoutesTransfers.listExpiredSubsidyCommitments(db, {
+        expiredBefore: new Date(
+          Date.now() - RoutesTransfers.subsidyCommitmentRecoveryTtlMs,
+        ).toISOString(),
+        limit: sweepLimit,
+      })
+      for (const transfer of abandoned) {
+        const result = await Transfer.transition(db, {
+          expectedVersion: transfer.version,
+          id: transfer.id,
+          status: 'expired',
+        })
+        if (result.type !== 'applied') continue
+        Observability.recordTransfer(options.metrics, { previous: transfer, record: result.record })
+        record('expired', transfer.providerId)
+        if (options.dispatchTransferUpdates && result.references.length > 0)
+          await options.dispatchTransferUpdates(result.references)
+      }
+      for (const provider of providers) {
+        let cursor = sweepCursors.get(provider.id)
+        let records = await RoutesTransfers.listProcessing(db, {
+          cursor,
+          limit: sweepLimit,
+          providerId: provider.id,
+        })
+        if (records.length === 0 && cursor !== undefined) {
+          cursor = undefined
+          sweepCursors.delete(provider.id)
+          records = await RoutesTransfers.listProcessing(db, {
+            limit: sweepLimit,
+            providerId: provider.id,
+          })
+        }
+        for (const transfer of records) {
+          await options.dispatch(
+            {
+              transferId: transfer.id,
+              type: 'routes:transfer:reconcile',
+            },
+            { delaySeconds: 0 },
+          )
+          cursor = transfer.id
+          sweepCursors.set(provider.id, cursor)
+          checked++
+        }
+        record('swept', provider.id, records.length)
+      }
+      return { checked }
+    },
+  }
+  const metrics = options.metrics
+  if (!metrics) return tracker
+  return {
+    ...tracker,
+    async reconcile(message) {
+      const startedAt = performance.now()
+      try {
+        const result = await tracker.reconcile(message)
+        metrics.histogram(
+          'routes_transfer_reconciliation_duration_ms',
+          performance.now() - startedAt,
+          { outcome: result.type },
+        )
+        return result
+      } catch (cause) {
+        metrics.histogram(
+          'routes_transfer_reconciliation_duration_ms',
+          performance.now() - startedAt,
+          { outcome: 'failed' },
+        )
+        throw cause
+      } finally {
+        metrics.flush()
+      }
+    },
+  }
+}
+
+export declare namespace createTracker {
+  /** Tracker dependencies and queue dispatch. */
+  type Options = {
+    /** Authoritative database or per-invocation database factory. */
+    db: Db.Source
+    /** Enqueues one delayed reconciliation follow-up. */
+    dispatch?: ((message: Message, options: { delaySeconds: number }) => Promise<void>) | undefined
+    /** Enqueues webhook updates staged with transfer mutations. */
+    dispatchTransferUpdates?:
+      | ((references: readonly Webhooks.QueueReference[]) => Promise<number>)
+      | undefined
+    /** Optional bounded operational metrics. */
+    metrics?: Metrics.Metrics | undefined
+    /** Route providers available for transfer reconciliation. */
+    providers: readonly Provider.Provider[]
+    /** Destination-chain subsidy settlers, active first with retained rotation keys after it. */
+    subsidies?: readonly TransferSubsidy.Settler[] | undefined
+  }
+
+  /** Reconciles one registered route transfer. */
+  type Tracker = {
+    /** Verifies or defers one destination delivery. */
+    reconcile(message: Message): Promise<Result>
+    /** Expires abandoned commitments and enqueues processing transfers. */
+    tick(): Promise<{ checked: number }>
+  }
+
+  /** One reconciliation disposition. */
+  type Result =
+    | { type: 'completed' }
+    | { type: 'ignored' }
+    | { type: 'pending' }
+    | { type: 'reopened' }
+}
+
+async function actionRequired(
+  transfer: RoutesTransfers.Record,
+  options: createTracker.Options,
+  statusReason: Transfer.StatusReason,
+  state: Pick<Transfer.transition.Options, 'subsidyAmount'> = {},
+): Promise<createTracker.Result> {
+  const result = await Transfer.transition(Db.get(options.db), {
+    expectedVersion: transfer.version,
+    id: transfer.id,
+    ...state,
+    status: 'action-required',
+    statusReason,
+  })
+  if (result.type === 'applied') {
+    Observability.recordTransfer(options.metrics, { previous: transfer, record: result.record })
+    if (options.dispatchTransferUpdates && result.references.length > 0)
+      await options.dispatchTransferUpdates(result.references)
+  }
+  return { type: 'ignored' }
+}
+
+async function followUp(
+  message: Message,
+  options: createTracker.Options,
+  record: (outcome: string) => void,
+): Promise<createTracker.Result> {
+  const attempt = (message.attempt ?? 0) + 1
+  if (attempt > maximumFollowUpAttempts) {
+    record('exhausted')
+    throw new ExhaustedError()
+  }
+  if (!options.dispatch) throw new DispatchError()
+  await options.dispatch(
+    { attempt, transferId: message.transferId, type: 'routes:transfer:reconcile' },
+    { delaySeconds: followUpDelaySeconds },
+  )
+  record('pending')
+  return { type: 'pending' }
+}
+
+class DispatchError extends Error {
+  override name = 'Routes.TransferReconciliation.DispatchError'
+}
+
+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/TransferSubsidy.test.ts

@@ -0,0 +1,172 @@
+import {
+  erc20Abi,
+  ExecutionRevertedError,
+  FeeCapTooLowError,
+  NonceTooHighError,
+  NonceTooLowError,
+  TipAboveFeeCapError,
+} from 'viem'
+import { base } from 'viem/chains'
+
+import * as Anvil from '../../../test/Anvil.js'
+import * as TestRoutes from '../../../test/Routes.js'
+import * as Chain from './Chain.js'
+import * as TransferSubsidy from './TransferSubsidy.js'
+
+describe('requiredAmount', () => {
+  test('normalizes USD stablecoins across decimal precisions', () => {
+    const snapshot = TestRoutes.transferSnapshot()
+    expect([
+      TransferSubsidy.requiredAmount({
+        destinationToken: { ...snapshot.destinationToken, decimals: 18 },
+        sourceAmount: '1000000',
+        sourceToken: snapshot.sourceToken,
+      }),
+      TransferSubsidy.requiredAmount({
+        destinationToken: { ...snapshot.destinationToken, decimals: 3 },
+        sourceAmount: '1000000',
+        sourceToken: snapshot.sourceToken,
+      }),
+    ]).toMatchInlineSnapshot(`
+      [
+        1000000000000000000n,
+        1000n,
+      ]
+    `)
+  })
+
+  test('rejects a different denomination', () => {
+    const snapshot = TestRoutes.transferSnapshot()
+    expect(() =>
+      TransferSubsidy.requiredAmount({
+        destinationToken: { ...snapshot.destinationToken, currency: 'EUR' },
+        sourceAmount: '1000000',
+        sourceToken: snapshot.sourceToken,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(`[Routes.TransferSubsidy.UnsupportedTokenError]`)
+  })
+})
+
+describe('read', () => {
+  test('accepts only complete persisted signed transactions', () => {
+    const transaction = {
+      account: `0x${'11'.repeat(20)}`,
+      amount: '3001',
+      chainId: 'eip155:8453',
+      hash: `0x${'22'.repeat(32)}`,
+      nonce: 7,
+      transaction: `0x${'33'.repeat(100)}`,
+    }
+    expect([TransferSubsidy.read(transaction), TransferSubsidy.read({ ...transaction, nonce: -1 })])
+      .toMatchInlineSnapshot(`
+        [
+          {
+            "account": "0x1111111111111111111111111111111111111111",
+            "amount": "3001",
+            "chainId": "eip155:8453",
+            "hash": "0x2222222222222222222222222222222222222222222222222222222222222222",
+            "nonce": 7,
+            "transaction": "0x33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333",
+          },
+          undefined,
+        ]
+      `)
+  })
+})
+
+describe('isPermanentPreparationError', () => {
+  test('separates rejected transactions from errors that a retry can recover', () => {
+    expect([
+      TransferSubsidy.isPermanentPreparationError(new ExecutionRevertedError()),
+      TransferSubsidy.isPermanentPreparationError(new FeeCapTooLowError()),
+      TransferSubsidy.isPermanentPreparationError(new NonceTooHighError()),
+      TransferSubsidy.isPermanentPreparationError(new NonceTooLowError()),
+      TransferSubsidy.isPermanentPreparationError(new TipAboveFeeCapError()),
+      TransferSubsidy.isPermanentPreparationError(new Error('tip higher than fee cap')),
+    ]).toEqual([true, false, false, false, false, false])
+  })
+})
+
+describe('isPermanentBroadcastError', () => {
+  test('rejects immutable signed transactions with invalid fee caps', () => {
+    expect([
+      TransferSubsidy.isPermanentBroadcastError(new TipAboveFeeCapError()),
+      TransferSubsidy.isPermanentBroadcastError(new Error('tip higher than fee cap')),
+      TransferSubsidy.isPermanentBroadcastError(new FeeCapTooLowError()),
+    ]).toEqual([true, true, false])
+  })
+})
+
+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 recipient = Anvil.getAccount(4).address
+      const token = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
+      await Anvil.setErc20Balance(anvil.client, {
+        address: account.address,
+        amount: 1_000_000n,
+        slot: 9n,
+        token,
+      })
+      const chain = Chain.from({
+        id: 'eip155:8453',
+        name: 'Base',
+        rpcUrls: [anvil.rpcUrl],
+        slug: 'base',
+      })
+      const settler = TransferSubsidy.create({
+        account,
+        fetch: globalThis.fetch,
+        policy: { maxAmount: '5' },
+      })
+      const nonce = await settler.pendingNonce({ chain })
+      await expect(
+        settler.prepare({
+          amount: 1_000_001n,
+          chain,
+          nonce,
+          recipient,
+          reservations: { nativeAmount: 0n, tokenAmount: 0n },
+          token,
+        }),
+      ).rejects.toThrow(TransferSubsidy.BalanceUnavailableError)
+      const transaction = await settler.prepare({
+        amount: 3_001n,
+        chain,
+        nonce,
+        recipient,
+        reservations: { nativeAmount: 0n, tokenAmount: 0n },
+        token,
+      })
+      await settler.broadcast({ chain, transaction })
+      await expect(settler.status({ chain, recipient, token, transaction })).resolves.toEqual({
+        broadcast: false,
+        type: 'pending',
+      })
+      await anvil.client.mine({ blocks: 64 })
+      await expect(settler.status({ chain, recipient, token, transaction })).resolves.toEqual({
+        type: 'success',
+      })
+      await expect(
+        anvil.client.readContract({
+          abi: erc20Abi,
+          address: token,
+          args: [recipient],
+          functionName: 'balanceOf',
+        }),
+      ).resolves.toBe(3_001n)
+      const rotated = TransferSubsidy.create({
+        account: Anvil.getAccount(5),
+        fetch: globalThis.fetch,
+        policy: { maxAmount: '5' },
+      })
+      await expect(rotated.status({ chain, recipient, token, transaction })).resolves.toEqual({
+        type: 'success',
+      })
+    } finally {
+      await anvil.stop()
+    }
+  })
+})