tapimo 0.15.0 → 0.18.0

package/src/db/tables/routesPolicies.ts

@@ -0,0 +1,251 @@
+import { sql, type Selectable } from 'kysely'
+
+import type * as Db from '../Db.js'
+import type * as Schema from '../Schema.js'
+import type * as Policy from '../../internal/routes/Policy.js'
+import * as RoutesSubsidies from './routesSubsidies.js'
+
+export type Table = Schema.RoutesPolicy
+export type Record = Omit<Selectable<Table>, 'apiKeyId' | 'projectId'> & Policy.Scope
+export type Layer = { scope: Policy.Scope; version: number; policy: Policy.Overrides }
+export class ConflictError extends Error {
+  override name = 'RoutesPolicies.ConflictError'
+}
+export class InvalidScopeError extends Error {
+  override name = 'RoutesPolicies.InvalidScopeError'
+}
+
+export async function get(db: Db.Db, scope: Policy.Scope): Promise<Record | undefined> {
+  const row = await scoped(db, scope).selectAll().executeTakeFirst()
+  return row && domain(row)
+}
+
+export async function load(
+  db: Db.Db,
+  scope: Policy.Scope,
+): Promise<{ layers: Layer[]; legacy: Policy.Legacy }> {
+  const scopes: Policy.Scope[] = [
+    { orgId: scope.orgId, environment: scope.environment },
+    ...(scope.projectId
+      ? [{ orgId: scope.orgId, environment: scope.environment, projectId: scope.projectId }]
+      : []),
+    ...(scope.apiKeyId ? [scope] : []),
+  ]
+  const records = await Promise.all(scopes.map((item) => get(db, item)))
+  const legacy = await RoutesSubsidies.getOrganization(db, scope.orgId)
+  return {
+    layers: records.map((record, index) =>
+      record
+        ? { scope: pickScope(record), version: record.version, policy: record.policy }
+        : { scope: scopes[index]!, version: 0, policy: {} },
+    ),
+    legacy: {
+      subsidyEnabled: legacy?.enabled ?? false,
+      maxAmount: legacy?.maxAmount ?? '0',
+      subsidyPayer: 'enterprise',
+    },
+  }
+}
+
+export function save(
+  db: Db.Db,
+  input: {
+    scope: Policy.Scope
+    version: number
+    policy: Policy.Overrides
+    /** Revalidates external key ownership under the policy lock. */
+    validateScope?: (() => Promise<boolean>) | undefined
+  },
+): Promise<Record> {
+  return db.transaction(async (tx) => {
+    await RoutesSubsidies.lockOrganization(tx, input.scope.orgId)
+    if (input.validateScope && !(await input.validateScope())) throw new InvalidScopeError()
+    return saveIn(tx, input)
+  })
+}
+
+export function clearKey(db: Db.Db, input: clearKey.Input): Promise<readonly Record[]> {
+  return db.transaction((tx) => clearKeyIn(tx, input))
+}
+
+/** Locks current, destination, and historical key policy owners before owner or admission locks. */
+export async function lockKeyOrganizations(
+  db: Db.Db,
+  input: lockKeyOrganizations.Input,
+): Promise<void> {
+  const rows = await db.kysely
+    .selectFrom('routes_policies')
+    .select('orgId')
+    .where('apiKeyId', '=', input.apiKeyId)
+    .distinct()
+    .execute()
+  for (const orgId of [...new Set([...input.orgIds, ...rows.map((row) => row.orgId)])].sort())
+    await RoutesSubsidies.lockOrganization(db, orgId)
+}
+
+export declare namespace lockKeyOrganizations {
+  /** Key being reassigned and its current and destination owners. */
+  type Input = {
+    /** API key identifier. */
+    apiKeyId: string
+    /** Current and destination organization identifiers. */
+    orgIds: readonly string[]
+  }
+}
+
+/** Clears key overrides inside a caller-owned transaction. */
+export async function clearKeyIn(db: Db.Db, input: clearKey.Input): Promise<readonly Record[]> {
+  const rows = await db.kysely
+    .selectFrom('routes_policies')
+    .selectAll()
+    .where('apiKeyId', '=', input.apiKeyId)
+    .orderBy('orgId')
+    .orderBy('environment')
+    .orderBy('projectId')
+    .execute()
+  const records: Record[] = []
+  for (const row of rows) {
+    await RoutesSubsidies.lockOrganization(db, row.orgId)
+    // Former projects may be deleted; retain monotonic revisions without revalidating their existence.
+    const updated = await db.kysely
+      .updateTable('routes_policies')
+      .set({ policy: {}, updatedAt: new Date().toISOString(), version: sql`version + 1` })
+      .where('orgId', '=', row.orgId)
+      .where('environment', '=', row.environment)
+      .where('projectId', '=', row.projectId)
+      .where('apiKeyId', '=', row.apiKeyId)
+      .returningAll()
+      .executeTakeFirst()
+    if (updated) records.push(domain(updated))
+  }
+  return records
+}
+
+export namespace clearKey {
+  export type Input = { apiKeyId: string }
+}
+
+export function copyKey(db: Db.Db, input: copyKey.Input): Promise<Record | undefined> {
+  if (
+    input.source.environment !== input.destination.environment ||
+    input.source.orgId !== input.destination.orgId ||
+    input.source.projectId !== input.destination.projectId
+  )
+    return Promise.reject(new InvalidScopeError())
+  return db.transaction((tx) => copyKeyIn(tx, input))
+}
+
+/** Copies key overrides inside a caller-owned transaction. */
+export async function copyKeyIn(db: Db.Db, input: copyKey.Input): Promise<Record | undefined> {
+  if (
+    input.source.environment !== input.destination.environment ||
+    input.source.orgId !== input.destination.orgId ||
+    input.source.projectId !== input.destination.projectId
+  )
+    throw new InvalidScopeError()
+  await RoutesSubsidies.lockOrganization(db, input.destination.orgId)
+  const source = await get(db, input.source)
+  if (!input.source.apiKeyId || !input.destination.apiKeyId) throw new InvalidScopeError()
+  if (!source) return undefined
+  const destination = await get(db, input.destination)
+  return saveIn(db, {
+    policy: source.policy,
+    scope: input.destination,
+    version: destination?.version ?? 0,
+  })
+}
+
+export namespace copyKey {
+  export type Input = { destination: Policy.Scope; source: Policy.Scope }
+}
+
+async function saveIn(
+  db: Db.Db,
+  input: { scope: Policy.Scope; version: number; policy: Policy.Overrides },
+): Promise<Record> {
+  await validateScope(db, input.scope)
+  if (
+    (input.scope.projectId !== undefined || input.scope.apiKeyId !== undefined) &&
+    input.policy.suspended !== undefined
+  )
+    throw new InvalidScopeError()
+  const before = await get(db, input.scope)
+  if ((before?.version ?? 0) !== input.version) throw new ConflictError()
+  const now = new Date().toISOString()
+  const keys = storage(input.scope)
+  const row =
+    input.version === 0
+      ? await db.kysely
+          .insertInto('routes_policies')
+          .values({ ...keys, version: 1, policy: input.policy, createdAt: now, updatedAt: now })
+          .returningAll()
+          .executeTakeFirstOrThrow()
+      : await db.kysely
+          .updateTable('routes_policies')
+          .set({ version: input.version + 1, policy: input.policy, updatedAt: now })
+          .where('orgId', '=', keys.orgId)
+          .where('environment', '=', keys.environment)
+          .where('projectId', '=', keys.projectId)
+          .where('apiKeyId', '=', keys.apiKeyId)
+          .where('version', '=', input.version)
+          .returningAll()
+          .executeTakeFirst()
+  if (!row) throw new ConflictError()
+  return domain(row)
+}
+
+function scoped(db: Db.Db, scope: Policy.Scope) {
+  const key = storage(scope)
+  return db.kysely
+    .selectFrom('routes_policies')
+    .where('orgId', '=', key.orgId)
+    .where('environment', '=', key.environment)
+    .where('projectId', '=', key.projectId)
+    .where('apiKeyId', '=', key.apiKeyId)
+}
+function storage(scope: Policy.Scope) {
+  return {
+    orgId: scope.orgId,
+    environment: scope.environment,
+    projectId: scope.projectId ?? '',
+    apiKeyId: scope.apiKeyId ?? '',
+  }
+}
+function domain(row: Selectable<Table>): Record {
+  return {
+    orgId: row.orgId,
+    environment: row.environment,
+    ...(row.projectId ? { projectId: row.projectId } : {}),
+    ...(row.apiKeyId ? { apiKeyId: row.apiKeyId } : {}),
+    version: row.version,
+    policy: row.policy,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  }
+}
+function pickScope(value: Policy.Scope): Policy.Scope {
+  return {
+    orgId: value.orgId,
+    environment: value.environment,
+    ...(value.projectId ? { projectId: value.projectId } : {}),
+    ...(value.apiKeyId ? { apiKeyId: value.apiKeyId } : {}),
+  }
+}
+async function validateScope(db: Db.Db, scope: Policy.Scope) {
+  if (scope.projectId) {
+    const project = await db.kysely
+      .selectFrom('projects')
+      .select('id')
+      .where('id', '=', scope.projectId)
+      .where('orgId', '=', scope.orgId)
+      .executeTakeFirst()
+    if (!project) throw new InvalidScopeError()
+  } else {
+    const org = await db.kysely
+      .selectFrom('organizations')
+      .select('id')
+      .where('id', '=', scope.orgId)
+      .executeTakeFirst()
+    if (!org) throw new InvalidScopeError()
+  }
+}

package/src/db/tables/routesTransferSubsidies.ts

@@ -7,6 +7,8 @@ import type * as Schema from '../Schema.js'
 export type Table = Schema.RoutesTransferSubsidy
 /** A shared subsidy transaction and its billing owner. */
 export type Record = Selectable<Table>
+/** Immutable evidence for an expired signed Solana attempt. */
+export type ExpiredAttemptTable = Schema.RoutesTransferSubsidyExpiredAttempt
 
 /** Serializes subsidy preparation for a source payment and returns its persisted settlement. */
 export async function getForUpdateIn(
@@ -36,3 +38,65 @@ export declare namespace getForUpdateIn {
     transactionRef: string
   }
 }
+
+/** Archives an expired Solana signature under the canonical source lock. */
+export async function markExpiredIn(
+  db: Db.Db,
+  options: markExpiredIn.Options,
+): Promise<markExpiredIn.Result> {
+  const settlement = await getForUpdateIn(db, options)
+  if (!settlement) return { type: 'not_found' }
+  if (settlement.transferId !== options.transferId) return { settlement, type: 'shared' }
+  if (
+    settlement.status !== 'active' ||
+    !settlement.destinationChainId.startsWith('solana:') ||
+    settlement.transaction !== options.signedTransaction
+  )
+    return { settlement, type: 'stale' }
+  const signed: unknown = JSON.parse(options.signedTransaction)
+  if (
+    !signed ||
+    typeof signed !== 'object' ||
+    !('hash' in signed) ||
+    signed.hash !== options.signedHash
+  )
+    return { settlement, type: 'stale' }
+
+  // The caller proves final expiry before entering this transaction. Exact transaction
+  // comparison prevents a late recovery worker from replacing a newer signature.
+  const expiredAt = new Date().toISOString()
+  await db.kysely
+    .insertInto('routes_transfer_subsidy_expired_attempts')
+    .values({
+      createdAt: settlement.createdAt,
+      expiredAt,
+      sourceChainId: settlement.sourceChainId,
+      transaction: JSON.stringify(settlement.transaction),
+      transactionHash: options.signedHash,
+      transactionRef: settlement.transactionRef,
+      transferId: settlement.transferId,
+    })
+    .execute()
+  await db.kysely
+    .updateTable('routes_transfer_subsidies')
+    .set({ status: 'expired' })
+    .where('sourceChainId', '=', options.sourceChainId)
+    .where('transactionRef', '=', options.transactionRef)
+    .where('status', '=', 'active')
+    .executeTakeFirstOrThrow()
+  return { settlement: { ...settlement, status: 'expired' }, type: 'expired' }
+}
+
+export declare namespace markExpiredIn {
+  /** Expected canonical signed Solana attempt and its original billing owner. */
+  type Options = getForUpdateIn.Options & {
+    /** Signature of the signed attempt being retired. */
+    signedHash: string
+    /** Exact serialized signed transaction persisted in the settlement row. */
+    signedTransaction: string
+    /** Original subsidy billing owner. */
+    transferId: string
+  }
+  /** Outcome of the source-keyed expiry compare and swap. */
+  type Result = { type: 'not_found' } | { settlement: Record; type: 'expired' | 'shared' | 'stale' }
+}

package/src/db/tables/routesTransferSubsidyNonces.ts

@@ -10,7 +10,10 @@ export type Record = Selectable<Table>
 
 /** Serializes inventory and nonce operations for one signer and chain. */
 async function lock(db: Db.Db, options: Lane): Promise<void> {
-  const key = `${options.chainId}:${options.account.toLowerCase()}`
+  const account = options.chainId.startsWith('eip155:')
+    ? options.account.toLowerCase()
+    : options.account
+  const key = `${options.chainId}:${account}`
   await sql`SELECT pg_advisory_xact_lock(hashtextextended(${key}, 0))`.execute(db.kysely)
 }
 
@@ -24,10 +27,13 @@ type Lane = {
 /** Locks a signer lane and rejects new work when its nonce cannot be recovered. */
 export async function lockAvailableIn(db: Db.Db, options: Lane): Promise<void> {
   await lock(db, options)
+  const account = options.chainId.startsWith('eip155:')
+    ? options.account.toLowerCase()
+    : options.account
   const current = await db.kysely
     .selectFrom('routes_transfer_subsidy_nonces')
     .selectAll()
-    .where('account', '=', options.account.toLowerCase())
+    .where('account', '=', account)
     .where('chainId', '=', options.chainId)
     .forUpdate()
     .executeTakeFirst()
@@ -51,7 +57,11 @@ export async function blockIn(db: Db.Db, options: block.Options): Promise<void>
       blockedTransferId: options.transferId,
       updatedAt: now,
     })
-    .where('account', '=', options.account.toLowerCase())
+    .where(
+      'account',
+      '=',
+      options.chainId.startsWith('eip155:') ? options.account.toLowerCase() : options.account,
+    )
     .where('chainId', '=', options.chainId)
     .executeTakeFirst()
   if (updated.numUpdatedRows !== 1n) throw new MissingCursorError()
@@ -69,7 +79,9 @@ export declare namespace block {
 
 /** Reserves one nonce under a transaction-scoped signer and chain lock. */
 export async function reserve(db: Db.Db, options: reserve.Options): Promise<number> {
-  const account = options.account.toLowerCase()
+  const account = options.chainId.startsWith('eip155:')
+    ? options.account.toLowerCase()
+    : options.account
   await lock(db, options)
   const current = await db.kysely
     .selectFrom('routes_transfer_subsidy_nonces')

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

@@ -85,6 +85,60 @@ describe('listProcessing', () => {
   })
 })
 
+describe('recordTronEventCursor', () => {
+  test('advances only the current source scan and leaves the public version unchanged', async () => {
+    const guid = `0x${'ab'.repeat(32)}`
+    const record = await seed({
+      providerState: { legacyMeshOutbound: { amount: '1000000', guid } },
+      snapshot: TestRoutes.transferSnapshot({
+        provider: { id: 'legacy-mesh', name: 'USDT0 Legacy Mesh' },
+      }),
+    })
+    const processing = await Transfer.transition(db, {
+      expectedVersion: record.version,
+      id: record.id,
+      status: 'processing',
+    })
+    if (processing.type !== 'applied') throw new Error('Expected processing transfer.')
+
+    const first = await RoutesTransfers.recordTronEventCursor(db, {
+      cursor: { fingerprint: 'next-page', offset: 0 },
+      guid,
+      id: record.id,
+      previousCursor: null,
+    })
+    expect(first?.providerState).toMatchObject({
+      legacyMeshOutbound: { guid },
+      tronEventCursor: { fingerprint: 'next-page', offset: 0 },
+    })
+    expect(first?.version).toBe(processing.record.version)
+    expect(
+      await RoutesTransfers.recordTronEventCursor(db, {
+        cursor: { fingerprint: 'wrong-source', offset: 0 },
+        guid: `0x${'cd'.repeat(32)}`,
+        id: record.id,
+        previousCursor: { fingerprint: 'next-page', offset: 0 },
+      }),
+    ).toBeUndefined()
+    expect(
+      await RoutesTransfers.recordTronEventCursor(db, {
+        cursor: { fingerprint: 'stale-page', offset: 0 },
+        guid,
+        id: record.id,
+        previousCursor: null,
+      }),
+    ).toBeUndefined()
+    const cleared = await RoutesTransfers.recordTronEventCursor(db, {
+      cursor: null,
+      guid,
+      id: record.id,
+      previousCursor: { fingerprint: 'next-page', offset: 0 },
+    })
+    expect(cleared?.providerState).not.toHaveProperty('tronEventCursor')
+    expect(cleared?.version).toBe(processing.record.version)
+  })
+})
+
 describe('count', () => {
   test('shares the list filter and stops at the cap', async () => {
     const total = await RoutesTransfers.count(db, owner, { cap: 100 })
@@ -134,6 +188,69 @@ describe('update', () => {
 })
 
 describe('subsidies', () => {
+  test('retains Tempo obligations operationally while billing only enterprise and legacy payers', async () => {
+    const records = await Promise.all(
+      (['tempo', 'enterprise', 'legacy'] as const).map(async (payer) => {
+        const record = await seed({
+          orgId: `org_transfer_payer_${payer}`,
+          ...(payer === 'legacy'
+            ? {}
+            : {
+                providerState: {
+                  routePolicy: {
+                    maxAmount: '1',
+                    scope: { environment: 'production', orgId: `org_transfer_payer_${payer}` },
+                    subsidyPayer: payer,
+                    versions: [1],
+                  },
+                },
+              }),
+          subsidyCommitment: {
+            account: `0x${'ac'.repeat(20)}`,
+            amount: { baseUnits: '1', currency: 'USD', decimals: 6, formatted: '0.000001' },
+            chainId: '4217',
+            nativeAmount: '0',
+            tokenAddress: `0x${'bc'.repeat(20)}`,
+          },
+        })
+        expect(await RoutesTransfers.hasUnreportedSubsidies(db, record.orgId)).toBe(true)
+        let result = await Transfer.transition(db, {
+          expectedVersion: record.version,
+          id: record.id,
+          status: 'processing',
+        })
+        if (result.type !== 'applied') throw new Error('Expected processing transfer.')
+        result = await Transfer.transition(db, {
+          expectedVersion: result.record.version,
+          id: record.id,
+          subsidyAmount: { baseUnits: '1', currency: 'USD', decimals: 6, formatted: '0.000001' },
+          subsidyTransactionHash: `0x${payer.charCodeAt(0).toString(16).repeat(64).slice(0, 64)}`,
+        })
+        if (result.type !== 'applied') throw new Error('Expected subsidized transfer.')
+        result = await Transfer.transition(db, {
+          expectedVersion: result.record.version,
+          id: record.id,
+          status: 'completed',
+        })
+        if (result.type !== 'applied') throw new Error('Expected completed transfer.')
+        expect(await RoutesTransfers.hasUnreportedSubsidies(db, record.orgId)).toBe(
+          payer !== 'tempo',
+        )
+        return result.record
+      }),
+    )
+
+    expect(records.map((record) => RoutesTransfers.subsidies(record))).toHaveLength(3)
+    expect((await RoutesTransfers.listUnreportedSubsidies(db)).map(({ id }) => id)).toEqual(
+      expect.arrayContaining(records.filter((_, index) => index > 0).map(({ id }) => id)),
+    )
+    expect((await RoutesTransfers.listUnreportedSubsidies(db)).map(({ id }) => id)).not.toContain(
+      records[0]!.id,
+    )
+    for (const record of records.slice(1))
+      await RoutesTransfers.markSubsidyReported(db, record.id, new Date().toISOString())
+  })
+
   test('keeps prepared liability durable and reports completed production usage once', async () => {
     const record = await seed({ orgId: 'org_transfer_subsidy' })
     const processing = await Transfer.transition(db, {
@@ -217,7 +334,11 @@ describe('subsidies', () => {
         chainId: commitment.chainId,
         tokenAddress: commitment.tokenAddress,
       }),
-    ).toEqual({ nativeAmount: 200n, tokenAmount: 6002n })
+    ).toEqual({
+      nativeAmount: 200n,
+      tokenAmount: 6002n,
+      tokenAmounts: { [commitment.tokenAddress]: 6002n },
+    })
     expect(await RoutesTransfers.hasUnreportedSubsidies(db, 'org_expired_transfer_subsidy')).toBe(
       true,
     )
@@ -244,11 +365,71 @@ describe('subsidies', () => {
         chainId: commitment.chainId,
         tokenAddress: commitment.tokenAddress,
       }),
-    ).toEqual({ nativeAmount: 100n, tokenAmount: 3001n })
+    ).toEqual({
+      nativeAmount: 100n,
+      tokenAmount: 3001n,
+      tokenAmounts: { [commitment.tokenAddress]: 3001n },
+    })
     expect(await RoutesTransfers.hasUnreportedSubsidies(db, expired.orgId)).toBe(false)
   })
 })
 
+describe('subsidyReservations', () => {
+  test('preserves case-sensitive Solana wallet and mint reservations', async () => {
+    const account = 'So11111111111111111111111111111111111111112'
+    const tokenAddress = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'
+    const chainId = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'
+    const record = await seed({
+      subsidyCommitment: {
+        account,
+        amount: { baseUnits: '3001', currency: 'USD', decimals: 6, formatted: '0.003001' },
+        chainId,
+        nativeAmount: '5000',
+        tokenAddress,
+      },
+    })
+    expect({ account: record.subsidyAccount, tokenAddress: record.subsidyTokenAddress }).toEqual({
+      account,
+      tokenAddress,
+    })
+    expect(
+      await RoutesTransfers.subsidyReservations(db, { account, chainId, tokenAddress }),
+    ).toEqual({
+      nativeAmount: 5000n,
+      tokenAmount: 3001n,
+      tokenAmounts: { [tokenAddress]: 3001n },
+    })
+  })
+
+  test('includes other delivery tokens that can also pay Tempo fees', async () => {
+    const account = `0x${'78'.repeat(20)}`
+    const token = `0x${'79'.repeat(20)}`
+    const feeToken = `0x${'80'.repeat(20)}`
+    const commitment = {
+      account,
+      amount: { baseUnits: '3001', currency: 'USD', decimals: 6, formatted: '0.003001' },
+      chainId: 'eip155:4217',
+      nativeAmount: '1000000000000',
+      tokenAddress: token,
+    }
+    const first = await seed({ subsidyCommitment: commitment })
+    await seed({ subsidyCommitment: { ...commitment, tokenAddress: feeToken } })
+    const options = { account, chainId: commitment.chainId, tokenAddress: token }
+    expect(await RoutesTransfers.subsidyReservations(db, options)).toEqual({
+      nativeAmount: 2_000_000_000_000n,
+      tokenAmount: 3001n,
+      tokenAmounts: { [feeToken]: 3001n, [token]: 3001n },
+    })
+    expect(
+      await RoutesTransfers.subsidyReservations(db, { ...options, excludeId: first.id }),
+    ).toEqual({
+      nativeAmount: 1_000_000_000_000n,
+      tokenAmount: 0n,
+      tokenAmounts: { [feeToken]: 3001n },
+    })
+  })
+})
+
 describe('list', () => {
   test('filters across owners and searches transaction references', async () => {
     const record = await seed({