tapimo 0.5.3 → 0.7.0

package/src/apps/data/routes/transfers.test.ts

@@ -1,12 +1,81 @@
 import type * as z from 'zod/mini'
-import { Schema } from 'tapimo'
+import { Value as core_Value } from 'ox'
+import { Db, Schema } from 'tapimo'
+import { FxOracle } from 'tapimo/apps'
 
 import * as TestApp from '../../../../test/App.js'
 import * as Runtime from '../../../../test/runtime.js'
 import * as Transfers from './transfers.js'
 
+// Deterministic EUR-based rate set so conversion math is exact in assertions.
+const fixed = FxOracle.from({
+  name: 'fixed',
+  rates: async () => ({
+    asOf: '2026-01-01T00:00:00.000Z',
+    base: 'EUR',
+    rates: { AUD: '1.6', USD: '1.0' },
+  }),
+})
+
 describe('GET /transfers', () => {
-  test('returns an unscoped transfer page, embedding tokens on demand', async () => {
+  test('parses granular token includes', () => {
+    expect(
+      Transfers.schema.getTransfers.Query.parse({
+        include: 'token.logoUri,token.verified',
+      }).include,
+    ).toMatchInlineSnapshot(`
+      [
+        "token.logoUri",
+        "token.verified",
+      ]
+    `)
+    expect(Transfers.schema.getTransfers.Query.safeParse({ include: 'token' }).success).toBe(false)
+  })
+
+  test('degrades unavailable verification data to null valuations', async () => {
+    const db = () =>
+      Db.postgres({
+        connectionString: 'postgresql://postgres:postgres@127.0.0.1:1/none',
+      })
+    const client = TestApp.client({ db, fx: { oracle: fixed } })
+
+    const response = await client.v1.transfers.$get(
+      { query: { limit: '5', token: TestApp.tokenWithHolders } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+    expect(response.status).toBe(200)
+    expect(body.data.length).toBeGreaterThan(0)
+    for (const entry of body.data) expect(entry.sourceAmount.valuation).toBeNull()
+
+    const emptyResponse = await client.v1.transfers.$get(
+      { query: { limit: '5', token: `0x${'11'.repeat(20)}` } },
+      TestApp.auth,
+    )
+    const empty = await TestApp.json(emptyResponse, Transfers.schema.getTransfers.Response)
+    expect(emptyResponse.status).toBe(200)
+    expect(empty.data).toMatchInlineSnapshot(`[]`)
+    expect(emptyResponse.headers.get('server-timing')?.includes('verified_tokens;dur=')).not.toBe(
+      true,
+    )
+
+    const unsupportedResponse = await client.v1.transfers.$get(
+      {
+        query: {
+          denomination: 'JPY',
+          limit: '5',
+          token: TestApp.tokenWithHolders,
+        },
+      },
+      TestApp.auth,
+    )
+    const unsupported = await TestApp.json(unsupportedResponse, Schema.ErrorResponse)
+    expect(unsupportedResponse.status).toBe(400)
+    expect(unsupported.error.code).toBe('query_invalid')
+  })
+
+  test('returns an unscoped transfer page with token metadata', async () => {
     const client = TestApp.client()
     const baseResponse = await client.v1.transfers.$get({ query: { limit: '5' } }, TestApp.auth)
     const base = await TestApp.json(baseResponse, Transfers.schema.getTransfers.Response)
@@ -23,7 +92,14 @@ describe('GET /transfers', () => {
       base.data.every(
         (entry) =>
           /^0x[0-9a-f]{40}$/.test(entry.sourceToken.address) &&
-          /^\d+$/.test(entry.sourceToken.amount) &&
+          /^\d+$/.test(entry.sourceAmount.baseUnits) &&
+          typeof entry.sourceAmount.currency === 'string' &&
+          Number.isInteger(entry.sourceAmount.decimals) &&
+          typeof entry.sourceAmount.formatted === 'string' &&
+          typeof entry.sourceToken.currency === 'string' &&
+          Number.isInteger(entry.sourceToken.decimals) &&
+          typeof entry.sourceToken.name === 'string' &&
+          typeof entry.sourceToken.symbol === 'string' &&
           Number.isInteger(entry.blockNumber) &&
           /^0x[0-9a-f]{40}$/.test(entry.sender) &&
           /^0x[0-9a-f]{40}$/.test(entry.recipient) &&
@@ -34,28 +110,35 @@ describe('GET /transfers', () => {
     // Transfers default to newest-first (descending block number).
     const blocks = base.data.map((entry) => entry.blockNumber)
     expect(blocks.every((block, index) => index === 0 || blocks[index - 1]! >= block)).toBe(true)
-    // Token metadata is opt-in: the base page's `sourceToken` carries only
-    // `address`/`amount`, with no metadata fields spread in.
-    expect(base.data.every((entry) => entry.sourceToken.symbol === undefined)).toBe(true)
+    // Quantities live beside the token reference; curated fields remain opt-in.
+    expect(
+      base.data.every(
+        (entry) =>
+          !('amount' in entry.sourceToken) &&
+          !('valuation' in entry.sourceToken) &&
+          entry.sourceToken.logoUri === undefined &&
+          entry.sourceToken.verified === undefined,
+      ),
+    ).toBe(true)
 
     const includedResponse = await client.v1.transfers.$get(
-      { query: { limit: '5', include: 'token' } },
+      { query: { limit: '5', include: 'token.logoUri,token.verified' } },
       TestApp.auth,
     )
     const included = await TestApp.json(includedResponse, Transfers.schema.getTransfers.Response)
 
     expect(includedResponse.status).toBe(200)
-    // Each `sourceToken` keeps its `address`/`amount`; when metadata resolves
-    // it is spread alongside. Resolution is best-effort, so a row whose
-    // metadata is unavailable simply omits the metadata fields.
+    // Curated fields remain optional without moving quantities back into the token.
     expect(
       included.data.every(
         (entry) =>
           /^0x[0-9a-f]{40}$/.test(entry.sourceToken.address) &&
-          /^\d+$/.test(entry.sourceToken.amount) &&
-          (entry.sourceToken.symbol === undefined ||
-            (typeof entry.sourceToken.symbol === 'string' &&
-              Number.isInteger(entry.sourceToken.decimals))),
+          /^\d+$/.test(entry.sourceAmount.baseUnits) &&
+          !('amount' in entry.sourceToken) &&
+          !('valuation' in entry.sourceToken) &&
+          typeof entry.sourceToken.symbol === 'string' &&
+          Number.isInteger(entry.sourceToken.decimals) &&
+          typeof entry.sourceToken.verified === 'boolean',
       ),
     ).toBe(true)
   })
@@ -74,24 +157,156 @@ describe('GET /transfers', () => {
 
   test('narrows transfers by address (either side)', async () => {
     const client = TestApp.client()
-    // Seed a real account from a recent transfer.
-    const seedResponse = await client.v1.transfers.$get({ query: { limit: '5' } }, TestApp.auth)
-    const seed = await TestApp.json(seedResponse, Transfers.schema.getTransfers.Response)
-    expect(seedResponse.status).toBe(200)
-    const account = seed.data[0]!.sender
-    expect(account).toMatch(/^0x[0-9a-f]{40}$/)
-
-    const filteredResponse = await client.v1.transfers.$get(
-      { query: { limit: '5', address: account } },
+    const runtime = Runtime.get()
+    const address = Schema.Address.parse(
+      runtime.mode === 'testnet'
+        ? '0xb1f382bd6deed37895528a6387bae4cd9569ac3c'
+        : runtime.fixtures!.fundedAccounts[0]!,
+    )
+    const response = await client.v1.transfers.$get(
+      { query: { address, include: 'totalCount', limit: '10' } },
       TestApp.auth,
     )
-    const filtered = await TestApp.json(filteredResponse, Transfers.schema.getTransfers.Response)
-    expect(filteredResponse.status).toBe(200)
+    const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+    expect(response.status).toBe(200)
     expect(
-      filtered.data.every((entry) => entry.sender === account || entry.recipient === account),
+      body.data.every((entry) => entry.sender === address || entry.recipient === address),
     ).toBe(true)
+    expect(body.meta!.totalCount).toBeGreaterThanOrEqual(body.data.length)
+    expect(body.meta!.totalCountCapped).toBe(body.meta!.totalCount! >= Schema.countCap)
   })
 
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'merges both address sides before paginating',
+    async () => {
+      const client = TestApp.client()
+      const address = '0xabb0023644c54a20d0fe92becfa764dacaf59ba9'
+      const toBlock = '27608730'
+      const [senderResponse, recipientResponse, addressResponse] = await Promise.all([
+        client.v1.transfers.$get(
+          {
+            query: { 'blockNumber.to': toBlock, limit: '10', order: 'desc', sender: address },
+          },
+          TestApp.auth,
+        ),
+        client.v1.transfers.$get(
+          {
+            query: { 'blockNumber.to': toBlock, limit: '10', order: 'desc', recipient: address },
+          },
+          TestApp.auth,
+        ),
+        client.v1.transfers.$get(
+          {
+            query: { address, 'blockNumber.to': toBlock, limit: '10', order: 'desc' },
+          },
+          TestApp.auth,
+        ),
+      ])
+      const sender = await TestApp.json(senderResponse, Transfers.schema.getTransfers.Response)
+      const recipient = await TestApp.json(
+        recipientResponse,
+        Transfers.schema.getTransfers.Response,
+      )
+      const combined = await TestApp.json(addressResponse, Transfers.schema.getTransfers.Response)
+
+      expect([senderResponse.status, recipientResponse.status, addressResponse.status]).toEqual([
+        200, 200, 200,
+      ])
+      const seen = new Set<string>()
+      const expected = [...sender.data, ...recipient.data]
+        .sort((a, b) => b.blockNumber - a.blockNumber || b.logIndex - a.logIndex)
+        .filter((entry) => {
+          if (seen.has(entry.id)) return false
+          seen.add(entry.id)
+          return true
+        })
+        .slice(0, 10)
+      expect(expected).toHaveLength(10)
+      expect(combined.data.map(({ id }) => id)).toEqual(expected.map(({ id }) => id))
+
+      const firstResponse = await client.v1.transfers.$get(
+        {
+          query: { address, 'blockNumber.to': toBlock, limit: '5', order: 'desc' },
+        },
+        TestApp.auth,
+      )
+      const first = await TestApp.json(firstResponse, Transfers.schema.getTransfers.Response)
+      expect(firstResponse.status).toBe(200)
+      expect(first.nextCursor).not.toBeNull()
+      if (!first.nextCursor) return
+
+      const [cursorResponse, positionalResponse] = await Promise.all([
+        client.v1.transfers.$get(
+          {
+            query: {
+              address,
+              'blockNumber.to': toBlock,
+              cursor: first.nextCursor,
+              limit: '5',
+              order: 'desc',
+            },
+          },
+          TestApp.auth,
+        ),
+        client.v1.transfers.$get(
+          {
+            query: {
+              address,
+              'blockNumber.to': toBlock,
+              limit: '5',
+              order: 'desc',
+              page: '2',
+            },
+          },
+          TestApp.auth,
+        ),
+      ])
+      const cursor = await TestApp.json(cursorResponse, Transfers.schema.getTransfers.Response)
+      const positional = await TestApp.json(
+        positionalResponse,
+        Transfers.schema.getTransfers.Response,
+      )
+      const expectedSecondPage = expected.slice(5, 10).map(({ id }) => id)
+
+      expect([cursorResponse.status, positionalResponse.status]).toEqual([200, 200])
+      expect([...first.data, ...cursor.data].map(({ id }) => id)).toEqual(
+        expected.map(({ id }) => id),
+      )
+      expect(positional.data.map(({ id }) => id)).toEqual(expectedSecondPage)
+    },
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'deduplicates self-transfers in address pages and counts',
+    async () => {
+      const client = TestApp.client()
+      const address = '0xabb0023644c54a20d0fe92becfa764dacaf59ba9'
+      const transactionHash = '0x915a11bcf4b5e667c631f9fb09ac8729f3b436f24eb0b552e54ec13a490ef57f'
+      const response = await client.v1.transfers.$get(
+        {
+          query: {
+            address,
+            'blockNumber.from': '27608730',
+            'blockNumber.to': '27608730',
+            include: 'totalCount',
+            limit: '50',
+            token: '0x20c0000000000000000000000000000000000003',
+          },
+        },
+        TestApp.auth,
+      )
+      const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+      expect(response.status).toBe(200)
+      expect(body.data.filter(({ id }) => id === `${transactionHash}-233`)).toHaveLength(1)
+      expect(body.meta).toMatchObject({
+        totalCount: body.data.length,
+        totalCountCapped: false,
+      })
+    },
+  )
+
   test('narrows transfers by sender and recipient independently', async () => {
     const client = TestApp.client()
     const seedResponse = await client.v1.transfers.$get({ query: { limit: '5' } }, TestApp.auth)
@@ -147,6 +362,9 @@ describe('GET /transfers', () => {
     const second = await TestApp.json(secondResponse, Transfers.schema.getTransfers.Response)
 
     expect(secondResponse.status).toBe(200)
+    expect(secondResponse.headers.get('cache-control')).toMatchInlineSnapshot(
+      `"private, max-age=60, stale-while-revalidate=300"`,
+    )
     expect(second.data.length).toBeGreaterThan(0)
     // Each row's identity on the unscoped feed is `(blockNumber, txHash,
     // sourceToken, sender, recipient, amount)` — a single transaction can
@@ -154,7 +372,7 @@ describe('GET /transfers', () => {
     // `(txHash, blockNumber)` shortcut is not unique here.
     type Entry = z.output<typeof Transfers.schema.getTransfers.Transfer>
     const keyOf = (entry: Entry) =>
-      `${entry.blockNumber}:${entry.transactionHash}:${entry.sourceToken.address}:${entry.sender}:${entry.recipient}:${entry.sourceToken.amount}`
+      `${entry.blockNumber}:${entry.transactionHash}:${entry.sourceToken.address}:${entry.sender}:${entry.recipient}:${entry.sourceAmount.baseUnits}`
     const firstKeys = new Set(first.data.map(keyOf))
     expect(second.data.every((entry) => !firstKeys.has(keyOf(entry)))).toBe(true)
   })
@@ -202,7 +420,7 @@ describe('GET /transfers', () => {
 
     type Entry = z.output<typeof Transfers.schema.getTransfers.Transfer>
     const keyOf = (entry: Entry) =>
-      `${entry.blockNumber}:${entry.transactionHash}:${entry.sourceToken.address}:${entry.sender}:${entry.recipient}:${entry.sourceToken.amount}`
+      `${entry.blockNumber}:${entry.transactionHash}:${entry.sourceToken.address}:${entry.sender}:${entry.recipient}:${entry.sourceAmount.baseUnits}`
     expect(page.data.map(keyOf)).toEqual(head.data.slice(5, 10).map(keyOf))
     // Offset pages still return a keyset cursor so clients can switch to deep
     // cursor traversal from a positional jump.
@@ -285,7 +503,7 @@ describe('GET /transfers', () => {
     expect(Number.isInteger(body.meta?.totalCount)).toBe(true)
     expect(body.meta!.totalCount).toBeGreaterThanOrEqual(body.data.length)
     expect(body.meta!.totalCount).toBeLessThanOrEqual(Schema.countCap)
-    expect(body.meta!.totalCountCapped).toBe(body.meta!.totalCount >= Schema.countCap)
+    expect(body.meta!.totalCountCapped).toBe(body.meta!.totalCount! >= Schema.countCap)
   })
 
   test('embeds a capped token-scoped total count on demand', async () => {
@@ -309,7 +527,7 @@ describe('GET /transfers', () => {
     expect(typeof body.meta?.totalCountCapped).toBe('boolean')
     // The count never exceeds the cap; `totalCountCapped` is set iff the cap was hit.
     expect(body.meta!.totalCount).toBeLessThanOrEqual(Schema.countCap)
-    expect(body.meta!.totalCountCapped).toBe(body.meta!.totalCount >= Schema.countCap)
+    expect(body.meta!.totalCountCapped).toBe(body.meta!.totalCount! >= Schema.countCap)
 
     // Without `include=totalCount`, the same page omits `meta` entirely and
     // does not run the count query.
@@ -319,7 +537,10 @@ describe('GET /transfers', () => {
     )
     const bare = await TestApp.json(bareResponse, Transfers.schema.getTransfers.Response)
     expect(bareResponse.status).toBe(200)
-    expect(bare.meta).toBeUndefined()
+    // Without the include, counts are omitted (`meta` carries at most rate
+    // provenance).
+    expect(bare.meta?.totalCount).toBeUndefined()
+    expect(bare.meta?.totalCountCapped).toBeUndefined()
     expect(bareResponse.headers.get('server-timing')?.includes('transfers_count;dur=')).toBe(false)
   })
 
@@ -351,6 +572,10 @@ describe('GET /transfers', () => {
       expect(transfer.recipient).toBe(crossToken.recipient)
       expect(transfer.sourceToken.address).toBe(crossToken.sourceToken)
       expect(transfer.destinationToken?.address).toBe(crossToken.destinationToken)
+      expect(transfer.sourceAmount.baseUnits).toMatch(/^\d+$/)
+      expect(transfer.destinationAmount?.baseUnits).toMatch(/^\d+$/)
+      expect('amount' in transfer.sourceToken).toBe(false)
+      expect('amount' in transfer.destinationToken!).toBe(false)
 
       // Without `include=crossToken`, the transaction stays as its raw per-log
       // legs (more than one row) and no row carries `destinationToken`.
@@ -422,6 +647,91 @@ describe('GET /transfers', () => {
     },
   )
 
+  test('values verified transfer legs in the default denomination', async () => {
+    const db = TestApp.database()
+    await TestApp.verifiedSeed(db, Runtime.get().chainId)
+    const client = TestApp.client({ db })
+
+    // pathUSD is curated USD, so its legs value at identity with no rates.
+    const response = await client.v1.transfers.$get(
+      { query: { limit: '5', token: TestApp.tokenWithHolders } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+    expect(response.status).toBe(200)
+    expect(body.data.length).toBeGreaterThan(0)
+    for (const entry of body.data)
+      expect(entry.sourceAmount.valuation).toEqual({
+        amount: core_Value.format(BigInt(entry.sourceAmount.baseUnits), 6),
+        currency: 'USD',
+      })
+    expect(body.meta?.pricing).toBeUndefined()
+  })
+
+  test('values transfer legs in a requested denomination', async () => {
+    const db = TestApp.database()
+    await TestApp.verifiedSeed(db, Runtime.get().chainId)
+    const client = TestApp.client({ db, fx: { oracle: fixed } })
+
+    // Denominations are case-insensitive.
+    const response = await client.v1.transfers.$get(
+      { query: { denomination: 'aud', limit: '5', token: TestApp.tokenWithHolders } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+    expect(response.status).toBe(200)
+    expect(body.data.length).toBeGreaterThan(0)
+    // USD -> AUD at the fixed 1.6 cross rate, floored to 6 dp.
+    for (const entry of body.data)
+      expect(entry.sourceAmount.valuation).toEqual({
+        amount: core_Value.format((BigInt(entry.sourceAmount.baseUnits) * 16n) / 10n, 6),
+        currency: 'AUD',
+      })
+    expect(body.meta?.pricing).toMatchInlineSnapshot(`
+      {
+        "asOf": "2026-01-01T00:00:00.000Z",
+        "basis": "nominal",
+        "source": "fixed",
+      }
+    `)
+  })
+
+  test.skipIf(Runtime.get().mode !== 'localnet')(
+    'nulls leg values for unverified tokens',
+    async () => {
+      // Curate only pathUSD so the faucet token queried below is unverified
+      // for this app, and its legs never value.
+      const db = TestApp.database()
+      await TestApp.verifiedSeed(db, Runtime.get().chainId, {
+        tokens: [
+          {
+            address: TestApp.tokenWithHolders,
+            currency: 'USD',
+            decimals: 6,
+            name: 'PathUSD',
+            symbol: 'pathUSD',
+          },
+        ],
+      })
+      const client = TestApp.client({ db })
+
+      const token = Runtime.get().fixtures!.transferTokenAddresses.find(
+        (address) => address.toLowerCase() !== TestApp.tokenWithHolders,
+      )!
+      const response = await client.v1.transfers.$get(
+        { query: { limit: '5', token } },
+        TestApp.auth,
+      )
+      const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+      expect(response.status).toBe(200)
+      expect(body.data.length).toBeGreaterThan(0)
+      for (const entry of body.data) expect(entry.sourceAmount.valuation).toBeNull()
+    },
+  )
+
   test('surfaces a 502 when transfer data is unavailable', async () => {
     // Point at an unreachable indexer so the upstream query fails deterministically.
     const client = TestApp.client({ tidx: { baseUrl: 'http://127.0.0.1:1' } })