tapimo 0.13.0 → 0.15.0

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

@@ -0,0 +1,338 @@
+import * as Transfer from '../../internal/routes/Transfer.js'
+import * as TestApp from '../../../test/App.js'
+import * as TestRoutes from '../../../test/Routes.js'
+import * as RoutesTransferTransactions from './routesTransferTransactions.js'
+import * as RoutesTransfers from './routesTransfers.js'
+
+const db = TestApp.database()
+
+const owner = { environment: 'production', orgId: 'org_list' } as const
+
+let counter = 0
+function seed(input: Partial<Transfer.create.Input> = {}) {
+  // Distinct create times keep ids strictly ordered for paging assertions.
+  return Transfer.create(db, {
+    apiKeyId: 'key_test',
+    environment: 'production',
+    id: Transfer.generateId(new Date(Date.UTC(2026, 0, 1, 0, 0, counter++))),
+    orgId: owner.orgId,
+    snapshot: TestRoutes.transferSnapshot({
+      quote: { expiresAt: '2099-01-01T00:01:00.000Z', sampledAt: '2099-01-01T00:00:00.000Z' },
+    }),
+    ...input,
+  })
+}
+
+describe('listByOwner', () => {
+  test('pages newest-first by id with owner isolation', async () => {
+    const first = await seed()
+    const second = await seed({ projectId: 'prj_a' })
+    const third = await seed()
+    await seed({ orgId: 'org_other' })
+    await seed({ environment: 'sandbox' })
+
+    const page = await RoutesTransfers.listByOwner(db, owner, { limit: 3 })
+    expect(page.map((row) => row.id)).toEqual([third.id, second.id, first.id])
+
+    const rest = await RoutesTransfers.listByOwner(db, owner, { cursor: third.id, limit: 3 })
+    expect(rest.map((row) => row.id)).toEqual([second.id, first.id])
+  })
+
+  test('narrows project-attributed owners to their project', async () => {
+    const rows = await RoutesTransfers.listByOwner(
+      db,
+      { ...owner, projectId: 'prj_a' },
+      { limit: 10 },
+    )
+    expect(rows.every((row) => row.projectId === 'prj_a')).toBe(true)
+    expect(rows.length).toBeGreaterThan(0)
+  })
+
+  test('filters by status', async () => {
+    const record = await seed()
+    await Transfer.transition(db, { expectedVersion: 1, id: record.id, status: 'expired' })
+    const rows = await RoutesTransfers.listByOwner(db, owner, {
+      limit: 10,
+      status: 'expired',
+    })
+    expect(rows.map((row) => row.id)).toEqual([record.id])
+  })
+})
+
+describe('listProcessing', () => {
+  test('returns only processing transfers for the provider', async () => {
+    const first = await seed({
+      snapshot: TestRoutes.transferSnapshot({ provider: { id: 'stargate', name: 'Stargate' } }),
+    })
+    const second = await seed({
+      snapshot: TestRoutes.transferSnapshot({ provider: { id: 'stargate', name: 'Stargate' } }),
+    })
+    const relay = await seed()
+    await Transfer.transition(db, { expectedVersion: 1, id: first.id, status: 'processing' })
+    await Transfer.transition(db, { expectedVersion: 1, id: second.id, status: 'processing' })
+    await Transfer.transition(db, { expectedVersion: 1, id: relay.id, status: 'processing' })
+
+    const page = await RoutesTransfers.listProcessing(db, { limit: 1, providerId: 'stargate' })
+    const rest = await RoutesTransfers.listProcessing(db, {
+      cursor: page[0]!.id,
+      limit: 1,
+      providerId: 'stargate',
+    })
+    expect([page.map((row) => row.id), rest.map((row) => row.id)]).toEqual([
+      [first.id],
+      [second.id],
+    ])
+  })
+})
+
+describe('count', () => {
+  test('shares the list filter and stops at the cap', async () => {
+    const total = await RoutesTransfers.count(db, owner, { cap: 100 })
+    expect(total).toBeGreaterThanOrEqual(3)
+    expect(await RoutesTransfers.count(db, owner, { cap: 2 })).toBe(3)
+    expect(await RoutesTransfers.count(db, { ...owner, orgId: 'org_none' }, { cap: 100 })).toBe(0)
+  })
+})
+
+describe('getOwned', () => {
+  test('returns owned rows and hides foreign ones', async () => {
+    const record = await seed()
+    expect((await RoutesTransfers.getOwned(db, owner, record.id))?.id).toBe(record.id)
+    expect(
+      await RoutesTransfers.getOwned(db, { ...owner, orgId: 'org_other' }, record.id),
+    ).toBeUndefined()
+    expect(
+      await RoutesTransfers.getOwned(db, { ...owner, projectId: 'prj_a' }, record.id),
+    ).toBeUndefined()
+  })
+})
+
+describe('update', () => {
+  test('applies only against the expected version', async () => {
+    const record = await seed()
+    const options = {
+      expectedVersion: 1,
+      id: record.id,
+      providerDeliveredAt: null,
+      snapshot: record.snapshot,
+      status: 'processing',
+      statusReason: null,
+      statusUpdatedAt: '2026-01-01T00:10:00.000Z',
+      subsidyAccount: null,
+      subsidyAmount: null,
+      subsidyChainId: null,
+      subsidyCommitmentAmount: null,
+      subsidyNativeAmount: null,
+      subsidyTokenAddress: null,
+      subsidyTransactionHash: null,
+      updatedAt: '2026-01-01T00:10:00.000Z',
+      version: 2,
+    } as const
+    expect((await RoutesTransfers.update(db, options))?.version).toBe(2)
+    expect(await RoutesTransfers.update(db, options)).toBeUndefined()
+  })
+})
+
+describe('subsidies', () => {
+  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, {
+      expectedVersion: record.version,
+      id: record.id,
+      status: 'processing',
+    })
+    if (processing.type !== 'applied') throw new Error('Expected processing transfer.')
+    const amount = {
+      baseUnits: '3001',
+      currency: 'USD',
+      decimals: 6,
+      formatted: '0.003001',
+    }
+    const prepared = await Transfer.transition(db, {
+      expectedVersion: processing.record.version,
+      id: record.id,
+      subsidyAmount: amount,
+      subsidyTransactionHash: `0x${'ab'.repeat(32)}`,
+    })
+    if (prepared.type !== 'applied') throw new Error('Expected prepared subsidy.')
+
+    expect(await RoutesTransfers.hasUnreportedSubsidies(db, 'org_transfer_subsidy')).toBe(true)
+    expect(await RoutesTransfers.listUnreportedSubsidies(db)).toEqual([])
+
+    const completed = await Transfer.transition(db, {
+      expectedVersion: prepared.record.version,
+      id: record.id,
+      status: 'completed',
+    })
+    if (completed.type !== 'applied') throw new Error('Expected completed subsidy.')
+    expect(RoutesTransfers.subsidies(completed.record)).toMatchObject([
+      { amount: { baseUnits: '3001' }, provider: 'tempo' },
+    ])
+    expect((await RoutesTransfers.listUnreportedSubsidies(db)).map(({ id }) => id)).toContain(
+      record.id,
+    )
+    expect(
+      await RoutesTransfers.subsidyUsage(db, {
+        environment: 'production',
+        from: record.createdAt,
+        orgId: 'org_transfer_subsidy',
+        to: new Date().toISOString(),
+      }),
+    ).toEqual({ amount: 3001n, count: 1 })
+
+    await RoutesTransfers.markSubsidyReported(db, record.id, new Date().toISOString())
+    expect(await RoutesTransfers.hasUnreportedSubsidies(db, 'org_transfer_subsidy')).toBe(false)
+    expect((await RoutesTransfers.get(db, record.id))?.subsidyMeterReportedAt).not.toBeNull()
+  })
+
+  test('releases abandoned commitments only after their expiry transition', async () => {
+    const amount = {
+      baseUnits: '3001',
+      currency: 'USD',
+      decimals: 6,
+      formatted: '0.003001',
+    } as const
+    const commitment = {
+      account: `0x${'55'.repeat(20)}`,
+      amount,
+      chainId: 'eip155:8453',
+      nativeAmount: '100',
+      tokenAddress: `0x${'66'.repeat(20)}`,
+    }
+    const expired = await seed({
+      orgId: 'org_expired_transfer_subsidy',
+      snapshot: TestRoutes.transferSnapshot({
+        quote: { expiresAt: '2026-01-01T00:01:00.000Z', sampledAt: '2026-01-01T00:00:00.000Z' },
+      }),
+      subsidyCommitment: commitment,
+    })
+    const active = await seed({
+      orgId: 'org_active_transfer_subsidy',
+      subsidyCommitment: commitment,
+    })
+
+    expect(
+      await RoutesTransfers.subsidyReservations(db, {
+        account: commitment.account,
+        chainId: commitment.chainId,
+        tokenAddress: commitment.tokenAddress,
+      }),
+    ).toEqual({ nativeAmount: 200n, tokenAmount: 6002n })
+    expect(await RoutesTransfers.hasUnreportedSubsidies(db, 'org_expired_transfer_subsidy')).toBe(
+      true,
+    )
+    expect(await RoutesTransfers.hasUnreportedSubsidies(db, active.orgId)).toBe(true)
+    expect(
+      (
+        await RoutesTransfers.listExpiredSubsidyCommitments(db, {
+          expiredBefore: new Date(
+            Date.now() - RoutesTransfers.subsidyCommitmentRecoveryTtlMs,
+          ).toISOString(),
+          limit: 10,
+        })
+      ).map(({ id }) => id),
+    ).toContain(expired.id)
+
+    await Transfer.transition(db, {
+      expectedVersion: expired.version,
+      id: expired.id,
+      status: 'expired',
+    })
+    expect(
+      await RoutesTransfers.subsidyReservations(db, {
+        account: commitment.account,
+        chainId: commitment.chainId,
+        tokenAddress: commitment.tokenAddress,
+      }),
+    ).toEqual({ nativeAmount: 100n, tokenAmount: 3001n })
+    expect(await RoutesTransfers.hasUnreportedSubsidies(db, expired.orgId)).toBe(false)
+  })
+})
+
+describe('list', () => {
+  test('filters across owners and searches transaction references', async () => {
+    const record = await seed({
+      orgId: 'org_admin_transfer',
+      snapshot: TestRoutes.transferSnapshot({
+        provider: { id: 'stargate_admin_list', name: 'Stargate' },
+      }),
+    })
+    const transactionRef = 'ad'.repeat(32)
+    await RoutesTransferTransactions.insert(db, {
+      chainId: 'tron:mainnet',
+      createdAt: record.createdAt,
+      role: 'source',
+      transactionRef,
+      transferId: record.id,
+    })
+
+    const rows = await RoutesTransfers.list(db, {
+      limit: 10,
+      providerId: 'stargate_admin_list',
+      query: transactionRef.toUpperCase(),
+    })
+
+    expect(rows.map(({ id }) => id)).toEqual([record.id])
+  })
+
+  test('filters to positive transfer subsidies', async () => {
+    const snapshot = TestRoutes.transferSnapshot({
+      provider: { id: 'subsidy_filter', name: 'Subsidy filter' },
+    })
+    const subsidized = await seed({ orgId: 'org_admin_transfer_subsidy', snapshot })
+    await seed({ orgId: 'org_admin_transfer_subsidy', snapshot })
+    const result = await Transfer.transition(db, {
+      expectedVersion: subsidized.version,
+      id: subsidized.id,
+      subsidyAmount: {
+        baseUnits: '3001',
+        currency: 'USD',
+        decimals: 6,
+        formatted: '0.003001',
+      },
+    })
+    if (result.type !== 'applied') throw new Error('Expected subsidized transfer.')
+
+    expect(
+      (
+        await RoutesTransfers.list(db, {
+          hasSubsidy: true,
+          limit: 10,
+          providerId: snapshot.provider.id,
+        })
+      ).map(({ id }) => id),
+    ).toEqual([subsidized.id])
+  })
+})
+
+describe('summarize', () => {
+  test('counts processing and action-required transfers without overlap', async () => {
+    const processing = await seed({
+      orgId: 'org_admin_transfer_summary',
+      snapshot: TestRoutes.transferSnapshot({
+        provider: { id: 'stargate_admin_summary', name: 'Stargate' },
+      }),
+    })
+    const actionRequired = await seed({
+      orgId: 'org_admin_transfer_summary',
+      snapshot: TestRoutes.transferSnapshot({
+        provider: { id: 'stargate_admin_summary', name: 'Stargate' },
+      }),
+    })
+    await Transfer.transition(db, {
+      expectedVersion: processing.version,
+      id: processing.id,
+      status: 'processing',
+    })
+    await Transfer.transition(db, {
+      expectedVersion: actionRequired.version,
+      id: actionRequired.id,
+      status: 'action-required',
+      statusReason: { code: 'manual_recovery_required', message: 'Needs review.' },
+    })
+
+    expect(
+      await RoutesTransfers.summarize(db, { providerId: 'stargate_admin_summary' }),
+    ).toMatchObject({ actionRequired: 1, inProgress: 1 })
+  })
+})