tapimo 0.5.2 → 0.6.0

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

@@ -1,12 +1,20 @@
-import { Address, Hex } from 'ox'
+import { Address, Hex, Value as core_Value } from 'ox'
+import { FxOracle } from 'tapimo/apps'
 import { encodeAbiParameters, encodeEventTopics } from 'viem'
 import { Abis } from 'viem/tempo'
 
 import * as TestApp from '../../../../test/App.js'
 import * as Runtime from '../../../../test/runtime.js'
+import * as Cursor from '../../../internal/Cursor.js'
 import * as Store from '../../../internal/Store.js'
 import * as Activities from './activities.js'
 
+// Deterministic EUR-based rate set so conversion math is exact in assertions.
+const fixed = FxOracle.from({
+  name: 'fixed',
+  rates: async () => ({ asOf: '2026-01-01', base: 'EUR', rates: { AUD: '1.6', USD: '1.0' } }),
+})
+
 /**
  * Real Tempo (Moderato) accounts, each exercising specific activity types.
  * Discovered by scanning indexed `logs` for the event each type classifies
@@ -102,6 +110,32 @@ function find(items: readonly Activities.Entry[], type: string): Activities.Entr
 }
 
 describe('GET /addresses/:address/activities', () => {
+  test('parses granular token includes for both activity endpoints', () => {
+    expect(
+      Activities.schema.getAddressActivities.Query.parse({
+        include: 'token.logoUri,token.verified',
+      }).include,
+    ).toMatchInlineSnapshot(`
+      [
+        "token.logoUri",
+        "token.verified",
+      ]
+    `)
+    expect(
+      Activities.schema.getTransactionActivities.Query.parse({
+        include: 'token.logoUri,token.verified',
+      }).include,
+    ).toMatchInlineSnapshot(`
+      [
+        "token.logoUri",
+        "token.verified",
+      ]
+    `)
+    expect(
+      Activities.schema.getAddressActivities.Query.safeParse({ include: 'token' }).success,
+    ).toBe(false)
+  })
+
   test('returns a newest-first, schema-valid feed with timing', async () => {
     const response = await request(accounts.keychain, { limit: '10' })
     expect(response.status).toBe(200)
@@ -130,7 +164,31 @@ describe('GET /addresses/:address/activities', () => {
     expect(transfer.data.transactionHash).toMatch(/^0x[0-9a-f]{64}$/)
     expect(typeof transfer.data.blockNumber).toBe('number')
     expect(transfer.data.sourceToken.address).toMatch(/^0x[0-9a-f]{40}$/)
-    expect(transfer.data.sourceToken.amount).toMatch(/^\d+$/)
+    expect(transfer.data.sourceToken).not.toHaveProperty('amount')
+    expect(typeof transfer.data.sourceToken.currency).toBe('string')
+    expect(typeof transfer.data.sourceToken.decimals).toBe('number')
+    expect(typeof transfer.data.sourceToken.name).toBe('string')
+    expect(typeof transfer.data.sourceToken.symbol).toBe('string')
+    expect(transfer.data.sourceAmount.baseUnits).toMatch(/^\d+$/)
+    expect(transfer.data.sourceAmount.currency).toBe(transfer.data.sourceToken.currency)
+    expect(transfer.data.sourceAmount.decimals).toBe(transfer.data.sourceToken.decimals)
+    expect(transfer.data.sourceAmount.formatted).toMatch(/^\d+(\.\d+)?$/)
+    expect(transfer.data.sourceToken.logoUri).toBeUndefined()
+    expect(transfer.data.sourceToken.verified).toBeUndefined()
+  })
+
+  test('includes requested token verification', async () => {
+    const transfer = find(
+      (
+        await activities(accounts.creator, {
+          include: 'token.logoUri,token.verified',
+        })
+      ).data,
+      'transfer',
+    )
+    expect(transfer?.type).toBe('transfer')
+    if (transfer?.type !== 'transfer') return
+    expect(typeof transfer.data.sourceToken.verified).toBe('boolean')
   })
 
   test.skipIf(runtime.mode === 'localnet')('swap data carries both sides of the swap', async () => {
@@ -139,8 +197,30 @@ describe('GET /addresses/:address/activities', () => {
     if (swap?.type !== 'swap') return
     expect(swap.data.sourceToken.address).toMatch(/^0x[0-9a-f]{40}$/)
     expect(swap.data.destinationToken.address).toMatch(/^0x[0-9a-f]{40}$/)
+    expect(swap.data.sourceToken).not.toHaveProperty('amount')
+    expect(swap.data.destinationToken).not.toHaveProperty('amount')
+    expect(swap.data.sourceAmount.baseUnits).toMatch(/^\d+$/)
+    expect(swap.data.destinationAmount.baseUnits).toMatch(/^\d+$/)
   })
 
+  test.skipIf(runtime.mode === 'localnet')(
+    'adds a structured refund amount when a session closes with a refund',
+    async () => {
+      const session = find((await activities(accounts.channel)).data, 'session-closed')
+      expect(session?.type).toBe('session-closed')
+      if (session?.type !== 'session-closed') return
+      if (!session.data.refund) {
+        expect(session.data.refundAmount).toBeUndefined()
+        return
+      }
+      expect(session.data.refundAmount).toBeDefined()
+      expect(session.data.refund).not.toHaveProperty('amount')
+      expect(session.data.refundAmount?.baseUnits).toMatch(/^\d+$/)
+      expect(session.data.refundAmount?.currency).toBe(session.data.refund.currency)
+      expect(session.data.refundAmount?.decimals).toBe(session.data.refund.decimals)
+    },
+  )
+
   test.skipIf(runtime.mode !== 'localnet')(
     'surfaces a cross-token transfer as outgoing in the sender feed',
     async () => {
@@ -162,6 +242,10 @@ describe('GET /addresses/:address/activities', () => {
       expect(transfer.data.recipient).toBe(crossToken.recipient)
       expect(transfer.data.sourceToken.address).toBe(crossToken.sourceToken)
       expect(transfer.data.destinationToken?.address).toBe(crossToken.destinationToken)
+      expect(transfer.data.sourceToken).not.toHaveProperty('amount')
+      expect(transfer.data.destinationToken).not.toHaveProperty('amount')
+      expect(transfer.data.sourceAmount.baseUnits).toMatch(/^\d+$/)
+      expect(transfer.data.destinationAmount?.baseUnits).toMatch(/^\d+$/)
     },
   )
 
@@ -202,6 +286,39 @@ describe('GET /addresses/:address/activities', () => {
     },
   )
 
+  test.skipIf(runtime.mode !== 'localnet')('values curated activity amounts', async () => {
+    const db = TestApp.database()
+    await TestApp.verifiedSeed(db, runtime.chainId)
+    const client = TestApp.client({ db, fx: { oracle: fixed } })
+    const hash = runtime.fixtures!.faucetTransactionHashes[0]!
+
+    const response = await client.v1.transactions[':transactionHash'].activities.$get(
+      { param: { transactionHash: hash }, query: { denomination: 'AUD' } },
+      TestApp.auth,
+    )
+    const body = await TestApp.json(response, Activities.schema.getTransactionActivities.Response)
+    expect(response.status).toBe(200)
+
+    // The faucet transaction moves curated USD tokens; their amounts value at
+    // the fixed 1.6 USD -> AUD rate.
+    const amounts = body.data.flatMap((item) =>
+      item.type === 'transfer' || item.type === 'mint' ? [item.data.sourceAmount] : [],
+    )
+    expect(amounts.length).toBeGreaterThan(0)
+    for (const amount of amounts)
+      expect(amount.valuation).toEqual({
+        amount: core_Value.format((BigInt(amount.baseUnits) * 16n) / 10n, 6),
+        currency: 'AUD',
+      })
+    expect(body.meta?.pricing).toMatchInlineSnapshot(`
+      {
+        "asOf": "2026-01-01",
+        "basis": "nominal",
+        "source": "fixed",
+      }
+    `)
+  })
+
   test('returns every item at the root by default (no group entries)', async () => {
     const body = await activities(accounts.channel)
     expect(body.data.every((entry) => entry.type !== 'group')).toBe(true)
@@ -210,9 +327,34 @@ describe('GET /addresses/:address/activities', () => {
   test('paginates with an opaque cursor', async () => {
     const first = await activities(accounts.keychain, { limit: '5' })
     if (!first.nextCursor) return
-    const second = await activities(accounts.keychain, { limit: '5', cursor: first.nextCursor })
+    const response = await request(accounts.keychain, { limit: '5', cursor: first.nextCursor })
+    expect(response.headers.get('cache-control')).toMatchInlineSnapshot(
+      `"private, max-age=60, stale-while-revalidate=300"`,
+    )
+    const second = await TestApp.json(response, Activities.schema.getAddressActivities.Response)
     expect(Array.isArray(second.data)).toBe(true)
   })
+
+  test('validates denominations on empty feeds', async () => {
+    const client = TestApp.client({ fx: { oracle: fixed } })
+    const cursor = Cursor.encode([0, 0])
+    const emptyResponse = await client.v1.addresses[':address'].activities.$get(
+      { param: { address: accounts.keychain }, query: { cursor, limit: '5' } },
+      TestApp.auth,
+    )
+    const empty = await TestApp.json(emptyResponse, Activities.schema.getAddressActivities.Response)
+    expect(emptyResponse.status).toBe(200)
+    expect(empty.data).toMatchInlineSnapshot(`[]`)
+
+    const response = await client.v1.addresses[':address'].activities.$get(
+      {
+        param: { address: accounts.keychain },
+        query: { cursor, denomination: 'JPY', limit: '5' },
+      },
+      TestApp.auth,
+    )
+    expect(response.status).toBe(400)
+  })
 })
 
 /** Resolves a real transaction hash from an address's (non-grouped) activity feed. */
@@ -239,6 +381,9 @@ describe('GET /transactions/:transactionHash/activities', () => {
 
     const response = await transactionActivitiesRequest(transactionHash)
     expect(response.status).toBe(200)
+    expect(response.headers.get('cache-control')).toMatchInlineSnapshot(
+      `"private, max-age=60, stale-while-revalidate=300"`,
+    )
     expect(response.headers.get('server-timing')?.includes('transaction_activities;dur=')).toBe(
       true,
     )
@@ -262,6 +407,27 @@ describe('GET /transactions/:transactionHash/activities', () => {
     )
   })
 
+  test('supports requested token verification', async () => {
+    const address = await activities(accounts.creator)
+    const entry = address.data.find((item) => item.type !== 'group' && 'sourceToken' in item.data)
+    expect(entry?.type).not.toBe('group')
+    if (!entry || entry.type === 'group') return
+
+    const body = await TestApp.json(
+      await transactionActivitiesRequest(entry.transactionHash, {
+        include: 'token.verified',
+      }),
+      Activities.schema.getTransactionActivities.Response,
+    )
+    const item = body.data.find((item) => 'sourceToken' in item.data)
+    expect(item).toBeDefined()
+    if (!item || !('sourceToken' in item.data) || !item.data.sourceToken || !item.data.sourceAmount)
+      return
+    expect(typeof item.data.sourceToken.verified).toBe('boolean')
+    expect(item.data.sourceToken).not.toHaveProperty('amount')
+    expect(item.data.sourceAmount.baseUnits).toMatch(/^\d+$/)
+  })
+
   test.skipIf(runtime.mode !== 'localnet')(
     'classifies a seeded cross-token transfer with both source and destination tokens',
     async () => {
@@ -283,6 +449,10 @@ describe('GET /transactions/:transactionHash/activities', () => {
       expect(transfer.data.recipient).toBe(crossToken.recipient)
       expect(transfer.data.sourceToken.address).toBe(crossToken.sourceToken)
       expect(transfer.data.destinationToken?.address).toBe(crossToken.destinationToken)
+      expect(transfer.data.sourceToken).not.toHaveProperty('amount')
+      expect(transfer.data.destinationToken).not.toHaveProperty('amount')
+      expect(transfer.data.sourceAmount.baseUnits).toMatch(/^\d+$/)
+      expect(transfer.data.destinationAmount?.baseUnits).toMatch(/^\d+$/)
     },
   )