tapimo 0.14.0 → 0.15.0

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

@@ -4,7 +4,7 @@ import * as z from 'zod/mini'
 import type * as App from '../../App.js'
 import * as Db from '../../db/Db.js'
 import * as db_Schema from '../../db/Schema.js'
-import * as core_Catalog from '../../db/tables/fundingCatalog.js'
+import * as core_Catalog from '../../db/tables/routesCatalog.js'
 import * as Timing from '../Timing.js'
 import * as Chain from './Chain.js'
 import * as Route from './Route.js'
@@ -15,16 +15,16 @@ const defaultRefreshMs = 10_000
 const emptyUpdatedAt = '1970-01-01T00:00:00.000Z'
 const emptyVersion = 'empty'
 
-/** Funding catalog schemas. */
+/** Route catalog schemas. */
 export namespace schema {
   const ChainId = z
     .string()
     .check(
       z.regex(/^(?:eip155:\d+|solana:[^:]+|tron:[^:]+)$/),
-      z.describe('CAIP-2 funding chain identifier.'),
+      z.describe('CAIP-2 route chain identifier.'),
     )
 
-  const Chain = z.extend(db_Schema.FundingChain, {
+  const Chain = z.extend(db_Schema.RoutesChain, {
     id: ChainId,
     parentChainId: z.nullable(ChainId),
   })
@@ -33,80 +33,80 @@ export namespace schema {
     .object({
       modes: z
         .readonly(z.array(z.enum(Transfer.modes)))
-        .check(z.minLength(1), z.describe('Amount modes enabled for funding transfers.')),
+        .check(z.minLength(1), z.describe('Amount modes enabled for route transfers.')),
     })
-    .check(z.describe('Funding transfer capability enabled on one provider route.'))
+    .check(z.describe('Route transfer capability enabled on one provider route.'))
 
-  /** Funding capabilities enabled on one provider route. */
+  /** Routes capabilities enabled on one provider route. */
   export const Capabilities = z
     .object({
       depositAddress: z
         .optional(z.literal(true))
-        .check(z.describe('Deposit-address funding support enabled on the route.')),
+        .check(z.describe('Deposit-address routes support enabled on the route.')),
       transfer: z
         .optional(TransferCapability)
-        .check(z.describe('Funding transfer support enabled on the route.')),
+        .check(z.describe('Route transfer support enabled on the route.')),
     })
     .check(
       z.refine(
         (capabilities) =>
           capabilities.depositAddress !== undefined || capabilities.transfer !== undefined,
       ),
-      z.describe('Funding capabilities enabled on one provider route.'),
+      z.describe('Routes capabilities enabled on one provider route.'),
     )
 
-  /** Provider-specific configuration for one funding route. */
+  /** Provider-specific configuration for one provider route. */
   export const Configuration = z
     .record(z.string(), z.unknown())
-    .check(z.describe('Provider-specific configuration for one funding route.'))
+    .check(z.describe('Provider-specific configuration for one provider route.'))
 
   // Absent or null `capabilities` keeps a route quote-only. Absent or null
   // `configuration` lets providers decide whether a route is configured.
-  const Route = z.extend(db_Schema.FundingRoute, {
+  const Route = z.extend(db_Schema.RoutesRoute, {
     capabilities: z.optional(z.nullable(Capabilities)),
     configuration: z.optional(z.nullable(Configuration)),
   })
 
-  /** Complete funding catalog content accepted by the publish boundary. */
+  /** Complete route catalog content accepted by the publish boundary. */
   export const Data = z
     .object({
       chainTokens: z
-        .readonly(z.array(db_Schema.FundingChainToken))
-        .check(z.describe('Chain-scoped funding tokens.')),
-      chains: z.readonly(z.array(Chain)).check(z.describe('Funding chains.')),
-      routes: z.readonly(z.array(Route)).check(z.describe('Funding provider routes.')),
-      tokens: z.readonly(z.array(db_Schema.FundingToken)).check(z.describe('Funding tokens.')),
+        .readonly(z.array(db_Schema.RoutesChainToken))
+        .check(z.describe('Chain-scoped route tokens.')),
+      chains: z.readonly(z.array(Chain)).check(z.describe('Route chains.')),
+      routes: z.readonly(z.array(Route)).check(z.describe('Route provider routes.')),
+      tokens: z.readonly(z.array(db_Schema.RoutesToken)).check(z.describe('Route tokens.')),
     })
-    .check(z.describe('Complete funding catalog content.'))
+    .check(z.describe('Complete route catalog content.'))
 }
 
-/** Funding capabilities enabled on one provider route. */
+/** Routes capabilities enabled on one provider route. */
 export type Capabilities = z.output<typeof schema.Capabilities>
 
-/** Provider-specific configuration for one funding route. */
+/** Provider-specific configuration for one provider route. */
 export type Configuration = z.output<typeof schema.Configuration>
 
-/** One hydrated provider route in a funding catalog snapshot. */
+/** One hydrated provider route in a route catalog snapshot. */
 export type ProviderRoute = {
-  /** Funding capabilities; absent means the route is quote-only. */
+  /** Routes capabilities; absent means the route is quote-only. */
   capabilities?: Capabilities | undefined
   /** Provider-specific route configuration. */
   configuration?: Configuration | undefined
-  /** Funding provider that supports the route. */
+  /** Route provider that supports the route. */
   providerId: string
-  /** Hydrated source-to-destination funding route. */
+  /** Hydrated source-to-destination provider route. */
   route: Route.Route
 }
 
-/** Compiled and indexed funding catalog. */
+/** Compiled and indexed route catalog. */
 export type Snapshot = {
-  /** Funding chains indexed by CAIP-2 id, slug, and alias. */
+  /** Route chains indexed by CAIP-2 id, slug, and alias. */
   chainsByKey: ReadonlyMap<string, Chain.Chain>
   /** Hydrated provider routes in stable catalog order. */
   routes: readonly ProviderRoute[]
   /** Hydrated provider routes grouped by provider id. */
   routesByProvider: ReadonlyMap<string, readonly ProviderRoute[]>
-  /** Canonical funding tokens indexed by stable id. */
+  /** Canonical route tokens indexed by stable id. */
   tokensById: ReadonlyMap<string, Token.Token>
   /** ISO timestamp of the catalog's last publish. */
   updatedAt: string
@@ -114,7 +114,7 @@ export type Snapshot = {
   version: string
 }
 
-/** Compiles stored funding catalog rows into a validated snapshot. */
+/** Compiles stored route catalog rows into a validated snapshot. */
 export function compile(rows: core_Catalog.Rows): Snapshot {
   const data = normalize({
     chainTokens: rows.chainTokens,
@@ -220,12 +220,12 @@ export function compile(rows: core_Catalog.Rows): Snapshot {
   }
 }
 
-/** Reads and compiles the current funding catalog from Postgres. */
+/** Reads and compiles the current route catalog from Postgres. */
 export async function read(db: Db.Db): Promise<Snapshot> {
   return compile(await core_Catalog.read(db))
 }
 
-/** Publishes a complete funding catalog and primes the current isolate. */
+/** Publishes a complete route catalog and primes the current isolate. */
 export async function publish(db: Db.Db, input: publish.Input): Promise<Snapshot> {
   const data = normalize(input)
   compile({
@@ -245,7 +245,7 @@ export async function publish(db: Db.Db, input: publish.Input): Promise<Snapshot
 }
 
 export declare namespace publish {
-  /** Complete funding catalog content. */
+  /** Complete route catalog content. */
   type Input = z.input<typeof schema.Data>
 }
 
@@ -255,9 +255,9 @@ export function prime(source: Db.Source, snapshot: Snapshot): Snapshot {
   return snapshot
 }
 
-/** Returns the current funding catalog snapshot with soft background refresh. */
+/** Returns the current route catalog snapshot with soft background refresh. */
 export function snapshot(c: Context<App.Environment>): Promise<Snapshot> {
-  return Timing.time(c, 'funding_catalog', async () => {
+  return Timing.time(c, 'routes_catalog', async () => {
     const source = c.get('dbCached')
     const cell = cells.get(source)
     if (cell && Date.now() - cell.checkedAt < defaultRefreshMs) return cell.snapshot
@@ -289,7 +289,7 @@ function refresh(c: Context<App.Environment>, source: Db.Source, current: Cell |
     try {
       const db = Db.get(source)
       if (current) {
-        const head = await Timing.time(c, 'funding_catalog_head', () => core_Catalog.head(db))
+        const head = await Timing.time(c, 'routes_catalog_head', () => core_Catalog.head(db))
         if (!head || head.version === current.snapshot.version) {
           cells.set(source, { checkedAt: Date.now(), snapshot: current.snapshot })
           return current.snapshot
@@ -300,7 +300,7 @@ function refresh(c: Context<App.Environment>, source: Db.Source, current: Cell |
       return next
     } catch (error) {
       if (!current) throw error
-      console.error('[funding-catalog] refresh failed; serving last good snapshot', error)
+      console.error('[routes-catalog] refresh failed; serving last good snapshot', error)
       cells.set(source, { checkedAt: Date.now(), snapshot: current.snapshot })
       return current.snapshot
     } finally {
@@ -358,7 +358,7 @@ function resolvePlacement(
   }
 }
 
-/** Error thrown when funding catalog references cannot be compiled. */
+/** Error thrown when route catalog references cannot be compiled. */
 export class InvalidCatalogError extends Error {
-  override name = 'Funding.Catalog.InvalidCatalogError'
+  override name = 'Routes.Catalog.InvalidCatalogError'
 }

package/src/internal/{funding → routes}/Chain.test.ts

@@ -68,7 +68,7 @@ describe('eip155Id', () => {
   test('rejects non-EIP-155 chains', () => {
     const chain = Chain.from({ id: 'solana:mainnet', name: 'Solana', slug: 'solana' })
     expect(() => Chain.eip155Id(chain)).toThrowErrorMatchingInlineSnapshot(
-      `[Funding.Chain.InvalidIdError]`,
+      `[Routes.Chain.InvalidIdError]`,
     )
   })
 })

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

@@ -1,9 +1,9 @@
 import * as Token from './Token.js'
 
-/** Canonical identifier for a funding chain. */
+/** Canonical identifier for a route chain. */
 export type Id = `eip155:${number}` | `solana:${string}` | `tron:${string}`
 
-/** Chain metadata for a funding token. */
+/** Chain metadata for a route token. */
 export type Chain = Callable &
   (
     | (Base & {
@@ -29,18 +29,18 @@ export type Chain = Callable &
 type Callable = (options: Callable.Options) => Selection
 
 declare namespace Callable {
-  /** Tokens selected for a funding route on this chain. */
+  /** Tokens selected for a provider route on this chain. */
   type Options = {
     /** Token definitions to resolve on the chain. */
     tokens: readonly Token.Token[]
   }
 }
 
-/** Tokens resolved for one funding chain. */
+/** Tokens resolved for one route chain. */
 export type Selection = {
   /** Chain shared by every selected token. */
   chain: Chain
-  /** Chain-scoped funding tokens. */
+  /** Chain-scoped route tokens. */
   tokens: readonly Token.Resolved[]
 }
 
@@ -53,13 +53,13 @@ type Base = {
   name: string
   /** Parent chain identifier when this chain is a Zone. */
   parentChainId?: Id | undefined
-  /** Public RPC endpoints used for funding-chain evidence. */
+  /** Public RPC endpoints used for routes-chain evidence. */
   rpcUrls: readonly string[]
   /** Stable chain segment used in quote identifiers. */
   slug: string
 }
 
-/** Creates funding chain metadata from a CAIP-2 identifier. */
+/** Creates route chain metadata from a CAIP-2 identifier. */
 export function from(options: from.Options): Chain {
   const { aliases = [], id, name, parentChainId, rpcUrls = [], slug } = options
   const base = { aliases, id, name, ...(parentChainId ? { parentChainId } : {}), rpcUrls, slug }
@@ -90,7 +90,7 @@ export function from(options: from.Options): Chain {
 }
 
 export declare namespace from {
-  /** Funding chain definition. */
+  /** Route chain definition. */
   type Options = {
     /** Additional caller-facing aliases accepted for this chain. */
     aliases?: readonly string[] | undefined
@@ -100,7 +100,7 @@ export declare namespace from {
     name: string
     /** Parent chain identifier when this chain is a Zone. */
     parentChainId?: Id | undefined
-    /** Public RPC endpoints used for funding-chain evidence. */
+    /** Public RPC endpoints used for routes-chain evidence. */
     rpcUrls?: readonly string[] | undefined
     /** Stable chain segment used in quote identifiers. */
     slug: string
@@ -114,7 +114,7 @@ export function eip155Id(chain: Chain): string {
   return match[1]
 }
 
-/** Error thrown when a funding chain identifier is invalid for an operation. */
+/** Error thrown when a route chain identifier is invalid for an operation. */
 export class InvalidIdError extends Error {
-  override name = 'Funding.Chain.InvalidIdError'
+  override name = 'Routes.Chain.InvalidIdError'
 }

package/src/internal/{funding → routes}/Deposit.test.ts

@@ -4,7 +4,7 @@ describe('generateId', () => {
   test('embeds the timestamp so lexical order is chronological', () => {
     const earlier = Deposit.generateId(new Date('2026-01-01T00:00:00.000Z'))
     const later = Deposit.generateId(new Date('2026-01-01T00:00:01.000Z'))
-    expect(earlier).toMatch(/^fdp_\d{15}_[0-9A-Za-z]{24}$/)
+    expect(earlier).toMatch(/^rdp_\d{15}_[0-9A-Za-z]{24}$/)
     expect(earlier < later).toBe(true)
   })
 })

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

@@ -1,21 +1,21 @@
 import * as z from 'zod/mini'
 
 import type * as Db from '../../db/Db.js'
-import * as FundingDepositAddresses from '../../db/tables/fundingDepositAddresses.js'
-import * as FundingDeposits from '../../db/tables/fundingDeposits.js'
+import * as RoutesDepositAddresses from '../../db/tables/routesDepositAddresses.js'
+import * as RoutesDeposits from '../../db/tables/routesDeposits.js'
 import * as Id from '../Id.js'
 import * as OpenApi from '../OpenApi.js'
 import * as Schema from '../Schema.js'
 import * as Provider from './Provider.js'
 
-/** Mechanisms that can first detect a funding deposit. */
+/** Mechanisms that can first detect a route deposit. */
 export const detectionTriggers = ['chain', 'manual', 'poll', 'webhook'] as const
 
-/** Mechanism that first detected a funding deposit. */
+/** Mechanism that first detected a route deposit. */
 export type DetectionTrigger = (typeof detectionTriggers)[number]
 
 /**
- * Public funding deposit statuses:
+ * Public route deposit statuses:
  *
  * - `action-required`: Automatic processing stopped and requires recovery or operator action.
  * - `bridging`: The provider is moving the source funds to Tempo.
@@ -35,7 +35,7 @@ export const statuses = [
   'settling',
 ] as const
 
-/** Lifecycle status of a detected funding deposit. */
+/** Lifecycle status of a detected route deposit. */
 export type Status = (typeof statuses)[number]
 
 /** Statuses that never change after verified chain evidence. */
@@ -44,20 +44,28 @@ export const terminalStatuses = ['completed', 'refunded'] as const satisfies rea
 /**
  * Customer-safe codes explaining a deposit that needs attention:
  *
+ * - `billing_past_due`: The organization must resolve past-due production billing.
+ * - `billing_required`: The organization must configure active production billing.
  * - `delivery_failed`: The provider or Tempo could not complete destination delivery.
  * - `delivery_liquidity_unavailable`: The selected strategy cannot obtain the required destination amount.
  * - `manual_recovery_required`: Automatic processing cannot safely continue.
  * - `refund_failed`: The provider could not refund the source funds.
+ * - `routes_subsidy_limit_exceeded`: The required subsidy exceeds the effective per-transaction limit.
+ * - `routes_subsidy_not_enabled`: The effective policy does not allow a subsidy.
  * - `source_amount_not_supported`: The source amount is outside the supported limits.
  * - `source_token_mismatch`: The transfer used a token other than the configured source token.
  * - `subsidy_balance_unavailable`: Tempo lacks enough pathUSD for the required subsidy.
  * - `subsidy_failed`: Tempo could not deliver the required subsidy.
  */
 export const statusReasonCodes = [
+  'billing_past_due',
+  'billing_required',
   'delivery_failed',
   'delivery_liquidity_unavailable',
   'manual_recovery_required',
   'refund_failed',
+  'routes_subsidy_limit_exceeded',
+  'routes_subsidy_not_enabled',
   'source_amount_not_supported',
   'source_token_mismatch',
   'subsidy_balance_unavailable',
@@ -90,24 +98,24 @@ export function canTransition(from: Status, to: Status): boolean {
   return transitions[from].includes(to)
 }
 
-/** Generates a funding deposit id (`fdp_…`, lexically time-ordered). */
+/** Generates a route deposit id (`rdp_…`, lexically time-ordered). */
 export function generateId(now: Date = new Date()): string {
-  return Id.generateSortable('fdp', now)
+  return Id.generateSortable('rdp', now)
 }
 
-/** Zod schemas owned by the funding deposit resource. */
+/** Zod schemas owned by the route deposit resource. */
 export namespace schema {
   const transactionHashes = (description: string) =>
     z
       .readonly(z.array(z.string()))
       .check(z.describe(description), z.meta({ examples: [[`0x${'aa'.repeat(32)}`]] }))
 
-  /** Mechanism that first detected a funding deposit. */
+  /** Mechanism that first detected a route deposit. */
   export const DetectionTrigger = z
     .enum(detectionTriggers)
     .check(z.describe('How the deposit was first detected.'), z.meta({ examples: ['webhook'] }))
 
-  /** Funding deposit lifecycle status. */
+  /** Route deposit lifecycle status. */
   export const Status = z
     .enum(statuses)
     .check(
@@ -133,7 +141,7 @@ export namespace schema {
           ),
       })
       .check(z.describe('Why a deposit needs attention or recovery.')),
-    'FundingDepositStatusReason',
+    'RoutesDepositStatusReason',
   )
 
   /** Public fields persisted as the deposit snapshot. */
@@ -142,9 +150,9 @@ export namespace schema {
       depositAddressId: z
         .string()
         .check(
-          z.regex(/^fda_[A-Za-z0-9_-]+$/),
-          z.describe('Funding deposit address that detected the transfer.'),
-          z.meta({ examples: ['fda_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx'] }),
+          z.regex(/^(?:fda|rda)_[A-Za-z0-9_-]+$/),
+          z.describe('Route deposit address that detected the transfer, including legacy IDs.'),
+          z.meta({ examples: ['rda_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx'] }),
         ),
       destinationAmount: z.optional(Schema.TokenAmount),
       destinationAmountRequired: z
@@ -192,8 +200,8 @@ export namespace schema {
       z.describe('Public route, provider observations, and verified evidence for one deposit.'),
     )
 
-  /** One detected funding deposit. */
-  export const FundingDeposit = OpenApi.component(
+  /** One detected route deposit. */
+  export const RoutesDeposit = OpenApi.component(
     z
       .object({
         createdAt: z.iso
@@ -212,9 +220,9 @@ export namespace schema {
         id: z
           .string()
           .check(
-            z.regex(/^fdp_[A-Za-z0-9_-]+$/),
-            z.describe('Funding deposit id (`fdp_…`).'),
-            z.meta({ examples: ['fdp_001785792060000_2ZPE2gvateYEQ0dQslgvkhjx'] }),
+            z.regex(/^(?:fdp|rdp)_[A-Za-z0-9_-]+$/),
+            z.describe('Route deposit id (`rdp_…`, or legacy `fdp_…`).'),
+            z.meta({ examples: ['rdp_001785792060000_2ZPE2gvateYEQ0dQslgvkhjx'] }),
           ),
         provider: Snapshot.shape.provider,
         recipient: Snapshot.shape.recipient,
@@ -242,29 +250,29 @@ export namespace schema {
           ),
       })
       .check(z.describe('One detected deposit and its delivery status.')),
-    'FundingDeposit',
+    'RoutesDeposit',
   )
 }
 
-/** Stored public snapshot of a funding deposit. */
+/** Stored public snapshot of a route deposit. */
 export type Snapshot = z.output<typeof schema.Snapshot>
 
-/** Customer-safe funding deposit status reason. */
+/** Customer-safe route deposit status reason. */
 export type StatusReason = z.output<typeof schema.StatusReason>
 
-/** A funding deposit as returned by reads. */
-export type Public = z.output<typeof schema.FundingDeposit>
+/** A route deposit as returned by reads. */
+export type Public = z.output<typeof schema.RoutesDeposit>
 
 /** Creates a durable record for one provider-observed source transaction. */
-export async function create(db: Db.Db, input: create.Input): Promise<FundingDeposits.Record> {
-  return FundingDeposits.insert(db, await record(db, input))
+export async function create(db: Db.Db, input: create.Input): Promise<RoutesDeposits.Record> {
+  return RoutesDeposits.insert(db, await record(db, input))
 }
 
 /** Creates or returns the deposit for one verified chain transfer. */
 export async function createFromSource(
   db: Db.Db,
   input: createFromSource.Input,
-): Promise<FundingDeposits.insertOrGetSource.Result> {
+): Promise<RoutesDeposits.insertOrGetSource.Result> {
   const stored = await record(db, {
     detectionTrigger: 'chain',
     now: input.now,
@@ -273,7 +281,7 @@ export async function createFromSource(
     sourceTransactionHash: input.sourceTransactionHash,
     sourceTransferIndex: input.sourceTransferIndex,
   })
-  return FundingDeposits.insertOrGetSource(db, {
+  return RoutesDeposits.insertOrGetSource(db, {
     ...stored,
     sourceTransferIndex: input.sourceTransferIndex,
   })
@@ -296,12 +304,12 @@ export declare namespace createFromSource {
 async function record(
   db: Db.Db,
   input: Omit<create.Input, 'providerRequestId'> & { providerRequestId: string | null },
-): Promise<FundingDeposits.Record> {
+): Promise<RoutesDeposits.Record> {
   const now = input.now ?? new Date()
   const depositAddressId = schema.Snapshot.shape.depositAddressId.parse(
     input.snapshot.depositAddressId,
   )
-  const address = await FundingDepositAddresses.get(db, depositAddressId)
+  const address = await RoutesDepositAddresses.get(db, depositAddressId)
   if (!address) throw new DepositAddressNotFoundError(depositAddressId)
   const snapshot = schema.Snapshot.parse({
     ...input.snapshot,
@@ -324,6 +332,7 @@ async function record(
     orgId: address.orgId,
     pollObservedAt: input.pollObservedAt ?? null,
     projectId: address.projectId,
+    providerDeliveredAt: null,
     providerOutputAmount: input.providerOutputAmount ?? null,
     providerOutputToken: address.providerOutputToken,
     providerRequestId: input.providerRequestId,
@@ -334,6 +343,7 @@ async function record(
       ]),
     ],
     providerState: input.providerState ?? null,
+    providerSubsidy: input.providerSubsidy ?? null,
     providerTransactionHashes: input.providerTransactionHashes ?? [],
     providerTransferIndex: input.providerTransferIndex ?? 0,
     retryState: input.retryState ?? null,
@@ -345,7 +355,9 @@ async function record(
     sourceTransferIndex: input.sourceTransferIndex ?? null,
     status: 'detected',
     statusReason: null,
+    statusUpdatedAt: now.toISOString(),
     subsidyAmount: input.subsidyAmount ?? null,
+    subsidyMeterReportedAt: null,
     tempoGasPaid: input.tempoGasPaid ?? null,
     updatedAt: now.toISOString(),
     version: 1,
@@ -372,6 +384,8 @@ export declare namespace create {
     providerRequestIds?: readonly string[] | undefined
     /** Bounded private provider state. */
     providerState?: PrivateState | undefined
+    /** Provider-paid subsidy amount and token. */
+    providerSubsidy?: Provider.Subsidy | undefined
     /** Provider-leg transaction references. */
     providerTransactionHashes?: readonly string[] | undefined
     /** Deposit position within the provider request. */
@@ -402,7 +416,8 @@ export async function transition(
   db: Db.Db,
   options: transition.Options,
 ): Promise<transition.Result> {
-  const current = await FundingDeposits.get(db, options.id)
+  const now = new Date()
+  const current = await RoutesDeposits.get(db, options.id)
   if (!current) return { type: 'not_found' }
   if (current.version !== options.expectedVersion) return { current, type: 'stale' }
   const status = options.status ?? current.status
@@ -429,13 +444,13 @@ export async function transition(
           sourceTransactionHashes: current.snapshot.sourceTransactionHashes,
         })
 
-  const updated = await FundingDeposits.update(db, {
-    expectedVersion: options.expectedVersion,
-    id: options.id,
+  const changes = {
+    providerDeliveredAt: current.providerDeliveredAt ?? options.providerDeliveredAt ?? null,
     providerOutputAmount: options.providerOutputAmount ?? current.providerOutputAmount,
     providerRequestId: current.providerRequestId ?? options.providerRequestId ?? null,
     providerRequestIds: options.providerRequestIds ?? current.providerRequestIds,
     providerState: options.providerState ?? current.providerState,
+    providerSubsidy: current.providerSubsidy ?? options.providerSubsidy ?? null,
     providerTransactionHashes:
       options.providerTransactionHashes ?? current.providerTransactionHashes,
     providerTransferIndex: options.providerTransferIndex ?? current.providerTransferIndex,
@@ -449,11 +464,27 @@ export async function transition(
     statusReason: options.statusReason ?? (status === current.status ? current.statusReason : null),
     subsidyAmount: options.subsidyAmount ?? current.subsidyAmount,
     tempoGasPaid: options.tempoGasPaid ?? current.tempoGasPaid,
-    updatedAt: new Date().toISOString(),
+  }
+  if (
+    Object.entries(changes).every(([key, value]) =>
+      sameValue(current[key as keyof typeof changes], value),
+    )
+  )
+    return { record: current, type: 'unchanged' }
+
+  const updated = await RoutesDeposits.update(db, {
+    ...changes,
+    expectedVersion: options.expectedVersion,
+    id: options.id,
+    statusUpdatedAt:
+      status === current.status
+        ? (current.statusUpdatedAt ?? current.updatedAt)
+        : now.toISOString(),
+    updatedAt: now.toISOString(),
     version: current.version + 1,
   })
   if (updated) return { record: updated, type: 'applied' }
-  const latest = await FundingDeposits.get(db, options.id)
+  const latest = await RoutesDeposits.get(db, options.id)
   return latest ? { current: latest, type: 'stale' } : { type: 'not_found' }
 }
 
@@ -462,8 +493,10 @@ export declare namespace transition {
   type Options = {
     /** Version that the change was computed against. */
     expectedVersion: number
-    /** Funding deposit id (`fdp_…`). */
+    /** Route deposit id (`rdp_…`). */
     id: string
+    /** When provider delivery was first verified. */
+    providerDeliveredAt?: string | undefined
     /** Provider output amount confirmed on Tempo. */
     providerOutputAmount?: z.output<typeof Schema.TokenAmount> | undefined
     /** Provider request attached after chain-first detection. */
@@ -472,6 +505,8 @@ export declare namespace transition {
     providerRequestIds?: readonly string[] | undefined
     /** Bounded private provider state. */
     providerState?: PrivateState | undefined
+    /** Provider-paid subsidy amount and token. */
+    providerSubsidy?: Provider.Subsidy | undefined
     /** Provider-leg transaction references. */
     providerTransactionHashes?: readonly string[] | undefined
     /** Deposit position within the attached provider request. */
@@ -498,15 +533,16 @@ export declare namespace transition {
 
   /** Outcome of a guarded deposit transition. */
   type Result =
-    | { record: FundingDeposits.Record; type: 'applied' }
-    | { current: FundingDeposits.Record; type: 'invalid' }
-    | { current: FundingDeposits.Record; type: 'stale' }
+    | { record: RoutesDeposits.Record; type: 'applied' }
+    | { record: RoutesDeposits.Record; type: 'unchanged' }
+    | { current: RoutesDeposits.Record; type: 'invalid' }
+    | { current: RoutesDeposits.Record; type: 'stale' }
     | { type: 'not_found' }
 }
 
 /** Serializes a stored deposit to the public read shape. */
-export function toPublic(record: FundingDeposits.Record): Public {
-  return schema.FundingDeposit.parse({
+export function toPublic(record: RoutesDeposits.Record): Public {
+  return schema.RoutesDeposit.parse({
     ...record.snapshot,
     createdAt: record.createdAt,
     ...(record.detectionTrigger === null ? {} : { detectionTrigger: record.detectionTrigger }),
@@ -520,10 +556,22 @@ export function toPublic(record: FundingDeposits.Record): Public {
   })
 }
 
+function sameValue(left: unknown, right: unknown): boolean {
+  if (left === right) return true
+  const serialize = (value: unknown) =>
+    JSON.stringify(value, (_key, entry: unknown) => {
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return entry
+      return Object.fromEntries(
+        Object.entries(entry).sort(([left], [right]) => left.localeCompare(right)),
+      )
+    })
+  return serialize(left) === serialize(right)
+}
+
 class DepositAddressNotFoundError extends Error {
-  override name = 'FundingDeposit.DepositAddressNotFoundError'
+  override name = 'RoutesDeposit.DepositAddressNotFoundError'
 
   constructor(id: string) {
-    super(`Funding deposit address ${id} not found`)
+    super(`Route deposit address ${id} not found`)
   }
 }