tapimo 0.15.0 → 0.18.0

package/src/db/tables/routesDeposits.test.ts

@@ -849,4 +849,137 @@ describe('subsidy reporting', () => {
       completed.record.statusUpdatedAt,
     )
   })
+
+  test.each(['completed', 'action-required', 'settling'] as const)(
+    'accounts for fixed-rate provider expenses in %s',
+    async (status) => {
+      const records = []
+      for (const subsidyPayer of ['tempo', 'enterprise'] as const) {
+        const address = await seedAddress({
+          orgId: `org_pinned_${subsidyPayer}_${status}`,
+          providerState: {
+            fixedRate: '1:1',
+            routePolicy: {
+              scope: { orgId: `org_pinned_${subsidyPayer}_${status}`, environment: 'production' },
+              subsidyPayer,
+              maxAmount: '1',
+              versions: [1],
+            },
+          },
+        })
+        const record = await seedDeposit(address, {
+          providerSubsidy: {
+            amount: { baseUnits: '23000', currency: 'USD', decimals: 6, formatted: '0.023' },
+            provider: 'relay',
+            token: address.snapshot.sourceToken,
+          },
+        })
+        await Deposit.transition(db, {
+          expectedVersion: record.version,
+          id: record.id,
+          status,
+        })
+        records.push(record)
+        expect(
+          await RoutesDeposits.subsidyUsage(db, {
+            orgId: address.orgId,
+            environment: 'production',
+            from: '2026-01-01T00:00:00.000Z',
+            to: '2027-01-01T00:00:00.000Z',
+          }),
+        ).toEqual(status === 'settling' ? { amount: 0n, count: 0 } : { amount: 23000n, count: 1 })
+        expect(await RoutesDeposits.hasUnreportedSubsidies(db, { orgId: address.orgId })).toBe(
+          subsidyPayer === 'enterprise' && status !== 'settling',
+        )
+      }
+      const billable = (await RoutesDeposits.listUnreportedSubsidies(db)).map(({ id }) => id)
+      expect(billable).not.toContain(records[0]!.id)
+      expect(billable.includes(records[1]!.id)).toBe(status !== 'settling')
+      await RoutesDeposits.markSubsidyReported(db, records[1]!.id, '2026-09-02T00:00:00.000Z')
+      expect(await RoutesDeposits.hasUnreportedSubsidies(db, { orgId: records[1]!.orgId })).toBe(
+        false,
+      )
+      expect((await RoutesDeposits.listUnreportedSubsidies(db)).map(({ id }) => id)).not.toContain(
+        records[1]!.id,
+      )
+    },
+  )
+
+  test('migration: excludes provider subsidies finalized before provider billing activation', async () => {
+    const before = new Date('2026-09-03T06:10:20.999Z')
+    const after = new Date('2026-09-03T06:10:21.001Z')
+    const address = await seedAddress({ orgId: 'org_legacy_provider_subsidy' })
+    const subsidy = {
+      amount: {
+        baseUnits: '23838',
+        currency: 'USD',
+        decimals: 6,
+        formatted: '0.023838',
+      },
+      provider: 'relay',
+      token: address.snapshot.sourceToken,
+    } as const
+    const legacy = await seedDeposit(address, { providerSubsidy: subsidy })
+    const current = await seedDeposit(address, { providerSubsidy: subsidy })
+    const inFlight = await seedDeposit(address, { providerSubsidy: subsidy })
+    vi.useFakeTimers({ now: before, toFake: ['Date'] })
+    try {
+      const completedLegacy = await Deposit.transition(db, {
+        expectedVersion: legacy.version,
+        id: legacy.id,
+        status: 'completed',
+      })
+      if (completedLegacy.type !== 'applied') throw new Error('Expected completed legacy subsidy.')
+      vi.setSystemTime(after)
+      const completedCurrent = await Deposit.transition(db, {
+        expectedVersion: current.version,
+        id: current.id,
+        status: 'completed',
+      })
+      if (completedCurrent.type !== 'applied')
+        throw new Error('Expected completed current subsidy.')
+    } finally {
+      vi.useRealTimers()
+    }
+
+    expect(
+      (await RoutesDeposits.listUnreportedSubsidies(db, { orgId: address.orgId }))
+        .map(({ id }) => id)
+        .toSorted(),
+    ).toEqual([current.id, legacy.id].toSorted())
+
+    const migration = Db.migrations.find(
+      (candidate) => candidate.name === '0270_routes_deposits_legacy_provider_subsidies_reported',
+    )
+    if (!migration) throw new Error('Expected the legacy provider subsidy migration.')
+    await migration.up(db.kysely).execute()
+
+    expect(
+      (await RoutesDeposits.listUnreportedSubsidies(db, { orgId: address.orgId })).map(
+        ({ id }) => id,
+      ),
+    ).toEqual([current.id])
+    expect((await RoutesDeposits.get(db, legacy.id))?.subsidyMeterReportedAt).toBe(
+      before.toISOString(),
+    )
+    expect((await RoutesDeposits.get(db, current.id))?.subsidyMeterReportedAt).toBeNull()
+
+    vi.useFakeTimers({ now: after, toFake: ['Date'] })
+    try {
+      const completedInFlight = await Deposit.transition(db, {
+        expectedVersion: inFlight.version,
+        id: inFlight.id,
+        status: 'completed',
+      })
+      if (completedInFlight.type !== 'applied')
+        throw new Error('Expected completed in-flight subsidy.')
+    } finally {
+      vi.useRealTimers()
+    }
+    expect(
+      (await RoutesDeposits.listUnreportedSubsidies(db, { orgId: address.orgId }))
+        .map(({ id }) => id)
+        .toSorted(),
+    ).toEqual([current.id, inFlight.id].toSorted())
+  })
 })

package/src/db/tables/routesDeposits.ts

@@ -1,4 +1,4 @@
-import { sql, type JSONColumnType, type Selectable } from 'kysely'
+import { type ExpressionBuilder, type JSONColumnType, type Selectable, sql } from 'kysely'
 
 import * as Fees from '../../internal/Fees.js'
 import type * as Db from '../Db.js'
@@ -810,6 +810,27 @@ export function subsidies(record: Record) {
   ]
 }
 
+function subsidyFinalized(eb: ExpressionBuilder<Db.Database, 'routes_deposits'>) {
+  return eb.or([
+    eb('status', '=', 'completed'),
+    eb.and([
+      eb('status', 'in', ['action-required', 'settling']),
+      eb('tempoGasPaid', 'is not', null),
+    ]),
+    // Fixed-rate shortfalls never create a later Tempo top-up, so provider expense is final.
+    eb.and([
+      eb('status', '=', 'action-required'),
+      eb.exists(
+        eb
+          .selectFrom('routes_deposit_addresses')
+          .select('routes_deposit_addresses.id')
+          .whereRef('routes_deposit_addresses.id', '=', 'routes_deposits.depositAddressId')
+          .where(sql<boolean>`routes_deposit_addresses.provider_state->>'fixedRate' = '1:1'`),
+      ),
+    ]),
+  ])
+}
+
 /** Lists verified production subsidies awaiting a Stripe acknowledgement. */
 export function listUnreportedSubsidies(
   db: Db.Db,
@@ -819,15 +840,7 @@ export function listUnreportedSubsidies(
     .selectFrom('routes_deposits')
     .selectAll()
     .where('environment', '=', 'production')
-    .where((eb) =>
-      eb.or([
-        eb('status', '=', 'completed'),
-        eb.and([
-          eb('status', 'in', ['action-required', 'settling']),
-          eb('tempoGasPaid', 'is not', null),
-        ]),
-      ]),
-    )
+    .where(subsidyFinalized)
     .where((eb) =>
       eb.or([
         sql<boolean>`(provider_subsidy->'amount'->>'baseUnits')::numeric > 0`,
@@ -839,6 +852,17 @@ export function listUnreportedSubsidies(
       ]),
     )
     .where('subsidyMeterReportedAt', 'is', null)
+    .where((eb) =>
+      eb.exists(
+        eb
+          .selectFrom('routes_deposit_addresses')
+          .select('routes_deposit_addresses.id')
+          .whereRef('routes_deposit_addresses.id', '=', 'routes_deposits.depositAddressId')
+          .where(
+            sql<boolean>`coalesce(routes_deposit_addresses.provider_state->'routePolicy'->>'subsidyPayer', 'enterprise') <> 'tempo'`,
+          ),
+      ),
+    )
     .orderBy('statusUpdatedAt', 'asc')
     .orderBy('id', 'asc')
   if (options.limit !== undefined) query = query.limit(options.limit)
@@ -878,17 +902,22 @@ export async function hasUnreportedSubsidies(
       .where('environment', '=', 'production')
       .where('orgId', '=', options.orgId)
       .where('status', 'in', ['action-required', 'settling', 'completed'])
+      .where((eb) =>
+        eb.exists(
+          eb
+            .selectFrom('routes_deposit_addresses')
+            .select('routes_deposit_addresses.id')
+            .whereRef('routes_deposit_addresses.id', '=', 'routes_deposits.depositAddressId')
+            .where(
+              sql<boolean>`coalesce(routes_deposit_addresses.provider_state->'routePolicy'->>'subsidyPayer', 'enterprise') <> 'tempo'`,
+            ),
+        ),
+      )
       .where((eb) =>
         eb.or([
           eb.and([
             sql<boolean>`(provider_subsidy->'amount'->>'baseUnits')::numeric > 0`,
-            eb.or([
-              eb('status', '=', 'completed'),
-              eb.and([
-                eb('status', 'in', ['action-required', 'settling']),
-                eb('tempoGasPaid', 'is not', null),
-              ]),
-            ]),
+            subsidyFinalized(eb),
           ]),
           eb.and([
             eb('settlementTransactionHash', 'is not', null),
@@ -929,15 +958,7 @@ export async function subsidyUsage(
     ])
     .where('orgId', '=', options.orgId)
     .where('environment', '=', options.environment)
-    .where((eb) =>
-      eb.or([
-        eb('status', '=', 'completed'),
-        eb.and([
-          eb('status', 'in', ['action-required', 'settling']),
-          eb('tempoGasPaid', 'is not', null),
-        ]),
-      ]),
-    )
+    .where(subsidyFinalized)
     .where((eb) =>
       eb.or([
         sql<boolean>`(provider_subsidy->'amount'->>'baseUnits')::numeric > 0`,

package/src/db/tables/routesIdempotency.test.ts

@@ -317,6 +317,86 @@ describe('claim', () => {
     ])
   })
 
+  test('resumes the oldest of several shared provider checkpoints', async () => {
+    const claims: RoutesIdempotency.release.Input[] = []
+    for (const [index, name] of ['older', 'newer'].entries()) {
+      vi.setSystemTime(new Date(now.getTime() + index * 1_000))
+      const request = input({
+        apiKeyId: `key_${name}`,
+        keyHash: `hash_${name}`,
+        operation: RoutesIdempotency.operations.depositAddress,
+      })
+      const claimed = await RoutesIdempotency.claim(db, request)
+      if (claimed.type !== 'claimed') throw new Error('Expected a fresh claim.')
+      claims.push({ ...request, createdAt: claimed.createdAt })
+    }
+    const [older, newer] = claims
+    if (!older || !newer) throw new Error('Expected two claims.')
+    for (const [claimed, response] of [
+      [older, '{"requestId":"relay_older"}'],
+      [newer, '{"requestId":"relay_newer"}'],
+    ] as const)
+      await RoutesIdempotency.checkpoint(db, { ...claimed, replayTtlMs, response })
+
+    await expect(
+      RoutesIdempotency.claim(
+        db,
+        input({
+          apiKeyId: 'key_rotated',
+          keyHash: 'hash_rotated',
+          operation: RoutesIdempotency.operations.depositAddress,
+        }),
+      ),
+    ).resolves.toMatchObject({
+      recoveredClaim: { apiKeyId: older.apiKeyId, createdAt: older.createdAt },
+      response: '{"requestId":"relay_older"}',
+      type: 'resume',
+    })
+  })
+
+  test('resumes the oldest of several provisioned match checkpoints', async () => {
+    const claims: RoutesIdempotency.release.Input[] = []
+    for (const [index, name] of ['older', 'newer', 'retry'].entries()) {
+      vi.setSystemTime(new Date(now.getTime() + index * 1_000))
+      const request = input({
+        apiKeyId: `key_${name}`,
+        keyHash: `hash_${name}`,
+        operation: RoutesIdempotency.operations.depositAddress,
+        requestHash: `req_${name}`,
+      })
+      const claimed = await RoutesIdempotency.claim(db, request)
+      if (claimed.type !== 'claimed') throw new Error('Expected a fresh claim.')
+      claims.push({ ...request, createdAt: claimed.createdAt })
+    }
+    const [older, newer, retry] = claims
+    if (!older || !newer || !retry) throw new Error('Expected three claims.')
+    const reserve = (claimed: RoutesIdempotency.release.Input) =>
+      RoutesIdempotency.reserveDepositAddressMatch(db, {
+        ...claimed,
+        matchHash: 'match_shared',
+        orgId: 'org_test',
+        ttlMs,
+      })
+    await expect(reserve(older)).resolves.toEqual({ type: 'reserved' })
+    await RoutesIdempotency.checkpoint(db, {
+      ...older,
+      replayTtlMs,
+      response: '{"requestId":"relay_older"}',
+    })
+    await expect(reserve(newer)).resolves.toMatchObject({ type: 'resume' })
+    await RoutesIdempotency.checkpoint(db, {
+      ...newer,
+      replayTtlMs,
+      response: '{"requestId":"relay_newer"}',
+    })
+
+    await expect(reserve(retry)).resolves.toMatchObject({
+      claim: { apiKeyId: older.apiKeyId, createdAt: older.createdAt },
+      response: '{"requestId":"relay_older"}',
+      type: 'resume',
+    })
+  })
+
   test('attributes an equivalent rolling-worker checkpoint for the same API key', async () => {
     const original = input({ operation: RoutesIdempotency.operations.depositAddress })
     const claimed = await RoutesIdempotency.claim(db, original)

package/src/db/tables/routesIdempotency.ts

@@ -70,6 +70,7 @@ export async function claim(db: Db.Db, input: claim.Input): Promise<claim.Result
       .where('status', '=', 'provisioned')
       .where((eb) => eb.or([eb('expiresAt', '>', now.toISOString()), eb('irrevocable', '=', true)]))
       .orderBy('createdAt', 'asc')
+      .limit(1)
       .forUpdate()
       .executeTakeFirst()
     if (!recoverable) return { createdAt: inserted.createdAt, type: 'claimed' }
@@ -311,6 +312,7 @@ export async function reserveDepositAddressMatch(
     .where('status', '=', 'provisioned')
     .where((eb) => eb.or([eb('expiresAt', '>', now.toISOString()), eb('irrevocable', '=', true)]))
     .orderBy('createdAt', 'asc')
+    .limit(1)
     .forUpdate()
     .executeTakeFirst()
   if (provisioned && claimed.status === 'pending') {

package/src/db/tables/routesPolicies.test.ts

@@ -0,0 +1,143 @@
+import * as TestApp from '../../../test/App.js'
+import * as Organizations from './organizations.js'
+import * as RoutesPolicies from './routesPolicies.js'
+
+describe('save', () => {
+  test('serializes competing version-zero writes as a domain conflict', async () => {
+    const db = TestApp.database()
+    await Organizations.create(db, { id: 'org_policy', name: 'Policy' })
+    const scope = { environment: 'production', orgId: 'org_policy' } as const
+    const results = await Promise.allSettled([
+      RoutesPolicies.save(db, { policy: { maxAmount: '1' }, scope, version: 0 }),
+      RoutesPolicies.save(db, { policy: { maxAmount: '2' }, scope, version: 0 }),
+    ])
+    expect(
+      results
+        .map((result) =>
+          result.status === 'fulfilled' ? result.value.version : result.reason?.name,
+        )
+        .sort((a, b) => String(a).localeCompare(String(b))),
+    ).toMatchInlineSnapshot(`
+      [
+        1,
+        "RoutesPolicies.ConflictError",
+      ]
+    `)
+  })
+})
+
+describe('load', () => {
+  test('preserves missing positional layers', async () => {
+    const db = TestApp.database()
+    await Organizations.create(db, { id: 'org_layers', name: 'Layers' })
+    const loaded = await RoutesPolicies.load(db, {
+      apiKeyId: 'key_1',
+      environment: 'sandbox',
+      orgId: 'org_layers',
+    })
+    expect(loaded.layers).toMatchInlineSnapshot(`
+      [
+        {
+          "policy": {},
+          "scope": {
+            "environment": "sandbox",
+            "orgId": "org_layers",
+          },
+          "version": 0,
+        },
+        {
+          "policy": {},
+          "scope": {
+            "apiKeyId": "key_1",
+            "environment": "sandbox",
+            "orgId": "org_layers",
+          },
+          "version": 0,
+        },
+      ]
+    `)
+  })
+})
+
+describe('clearKey', () => {
+  test('clears every matching scope, increments revisions, and ignores an absent key', async () => {
+    const db = TestApp.database()
+    await Organizations.create(db, { id: 'org_clear', name: 'Clear' })
+    for (const environment of ['production', 'sandbox'] as const)
+      await RoutesPolicies.save(db, {
+        policy: { maxAmount: environment === 'production' ? '1' : '2' },
+        scope: { apiKeyId: 'key_clear', environment, orgId: 'org_clear' },
+        version: 0,
+      })
+
+    const cleared = await RoutesPolicies.clearKey(db, { apiKeyId: 'key_clear' })
+
+    expect(cleared.map(({ policy, version }) => ({ policy, version }))).toEqual([
+      { policy: {}, version: 2 },
+      { policy: {}, version: 2 },
+    ])
+    await expect(
+      RoutesPolicies.save(db, {
+        policy: { maxAmount: '3' },
+        scope: { apiKeyId: 'key_clear', environment: 'production', orgId: 'org_clear' },
+        version: 1,
+      }),
+    ).rejects.toBeInstanceOf(RoutesPolicies.ConflictError)
+    await expect(RoutesPolicies.clearKey(db, { apiKeyId: 'key_missing' })).resolves.toEqual([])
+    for (const environment of ['production', 'sandbox'] as const)
+      expect(
+        await RoutesPolicies.get(db, {
+          apiKeyId: 'key_clear',
+          environment,
+          orgId: 'org_clear',
+        }),
+      ).toMatchObject({ policy: {}, version: 2 })
+  })
+})
+
+describe('copyKey', () => {
+  test('copies independently, no-ops when absent, rejects cross-scope, and rolls back', async () => {
+    const db = TestApp.database()
+    await Organizations.create(db, { id: 'org_copy', name: 'Copy' })
+    const source = { apiKeyId: 'key_source', environment: 'production', orgId: 'org_copy' } as const
+    const destination = { ...source, apiKeyId: 'key_destination' }
+    await RoutesPolicies.save(db, {
+      policy: { maxAmount: '7' },
+      scope: source,
+      version: 0,
+    })
+
+    await RoutesPolicies.copyKey(db, { destination, source })
+    await RoutesPolicies.save(db, {
+      policy: { maxAmount: '9' },
+      scope: source,
+      version: 1,
+    })
+    expect((await RoutesPolicies.get(db, destination))?.policy).toEqual({ maxAmount: '7' })
+    await expect(
+      RoutesPolicies.copyKey(db, {
+        destination: { ...destination, apiKeyId: 'key_absent_destination' },
+        source: { ...source, apiKeyId: 'key_absent' },
+      }),
+    ).resolves.toBeUndefined()
+    await expect(
+      RoutesPolicies.copyKey(db, {
+        destination: { ...destination, environment: 'sandbox' },
+        source,
+      }),
+    ).rejects.toThrow(RoutesPolicies.InvalidScopeError)
+
+    await expect(
+      db.transaction(async (tx) => {
+        await RoutesPolicies.copyKeyIn(tx, {
+          destination: { ...destination, apiKeyId: 'key_rollback' },
+          source,
+        })
+        throw new Error('rollback')
+      }),
+    ).rejects.toThrow('rollback')
+    expect(
+      await RoutesPolicies.get(db, { ...destination, apiKeyId: 'key_rollback' }),
+    ).toBeUndefined()
+  })
+})