tapimo 0.7.1 → 0.7.2

package/src/internal/funding/Transfer.test.ts

@@ -0,0 +1,369 @@
+import * as TestApp from '../../../test/App.js'
+import * as TestFunding from '../../../test/Funding.js'
+import * as Transfer from './Transfer.js'
+
+const db = TestApp.database()
+const now = new Date('2026-01-01T00:00:00.000Z')
+
+beforeEach(() => vi.useFakeTimers({ now, toFake: ['Date'] }))
+afterEach(() => vi.useRealTimers())
+
+function createInput(overrides: Partial<Transfer.create.Input> = {}): Transfer.create.Input {
+  return {
+    apiKeyId: 'key_test',
+    environment: 'production',
+    orgId: 'org_test',
+    snapshot: TestFunding.transferSnapshot(),
+    ...overrides,
+  }
+}
+
+describe('canTransition', () => {
+  test('encodes the public state chart', () => {
+    const table = Object.fromEntries(
+      Transfer.statuses.map((from) => [
+        from,
+        Transfer.statuses.filter((to) => Transfer.canTransition(from, to)),
+      ]),
+    )
+    expect(table).toMatchInlineSnapshot(`
+      {
+        "action-required": [
+          "processing",
+          "refunding",
+          "completed",
+          "refunded",
+        ],
+        "awaiting-source": [
+          "processing",
+          "action-required",
+          "expired",
+        ],
+        "completed": [],
+        "expired": [],
+        "processing": [
+          "refunding",
+          "completed",
+          "action-required",
+        ],
+        "refunded": [],
+        "refunding": [
+          "refunded",
+          "action-required",
+        ],
+      }
+    `)
+  })
+})
+
+describe('isTerminal', () => {
+  test('only chain-verified and expiry outcomes are terminal', () => {
+    expect(Transfer.statuses.filter(Transfer.isTerminal)).toMatchInlineSnapshot(`
+      [
+        "completed",
+        "refunded",
+        "expired",
+      ]
+    `)
+  })
+})
+
+describe('generateId', () => {
+  test('embeds the timestamp so lexical order is chronological', () => {
+    const earlier = Transfer.generateId(new Date('2026-01-01T00:00:00.000Z'))
+    const later = Transfer.generateId(new Date('2026-01-01T00:00:01.000Z'))
+    expect(earlier).toMatch(/^ftr_\d{15}_[0-9A-Za-z]{24}$/)
+    expect(earlier < later).toBe(true)
+  })
+})
+
+describe('create', () => {
+  test('creates the row and its version-1 event atomically', async () => {
+    const record = await Transfer.create(db, createInput())
+    const { id, snapshot: _, ...rest } = record
+    expect(id).toMatch(/^ftr_/)
+    expect(rest).toMatchInlineSnapshot(`
+      {
+        "apiKeyId": "key_test",
+        "createdAt": "2026-01-01T00:00:00.000Z",
+        "environment": "production",
+        "method": "transaction",
+        "mode": "exactSource",
+        "orgId": "org_test",
+        "projectId": null,
+        "providerId": "relay",
+        "providerState": null,
+        "quoteExpiresAt": "2026-01-01T00:01:00.000Z",
+        "status": "awaiting-source",
+        "statusReason": null,
+        "updatedAt": "2026-01-01T00:00:00.000Z",
+        "version": 1,
+      }
+    `)
+
+    const events = await db.kysely
+      .selectFrom('funding_transfer_events')
+      .select(['status', 'transferId', 'version'])
+      .where('transferId', '=', id)
+      .execute()
+    expect(events).toEqual([{ status: 'awaiting-source', transferId: id, version: 1 }])
+  })
+
+  test('normalizes quote expiry and strips executable actions before persistence', async () => {
+    const snapshot = {
+      ...TestFunding.transferSnapshot({
+        quote: { expiresAt: '2026-01-01T00:01:00Z', sampledAt: '2026-01-01T00:00:00.000Z' },
+      }),
+      action: { type: 'evm:calls' },
+    }
+    const record = await Transfer.create(db, createInput({ snapshot }))
+    expect({
+      action: 'action' in record.snapshot,
+      expiresAt: record.snapshot.quote.expiresAt,
+      quoteExpiresAt: record.quoteExpiresAt,
+    }).toEqual({
+      action: false,
+      expiresAt: '2026-01-01T00:01:00.000Z',
+      quoteExpiresAt: '2026-01-01T00:01:00.000Z',
+    })
+  })
+})
+
+describe('transition', () => {
+  test('applies a guarded status change and appends an event', async () => {
+    const record = await Transfer.create(db, createInput())
+    vi.setSystemTime(new Date('2026-01-01T00:00:10.000Z'))
+    const result = await Transfer.transition(db, {
+      expectedVersion: 1,
+      id: record.id,
+      status: 'processing',
+    })
+    expect(result.type).toBe('applied')
+    if (result.type !== 'applied') return
+    expect({
+      status: result.record.status,
+      updatedAt: result.record.updatedAt,
+      version: result.record.version,
+    }).toEqual({ status: 'processing', updatedAt: '2026-01-01T00:00:10.000Z', version: 2 })
+
+    const events = await db.kysely
+      .selectFrom('funding_transfer_events')
+      .select(['status', 'version'])
+      .where('transferId', '=', record.id)
+      .orderBy('version', 'asc')
+      .execute()
+    expect(events).toEqual([
+      { status: 'awaiting-source', version: 1 },
+      { status: 'processing', version: 2 },
+    ])
+  })
+
+  test('competing transitions converge on one version', async () => {
+    const record = await Transfer.create(db, createInput())
+    const first = await Transfer.transition(db, {
+      expectedVersion: 1,
+      id: record.id,
+      status: 'processing',
+    })
+    const second = await Transfer.transition(db, {
+      expectedVersion: 1,
+      id: record.id,
+      status: 'expired',
+    })
+    expect([first.type, second.type]).toEqual(['applied', 'stale'])
+    if (second.type !== 'stale') return
+    expect(second.current.version).toBe(2)
+  })
+
+  test('rejects transitions the lifecycle does not allow', async () => {
+    const record = await Transfer.create(db, createInput())
+    await Transfer.transition(db, { expectedVersion: 1, id: record.id, status: 'expired' })
+    const result = await Transfer.transition(db, {
+      expectedVersion: 2,
+      id: record.id,
+      status: 'processing',
+    })
+    expect(result.type).toBe('invalid')
+  })
+
+  test('carries a customer-safe status reason', async () => {
+    const record = await Transfer.create(db, createInput())
+    await Transfer.transition(db, { expectedVersion: 1, id: record.id, status: 'processing' })
+    const result = await Transfer.transition(db, {
+      expectedVersion: 2,
+      id: record.id,
+      status: 'action-required',
+      statusReason: {
+        code: 'destination_amount_below_minimum',
+        message: 'The verified destination amount did not satisfy the quoted minimum.',
+      },
+    })
+    expect(result.type).toBe('applied')
+    if (result.type !== 'applied') return
+    expect(result.record.statusReason).toMatchInlineSnapshot(`
+      {
+        "code": "destination_amount_below_minimum",
+        "message": "The verified destination amount did not satisfy the quoted minimum.",
+      }
+    `)
+  })
+
+  test('preserves the reason for snapshot updates and clears it on lifecycle changes', async () => {
+    const record = await Transfer.create(db, createInput())
+    await Transfer.transition(db, { expectedVersion: 1, id: record.id, status: 'processing' })
+    await Transfer.transition(db, {
+      expectedVersion: 2,
+      id: record.id,
+      status: 'action-required',
+      statusReason: {
+        code: 'destination_amount_below_minimum',
+        message: 'The verified destination amount did not satisfy the quoted minimum.',
+      },
+    })
+    const snapshot = await Transfer.transition(db, {
+      expectedVersion: 3,
+      id: record.id,
+      snapshot: TestFunding.transferSnapshot({
+        sourceTransactionHashes: [`0x${'aa'.repeat(32)}`],
+      }),
+    })
+    expect(snapshot.type).toBe('applied')
+    if (snapshot.type !== 'applied') return
+    expect(snapshot.record.statusReason?.code).toBe('destination_amount_below_minimum')
+
+    const processing = await Transfer.transition(db, {
+      expectedVersion: 4,
+      id: record.id,
+      status: 'processing',
+    })
+    expect(processing.type).toBe('applied')
+    if (processing.type !== 'applied') return
+    expect(processing.record.statusReason).toBeNull()
+  })
+
+  test('updates the snapshot without a status change', async () => {
+    const record = await Transfer.create(db, createInput())
+    const result = await Transfer.transition(db, {
+      expectedVersion: 1,
+      id: record.id,
+      snapshot: TestFunding.transferSnapshot({
+        sourceTransactionHashes: [`0x${'aa'.repeat(32)}`],
+      }),
+    })
+    expect(result.type).toBe('applied')
+    if (result.type !== 'applied') return
+    expect({
+      hashes: result.record.snapshot.sourceTransactionHashes,
+      status: result.record.status,
+      version: result.record.version,
+    }).toEqual({
+      hashes: [`0x${'aa'.repeat(32)}`],
+      status: 'awaiting-source',
+      version: 2,
+    })
+  })
+
+  test('strips executable actions from replacement snapshots', async () => {
+    const record = await Transfer.create(db, createInput())
+    const snapshot = {
+      ...TestFunding.transferSnapshot(),
+      action: { type: 'evm:calls' },
+    }
+    const result = await Transfer.transition(db, {
+      expectedVersion: 1,
+      id: record.id,
+      snapshot,
+    })
+    expect(result.type).toBe('applied')
+    if (result.type !== 'applied') return
+    expect('action' in result.record.snapshot).toBe(false)
+  })
+
+  test('reports a missing transfer', async () => {
+    const result = await Transfer.transition(db, {
+      expectedVersion: 1,
+      id: 'ftr_000000000000000_000000000000000000000000',
+      status: 'processing',
+    })
+    expect(result.type).toBe('not_found')
+  })
+})
+
+describe('toPublic', () => {
+  test('serializes the snapshot with lifecycle fields and no ownership columns', async () => {
+    const record = await Transfer.create(db, createInput({ projectId: 'prj_test' }))
+    const { id, ...rest } = Transfer.toPublic(record)
+    expect(id).toMatch(/^ftr_/)
+    expect(rest).toMatchInlineSnapshot(`
+      {
+        "createdAt": "2026-01-01T00:00:00.000Z",
+        "destinationAmount": {
+          "baseUnits": "979295",
+          "currency": "USD",
+          "decimals": 6,
+          "formatted": "0.979295",
+        },
+        "destinationAmountMin": {
+          "baseUnits": "939242",
+          "currency": "USD",
+          "decimals": 6,
+          "formatted": "0.939242",
+        },
+        "destinationChain": {
+          "addressFormat": "hex",
+          "id": "eip155:4217",
+          "kind": "evm",
+          "name": "Tempo",
+        },
+        "destinationToken": {
+          "address": "0x20c000000000000000000000b9537d11c60e8b50",
+          "currency": "USD",
+          "decimals": 6,
+          "name": "Bridged USDC (Stargate)",
+          "standard": "TIP-20",
+          "symbol": "USDC.e",
+          "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
+          "verified": true,
+        },
+        "fees": [],
+        "method": "transaction",
+        "mode": "exactSource",
+        "provider": {
+          "id": "relay",
+          "name": "Relay",
+        },
+        "quote": {
+          "expiresAt": "2026-01-01T00:01:00.000Z",
+          "sampledAt": "2026-01-01T00:00:00.000Z",
+        },
+        "recipient": "0x1111111111111111111111111111111111111111",
+        "sender": "0x2222222222222222222222222222222222222222",
+        "sourceAmount": {
+          "baseUnits": "1000000",
+          "currency": "USD",
+          "decimals": 6,
+          "formatted": "1",
+        },
+        "sourceChain": {
+          "addressFormat": "hex",
+          "id": "eip155:8453",
+          "kind": "evm",
+          "name": "Base",
+        },
+        "sourceToken": {
+          "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+          "currency": "USD",
+          "decimals": 6,
+          "name": "USD Coin",
+          "standard": "ERC-20",
+          "symbol": "USDC",
+          "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+          "verified": true,
+        },
+        "status": "awaiting-source",
+        "updatedAt": "2026-01-01T00:00:00.000Z",
+        "version": 1,
+      }
+    `)
+  })
+})