tapimo 0.7.0 → 0.7.2

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

@@ -0,0 +1,580 @@
+import { sql } from 'kysely'
+
+import * as DepositAddress from '../../internal/funding/DepositAddress.js'
+import * as TestApp from '../../../test/App.js'
+import * as TestFunding from '../../../test/Funding.js'
+import * as Db from '../Db.js'
+import * as FundingDepositAddresses from './fundingDepositAddresses.js'
+
+const db = TestApp.database()
+const owner = { environment: 'production', orgId: 'org_deposit_addresses' } as const
+
+let counter = 0
+function seed(input: Partial<DepositAddress.create.Input> = {}) {
+  const index = counter++
+  const now = new Date(Date.UTC(2026, 0, 1, 0, 0, index))
+  const { snapshot, ...rest } = input
+  return DepositAddress.create(db, {
+    apiKeyId: 'key_test',
+    deliveryStrategy: 'provider',
+    environment: owner.environment,
+    id: DepositAddress.generateId(now),
+    now,
+    orgId: owner.orgId,
+    providerOutputToken: TestFunding.providerOutputToken(),
+    snapshot: TestFunding.depositAddressSnapshot({
+      provider: { id: `relay_${index}`, name: 'Relay' },
+      recipient: `0x${index.toString(16).padStart(40, '0')}`,
+      ...snapshot,
+    }),
+    ...rest,
+  })
+}
+
+describe('getOwned', () => {
+  test('returns owned addresses and hides foreign ownership', async () => {
+    const record = await seed()
+    expect((await FundingDepositAddresses.getOwned(db, owner, record.id))?.id).toBe(record.id)
+    expect(
+      await FundingDepositAddresses.getOwned(db, { ...owner, orgId: 'org_other' }, record.id),
+    ).toBeUndefined()
+    expect(
+      await FundingDepositAddresses.getOwned(db, { ...owner, projectId: 'prj_other' }, record.id),
+    ).toBeUndefined()
+  })
+})
+
+describe('subsidize migration', () => {
+  test('backfills legacy snapshots and remains safe to rerun', async () => {
+    const record = await seed({
+      snapshot: TestFunding.depositAddressSnapshot({ subsidize: true }),
+    })
+    await sql`UPDATE funding_deposit_addresses SET snapshot = snapshot - 'subsidize' WHERE id = ${record.id}`.execute(
+      db.kysely,
+    )
+    const migration = Db.migrations.find(
+      (candidate) => candidate.name === '0106_funding_deposit_addresses_snapshot_subsidize',
+    )
+    if (!migration) throw new Error('Expected the snapshot subsidy migration.')
+
+    const legacy = await FundingDepositAddresses.get(db, record.id)
+    if (!legacy) throw new Error('Expected a legacy funding deposit address.')
+    for (let run = 0; run < 2; run++) await migration.up(db.kysely).execute()
+    const migrated = await FundingDepositAddresses.get(db, record.id)
+    if (!migrated) throw new Error('Expected a migrated funding deposit address.')
+
+    expect({
+      legacyPublic: DepositAddress.toPublic(legacy),
+      migratedSnapshot: migrated.snapshot,
+    }).toMatchInlineSnapshot(
+      {
+        legacyPublic: {
+          createdAt: expect.any(String),
+          id: expect.any(String),
+          updatedAt: expect.any(String),
+        },
+      },
+      `
+      {
+        "legacyPublic": {
+          "address": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+          "createdAt": Any<String>,
+          "destinationChain": {
+            "addressFormat": "hex",
+            "id": "eip155:4217",
+            "kind": "evm",
+            "name": "Tempo",
+          },
+          "destinationToken": {
+            "address": "0x20c00000000000000000000014f22ca97301eb73",
+            "currency": "USD",
+            "decimals": 6,
+            "name": "USDT0",
+            "standard": "TIP-20",
+            "symbol": "USDT0",
+            "tokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
+            "verified": true,
+          },
+          "id": Any<String>,
+          "provider": {
+            "id": "relay",
+            "name": "Relay",
+          },
+          "recipient": "0x1111111111111111111111111111111111111111",
+          "refundAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+          "sourceChain": {
+            "addressFormat": "base58check",
+            "id": "tron:0x2b6653dc",
+            "kind": "tron",
+            "name": "Tron",
+          },
+          "sourceToken": {
+            "address": "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+            "currency": "USD",
+            "decimals": 6,
+            "name": "Tether USD",
+            "standard": "TRC-20",
+            "symbol": "USDT",
+            "tokenKey": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+            "verified": true,
+          },
+          "status": "active",
+          "subsidize": true,
+          "updatedAt": Any<String>,
+        },
+        "migratedSnapshot": {
+          "address": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+          "destinationChain": {
+            "addressFormat": "hex",
+            "id": "eip155:4217",
+            "kind": "evm",
+            "name": "Tempo",
+          },
+          "destinationToken": {
+            "address": "0x20c00000000000000000000014f22ca97301eb73",
+            "currency": "USD",
+            "decimals": 6,
+            "name": "USDT0",
+            "standard": "TIP-20",
+            "symbol": "USDT0",
+            "tokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
+            "verified": true,
+          },
+          "provider": {
+            "id": "relay",
+            "name": "Relay",
+          },
+          "recipient": "0x1111111111111111111111111111111111111111",
+          "refundAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+          "sourceChain": {
+            "addressFormat": "base58check",
+            "id": "tron:0x2b6653dc",
+            "kind": "tron",
+            "name": "Tron",
+          },
+          "sourceToken": {
+            "address": "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+            "currency": "USD",
+            "decimals": 6,
+            "name": "Tether USD",
+            "standard": "TRC-20",
+            "symbol": "USDT",
+            "tokenKey": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+            "verified": true,
+          },
+          "subsidize": true,
+        },
+      }
+    `,
+    )
+  })
+})
+
+describe('getMatching', () => {
+  test('matches the owner, route, recipient, and refund address', async () => {
+    const record = await seed()
+    const match: FundingDepositAddresses.Match = {
+      destinationTokenKey: record.destinationTokenKey,
+      environment: record.environment,
+      orgId: record.orgId,
+      recipient: record.recipient,
+      refundAddress: record.refundAddress,
+      sourceChainId: record.sourceChainId,
+      sourceTokenKey: record.sourceTokenKey,
+      subsidize: record.subsidize,
+    }
+
+    expect((await FundingDepositAddresses.getMatching(db, match))?.id).toBe(record.id)
+    expect(
+      await FundingDepositAddresses.getMatching(db, { ...match, refundAddress: 'TWrong' }),
+    ).toBeUndefined()
+  })
+})
+
+describe('claimDue', () => {
+  test('claims due addresses once and reclaims an expired lease with a new fence', async () => {
+    const record = await seed()
+    const now = '2027-01-01T00:00:00.000Z'
+    const first = await FundingDepositAddresses.claimDue(db, {
+      leaseUntil: '2027-01-01T00:01:00.000Z',
+      limit: 10,
+      now,
+      providerId: record.providerId,
+    })
+    const blocked = await FundingDepositAddresses.claimDue(db, {
+      leaseUntil: '2027-01-01T00:02:00.000Z',
+      limit: 10,
+      now,
+      providerId: record.providerId,
+    })
+    const reclaimed = await FundingDepositAddresses.claimDue(db, {
+      leaseUntil: '2027-01-01T00:03:00.000Z',
+      limit: 10,
+      now: '2027-01-01T00:01:00.000Z',
+      providerId: record.providerId,
+    })
+
+    expect({ blocked, first, reclaimed }).toMatchInlineSnapshot(
+      {
+        first: [
+          {
+            id: expect.any(String),
+            providerOutputToken: expect.any(Object),
+            snapshot: expect.any(Object),
+          },
+        ],
+        reclaimed: [
+          {
+            id: expect.any(String),
+            providerOutputToken: expect.any(Object),
+            snapshot: expect.any(Object),
+          },
+        ],
+      },
+      `
+      {
+        "blocked": [],
+        "first": [
+          {
+            "address": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+            "apiKeyId": "key_test",
+            "createdAt": "2026-01-01T00:00:03.000Z",
+            "deliveryStrategy": "provider",
+            "destinationTokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
+            "environment": "production",
+            "id": Any<String>,
+            "lastPolledAt": null,
+            "nextPollAt": "2026-01-01T00:00:03.000Z",
+            "orgId": "org_deposit_addresses",
+            "pollFailureCount": 0,
+            "pollLeaseUntil": "2027-01-01T00:01:00.000Z",
+            "pollLeaseVersion": 1,
+            "projectId": null,
+            "providerId": "relay_3",
+            "providerOutputToken": Any<Object>,
+            "providerRequestIds": [],
+            "providerState": null,
+            "recipient": "0x0000000000000000000000000000000000000003",
+            "refundAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+            "snapshot": Any<Object>,
+            "sourceChainId": "tron:0x2b6653dc",
+            "sourceTokenKey": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+            "status": "active",
+            "subsidize": false,
+            "updatedAt": "2026-01-01T00:00:03.000Z",
+            "version": 1,
+          },
+        ],
+        "reclaimed": [
+          {
+            "address": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+            "apiKeyId": "key_test",
+            "createdAt": "2026-01-01T00:00:03.000Z",
+            "deliveryStrategy": "provider",
+            "destinationTokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
+            "environment": "production",
+            "id": Any<String>,
+            "lastPolledAt": null,
+            "nextPollAt": "2026-01-01T00:00:03.000Z",
+            "orgId": "org_deposit_addresses",
+            "pollFailureCount": 0,
+            "pollLeaseUntil": "2027-01-01T00:03:00.000Z",
+            "pollLeaseVersion": 2,
+            "projectId": null,
+            "providerId": "relay_3",
+            "providerOutputToken": Any<Object>,
+            "providerRequestIds": [],
+            "providerState": null,
+            "recipient": "0x0000000000000000000000000000000000000003",
+            "refundAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+            "snapshot": Any<Object>,
+            "sourceChainId": "tron:0x2b6653dc",
+            "sourceTokenKey": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+            "status": "active",
+            "subsidize": false,
+            "updatedAt": "2026-01-01T00:00:03.000Z",
+            "version": 1,
+          },
+        ],
+      }
+    `,
+    )
+  })
+})
+
+describe('completePoll', () => {
+  test('persists reconciliation state only for the current lease', async () => {
+    const record = await seed()
+    const [claim] = await FundingDepositAddresses.claimDue(db, {
+      leaseUntil: '2027-01-01T00:01:00.000Z',
+      limit: 1,
+      now: '2027-01-01T00:00:00.000Z',
+      providerId: record.providerId,
+    })
+    if (!claim) throw new Error('Expected a claimed address.')
+    const completed = await FundingDepositAddresses.completePoll(db, {
+      id: record.id,
+      lastPolledAt: '2027-01-01T00:00:10.000Z',
+      nextPollAt: '2027-01-01T00:01:10.000Z',
+      pollLeaseVersion: claim.pollLeaseVersion,
+      providerRequestIds: ['relay-request', 'relay-child'],
+      providerState: { highWater: '2027-01-01T00:00:05.000Z' },
+    })
+    const stale = await FundingDepositAddresses.completePoll(db, {
+      id: record.id,
+      lastPolledAt: '2027-01-01T00:00:20.000Z',
+      nextPollAt: '2027-01-01T00:01:20.000Z',
+      pollLeaseVersion: claim.pollLeaseVersion - 1,
+      providerRequestIds: [],
+      providerState: null,
+    })
+
+    expect({ completed, stale }).toMatchInlineSnapshot(
+      {
+        completed: {
+          id: expect.any(String),
+          providerOutputToken: expect.any(Object),
+          snapshot: expect.any(Object),
+        },
+      },
+      `
+      {
+        "completed": {
+          "address": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+          "apiKeyId": "key_test",
+          "createdAt": "2026-01-01T00:00:04.000Z",
+          "deliveryStrategy": "provider",
+          "destinationTokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
+          "environment": "production",
+          "id": Any<String>,
+          "lastPolledAt": "2027-01-01T00:00:10.000Z",
+          "nextPollAt": "2027-01-01T00:01:10.000Z",
+          "orgId": "org_deposit_addresses",
+          "pollFailureCount": 0,
+          "pollLeaseUntil": null,
+          "pollLeaseVersion": 1,
+          "projectId": null,
+          "providerId": "relay_4",
+          "providerOutputToken": Any<Object>,
+          "providerRequestIds": [
+            "relay-request",
+            "relay-child",
+          ],
+          "providerState": {
+            "highWater": "2027-01-01T00:00:05.000Z",
+          },
+          "recipient": "0x0000000000000000000000000000000000000004",
+          "refundAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+          "snapshot": Any<Object>,
+          "sourceChainId": "tron:0x2b6653dc",
+          "sourceTokenKey": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+          "status": "active",
+          "subsidize": false,
+          "updatedAt": "2026-01-01T00:00:04.000Z",
+          "version": 1,
+        },
+        "stale": undefined,
+      }
+    `,
+    )
+  })
+})
+
+describe('failPoll', () => {
+  test('increments failures and releases only the current lease', async () => {
+    const record = await seed()
+    const [claim] = await FundingDepositAddresses.claimDue(db, {
+      leaseUntil: '2027-01-01T00:01:00.000Z',
+      limit: 1,
+      now: '2027-01-01T00:00:00.000Z',
+      providerId: record.providerId,
+    })
+    if (!claim) throw new Error('Expected a claimed address.')
+    const failed = await FundingDepositAddresses.failPoll(db, {
+      id: record.id,
+      nextPollAt: '2027-01-01T00:00:30.000Z',
+      pollLeaseVersion: claim.pollLeaseVersion,
+    })
+    const stale = await FundingDepositAddresses.failPoll(db, {
+      id: record.id,
+      nextPollAt: '2027-01-01T00:00:40.000Z',
+      pollLeaseVersion: claim.pollLeaseVersion - 1,
+    })
+
+    expect({ failed, stale }).toMatchInlineSnapshot(
+      {
+        failed: {
+          id: expect.any(String),
+          providerOutputToken: expect.any(Object),
+          snapshot: expect.any(Object),
+        },
+      },
+      `
+      {
+        "failed": {
+          "address": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+          "apiKeyId": "key_test",
+          "createdAt": "2026-01-01T00:00:05.000Z",
+          "deliveryStrategy": "provider",
+          "destinationTokenKey": "eip155:4217/erc20:0x20c00000000000000000000014f22ca97301eb73",
+          "environment": "production",
+          "id": Any<String>,
+          "lastPolledAt": null,
+          "nextPollAt": "2027-01-01T00:00:30.000Z",
+          "orgId": "org_deposit_addresses",
+          "pollFailureCount": 1,
+          "pollLeaseUntil": null,
+          "pollLeaseVersion": 1,
+          "projectId": null,
+          "providerId": "relay_5",
+          "providerOutputToken": Any<Object>,
+          "providerRequestIds": [],
+          "providerState": null,
+          "recipient": "0x0000000000000000000000000000000000000005",
+          "refundAddress": "TJRabPrwbZy45sbavfcjinPJC18kjpRTv8",
+          "snapshot": Any<Object>,
+          "sourceChainId": "tron:0x2b6653dc",
+          "sourceTokenKey": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+          "status": "active",
+          "subsidize": false,
+          "updatedAt": "2026-01-01T00:00:05.000Z",
+          "version": 1,
+        },
+        "stale": undefined,
+      }
+    `,
+    )
+  })
+})
+
+describe('insertOrGet', () => {
+  test('returns the existing address for an identical reusable identity', async () => {
+    const record = await seed()
+    const match: FundingDepositAddresses.Match = {
+      destinationTokenKey: record.destinationTokenKey,
+      environment: record.environment,
+      orgId: record.orgId,
+      recipient: record.recipient,
+      refundAddress: record.refundAddress,
+      sourceChainId: record.sourceChainId,
+      sourceTokenKey: record.sourceTokenKey,
+      subsidize: record.subsidize,
+    }
+    const duplicate = { ...record, id: DepositAddress.generateId(new Date('2027-01-01')) }
+
+    await expect(
+      FundingDepositAddresses.insertOrGet(db, { match, record: duplicate }),
+    ).resolves.toMatchObject({
+      id: record.id,
+    })
+  })
+
+  test('rejects a provider address assigned to another reusable identity', async () => {
+    const provider = { id: `relay_collision_${counter}`, name: 'Relay' }
+    const first = await seed({
+      snapshot: TestFunding.depositAddressSnapshot({
+        provider,
+        recipient: `0x${'cd'.repeat(20)}`,
+      }),
+    })
+    const recipient = `0x${'ab'.repeat(20)}`
+    const record: FundingDepositAddresses.Record = {
+      ...first,
+      id: DepositAddress.generateId(new Date('2027-01-01')),
+      orgId: 'org_other',
+      recipient,
+      snapshot: { ...first.snapshot, recipient },
+    }
+    const match: FundingDepositAddresses.Match = {
+      destinationTokenKey: record.destinationTokenKey,
+      environment: record.environment,
+      orgId: record.orgId,
+      recipient: record.recipient,
+      refundAddress: record.refundAddress,
+      sourceChainId: record.sourceChainId,
+      sourceTokenKey: record.sourceTokenKey,
+      subsidize: record.subsidize,
+    }
+
+    await expect(
+      FundingDepositAddresses.insertOrGet(db, { match, record }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingDepositAddresses.ConflictError]`)
+    expect((await FundingDepositAddresses.get(db, first.id))?.id).toBe(first.id)
+  })
+})
+
+describe('insert', () => {
+  test('prevents one provider address from belonging to two resources', async () => {
+    const provider = { id: `relay_unique_${counter}`, name: 'Relay' }
+    const first = await seed({ snapshot: TestFunding.depositAddressSnapshot({ provider }) })
+    await expect(
+      seed({ snapshot: TestFunding.depositAddressSnapshot({ provider }), orgId: 'org_other' }),
+    ).rejects.toMatchObject({ code: '23505' })
+    expect((await FundingDepositAddresses.get(db, first.id))?.id).toBe(first.id)
+  })
+})
+
+describe('update', () => {
+  test('applies allowed transitions once against the expected version', async () => {
+    const record = await seed()
+    const applied = await DepositAddress.transition(db, {
+      expectedVersion: 1,
+      id: record.id,
+      status: 'action-required',
+    })
+    expect(applied.type).toBe('applied')
+    expect(
+      await DepositAddress.transition(db, {
+        expectedVersion: 1,
+        id: record.id,
+        status: 'action-required',
+      }),
+    ).toMatchObject({ type: 'stale' })
+  })
+})
+
+describe('toPublic', () => {
+  test('omits private provider and ownership state', async () => {
+    const record = await seed({
+      providerRequestIds: ['relay-request'],
+      providerState: { correlation: 'private' },
+    })
+    expect(DepositAddress.toPublic(record)).not.toMatchObject({
+      apiKeyId: expect.anything(),
+      deliveryStrategy: expect.anything(),
+      providerOutputToken: expect.anything(),
+      providerRequestIds: expect.anything(),
+      providerState: expect.anything(),
+    })
+  })
+})
+
+describe('renewPoll', () => {
+  test('extends only the current active lease', async () => {
+    const record = await seed()
+    const [claim] = await FundingDepositAddresses.claimDue(db, {
+      leaseUntil: '2027-01-01T00:01:00.000Z',
+      limit: 1,
+      now: '2027-01-01T00:00:00.000Z',
+      providerId: record.providerId,
+    })
+    if (!claim) throw new Error('Expected a claimed address.')
+    const renewed = await FundingDepositAddresses.renewPoll(db, {
+      id: claim.id,
+      leaseUntil: '2027-01-01T00:02:00.000Z',
+      pollLeaseVersion: claim.pollLeaseVersion,
+    })
+    const stale = await FundingDepositAddresses.renewPoll(db, {
+      id: claim.id,
+      leaseUntil: '2027-01-01T00:03:00.000Z',
+      pollLeaseVersion: claim.pollLeaseVersion - 1,
+    })
+
+    expect({ renewed, stale }).toMatchInlineSnapshot(`
+      {
+        "renewed": true,
+        "stale": false,
+      }
+    `)
+  })
+})