tapimo 0.14.0 → 0.15.1

package/src/internal/{funding → routes}/Reconciliation.ts

@@ -1,30 +1,35 @@
 import { Hex } from 'ox'
+import * as z from 'zod/mini'
 
 import * as Db from '../../db/Db.js'
-import * as FundingDepositAddresses from '../../db/tables/fundingDepositAddresses.js'
-import * as FundingDepositRequestObservations from '../../db/tables/fundingDepositRequestObservations.js'
-import * as FundingDeposits from '../../db/tables/fundingDeposits.js'
+import * as RoutesDepositAddresses from '../../db/tables/routesDepositAddresses.js'
+import * as RoutesDepositRequestObservations from '../../db/tables/routesDepositRequestObservations.js'
+import * as RoutesDeposits from '../../db/tables/routesDeposits.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 Deposit from './Deposit.js'
 import * as DepositWebhook from './DepositWebhook.js'
+import * as Observability from './Observability.js'
 import * as Provider from './Provider.js'
 import * as Subsidy from './Subsidy.js'
 
 const defaultBatchSize = 25
 const defaultLeaseMs = 2 * 60_000
 const defaultPollIntervalMs = 60_000
-const chainProviderFollowUpDelaySeconds = 1
-const chainProviderMaximumFollowUpAttempts = 30
+const chainCatchUpFollowUpDelaySeconds = 1
+const chainCatchUpMaximumFollowUpAttempts = 30
 const followUpDelaySeconds = { delivery: 1, provider: 5, settlement: 2 } as const satisfies Record<
   Provider.Webhook.receive.FollowUp['kind'],
   number
 >
 const maximumPages = 100
 const maximumFollowUpAttempts = 6
+const providerMaximumFollowUpAttempts = 24
 const providerFailureStatuses = ['failure'] as const
 const providerRefundStatuses = ['refund', 'refunded'] as const
+const unattributedBatchSize = 25
 
 /** Verified token transfer returned by an authoritative chain reader. */
 export type TransferEvidence = {
@@ -63,9 +68,10 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
   const batchSize = options.batchSize ?? defaultBatchSize
   const leaseMs = options.leaseMs ?? defaultLeaseMs
   const pollIntervalMs = options.pollIntervalMs ?? defaultPollIntervalMs
+  const recordProviderOperation = MetricSink.routesProviderOperations(options.metrics)
 
   const record = (outcome: string, providerId: string, trigger: Deposit.DetectionTrigger) => {
-    options.metrics?.count('funding_deposit_reconciliation_count', 1, {
+    options.metrics?.count('routes_deposit_reconciliation_count', 1, {
       outcome,
       provider: providerId,
       trigger,
@@ -100,11 +106,20 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
         await heartbeat.ready()
         const requests = await listRequests(provider, {
           address: claimed,
+          onAttempt: recordProviderOperation,
           requestId: message.requestId,
           signal: options.signal,
+        }).catch(async () => {
+          // The durable poll owns provider retries; queue redelivery must not advance its backoff again.
+          const leaseFailure = await heartbeat.stop()
+          if (leaseFailure !== undefined) throw leaseFailure
+          await fail(database, claimed, now(), pollIntervalMs)
+          record('provider_unavailable', claimed.providerId, trigger)
+          return undefined
         })
+        if (!requests) return { type: 'provider_unavailable' }
         if (trigger === 'poll')
-          await FundingDepositRequestObservations.observePoll(database, {
+          await RoutesDepositRequestObservations.observePoll(database, {
             depositAddressId: claimed.id,
             observedAt: now().toISOString(),
             providerRequestIds: requests.requests.map((request) => request.id),
@@ -137,6 +152,7 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
           ...requests.pendingRequestIds,
           ...(message.requestId ? [message.requestId] : []),
         ])
+        const sourceRoutesIntervals: Observability.LifecycleInterval[] = []
         let followUpKind: Provider.Webhook.receive.FollowUp['kind'] | undefined
         for (const request of requests.requests) {
           const result = await reconcileRequest(database, {
@@ -144,6 +160,13 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
             metrics: options.metrics,
             onDeposit,
             provider,
+            ...(options.recordLifecycleInterval
+              ? {
+                  recordLifecycleInterval: async (interval) => {
+                    sourceRoutesIntervals.push(interval)
+                  },
+                }
+              : {}),
             request,
             signal: options.signal,
             subsidies: options.subsidies,
@@ -159,8 +182,15 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
             followUpKind = result.followUp ?? followUpKind ?? 'provider'
           }
         }
+        const sourceRoutes = sourceRoutesIntervals.toSorted((left, right) =>
+          left.endedAt.localeCompare(right.endedAt),
+        )[0]
+        if (sourceRoutes) await options.recordLifecycleInterval?.(sourceRoutes)
+        const page = await checkpointUnattributed(database, { address: claimed, now: startedAt })
+        heartbeat.assert()
         const unattributed = await reconcileUnattributed(database, {
           address: claimed,
+          deposits: page.deposits,
           metrics: options.metrics,
           onDeposit,
           provider,
@@ -172,11 +202,11 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
         updated += unattributed.updatedIds.size
         if (!unattributed.terminal)
           followUpKind = unattributed.followUp ?? followUpKind ?? 'provider'
-        const awaitsProvider = await FundingDeposits.hasUnattributed(database, claimed.id)
+        const awaitsProvider = await RoutesDeposits.hasUnattributed(database, claimed.id)
         if (message.requestId && message.webhookTiming && !webhookUpdateObserved)
           pendingRequestIds.add(message.requestId)
         if (created > 0)
-          options.metrics?.count('funding_deposit_detection_count', created, {
+          options.metrics?.count('routes_deposit_detection_count', created, {
             provider: claimed.providerId,
             trigger,
           })
@@ -185,12 +215,12 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
           const references = [...depositWebhookReferences.values()]
           await options.dispatchDepositUpdates(references).then(
             (count) =>
-              options.metrics?.count('funding_deposit_webhook_enqueue_count', count, {
+              options.metrics?.count('routes_deposit_webhook_enqueue_count', count, {
                 outcome: 'succeeded',
                 provider: claimed.providerId,
               }),
             (cause) => {
-              options.metrics?.count('funding_deposit_webhook_enqueue_count', references.length, {
+              options.metrics?.count('routes_deposit_webhook_enqueue_count', references.length, {
                 outcome: 'failed',
                 provider: claimed.providerId,
               })
@@ -199,16 +229,21 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
           )
         }
 
+        if (unattributed.errors.length > 0)
+          throw new AggregateError(
+            unattributed.errors,
+            'Unattributed deposit reconciliation failed.',
+          )
         const leaseFailure = await heartbeat.stop()
         if (leaseFailure !== undefined) throw leaseFailure
         const completedAt = now()
-        const stored = await FundingDepositAddresses.completePoll(database, {
+        const stored = await RoutesDepositAddresses.completePoll(database, {
           id: claimed.id,
           lastPolledAt: completedAt.toISOString(),
           nextPollAt: new Date(completedAt.getTime() + pollIntervalMs).toISOString(),
           pollLeaseVersion: claimed.pollLeaseVersion,
           providerRequestIds: claimed.providerRequestIds,
-          providerState: reconciliationState(claimed.providerState, {
+          providerState: reconciliationState(page.address.providerState, {
             pendingRequestIds: [...pendingRequestIds],
             requests,
             ...(message.webhookTiming && message.requestId && webhookUpdateObserved
@@ -233,7 +268,7 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
                   followUp: followUp.state,
                   ...(message.requestId ? { requestId: message.requestId } : {}),
                   trigger,
-                  type: 'funding:deposit-address:reconcile',
+                  type: 'routes:deposit-address:reconcile',
                   ...(message.webhookTiming && !webhookUpdateObserved
                     ? { webhookTiming: message.webhookTiming }
                     : {}),
@@ -258,7 +293,7 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
           })
         record('completed', claimed.providerId, trigger)
         options.metrics?.histogram(
-          'funding_deposit_reconciliation_duration_ms',
+          'routes_deposit_reconciliation_duration_ms',
           completedAt.getTime() - startedAt.getTime(),
           { provider: claimed.providerId, trigger },
         )
@@ -281,7 +316,7 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
       let failed = 0
       for (const provider of options.providers) {
         if (!Provider.canListDepositAddressRequests(provider)) continue
-        const records = await FundingDepositAddresses.claimDue(database, {
+        const records = await RoutesDepositAddresses.claimDue(database, {
           leaseUntil,
           limit: Math.max(0, batchSize - claimed),
           now: startedAt.toISOString(),
@@ -290,7 +325,7 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
         for (const address of records) {
           claimed += 1
           options.metrics?.histogram(
-            'funding_deposit_poll_lag_ms',
+            'routes_deposit_poll_lag_ms',
             Math.max(0, startedAt.getTime() - new Date(address.nextPollAt).getTime()),
             { provider: provider.id },
           )
@@ -299,7 +334,7 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
               addressId: address.id,
               pollLeaseVersion: address.pollLeaseVersion,
               trigger: 'poll',
-              type: 'funding:deposit-address:reconcile',
+              type: 'routes:deposit-address:reconcile',
             })
             record('enqueued', provider.id, 'poll')
           } catch {
@@ -328,7 +363,7 @@ export declare namespace createTracker {
       message: Provider.Webhook.receive.Dispatchable,
       options?: createTracker.DispatchOptions,
     ) => Promise<void>
-    /** Stages and dispatches committed funding deposit webhook updates. */
+    /** Stages and dispatches committed route deposit webhook updates. */
     dispatchDepositUpdates?:
       | ((references: readonly Webhooks.QueueReference[]) => Promise<number>)
       | undefined
@@ -340,8 +375,12 @@ export declare namespace createTracker {
     now?: (() => Date) | undefined
     /** Delay before a successfully reconciled address is polled again. */
     pollIntervalMs?: number | undefined
-    /** Configured funding provider integrations. */
+    /** Configured route provider integrations. */
     providers: readonly Provider.Provider[]
+    /** Records completed route lifecycle intervals. */
+    recordLifecycleInterval?:
+      | ((interval: Observability.LifecycleInterval) => Promise<void>)
+      | undefined
     /** Optional cancellation signal for provider reads. */
     signal?: AbortSignal | undefined
     /** Optional pathUSD-funded subsidy settler. */
@@ -377,12 +416,12 @@ type ClaimOptions = {
 
 async function claim(db: Db.Db, message: Provider.Webhook.receive.Queued, options: ClaimOptions) {
   if (message.pollLeaseVersion === undefined)
-    return FundingDepositAddresses.claim(db, {
+    return RoutesDepositAddresses.claim(db, {
       id: message.addressId,
       leaseUntil: options.leaseUntil,
       now: options.now,
     })
-  const current = await FundingDepositAddresses.get(db, message.addressId)
+  const current = await RoutesDepositAddresses.get(db, message.addressId)
   if (
     !current?.pollLeaseUntil ||
     current.pollLeaseUntil <= options.now ||
@@ -394,12 +433,12 @@ async function claim(db: Db.Db, message: Provider.Webhook.receive.Queued, option
 
 async function fail(
   db: Db.Db,
-  address: FundingDepositAddresses.Record,
+  address: RoutesDepositAddresses.Record,
   now: Date,
   pollIntervalMs: number,
 ) {
   const delay = Math.min(pollIntervalMs * 2 ** address.pollFailureCount, 15 * 60_000)
-  return FundingDepositAddresses.failPoll(db, {
+  return RoutesDepositAddresses.failPoll(db, {
     id: address.id,
     nextPollAt: new Date(now.getTime() + delay).toISOString(),
     pollLeaseVersion: address.pollLeaseVersion,
@@ -413,14 +452,14 @@ type MaintainLeaseOptions = {
 
 function maintainLease(
   db: Db.Db,
-  address: FundingDepositAddresses.Record,
+  address: RoutesDepositAddresses.Record,
   options: MaintainLeaseOptions,
 ) {
   let failure: unknown
   let stopped = false
   const extend = async () => {
     if (stopped || failure !== undefined) return
-    const renewed = await FundingDepositAddresses.renewPoll(db, {
+    const renewed = await RoutesDepositAddresses.renewPoll(db, {
       id: address.id,
       leaseUntil: new Date(options.now().getTime() + options.leaseMs).toISOString(),
       pollLeaseVersion: address.pollLeaseVersion,
@@ -465,7 +504,8 @@ type Requests = {
 }
 
 type ListRequestsOptions = {
-  address: FundingDepositAddresses.Record
+  address: RoutesDepositAddresses.Record
+  onAttempt: (result: Provider.ProviderAttemptResult) => void
   requestId?: string | undefined
   signal?: AbortSignal | undefined
 }
@@ -482,9 +522,19 @@ async function listRequests(
   const requests: Provider.listDepositAddressRequests.ReturnType['requests'][number][] = []
   let continuation: string | undefined
   for (let page = 0; page < maximumPages; page++) {
-    const result = await provider.listDepositAddressRequests(
-      { address: options.address.address, ...(continuation ? { continuation } : {}) },
-      options.signal ?? new AbortController().signal,
+    const result = await Provider.observe(
+      provider,
+      () =>
+        provider.listDepositAddressRequests(
+          {
+            address: options.address.address,
+            ...(continuation ? { continuation } : {}),
+            destinationToken: options.address.snapshot.destinationToken,
+            sourceToken: options.address.snapshot.sourceToken,
+          },
+          options.signal ?? new AbortController().signal,
+        ),
+      { onAttempt: options.onAttempt, operation: 'listDepositAddressRequests' },
     )
     requests.push(
       ...result.requests.filter(
@@ -509,9 +559,19 @@ async function listRequests(
     ...(options.requestId ? [options.requestId] : []),
   ])) {
     if (observed.has(requestId)) continue
-    const result = await provider.listDepositAddressRequests(
-      { address: options.address.address, requestId },
-      options.signal ?? new AbortController().signal,
+    const result = await Provider.observe(
+      provider,
+      () =>
+        provider.listDepositAddressRequests(
+          {
+            address: options.address.address,
+            destinationToken: options.address.snapshot.destinationToken,
+            requestId,
+            sourceToken: options.address.snapshot.sourceToken,
+          },
+          options.signal ?? new AbortController().signal,
+        ),
+      { onAttempt: options.onAttempt, operation: 'listDepositAddressRequests' },
     )
     requests.push(...result.requests)
   }
@@ -544,7 +604,7 @@ type HighWater = {
   updatedAt?: string | undefined
 }
 
-function readHighWater(state: FundingDepositAddresses.Record['providerState']): HighWater {
+function readHighWater(state: RoutesDepositAddresses.Record['providerState']): HighWater {
   if (!state || typeof state !== 'object') return { pendingRequestIds: [], requestIds: [] }
   const reconciliation = state['reconciliation']
   if (!reconciliation || typeof reconciliation !== 'object')
@@ -587,7 +647,7 @@ type ReconciliationStateOptions = {
 }
 
 function reconciliationState(
-  state: FundingDepositAddresses.Record['providerState'],
+  state: RoutesDepositAddresses.Record['providerState'],
   options: ReconciliationStateOptions,
 ) {
   const current = state && typeof state === 'object' ? state : {}
@@ -611,20 +671,20 @@ function reconciliationState(
 }
 
 type ObservedSourceTransaction = {
-  deposits: FundingDeposits.Record[]
+  deposits: RoutesDeposits.Record[]
   transactionHash: string
   transfers: readonly TransferEvidence[]
 }
 
 type VerifiedDeposit = {
-  deposit: FundingDeposits.Record
+  deposit: RoutesDeposits.Record
   required: bigint
   source: TransferEvidence
   sourceAmount: bigint
 }
 
 type ReconcileDeliveryOptions = {
-  address: FundingDepositAddresses.Record
+  address: RoutesDepositAddresses.Record
   metrics?: Metrics.Metrics | undefined
   onDeposit?: reconcileRequest.Options['onDeposit'] | undefined
   provider?: Provider.Provider | undefined
@@ -651,53 +711,102 @@ async function observeProviderDelivery(options: ReconcileDeliveryOptions) {
   )
     return undefined
 
-  const result = await options.provider
-    .observeDepositAddressRequest(
-      {
-        address: options.address.address,
-        destinationChain: options.address.snapshot.destinationChain,
-        destinationToken: options.address.providerOutputToken,
-        providerState: entry.deposit.providerState ?? undefined,
-        recipient: options.address.recipient,
-        refundAddress: options.address.refundAddress,
-        ...(options.request ? { request: options.request } : {}),
-        source: entry.source,
-        sourceChain: options.address.snapshot.sourceChain,
-        sourceToken: options.address.snapshot.sourceToken,
-      },
-      options.signal ?? new AbortController().signal,
-    )
-    .catch((cause) => {
-      if (options.signal?.aborted) throw cause
-      return undefined
-    })
-  options.metrics?.count('funding_deposit_delivery_observation_count', 1, {
+  const provider = options.provider
+  const recordProviderOperation = MetricSink.routesProviderOperations(options.metrics)
+  const result = await Provider.observe(
+    provider,
+    () =>
+      provider.observeDepositAddressRequest(
+        {
+          address: options.address.address,
+          destinationChain: options.address.snapshot.destinationChain,
+          destinationToken: options.address.providerOutputToken,
+          providerState: entry.deposit.providerState ?? undefined,
+          recipient: options.address.recipient,
+          refundAddress: options.address.refundAddress,
+          ...(options.request ? { request: options.request } : {}),
+          source: entry.source,
+          sourceChain: options.address.snapshot.sourceChain,
+          sourceToken: options.address.snapshot.sourceToken,
+        },
+        options.signal ?? new AbortController().signal,
+      ),
+    { onAttempt: recordProviderOperation, operation: 'observeDepositAddressRequest' },
+  ).catch((cause) => {
+    if (options.signal?.aborted) throw cause
+    return undefined
+  })
+  options.metrics?.count('routes_deposit_delivery_observation_count', 1, {
     outcome: result?.type ?? 'failed',
     provider: options.address.providerId,
   })
   return result
 }
 
+async function checkpointUnattributed(db: Db.Db, options: checkpointUnattributed.Options) {
+  const parsed = z.safeParse(
+    z.object({
+      before: z.iso.datetime(),
+      cursor: z.object({ createdAt: z.iso.datetime(), id: z.string() }),
+    }),
+    options.address.providerState?.['unattributed'],
+  )
+  const before = parsed.success ? parsed.data.before : options.now.toISOString()
+  const deposits = await RoutesDeposits.listUnattributed(db, {
+    before,
+    cursor: parsed.success ? parsed.data.cursor : undefined,
+    depositAddressId: options.address.id,
+    limit: unattributedBatchSize,
+  })
+  if (!parsed.success && deposits.length < unattributedBatchSize)
+    return { address: options.address, deposits }
+  const last = deposits.at(-1)
+  // Checkpoint attempts before RPC work so failures cannot pin a page. A fixed boundary lets old rows recur despite new arrivals.
+  const address = await RoutesDepositAddresses.checkpointPoll(db, {
+    id: options.address.id,
+    pollLeaseVersion: options.address.pollLeaseVersion,
+    providerState: {
+      ...options.address.providerState,
+      unattributed:
+        deposits.length === unattributedBatchSize && last
+          ? { before, cursor: { createdAt: last.createdAt, id: last.id } }
+          : undefined,
+    },
+  })
+  if (!address) throw new StaleLeaseError()
+  return { address, deposits }
+}
+
+declare namespace checkpointUnattributed {
+  type Options = {
+    address: RoutesDepositAddresses.Record
+    now: Date
+  }
+}
+
 async function reconcileUnattributed(db: Db.Db, options: reconcileUnattributed.Options) {
-  const deposits = await FundingDeposits.listUnattributed(db, options.address.id)
-  if (deposits.length === 0) return { terminal: true, updatedIds: new Set<string>() }
-
-  const transfersByTransaction = new Map(
-    await Promise.all(
-      unique(deposits.map((deposit) => deposit.sourceTransactionHash)).map(
-        async (transactionHash) =>
-          [
+  const { deposits } = options
+  if (deposits.length === 0) return { errors: [], terminal: true, updatedIds: new Set<string>() }
+
+  const sources = await Promise.allSettled(
+    unique(deposits.map((deposit) => deposit.sourceTransactionHash)).map(
+      async (transactionHash) =>
+        [
+          transactionHash,
+          await options.verifyTransfers({
+            chain: options.address.snapshot.sourceChain,
+            recipient: options.address.address,
+            token: options.address.snapshot.sourceToken,
             transactionHash,
-            await options.verifyTransfers({
-              chain: options.address.snapshot.sourceChain,
-              recipient: options.address.address,
-              token: options.address.snapshot.sourceToken,
-              transactionHash,
-            }),
-          ] as const,
-      ),
+          }),
+        ] as const,
     ),
   )
+  const errors: unknown[] = []
+  const transfersByTransaction = new Map<string, readonly TransferEvidence[]>()
+  for (const result of sources)
+    if (result.status === 'fulfilled') transfersByTransaction.set(...result.value)
+    else errors.push(result.reason)
   let followUp: reconcileRequest.ReturnType['followUp']
   let terminal = true
   const updatedIds = new Set<string>()
@@ -723,20 +832,30 @@ async function reconcileUnattributed(db: Db.Db, options: reconcileUnattributed.O
           sourceAmount: BigInt(source.amount),
         },
       ],
+    }).catch((cause: unknown) => {
+      errors.push(cause)
+      return undefined
     })
+    if (!delivery) {
+      terminal = false
+      continue
+    }
     if (delivery.followUp === 'delivery' || !followUp) followUp = delivery.followUp
     if (!delivery.terminal) terminal = false
     for (const id of delivery.updatedIds) updatedIds.add(id)
   }
   return {
     ...(followUp ? { followUp } : {}),
+    errors,
     terminal,
     updatedIds,
   }
 }
 
 declare namespace reconcileUnattributed {
-  type Options = Omit<ReconcileDeliveryOptions, 'request' | 'verified'>
+  type Options = Omit<ReconcileDeliveryOptions, 'request' | 'verified'> & {
+    deposits: readonly RoutesDeposits.Record[]
+  }
 }
 
 /** Reconciles one provider request against verified chain evidence. */
@@ -745,12 +864,12 @@ export async function reconcileRequest(
   options: reconcileRequest.Options,
 ): Promise<reconcileRequest.ReturnType> {
   const trigger = options.trigger ?? 'poll'
-  const observation = await FundingDepositRequestObservations.get(db, {
+  const observation = await RoutesDepositRequestObservations.get(db, {
     depositAddressId: options.address.id,
     providerRequestId: options.request.id,
   })
   if (observation)
-    await FundingDeposits.recordRequestObservation(db, {
+    await RoutesDeposits.recordRequestObservation(db, {
       depositAddressId: observation.depositAddressId,
       ...(observation.pollObservedAt ? { pollObservedAt: observation.pollObservedAt } : {}),
       providerRequestId: observation.providerRequestId,
@@ -762,16 +881,17 @@ export async function reconcileRequest(
   const observed: ObservedSourceTransaction[] = []
   // Persist provider observations first so transient chain failures do not hide acknowledged deposits.
   for (const transactionHash of unique(options.request.sourceTransactionHashes)) {
-    const deposits = await FundingDeposits.withSourceTransaction(db, {
+    const createdBefore = created
+    const deposits = await RoutesDeposits.withSourceTransaction(db, {
       depositAddressId: options.address.id,
-      fn: async (tx): Promise<FundingDeposits.Record[]> => {
-        let records = await FundingDeposits.listByProviderObservation(tx, {
+      fn: async (tx): Promise<RoutesDeposits.Record[]> => {
+        let records = await RoutesDeposits.listByProviderObservation(tx, {
           depositAddressId: options.address.id,
           providerRequestId: options.request.id,
           sourceTransactionHash: transactionHash,
         })
         if (records.length === 0)
-          records = await FundingDeposits.listBySourceTransaction(tx, {
+          records = await RoutesDeposits.listBySourceTransaction(tx, {
             depositAddressId: options.address.id,
             sourceTransactionHash: transactionHash,
           })
@@ -803,6 +923,8 @@ export async function reconcileRequest(
       },
       sourceTransactionHash: transactionHash,
     })
+    if (created > createdBefore)
+      Observability.recordDeposit(options.metrics, { record: deposits[0]! })
     observed.push({ deposits, transactionHash, transfers: [] })
   }
 
@@ -877,6 +999,7 @@ export async function reconcileRequest(
             ? { webhookReceivedAt: observation.webhookReceivedAt }
             : {}),
         })
+        Observability.recordDeposit(options.metrics, { record: deposit })
         source.deposits.push(deposit)
         created += 1
       }
@@ -885,9 +1008,11 @@ export async function reconcileRequest(
         deposit.providerRequestId === null ||
         !deposit.providerRequestIds.includes(options.request.id)
       ) {
-        const result = await transitionDeposit(
-          db,
-          {
+        const result = await transitionDeposit(db, {
+          current: deposit,
+          metrics: options.metrics,
+          onDeposit: options.onDeposit,
+          transition: {
             expectedVersion: deposit.version,
             id: deposit.id,
             providerRequestId: options.request.id,
@@ -902,8 +1027,7 @@ export async function reconcileRequest(
             sourceTransferIndex: transfer.transferIndex,
             status: deposit.status === 'detected' ? 'bridging' : deposit.status,
           },
-          options.onDeposit,
-        )
+        })
         if (result.type === 'applied') {
           deposit = result.record
           updatedIds.add(deposit.id)
@@ -916,6 +1040,18 @@ export async function reconcileRequest(
   if (!sourceEvidenceComplete) {
     return { created, terminal: false, updated: updatedIds.size }
   }
+  if (options.recordLifecycleInterval) {
+    const first = await RoutesDeposits.getFirstByAddress(db, options.address.id)
+    if (
+      first &&
+      first.providerRequestId === options.request.id &&
+      updatedIds.has(first.id) &&
+      verified.some(({ deposit }) => deposit.id === first.id)
+    )
+      await options.recordLifecycleInterval(
+        Observability.depositAddressSourceRoutesInterval(options),
+      )
+  }
   const recovery = await reconcileProviderRecovery(db, { ...options, verified })
   if (recovery) {
     for (const id of recovery.updatedIds) updatedIds.add(id)
@@ -940,15 +1076,19 @@ export declare namespace reconcileRequest {
   /** Provider request, address, and settlement dependencies. */
   type Options = {
     /** Reusable deposit address attributed by the provider. */
-    address: FundingDepositAddresses.Record
+    address: RoutesDepositAddresses.Record
     /** Optional bounded operational metrics sink. */
     metrics?: Metrics.Metrics | undefined
     /** Observes the latest committed form of each verified deposit. */
     onDeposit?:
-      | ((deposit: FundingDeposits.Record, references: readonly Webhooks.QueueReference[]) => void)
+      | ((deposit: RoutesDeposits.Record, references: readonly Webhooks.QueueReference[]) => void)
       | undefined
     /** Provider integration that discovered the request. */
     provider?: Provider.Provider | undefined
+    /** Records completed route lifecycle intervals. */
+    recordLifecycleInterval?:
+      | ((interval: Observability.LifecycleInterval) => Promise<void>)
+      | undefined
     /** Provider request containing discovered chain transactions. */
     request: Provider.listDepositAddressRequests.ReturnType['requests'][number]
     /** Abort signal forwarded to provider delivery observation. */
@@ -976,15 +1116,33 @@ export declare namespace reconcileRequest {
 
 async function transitionDeposit(
   db: Db.Db,
-  options: Deposit.transition.Options,
-  onDeposit: reconcileRequest.Options['onDeposit'],
+  options: transitionDeposit.Options,
 ): Promise<Deposit.transition.Result> {
-  const committed = await DepositWebhook.transition(db, options)
-  if (committed.result.type === 'applied')
-    onDeposit?.(committed.result.record, committed.references)
+  const committed = await DepositWebhook.transition(db, {
+    ...options.transition,
+    ...(options.providerEvidenceComplete ? { providerDeliveredAt: new Date().toISOString() } : {}),
+  })
+  if (committed.result.type === 'applied') {
+    Observability.recordDeposit(options.metrics, {
+      previous: options.current,
+      ...(options.providerEvidenceComplete ? { providerEvidenceComplete: true } : {}),
+      record: committed.result.record,
+    })
+    options.onDeposit?.(committed.result.record, committed.references)
+  }
   return committed.result
 }
 
+declare namespace transitionDeposit {
+  type Options = {
+    current: RoutesDeposits.Record
+    metrics?: Metrics.Metrics | undefined
+    onDeposit: reconcileRequest.Options['onDeposit']
+    providerEvidenceComplete?: boolean | undefined
+    transition: Deposit.transition.Options
+  }
+}
+
 async function reconcileProviderRecovery(db: Db.Db, options: ReconcileDeliveryOptions) {
   const failed = (providerFailureStatuses as readonly string[]).includes(
     options.request?.status ?? '',
@@ -1054,9 +1212,11 @@ async function reconcileProviderRecovery(db: Db.Db, options: ReconcileDeliveryOp
     if (Deposit.isTerminal(entry.deposit.status)) continue
     let deposit = entry.deposit
     if (deposit.status !== 'refunding') {
-      const result = await transitionDeposit(
-        db,
-        {
+      const result = await transitionDeposit(db, {
+        current: deposit,
+        metrics: options.metrics,
+        onDeposit: options.onDeposit,
+        transition: {
           expectedVersion: deposit.version,
           id: deposit.id,
           providerTransactionHashes: unique([
@@ -1065,8 +1225,7 @@ async function reconcileProviderRecovery(db: Db.Db, options: ReconcileDeliveryOp
           ]),
           status: 'refunding',
         },
-        options.onDeposit,
-      )
+      })
       if (result.type === 'applied') {
         deposit = result.record
         updatedIds.add(deposit.id)
@@ -1078,9 +1237,11 @@ async function reconcileProviderRecovery(db: Db.Db, options: ReconcileDeliveryOp
       terminal = false
       continue
     }
-    const result = await transitionDeposit(
-      db,
-      {
+    const result = await transitionDeposit(db, {
+      current: deposit,
+      metrics: options.metrics,
+      onDeposit: options.onDeposit,
+      transition: {
         expectedVersion: deposit.version,
         id: deposit.id,
         snapshot: {
@@ -1094,8 +1255,7 @@ async function reconcileProviderRecovery(db: Db.Db, options: ReconcileDeliveryOp
         },
         status: 'refunded',
       },
-      options.onDeposit,
-    )
+    })
     if (result.type === 'applied') updatedIds.add(deposit.id)
     else if (result.type !== 'stale' || !Deposit.isTerminal(result.current.status)) terminal = false
   }
@@ -1106,7 +1266,7 @@ async function reconcileProviderRecovery(db: Db.Db, options: ReconcileDeliveryOp
     if (failed) return 'provider_failed'
     return 'pending'
   })()
-  options.metrics?.count('funding_deposit_refund_count', 1, {
+  options.metrics?.count('routes_deposit_refund_count', 1, {
     outcome,
     provider: options.address.providerId,
   })
@@ -1121,7 +1281,14 @@ async function reconcileDelivery(db: Db.Db, options: ReconcileDeliveryOptions) {
   let followUp: reconcileRequest.ReturnType['followUp']
   let terminal = true
   const updatedIds = new Set<string>()
-  if (options.verified.every((entry) => Deposit.isTerminal(entry.deposit.status)))
+  const allTerminal = options.verified.every((entry) => Deposit.isTerminal(entry.deposit.status))
+  // Providers can publish sponsorship after destination finality, so terminal rows
+  // remain eligible for a bounded metadata follow-up.
+  if (
+    allTerminal &&
+    (!options.address.snapshot.subsidize ||
+      options.verified.some((entry) => entry.deposit.providerSubsidy))
+  )
     return { terminal, updatedIds }
   const deliveryObservation = await observeProviderDelivery(options)
   if (deliveryObservation?.type === 'pending') followUp = 'delivery'
@@ -1152,6 +1319,36 @@ async function reconcileDelivery(db: Db.Db, options: ReconcileDeliveryOptions) {
     0n,
   )
   const totalRequired = options.verified.reduce((total, entry) => total + entry.required, 0n)
+  const providerSubsidy =
+    options.request?.subsidy ??
+    (providerEvidenceComplete && deliveryObservation?.type === 'verified'
+      ? deliveryObservation.subsidy
+      : undefined)
+  // Providers report one subsidy per request, so attribute it to the first verified transfer.
+  const providerSubsidyDepositId = providerSubsidy ? options.verified[0]?.deposit.id : undefined
+  if (allTerminal) {
+    if (!providerEvidenceComplete || !providerSubsidy)
+      return { ...(followUp ? { followUp } : {}), terminal: false, updatedIds }
+    const deposit = options.verified.find(
+      (entry) => entry.deposit.id === providerSubsidyDepositId,
+    )?.deposit
+    if (!deposit || deposit.providerSubsidy) return { terminal, updatedIds }
+    const result = await transitionDeposit(db, {
+      current: deposit,
+      metrics: options.metrics,
+      onDeposit: options.onDeposit,
+      transition: {
+        expectedVersion: deposit.version,
+        id: deposit.id,
+        providerSubsidy,
+      },
+    })
+    if (result.type === 'applied') updatedIds.add(deposit.id)
+    return {
+      terminal: result.type !== 'stale' || Boolean(result.current.providerSubsidy),
+      updatedIds,
+    }
+  }
   let allocated = 0n
   let cumulativeRequired = 0n
 
@@ -1165,94 +1362,144 @@ async function reconcileDelivery(db: Db.Db, options: ReconcileDeliveryOptions) {
     const { deposit } = entry
     if (Deposit.isTerminal(deposit.status)) continue
 
-    const settlement = await reconcileSubsidy({
-      address: options.address,
-      delivered,
-      deposit,
-      providerEvidenceComplete,
-      required,
-      sourceAmount,
-      subsidies: options.subsidies,
-      verifyTransfers: options.verifyTransfers,
-    })
+    const prepare = async (database: Db.Db) => {
+      const settlement = await reconcileSubsidy(database, {
+        address: options.address,
+        delivered,
+        deposit,
+        providerEvidenceComplete,
+        required,
+        sourceAmount,
+        subsidies: options.subsidies,
+        verifyTransfers: options.verifyTransfers,
+      })
+      const destinationAmount = Value.tokenAmount({
+        baseUnits: delivered + settlement.delivered,
+        currency: options.address.snapshot.destinationToken.currency,
+        decimals: options.address.snapshot.destinationToken.decimals,
+      })
+      const destinationAmountRequired = (() => {
+        if (options.address.snapshot.subsidize)
+          return Value.tokenAmount({
+            baseUnits: required,
+            currency: options.address.snapshot.destinationToken.currency,
+            decimals: options.address.snapshot.destinationToken.decimals,
+          })
+        if (settlement.status === 'completed') return destinationAmount
+        return undefined
+      })()
+      return {
+        settlement,
+        transition: {
+          expectedVersion: deposit.version,
+          id: deposit.id,
+          ...(delivered > 0n
+            ? {
+                providerOutputAmount: Value.tokenAmount({
+                  baseUnits: delivered,
+                  currency: options.address.providerOutputToken.currency,
+                  decimals: options.address.providerOutputToken.decimals,
+                }),
+              }
+            : {}),
+          ...(providerEvidenceComplete ? { providerDeliveredAt: new Date().toISOString() } : {}),
+          ...(providerSubsidy && deposit.id === providerSubsidyDepositId
+            ? { providerSubsidy }
+            : {}),
+          providerRequestIds: options.request
+            ? unique([...deposit.providerRequestIds, options.request.id])
+            : deposit.providerRequestIds,
+          ...(deliveryObservation?.providerState
+            ? {
+                providerState: {
+                  ...deposit.providerState,
+                  ...deliveryObservation.providerState,
+                },
+              }
+            : {}),
+          providerTransactionHashes: unique([
+            ...deposit.providerTransactionHashes,
+            ...providerTransactionHashes,
+            ...(deliveryObservation?.providerTransactionHashes ?? []),
+          ]),
+          ...(settlement.settlementTransaction
+            ? { settlementTransaction: settlement.settlementTransaction }
+            : {}),
+          ...(settlement.settlementTransactionHash
+            ? { settlementTransactionHash: settlement.settlementTransactionHash }
+            : {}),
+          snapshot: {
+            ...deposit.snapshot,
+            ...(delivered + settlement.delivered > 0n ? { destinationAmount } : {}),
+            ...(destinationAmountRequired ? { destinationAmountRequired } : {}),
+            destinationTransactionHashes: unique([
+              ...(deposit.snapshot.destinationTransactionHashes ?? []),
+              ...destinationTransfers.map((evidence) => evidence.transactionHash),
+              ...settlement.destinationTransactionHashes,
+            ]),
+          },
+          status: settlement.status,
+          ...(settlement.statusReason ? { statusReason: settlement.statusReason } : {}),
+          ...(settlement.subsidyAmount ? { subsidyAmount: settlement.subsidyAmount } : {}),
+          ...(settlement.tempoGasPaid ? { tempoGasPaid: settlement.tempoGasPaid } : {}),
+        },
+      }
+    }
+    const { committed, settlement } = await (async () => {
+      if (!options.address.snapshot.subsidize) {
+        const prepared = await prepare(db)
+        return {
+          committed: await DepositWebhook.transition(db, prepared.transition),
+          settlement: prepared.settlement,
+        }
+      }
+      return RoutesDeposits.withSubsidySettlement(db, {
+        fn: async (tx) => {
+          const prepared = await prepare(tx)
+          const result = await Deposit.transition(tx, prepared.transition)
+          const staged =
+            result.type === 'applied'
+              ? await DepositWebhook.stage(tx, { records: [result.record] })
+              : undefined
+          return {
+            committed: { references: staged?.references ?? [], result },
+            settlement: prepared.settlement,
+          }
+        },
+        orgId: options.address.orgId,
+      })
+    })()
     if (settlement.outcome)
-      options.metrics?.count('funding_deposit_subsidy_count', 1, {
+      options.metrics?.count('routes_deposit_subsidy_count', 1, {
         outcome: settlement.outcome,
         provider: options.address.providerId,
       })
-    if (settlement.status === 'bridging' || settlement.status === 'settling') terminal = false
+    const policyPending =
+      settlement.outcome === 'routes_subsidy_limit_exceeded' ||
+      (settlement.outcome !== undefined && settlement.outcome in Subsidy.denialMessages)
+    if (settlement.status === 'bridging' || settlement.status === 'settling' || policyPending)
+      terminal = false
     if (settlement.status === 'settling') followUp = 'settlement'
-    const destinationAmount = Value.tokenAmount({
-      baseUnits: delivered + settlement.delivered,
-      currency: options.address.snapshot.destinationToken.currency,
-      decimals: options.address.snapshot.destinationToken.decimals,
-    })
-    const result = await transitionDeposit(
-      db,
-      {
-        expectedVersion: deposit.version,
-        id: deposit.id,
-        ...(delivered > 0n
-          ? {
-              providerOutputAmount: Value.tokenAmount({
-                baseUnits: delivered,
-                currency: options.address.providerOutputToken.currency,
-                decimals: options.address.providerOutputToken.decimals,
-              }),
-            }
-          : {}),
-        providerRequestIds: options.request
-          ? unique([...deposit.providerRequestIds, options.request.id])
-          : deposit.providerRequestIds,
-        ...(deliveryObservation?.providerState
-          ? {
-              providerState: {
-                ...deposit.providerState,
-                ...deliveryObservation.providerState,
-              },
-            }
-          : {}),
-        providerTransactionHashes: unique([
-          ...deposit.providerTransactionHashes,
-          ...providerTransactionHashes,
-          ...(deliveryObservation?.providerTransactionHashes ?? []),
-        ]),
-        ...(settlement.settlementTransaction
-          ? { settlementTransaction: settlement.settlementTransaction }
-          : {}),
-        ...(settlement.settlementTransactionHash
-          ? { settlementTransactionHash: settlement.settlementTransactionHash }
-          : {}),
-        snapshot: {
-          ...deposit.snapshot,
-          ...(delivered + settlement.delivered > 0n ? { destinationAmount } : {}),
-          ...(settlement.status === 'completed' && !options.address.snapshot.subsidize
-            ? { destinationAmountRequired: destinationAmount }
-            : {}),
-          destinationTransactionHashes: unique([
-            ...(deposit.snapshot.destinationTransactionHashes ?? []),
-            ...destinationTransfers.map((evidence) => evidence.transactionHash),
-            ...settlement.destinationTransactionHashes,
-          ]),
-        },
-        status: settlement.status,
-        ...(settlement.statusReason ? { statusReason: settlement.statusReason } : {}),
-        ...(settlement.subsidyAmount ? { subsidyAmount: settlement.subsidyAmount } : {}),
-        ...(settlement.tempoGasPaid ? { tempoGasPaid: settlement.tempoGasPaid } : {}),
-      },
-      options.onDeposit,
-    )
+    const { result } = committed
     if (result.type === 'applied') {
+      Observability.recordDeposit(options.metrics, {
+        previous: deposit,
+        ...(providerEvidenceComplete ? { providerEvidenceComplete: true } : {}),
+        record: result.record,
+      })
+      options.onDeposit?.(result.record, committed.references)
       updatedIds.add(deposit.id)
+    }
+    if (result.type === 'applied' || result.type === 'unchanged') {
       if (settlement.broadcast && options.subsidies) {
         await options.subsidies.broadcast(settlement.broadcast).catch((cause) => {
-          options.metrics?.count('funding_deposit_subsidy_count', 1, {
+          options.metrics?.count('routes_deposit_subsidy_count', 1, {
             outcome: 'broadcast_failed',
             provider: options.address.providerId,
           })
           throw cause
         })
-        options.metrics?.count('funding_deposit_subsidy_count', 1, {
+        options.metrics?.count('routes_deposit_subsidy_count', 1, {
           outcome: 'broadcast',
           provider: options.address.providerId,
         })
@@ -1263,9 +1510,9 @@ async function reconcileDelivery(db: Db.Db, options: ReconcileDeliveryOptions) {
 }
 
 type ReconcileSubsidyOptions = {
-  address: FundingDepositAddresses.Record
+  address: RoutesDepositAddresses.Record
   delivered: bigint
-  deposit: FundingDeposits.Record
+  deposit: RoutesDeposits.Record
   providerEvidenceComplete: boolean
   required: bigint
   sourceAmount: bigint
@@ -1277,7 +1524,19 @@ type ReconcileSubsidyResult = {
   broadcast?: Subsidy.Settler.broadcast.Parameters | undefined
   delivered: bigint
   destinationTransactionHashes: readonly string[]
-  outcome?: string | undefined
+  outcome?:
+    | 'balance_unavailable'
+    | 'completed'
+    | 'liquidity_unavailable'
+    | 'pending'
+    | 'prepared'
+    | 'reverted'
+    | 'routes_subsidy_limit_exceeded'
+    | 'underfilled'
+    | 'unavailable'
+    | 'unsupported'
+    | Subsidy.DenialReason
+    | undefined
   settlementTransaction?: string | undefined
   settlementTransactionHash?: string | undefined
   status: Deposit.Status
@@ -1286,7 +1545,10 @@ type ReconcileSubsidyResult = {
   tempoGasPaid?: string | undefined
 }
 
-async function reconcileSubsidy(options: ReconcileSubsidyOptions): Promise<ReconcileSubsidyResult> {
+async function reconcileSubsidy(
+  db: Db.Db,
+  options: ReconcileSubsidyOptions,
+): Promise<ReconcileSubsidyResult> {
   const empty = { delivered: 0n, destinationTransactionHashes: [] } as const
   if (options.required === 0n)
     return {
@@ -1328,7 +1590,11 @@ async function reconcileSubsidy(options: ReconcileSubsidyOptions): Promise<Recon
           code: 'subsidy_failed',
           message: 'Tempo could not deliver the required subsidy.',
         },
-        subsidyAmount,
+        subsidyAmount: Value.tokenAmount({
+          baseUnits: 0n,
+          currency: options.address.snapshot.destinationToken.currency,
+          decimals: options.address.snapshot.destinationToken.decimals,
+        }),
         tempoGasPaid: status.tempoGasPaid,
       }
     if (status.type === 'pending')
@@ -1355,7 +1621,11 @@ async function reconcileSubsidy(options: ReconcileSubsidyOptions): Promise<Recon
       destinationTransactionHashes: transfers.map((transfer) => transfer.transactionHash),
       outcome: options.delivered + delivered >= options.required ? 'completed' : 'underfilled',
       status: options.delivered + delivered >= options.required ? 'completed' : 'settling',
-      subsidyAmount,
+      subsidyAmount: Value.tokenAmount({
+        baseUnits: delivered,
+        currency: options.address.snapshot.destinationToken.currency,
+        decimals: options.address.snapshot.destinationToken.decimals,
+      }),
       tempoGasPaid: status.tempoGasPaid,
     }
   }
@@ -1374,6 +1644,35 @@ async function reconcileSubsidy(options: ReconcileSubsidyOptions): Promise<Recon
     }
   }
   if (!options.providerEvidenceComplete) return { ...empty, status: 'bridging' }
+  const policy = await Subsidy.check(db, {
+    environment: options.address.environment,
+    orgId: options.address.orgId,
+  })
+  if (policy.type === 'denied')
+    return {
+      ...empty,
+      outcome: policy.reason,
+      status: 'action-required',
+      statusReason: {
+        code: policy.reason,
+        message: Subsidy.denialMessages[policy.reason],
+      },
+    }
+  if (
+    !Subsidy.supportsGap(policy, {
+      amount: deficit,
+      destinationToken: options.address.snapshot.destinationToken,
+    })
+  )
+    return {
+      ...empty,
+      outcome: 'routes_subsidy_limit_exceeded',
+      status: 'action-required',
+      statusReason: {
+        code: 'routes_subsidy_limit_exceeded',
+        message: 'The required subsidy exceeds the per-transaction limit.',
+      },
+    }
   if (!options.subsidies)
     return {
       ...empty,
@@ -1460,13 +1759,16 @@ function nextFollowUp(
   kind: Provider.Webhook.receive.FollowUp['kind'],
 ) {
   const attempt = message.followUp?.kind === kind ? message.followUp.attempt + 1 : 0
-  const chainProvider = kind === 'provider' && message.trigger === 'chain'
-  const maximumAttempts = chainProvider
-    ? chainProviderMaximumFollowUpAttempts
-    : maximumFollowUpAttempts
+  // Provider fee metadata can arrive after delivery, so its slower retry window outlives chain catch-up.
+  const chainCatchUp = kind === 'delivery' && message.trigger === 'chain'
+  const maximumAttempts = (() => {
+    if (chainCatchUp) return chainCatchUpMaximumFollowUpAttempts
+    if (kind === 'provider') return providerMaximumFollowUpAttempts
+    return maximumFollowUpAttempts
+  })()
   if (attempt >= maximumAttempts) return undefined
   return {
-    delaySeconds: chainProvider ? chainProviderFollowUpDelaySeconds : followUpDelaySeconds[kind],
+    delaySeconds: chainCatchUp ? chainCatchUpFollowUpDelaySeconds : followUpDelaySeconds[kind],
     state: { attempt, kind },
   }
 }
@@ -1474,7 +1776,7 @@ function nextFollowUp(
 type RecordWebhookLatencyOptions = {
   /** When Tempo completed the webhook-triggered reconciliation. */
   completedAt: Date
-  /** Funding provider that sent the webhook. */
+  /** Route provider that sent the webhook. */
   providerId: string
   /** Authenticated timestamps carried from webhook receipt. */
   timing: Provider.Webhook.receive.WebhookTiming
@@ -1498,23 +1800,19 @@ function recordWebhookLatency(
     { from: providerUpdatedAt, segment: 'provider_to_reconciled', to: completedAt },
   ] as const
   for (const segment of segments)
-    metrics.histogram(
-      'funding_deposit_webhook_latency_ms',
-      Math.max(0, segment.to - segment.from),
-      {
-        provider: options.providerId,
-        segment: segment.segment,
-        status: options.timing.providerStatus,
-      },
-    )
+    metrics.histogram('routes_deposit_webhook_latency_ms', Math.max(0, segment.to - segment.from), {
+      provider: options.providerId,
+      segment: segment.segment,
+      status: options.timing.providerStatus,
+    })
 }
 
 /** Provider pagination exceeded the bounded reconciliation limit. */
 export class PaginationLimitError extends Error {
-  override name = 'Funding.Reconciliation.PaginationLimitError'
+  override name = 'Routes.Reconciliation.PaginationLimitError'
 }
 
 /** The reconciliation lease was claimed by another worker. */
 export class StaleLeaseError extends Error {
-  override name = 'Funding.Reconciliation.StaleLeaseError'
+  override name = 'Routes.Reconciliation.StaleLeaseError'
 }