tapimo 0.9.0 → 0.10.0

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

@@ -8,6 +8,7 @@ import { Addresses } from 'viem/tempo'
 
 import * as TestApp from '../../../../test/App.js'
 import * as Runtime from '../../../../test/runtime.js'
+import * as Tidx from '../../../internal/Tidx.js'
 import * as Transfers from './transfers.js'
 
 // Deterministic EUR-based rate set so conversion math is exact in assertions.
@@ -79,6 +80,35 @@ describe('GET /transfers', () => {
     },
   )
 
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'returns an empty page for an address with only non-TIP-20 events',
+    async () => {
+      const client = TestApp.client({
+        tidx: { auth: process.env.TIDX_AUTH, baseUrl: Tidx.url[4217] },
+      })
+      const response = await client.v1.transfers.$get(
+        {
+          query: {
+            address: '0x9ef044cb9b80230b60a46b4ed3958672419e668f',
+            chainId: '4217',
+            limit: '10',
+            page: '1',
+          },
+        },
+        TestApp.auth,
+      )
+      const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+      expect(response.status).toBe(200)
+      expect(body).toMatchInlineSnapshot(`
+        {
+          "data": [],
+          "nextCursor": null,
+        }
+      `)
+    },
+  )
+
   test('degrades unavailable verification data to null valuations', async () => {
     const db = () =>
       Db.postgres({
@@ -87,7 +117,13 @@ describe('GET /transfers', () => {
     const client = TestApp.client({ db, fx: { oracle: fixed } })
 
     const response = await client.v1.transfers.$get(
-      { query: { limit: '5', token: TestApp.tokenWithHolders } },
+      {
+        query: {
+          limit: '5',
+          token: TestApp.tokenWithHolders,
+          'valuation.currency': 'USD',
+        },
+      },
       TestApp.auth,
     )
     const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
@@ -383,6 +419,87 @@ describe('GET /transfers', () => {
     expect(byRecipient.data.every((entry) => entry.recipient === recipient)).toBe(true)
   })
 
+  test('paginates recipient scans through the real indexer', async () => {
+    const runtime = Runtime.get()
+    const recipient = Schema.Address.parse(
+      runtime.mode === 'testnet'
+        ? '0xabb0023644c54a20d0fe92becfa764dacaf59ba9'
+        : runtime.fixtures!.fundedAccounts[0]!,
+    )
+    const tidx = Tidx.getClient({
+      chainId: runtime.chainId,
+      tidx:
+        runtime.mode === 'localnet'
+          ? { baseUrl: runtime.tidxUrl }
+          : { auth: process.env.TIDX_AUTH, baseUrl: runtime.tidxUrl },
+    })
+    const bounds = runtime.mode === 'testnet' ? { toBlock: 27_608_730 } : {}
+    const reference = await Transfers.scan(
+      { tidx },
+      { chainId: runtime.chainId, limit: 2, order: 'desc', recipient, ...bounds },
+    )
+    const first = await Transfers.scan(
+      { tidx },
+      { chainId: runtime.chainId, limit: 1, order: 'desc', recipient, ...bounds },
+    )
+
+    expect(reference.items).toHaveLength(2)
+    expect(first.items).toHaveLength(1)
+    expect(first.nextCursor).not.toBeNull()
+    if (!first.nextCursor) return
+
+    const [cursor, positional] = await Promise.all([
+      Transfers.scan(
+        { tidx },
+        {
+          chainId: runtime.chainId,
+          cursor: first.nextCursor,
+          limit: 1,
+          order: 'desc',
+          recipient,
+          ...bounds,
+        },
+      ),
+      Transfers.scan(
+        { tidx },
+        { chainId: runtime.chainId, limit: 1, order: 'desc', page: 2, recipient, ...bounds },
+      ),
+    ])
+    const ids = (page: Transfers.scan.Page) =>
+      page.items.map(({ data }) => `${data.transactionHash}-${data.logIndex}`)
+    const [sameAddress, senderAddress] = await Promise.all([
+      Transfers.scan(
+        { tidx },
+        {
+          chainId: runtime.chainId,
+          eitherSide: recipient,
+          limit: 2,
+          order: 'desc',
+          recipient,
+          ...bounds,
+        },
+      ),
+      Transfers.scan(
+        { tidx },
+        {
+          chainId: runtime.chainId,
+          eitherSide: first.items[0]!.data.sender,
+          limit: 1,
+          order: 'desc',
+          recipient,
+          ...bounds,
+        },
+      ),
+    ])
+
+    expect(ids(first)).toEqual(ids(reference).slice(0, 1))
+    expect(ids(cursor)).toEqual(ids(reference).slice(1, 2))
+    expect(ids(positional)).toEqual(ids(reference).slice(1, 2))
+    expect(ids(sameAddress)).toEqual(ids(reference))
+    expect(ids(senderAddress)).toEqual(ids(first))
+    expect([...reference.items, ...cursor.items, ...positional.items].every(({ data }) => data.recipient === recipient && data.address.startsWith('0x20c'))).toBe(true) // prettier-ignore
+  })
+
   test('rejects mixing `address` with `sender` or `recipient`', async () => {
     const client = TestApp.client()
     const response = await client.v1.transfers.$get(
@@ -640,7 +757,7 @@ describe('GET /transfers', () => {
   )
 
   test.skipIf(Runtime.get().mode !== 'localnet')(
-    'counts unscoped cross-token transfers',
+    'counts address-scoped cross-token transfers',
     async () => {
       const crossToken = Runtime.get().fixtures?.crossTokenTransfer
       expect(crossToken).toBeDefined()
@@ -652,7 +769,7 @@ describe('GET /transfers', () => {
           query: {
             address: crossToken.sender,
             include: 'crossToken,totalCount',
-            limit: '50',
+            limit: '200',
           },
         },
         TestApp.auth,
@@ -661,9 +778,72 @@ describe('GET /transfers', () => {
 
       expect(response.status).toBe(200)
       expect(response.headers.get('server-timing')?.includes('transfers_count;dur=')).toBe(true)
-      expect(body.data.some((entry) => entry.transactionHash === crossToken.hash)).toBe(true)
-      expect(body.meta).toBeDefined()
-      expect(body.meta!.totalCount).toBeGreaterThanOrEqual(body.data.length)
+      expect(body.data.filter((entry) => entry.transactionHash === crossToken.hash)).toHaveLength(1)
+      expect(body.nextCursor).toBeNull()
+      expect(body.meta).toMatchObject({
+        totalCount: body.data.length,
+        totalCountCapped: false,
+      })
+    },
+  )
+
+  test.skipIf(Runtime.get().mode !== 'localnet')(
+    'applies address page offsets after merging both sides',
+    async () => {
+      const address = Runtime.get().fixtures?.crossTokenTransfer?.sender
+      expect(address).toBeDefined()
+      if (!address) return
+
+      const client = TestApp.client()
+      const [referenceResponse, firstResponse, secondResponse] = await Promise.all([
+        client.v1.transfers.$get({ query: { address, limit: '10' } }, TestApp.auth),
+        client.v1.transfers.$get({ query: { address, limit: '5' } }, TestApp.auth),
+        client.v1.transfers.$get({ query: { address, limit: '5', page: '2' } }, TestApp.auth),
+      ])
+      const reference = await TestApp.json(
+        referenceResponse,
+        Transfers.schema.getTransfers.Response,
+      )
+      const first = await TestApp.json(firstResponse, Transfers.schema.getTransfers.Response)
+      const second = await TestApp.json(secondResponse, Transfers.schema.getTransfers.Response)
+
+      expect([referenceResponse.status, firstResponse.status, secondResponse.status]).toEqual([
+        200, 200, 200,
+      ])
+      expect(reference.data).toHaveLength(10)
+      expect(first.data.map(({ id }) => id)).toEqual(reference.data.slice(0, 5).map(({ id }) => id))
+      expect(second.data.map(({ id }) => id)).toEqual(
+        reference.data.slice(5, 10).map(({ id }) => id),
+      )
+    },
+  )
+
+  test.skipIf(Runtime.get().mode !== 'localnet')(
+    'counts address-scoped plumbing from complete cross-token legs',
+    async () => {
+      const crossToken = Runtime.get().fixtures?.crossTokenTransfer
+      expect(crossToken).toBeDefined()
+      if (!crossToken) return
+
+      const client = TestApp.client()
+      const response = await client.v1.transfers.$get(
+        {
+          query: {
+            address: Addresses.stablecoinDex,
+            include: 'crossToken,totalCount',
+            limit: '50',
+          },
+        },
+        TestApp.auth,
+      )
+      const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+      expect(response.status).toBe(200)
+      expect(body.data.some((entry) => entry.transactionHash === crossToken.hash)).toBe(false)
+      expect(body.meta).toMatchObject({
+        totalCount: body.data.length,
+        totalCountCapped: false,
+      })
     },
   )
 
@@ -694,12 +874,11 @@ describe('GET /transfers', () => {
     },
   )
 
-  test('values verified transfer legs in the default denomination', async () => {
+  test('omits transfer valuations unless a denomination is requested', 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,
@@ -708,12 +887,9 @@ describe('GET /transfers', () => {
 
     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',
-      })
+    for (const entry of body.data) expect('valuation' in entry.sourceAmount).toBe(false)
     expect(body.meta?.valuation).toBeUndefined()
+    expect(response.headers.get('server-timing')).not.toContain('valuation_rates;dur=')
   })
 
   test('values transfer legs in a requested denomination', async () => {
@@ -774,7 +950,7 @@ describe('GET /transfers', () => {
         (address) => address.toLowerCase() !== TestApp.tokenWithHolders,
       )!
       const response = await client.v1.transfers.$get(
-        { query: { limit: '5', token } },
+        { query: { limit: '5', token, 'valuation.currency': 'USD' } },
         TestApp.auth,
       )
       const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
@@ -803,6 +979,96 @@ describe('GET /transfers', () => {
       }
     `)
   })
+
+  test('bounds an unscoped transfer page by timestamp', async () => {
+    const client = TestApp.client()
+    const runtime = Runtime.get()
+    const tidx = Tidx.getClient({
+      chainId: runtime.chainId,
+      tidx:
+        runtime.mode === 'localnet'
+          ? { baseUrl: runtime.tidxUrl }
+          : { auth: process.env.TIDX_AUTH, baseUrl: runtime.tidxUrl },
+    })
+    const latest = await Transfers.scan(
+      { tidx },
+      { chainId: runtime.chainId, limit: 1, order: 'desc' },
+    )
+    const latestTransfer = latest.items[0]?.data
+    if (latestTransfer === undefined) throw new Error('expected an indexed transfer')
+
+    const block = await tidx.fetch({
+      chainId: runtime.chainId,
+      query: `SELECT timestamp FROM blocks WHERE num = ${latestTransfer.blockNumber} LIMIT 1`,
+    })
+    const seconds = block.rows[0]?.['timestamp']
+    if (typeof seconds !== 'number') throw new Error('expected an indexed block timestamp')
+    const timestamp = new Date(seconds * 1_000).toISOString()
+    const response = await client.v1.transfers.$get(
+      {
+        query: {
+          limit: '5',
+          order: 'desc',
+          'timestamp.from': timestamp,
+          'timestamp.to': timestamp,
+        },
+      },
+      TestApp.auth,
+    )
+    const page = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+    expect(response.status).toBe(200)
+    expect(page.data.length).toBeGreaterThan(0)
+    expect(page.data.every((item) => Date.parse(item.timestamp) === Date.parse(timestamp))).toBe(
+      true,
+    )
+
+    const fractionalResponse = await client.v1.transfers.$get(
+      {
+        query: {
+          limit: '5',
+          order: 'desc',
+          'timestamp.from': new Date(seconds * 1_000 + 500).toISOString(),
+          'timestamp.to': new Date(seconds * 1_000 + 999).toISOString(),
+        },
+      },
+      TestApp.auth,
+    )
+    const fractional = await TestApp.json(
+      fractionalResponse,
+      Transfers.schema.getTransfers.Response,
+    )
+
+    expect(fractionalResponse.status).toBe(200)
+    expect(fractional.data).toEqual([])
+
+    const emptyResponse = await client.v1.transfers.$get(
+      {
+        query: {
+          limit: '5',
+          order: 'desc',
+          'timestamp.to': '1970-01-01T00:00:00Z',
+        },
+      },
+      TestApp.auth,
+    )
+    const empty = await TestApp.json(emptyResponse, Transfers.schema.getTransfers.Response)
+
+    expect(emptyResponse.status).toBe(200)
+    expect(empty.data).toEqual([])
+  })
+
+  test('keeps the largest positional window within the indexer row limit', async () => {
+    const client = TestApp.client()
+    const response = await client.v1.transfers.$get(
+      { query: { limit: '200', order: 'desc', page: '50' } },
+      TestApp.auth,
+    )
+    const page = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+    expect(response.status).toBe(200)
+    expect(page.data.length).toBeLessThanOrEqual(200)
+  })
 })
 
 describe('collate', () => {
@@ -816,7 +1082,11 @@ describe('collate', () => {
   test('passes a lone engine-paged stream through untouched', () => {
     const rows = [row(40, 4), row(20, 2)]
     expect(
-      Transfers.collate([{ rows, sample: false }], { limit: 3, offset: 0, order: 'desc' }),
+      Transfers.collate([{ capped: false, rows, sample: false }], {
+        limit: 3,
+        offset: 0,
+        order: 'desc',
+      }),
     ).toEqual({
       capped: false,
       rows,
@@ -827,8 +1097,8 @@ describe('collate', () => {
     const shared = row(30, 3)
     const { capped, rows } = Transfers.collate(
       [
-        { rows: [row(40, 4), shared], sample: false },
-        { rows: [{ ...shared }, row(10, 1)], sample: false },
+        { capped: false, rows: [row(40, 4), shared], sample: false },
+        { capped: false, rows: [{ ...shared }, row(10, 1)], sample: false },
       ],
       { limit: 2, offset: 1, order: 'desc' },
     )
@@ -837,21 +1107,92 @@ describe('collate', () => {
   })
 
   test('orders and pages a below-cap fallback sample', () => {
-    const { capped, rows } = Transfers.collate([{ rows: [row(10, 1), row(30, 3)], sample: true }], {
-      limit: 2,
-      offset: 0,
-      order: 'desc',
-    })
+    const { capped, rows } = Transfers.collate(
+      [{ capped: false, rows: [row(10, 1), row(30, 3)], sample: true }],
+      { limit: 2, offset: 0, order: 'desc' },
+    )
     expect(capped).toBe(false)
     expect(rows.map((entry) => entry['block_num'])).toEqual([30, 10])
   })
 
+  test('preserves the cap marker on an ordered stream', () => {
+    const rows = [row(30, 3), row(10, 1)]
+    expect(
+      Transfers.collate([{ capped: true, rows, sample: false }], {
+        limit: 2,
+        offset: 0,
+        order: 'desc',
+      }),
+    ).toEqual({ capped: true, rows })
+  })
+
+  test('preserves resumable progress on a lone ordered stream', () => {
+    const rows = [row(30, 3), row(10, 1)]
+    const resume = { offset: 4, position: [10, 1] as const }
+    expect(
+      Transfers.collate([{ capped: true, resume, rows, sample: false }], {
+        limit: 2,
+        offset: 0,
+        order: 'desc',
+      }),
+    ).toEqual({ capped: true, resume, rows })
+  })
+
+  test('preserves common resumable progress across split ordered streams', () => {
+    const result = Transfers.collate(
+      [
+        {
+          capped: true,
+          resume: { offset: 0, position: [20, 2] },
+          rows: [row(50, 5), row(30, 3)],
+          sample: false,
+        },
+        {
+          capped: true,
+          resume: { offset: 0, position: [25, 2] },
+          rows: [row(45, 4), row(25, 2)],
+          sample: false,
+        },
+      ],
+      { limit: 5, offset: 1, order: 'desc' },
+    )
+    expect(result).toEqual({
+      capped: true,
+      resume: { offset: 0, position: [25, 2] },
+      rows: [row(45, 4), row(30, 3), row(25, 2)],
+    })
+  })
+
+  test('returns a complete split window before the common resume point', () => {
+    const result = Transfers.collate(
+      [
+        {
+          capped: true,
+          resume: { offset: 0, position: [20, 2] },
+          rows: [row(50, 5), row(30, 3)],
+          sample: false,
+        },
+        {
+          capped: true,
+          resume: { offset: 0, position: [25, 2] },
+          rows: [row(45, 4), row(25, 2)],
+          sample: false,
+        },
+      ],
+      { limit: 3, offset: 0, order: 'desc' },
+    )
+    expect(result).toEqual({
+      capped: false,
+      rows: [row(50, 5), row(45, 4), row(30, 3)],
+    })
+  })
+
   test('flags a fallback sample that hit the cap', () => {
     const sample = Array.from({ length: Schema.countCap }, (_, index) => row(index + 1, index))
     const { capped, rows } = Transfers.collate(
       [
-        { rows: [row(40_000, 20_000)], sample: false },
-        { rows: sample, sample: true },
+        { capped: false, rows: [row(40_000, 20_000)], sample: false },
+        { capped: true, rows: sample, sample: true },
       ],
       { limit: 3, offset: 0, order: 'desc' },
     )
@@ -893,6 +1234,43 @@ describe('foldCount', () => {
     })
   })
 
+  test('classifies filtered plumbing rows from complete transaction legs', () => {
+    const txHash = `0x${'dd'.repeat(32)}`
+    const rows = [
+      leg(txHash, 0, swapper, Addresses.stablecoinDex, sourceToken),
+      leg(txHash, 1, Addresses.stablecoinDex, swapper, destinationToken),
+      leg(txHash, 2, swapper, recipient, destinationToken),
+      leg(txHash, 3, swapper, Addresses.feeManager, sourceToken),
+    ]
+    expect(
+      Transfers.foldCount(rows.slice(0, 2), { capped: false, classificationRows: rows }),
+    ).toEqual({
+      totalCount: 0,
+      totalCountCapped: false,
+    })
+  })
+
+  test('uses log order when classifying complete transaction legs', () => {
+    const txHash = `0x${'dd'.repeat(32)}`
+    const thirdToken = '0x20c0000000000000000000000000000000000003'
+    const rows = [
+      leg(txHash, 1, swapper, Addresses.stablecoinDex, sourceToken),
+      leg(txHash, 4, Addresses.stablecoinDex, swapper, destinationToken),
+      leg(txHash, 5, swapper, Addresses.stablecoinDex, destinationToken),
+      leg(txHash, 7, Addresses.stablecoinDex, swapper, thirdToken),
+    ]
+    const delivery = leg(txHash, 8, swapper, recipient, thirdToken)
+    expect(
+      Transfers.foldCount(rows, {
+        capped: false,
+        classificationRows: [rows[2]!, rows[3]!, delivery, rows[0]!, rows[1]!],
+      }),
+    ).toEqual({
+      totalCount: 4,
+      totalCountCapped: false,
+    })
+  })
+
   test('keeps a cap-truncated sample conservative', () => {
     const txHash = `0x${'dd'.repeat(32)}`
     // A partial bundle: the DEX return leg fell outside the cap, defeating