tapimo 0.0.0 → 0.0.2

package/src/apps/transfers.test.ts

@@ -0,0 +1,371 @@
+import type * as z from 'zod/mini'
+import { Schema } from 'cadent'
+
+import * as TestApp from '../../test/App.js'
+import * as Runtime from '../../test/runtime.js'
+import * as Transfers from './transfers.js'
+
+describe('GET /transfers', () => {
+  test('returns an unscoped transfer page, embedding tokens on demand', 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)
+
+    expect(baseResponse.status).toBe(200)
+    expect(baseResponse.headers.get('server-timing')?.includes('transfers;dur=')).toBe(true)
+    expect(Array.isArray(base.data)).toBe(true)
+    expect(base.data.length).toBeLessThanOrEqual(5)
+    // Pagination fields stay at the response root; cursor pagination has no
+    // `page`, just an opaque `nextCursor`.
+    expect('page' in base).toBe(false)
+    expect(base.nextCursor === null || typeof base.nextCursor === 'string').toBe(true)
+    expect(
+      base.data.every(
+        (entry) =>
+          /^0x[0-9a-f]{40}$/.test(entry.sourceToken.address) &&
+          /^\d+$/.test(entry.sourceToken.amount) &&
+          Number.isInteger(entry.blockNumber) &&
+          /^0x[0-9a-f]{40}$/.test(entry.sender) &&
+          /^0x[0-9a-f]{40}$/.test(entry.recipient) &&
+          /^0x[0-9a-f]{64}$/.test(entry.transactionHash) &&
+          !Number.isNaN(Date.parse(entry.timestamp)),
+      ),
+    ).toBe(true)
+    // 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)
+
+    const includedResponse = await client.v1.transfers.$get(
+      { query: { limit: '5', include: 'token' } },
+      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.
+    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))),
+      ),
+    ).toBe(true)
+  })
+
+  test('narrows transfers to a single token', async () => {
+    const client = TestApp.client()
+    const response = await client.v1.transfers.$get(
+      { query: { limit: '5', token: TestApp.token } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+    expect(response.status).toBe(200)
+    expect(body.data.every((entry) => entry.sourceToken.address === TestApp.token)).toBe(true)
+  })
+
+  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 } },
+      TestApp.auth,
+    )
+    const filtered = await TestApp.json(filteredResponse, Transfers.schema.getTransfers.Response)
+    expect(filteredResponse.status).toBe(200)
+    expect(
+      filtered.data.every((entry) => entry.sender === account || entry.recipient === account),
+    ).toBe(true)
+  })
+
+  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)
+    const seed = await TestApp.json(seedResponse, Transfers.schema.getTransfers.Response)
+    expect(seedResponse.status).toBe(200)
+    const { sender, recipient } = seed.data[0]!
+    expect(sender).toMatch(/^0x[0-9a-f]{40}$/)
+    expect(recipient).toMatch(/^0x[0-9a-f]{40}$/)
+
+    const bySenderResponse = await client.v1.transfers.$get(
+      { query: { limit: '5', sender } },
+      TestApp.auth,
+    )
+    const bySender = await TestApp.json(bySenderResponse, Transfers.schema.getTransfers.Response)
+    expect(bySenderResponse.status).toBe(200)
+    expect(bySender.data.every((entry) => entry.sender === sender)).toBe(true)
+
+    const byRecipientResponse = await client.v1.transfers.$get(
+      { query: { limit: '5', recipient } },
+      TestApp.auth,
+    )
+    const byRecipient = await TestApp.json(
+      byRecipientResponse,
+      Transfers.schema.getTransfers.Response,
+    )
+    expect(byRecipientResponse.status).toBe(200)
+    expect(byRecipient.data.every((entry) => entry.recipient === recipient)).toBe(true)
+  })
+
+  test('rejects mixing `address` with `sender` or `recipient`', async () => {
+    const client = TestApp.client()
+    const response = await client.v1.transfers.$get(
+      { query: { address: TestApp.token, sender: TestApp.token } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+
+    expect(response.status).toMatchInlineSnapshot(`400`)
+    expect(body.error.code).toMatchInlineSnapshot(`"query_invalid"`)
+  })
+
+  test('walks the cursor to a disjoint next page', async () => {
+    const client = TestApp.client()
+    const firstResponse = await client.v1.transfers.$get({ query: { limit: '5' } }, TestApp.auth)
+    const first = await TestApp.json(firstResponse, Transfers.schema.getTransfers.Response)
+    expect(firstResponse.status).toBe(200)
+    if (!first.nextCursor) return
+
+    const secondResponse = await client.v1.transfers.$get(
+      { query: { limit: '5', cursor: first.nextCursor } },
+      TestApp.auth,
+    )
+    const second = await TestApp.json(secondResponse, Transfers.schema.getTransfers.Response)
+
+    expect(secondResponse.status).toBe(200)
+    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
+    // emit transfers across multiple contracts, so the per-token feed's
+    // `(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}`
+    const firstKeys = new Set(first.data.map(keyOf))
+    expect(second.data.every((entry) => !firstKeys.has(keyOf(entry)))).toBe(true)
+  })
+
+  test('rejects invalid timestamp bounds', async () => {
+    const client = TestApp.client()
+    const response = await client.v1.transfers.$get(
+      { query: { 'timestamp.from': 'not-a-timestamp' } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+
+    expect(response.status).toMatchInlineSnapshot(`400`)
+    expect(body.error.code).toMatchInlineSnapshot(`"query_invalid"`)
+  })
+
+  test('rejects invalid pagination', async () => {
+    const client = TestApp.client()
+    const response = await client.v1.transfers.$get({ query: { limit: '0' } }, TestApp.auth)
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+
+    expect(response.status).toMatchInlineSnapshot(`400`)
+    expect(body.error.code).toMatchInlineSnapshot(`"query_invalid"`)
+  })
+
+  test('serves a bounded positional page via `page`', async () => {
+    const client = TestApp.client()
+    // Ascending order anchors the feed at the first indexed transfer, so
+    // positional pages are deterministic: the offset page must equal the
+    // matching slice of the head page.
+    const headResponse = await client.v1.transfers.$get(
+      { query: { limit: '10', order: 'asc' } },
+      TestApp.auth,
+    )
+    const head = await TestApp.json(headResponse, Transfers.schema.getTransfers.Response)
+    expect(headResponse.status).toBe(200)
+    expect(head.data.length).toBe(10)
+
+    const offsetResponse = await client.v1.transfers.$get(
+      { query: { limit: '5', order: 'asc', page: '2' } },
+      TestApp.auth,
+    )
+    const page = await TestApp.json(offsetResponse, Transfers.schema.getTransfers.Response)
+    expect(offsetResponse.status).toBe(200)
+
+    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}`
+    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.
+    expect(typeof page.nextCursor).toBe('string')
+  })
+
+  test('rejects `page` combined with `cursor`', async () => {
+    const client = TestApp.client()
+    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)
+    if (!seed.nextCursor) return
+
+    const response = await client.v1.transfers.$get(
+      { query: { cursor: seed.nextCursor, page: '2' } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+
+    expect(response.status).toMatchInlineSnapshot(`400`)
+    expect(body.error.code).toMatchInlineSnapshot(`"query_invalid"`)
+  })
+
+  test('rejects a page window beyond the bounded cap', async () => {
+    const client = TestApp.client()
+    const response = await client.v1.transfers.$get(
+      { query: { limit: '20', page: '501' } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+
+    expect(response.status).toMatchInlineSnapshot(`400`)
+    expect(body.error.code).toMatchInlineSnapshot(`"query_invalid"`)
+  })
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'resolves memo and attribution on demand via include=memo',
+    async () => {
+      const client = TestApp.client()
+      // Real Moderato account that both sends and receives MPP-attributed
+      // transfers (memos prefixed with the attribution tag).
+      const account = '0xd92087abdc3af63b284b6cf8282061df5f0f7dda'
+      const response = await client.v1.transfers.$get(
+        { query: { address: account, include: 'memo', limit: '50' } },
+        TestApp.auth,
+      )
+      const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+      expect(response.status).toBe(200)
+      // At least one transfer carries a resolved MPP service name; attribution
+      // fingerprints are suppressed from the display `memo`, so any present
+      // memo is decoded text.
+      expect(
+        body.data.some((t) => typeof t.attribution === 'string' && t.attribution.length > 0),
+      ).toBe(true)
+      expect(body.data.every((t) => t.memo === undefined || typeof t.memo === 'string')).toBe(true)
+
+      // Without `include=memo`, the same page omits both fields.
+      const bareResponse = await client.v1.transfers.$get(
+        { query: { address: account, limit: '50' } },
+        TestApp.auth,
+      )
+      const bare = await TestApp.json(bareResponse, Transfers.schema.getTransfers.Response)
+      expect(bareResponse.status).toBe(200)
+      expect(bare.data.every((t) => t.attribution === undefined && t.memo === undefined)).toBe(true)
+    },
+  )
+
+  test('embeds a capped total count on demand via include=totalCount', async () => {
+    const client = TestApp.client()
+
+    if (Runtime.get().mode === 'localnet') expect(TestApp.token).toBeDefined()
+
+    // A token-scoped page: the count is the matched-row total, independent of
+    // the page `limit`, and surfaces under `meta` (not the pagination fields).
+    const response = await client.v1.transfers.$get(
+      { query: { token: TestApp.token, include: 'totalCount', limit: '5' } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+
+    expect(response.status).toBe(200)
+    expect(response.headers.get('server-timing')?.includes('transfers_count;dur=')).toBe(true)
+    expect(body.meta).toBeDefined()
+    expect(Number.isInteger(body.meta?.totalCount)).toBe(true)
+    expect(body.meta!.totalCount).toBeGreaterThanOrEqual(body.data.length)
+    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)
+
+    // Without `include=totalCount`, the same page omits `meta` entirely and
+    // does not run the count query.
+    const bareResponse = await client.v1.transfers.$get(
+      { query: { token: TestApp.token, limit: '5' } },
+      TestApp.auth,
+    )
+    const bare = await TestApp.json(bareResponse, Transfers.schema.getTransfers.Response)
+    expect(bareResponse.status).toBe(200)
+    expect(bare.meta).toBeUndefined()
+    expect(bareResponse.headers.get('server-timing')?.includes('transfers_count;dur=')).toBe(false)
+  })
+
+  test.skipIf(Runtime.get().mode !== 'localnet')(
+    'folds a cross-token transfer into one row via include=crossToken',
+    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: crossToken.sender, include: 'crossToken', limit: '50' } },
+        TestApp.auth,
+      )
+      const body = await TestApp.json(response, Transfers.schema.getTransfers.Response)
+      expect(response.status).toBe(200)
+      expect(response.headers.get('server-timing')?.includes('transfers_cross_token;dur=')).toBe(
+        true,
+      )
+
+      // The transaction's several transfer legs fold into a single row: the
+      // token swapped into the DEX becomes `sourceToken`, and the token
+      // delivered to the recipient becomes `destinationToken`.
+      const folded = body.data.filter((entry) => entry.transactionHash === crossToken.hash)
+      expect(folded.length).toBe(1)
+      const transfer = folded[0]!
+      expect(transfer.sender).toBe(crossToken.sender)
+      expect(transfer.recipient).toBe(crossToken.recipient)
+      expect(transfer.sourceToken.address).toBe(crossToken.sourceToken)
+      expect(transfer.destinationToken?.address).toBe(crossToken.destinationToken)
+
+      // Without `include=crossToken`, the transaction stays as its raw per-log
+      // legs (more than one row) and no row carries `destinationToken`.
+      const bareResponse = await client.v1.transfers.$get(
+        { query: { address: crossToken.sender, limit: '50' } },
+        TestApp.auth,
+      )
+      const bare = await TestApp.json(bareResponse, Transfers.schema.getTransfers.Response)
+      expect(bareResponse.status).toBe(200)
+      expect(
+        bare.data.filter((entry) => entry.transactionHash === crossToken.hash).length,
+      ).toBeGreaterThan(1)
+      expect(bare.data.every((entry) => entry.destinationToken === undefined)).toBe(true)
+    },
+  )
+
+  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' } })
+
+    const response = await client.v1.transfers.$get({ query: {} }, TestApp.auth)
+    const body = await TestApp.json(response, Schema.ErrorResponse)
+    const { requestId, error } = body
+    const { message, ...stableError } = error
+
+    expect(response.status).toMatchInlineSnapshot(`502`)
+    expect(typeof requestId).toMatchInlineSnapshot(`"string"`)
+    expect(typeof message).toMatchInlineSnapshot(`"string"`)
+    expect(stableError).toMatchInlineSnapshot(`
+      {
+        "code": "upstream_error",
+      }
+    `)
+  })
+})