tapimo 0.11.0 → 0.12.0

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

@@ -3,7 +3,7 @@
 import { Address, Hex, Value as core_Value } from 'ox'
 import { FxOracle } from 'tapimo/apps'
 import { createClient, encodeAbiParameters, encodeEventTopics, http } from 'viem'
-import { sendTransactionSync } from 'viem/actions'
+import { getLogs, sendTransactionSync } from 'viem/actions'
 import { Abis, Actions, Addresses } from 'viem/tempo'
 
 import * as TestApp from '../../../../test/App.js'
@@ -143,6 +143,9 @@ describe('GET /addresses/:address/activities', () => {
     expect(
       Activities.schema.getAddressActivities.Query.safeParse({ include: 'token' }).success,
     ).toBe(false)
+    expect(
+      Activities.schema.getAddressActivities.Query.parse({ include: 'zones' }).include,
+    ).toStrictEqual(['zones'])
   })
 
   test('returns a newest-first, schema-valid feed with timing', async () => {
@@ -536,6 +539,7 @@ describe('GET /transactions/:transactionHash/activities', () => {
     )
 
     const body = await TestApp.json(response, Activities.schema.getTransactionActivities.Response)
+    expect(body.chainId).toBe(runtime.chainId)
     expect(body.data.length).toBeGreaterThan(0)
     // Every classified item belongs to the requested transaction.
     expect(body.data.every((item) => item.transactionHash === transactionHash)).toBe(true)
@@ -607,6 +611,174 @@ describe('GET /transactions/:transactionHash/activities', () => {
     const response = await transactionActivitiesRequest(`0x${'0'.repeat(64)}`)
     expect(response.status).toBe(404)
   })
+
+  test.skipIf(runtime.mode !== 'localnet')(
+    'infers indexed Zone activity by transaction and address',
+    async () => {
+      const account = Tempo.accounts[0]
+      const [zoneCreated] = await getLogs(Tempo.client, {
+        event: {
+          inputs: [
+            { indexed: true, name: 'zoneId', type: 'uint32' },
+            { indexed: true, name: 'portal', type: 'address' },
+            { indexed: false, name: 'initialToken', type: 'address' },
+            { indexed: false, name: 'admin', type: 'address' },
+            { indexed: false, name: 'sequencer', type: 'address' },
+            { indexed: false, name: 'verifier', type: 'address' },
+            { indexed: false, name: 'genesisBlockHash', type: 'bytes32' },
+            { indexed: false, name: 'genesisTempoBlockHash', type: 'bytes32' },
+            { indexed: false, name: 'genesisTempoBlockNumber', type: 'uint64' },
+          ],
+          name: 'ZoneCreated',
+          type: 'event',
+        },
+        fromBlock: 0n,
+        strict: true,
+        toBlock: 'latest',
+      })
+      expect(zoneCreated).toBeDefined()
+      if (!zoneCreated) return
+
+      const zone = TestApp.zone({
+        chainId: runtime.zone.chainId,
+        rpcUrl: runtime.zone.internalRpcUrl,
+        sourceChainId: runtime.chainId,
+        tidxUrl: runtime.tidxUrl,
+      })
+      const zoneClient = createClient({
+        account,
+        chain: zone,
+        pollingInterval: 100,
+        transport: http(runtime.zone.internalRpcUrl),
+      })
+      const balanceBefore = await Actions.token.getBalance(zoneClient, {
+        account: account.address,
+        token: Addresses.pathUsd,
+      })
+      await Actions.zone.depositSync(Tempo.getClient({ account }), {
+        amount: 1_000_000n,
+        portalAddress: zoneCreated.args.portal,
+        token: Addresses.pathUsd,
+        zoneId: zoneCreated.args.zoneId,
+      })
+
+      let balance = balanceBefore
+      const balanceDeadline = Date.now() + 60_000
+      while (balance.amount <= balanceBefore.amount && Date.now() < balanceDeadline) {
+        await new Promise((resolve) => setTimeout(resolve, 100))
+        balance = await Actions.token.getBalance(zoneClient, {
+          account: account.address,
+          token: Addresses.pathUsd,
+        })
+      }
+      expect(balance.amount).toBeGreaterThan(balanceBefore.amount)
+
+      const { receipt } = await Actions.token.transferSync(zoneClient, {
+        amount: 1n,
+        to: Tempo.accounts[1].address,
+        token: Addresses.pathUsd,
+      })
+      const zoneReader = {
+        ...TestApp.key,
+        id: 'key_inferred_zone',
+        scopes: [...TestApp.key.scopes, `zone:${runtime.zone.chainId}:read`],
+        token: 'secret_inferred_zone',
+      } satisfies TestApp.kvStore.Key
+      const client = TestApp.client({
+        auth: { keys: [zoneReader] },
+        zones: [zone],
+      })
+      let response = await client.v1.transactions[':transactionHash'].activities.$get(
+        {
+          param: { transactionHash: receipt.transactionHash },
+          query: { chainId: String(runtime.chainId), include: 'zones' },
+        },
+        { headers: { authorization: `Bearer ${zoneReader.token}` } },
+      )
+      const deadline = Date.now() + 60_000
+      while ((response.status === 404 || response.status === 502) && Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 500))
+        response = await client.v1.transactions[':transactionHash'].activities.$get(
+          {
+            param: { transactionHash: receipt.transactionHash },
+            query: { chainId: String(runtime.chainId), include: 'zones' },
+          },
+          { headers: { authorization: `Bearer ${zoneReader.token}` } },
+        )
+      }
+      const body = await TestApp.json(response, Activities.schema.getTransactionActivities.Response)
+
+      expect(response.status).toBe(200)
+      expect(response.headers.get('cache-control')).toBe('no-store')
+      expect(body.chainId).toBe(runtime.zone.chainId)
+      const cached = await client.v1.transactions[':transactionHash'].activities.$get(
+        {
+          param: { transactionHash: receipt.transactionHash },
+          query: { chainId: String(runtime.chainId), include: 'zones' },
+        },
+        { headers: { authorization: `Bearer ${zoneReader.token}` } },
+      )
+      expect(cached.status).toBe(200)
+      expect(cached.headers.get('server-timing')).not.toContain('tidx;dur=')
+
+      const missingHash = `0x${'ff'.repeat(32)}` as Hex.Hex
+      const getMissing = () =>
+        client.v1.transactions[':transactionHash'].activities.$get(
+          {
+            param: { transactionHash: missingHash },
+            query: { chainId: String(runtime.chainId), include: 'zones' },
+          },
+          { headers: { authorization: `Bearer ${zoneReader.token}` } },
+        )
+      const missing = [await getMissing(), await getMissing()]
+      expect(missing.map(({ status }) => status)).toStrictEqual([404, 404])
+      expect(
+        missing.every((item) => item.headers.get('server-timing')?.includes('tidx;dur=')),
+      ).toBe(true)
+
+      const transfer = body.data.find((item) => item.type === 'transfer')
+      expect(transfer?.transactionHash).toBe(receipt.transactionHash)
+      if (transfer?.type !== 'transfer') return
+      expect(transfer.data.recipient).toBe(Tempo.accounts[1].address.toLowerCase())
+
+      const zoneAddressActivities = await (async () => {
+        const deadline = Date.now() + 60_000
+        while (Date.now() < deadline) {
+          const response = await client.v1.addresses[':address'].activities.$get(
+            {
+              param: { address: account.address },
+              query: {
+                chainId: String(runtime.chainId),
+                include: 'zones',
+                limit: '50',
+              },
+            },
+            { headers: { authorization: `Bearer ${zoneReader.token}` } },
+          )
+          if (response.status === 200) {
+            const body = await TestApp.json(
+              response,
+              Activities.schema.getAddressActivities.Response,
+            )
+            if (
+              body.data.some(
+                (item) => item.type !== 'group' && item.transactionHash === receipt.transactionHash,
+              )
+            )
+              return { body, response }
+          }
+          await new Promise((resolve) => setTimeout(resolve, 500))
+        }
+        throw new Error('Timed out waiting for inferred Zone address activity')
+      })()
+      const addressTransfer = zoneAddressActivities.body.data.find(
+        (item) => item.type !== 'group' && item.transactionHash === receipt.transactionHash,
+      )
+      expect(zoneAddressActivities.response.headers.get('cache-control')).toBe('no-store')
+      expect(addressTransfer?.chainId).toBe(runtime.zone.chainId)
+    },
+    180_000,
+  )
 })
 
 describe('Activities.list classification', () => {
@@ -627,6 +799,161 @@ describe('Activities.list classification', () => {
     }
   }
 
+  function pagedProvider(rows: Activities.Row[]): Activities.Provider {
+    return {
+      cursorForGroup: (group) => `${group.blockNum}:${group.txIdx}`,
+      fetchRows: async ({ cursor, limit }) => {
+        const [blockNum, txIdx] = cursor?.split(':').map(Number) ?? []
+        return {
+          rows: rows
+            .filter(
+              (row) =>
+                blockNum === undefined ||
+                row.blockNum < blockNum ||
+                (row.blockNum === blockNum && row.txIdx < txIdx!),
+            )
+            .slice(0, limit + 1),
+        }
+      },
+    }
+  }
+
+  function unknownRow(options: {
+    blockNum: number
+    blockTimestamp: number
+    hash: string
+  }): Activities.Row {
+    return {
+      blockNum: options.blockNum,
+      blockTimestamp: options.blockTimestamp,
+      data: '0x',
+      feePayer: null,
+      logAddress: '0x2222222222222222222222222222222222222222',
+      logIdx: 0,
+      selector: null,
+      source: 'q1',
+      topic1: null,
+      topic2: null,
+      topic3: null,
+      txHash: `0x${options.hash.repeat(64)}` as Hex.Hex,
+      txIdx: 0,
+      txSender: viewer,
+    }
+  }
+
+  test('merges Zone pages and retains each provider cursor', async () => {
+    const providers = [
+      {
+        chainId: 10,
+        provider: pagedProvider([
+          unknownRow({ blockNum: 30, blockTimestamp: 300, hash: 'a' }),
+          unknownRow({ blockNum: 10, blockTimestamp: 100, hash: 'c' }),
+        ]),
+      },
+      {
+        chainId: 20,
+        provider: pagedProvider([unknownRow({ blockNum: 20, blockTimestamp: 200, hash: 'b' })]),
+      },
+    ]
+    const first = await Activities.listZones({
+      address: viewer,
+      limit: 2,
+      providers,
+      store: store(),
+    })
+    const second = await Activities.listZones({
+      address: viewer,
+      cursor: first.nextCursor!,
+      limit: 2,
+      providers,
+      store: store(),
+    })
+
+    expect(first.items.map((item) => [item.chainId, item.timestamp])).toStrictEqual([
+      [10, '1970-01-01T00:05:00.000Z'],
+      [20, '1970-01-01T00:03:20.000Z'],
+    ])
+    expect(first.nextCursor).not.toBeNull()
+    expect(second.items.map((item) => item.chainId)).toStrictEqual([10])
+    expect(second.nextCursor).toBeNull()
+  })
+
+  test('retains unused Zone buffers while filling a grouped page', async () => {
+    const signer = '0x3333333333333333333333333333333333333333' as Address.Address
+    const calls = new Map<number, number>()
+    const providers = [
+      { chainId: 10, hashes: ['1', '3', '5'], timestamps: [600, 400, 200] },
+      { chainId: 20, hashes: ['2', '4', '6'], timestamps: [500, 300, 100] },
+    ].map(({ chainId, hashes, timestamps }) => {
+      const source = pagedProvider(
+        timestamps.map((blockTimestamp, index) => ({
+          ...unknownRow({ blockNum: blockTimestamp, blockTimestamp, hash: hashes[index]! }),
+          feePayer: viewer,
+          txSender: signer,
+        })),
+      )
+      return {
+        chainId,
+        provider: {
+          cursorForGroup: (group) => source.cursorForGroup(group),
+          fetchRows: async (options) => {
+            calls.set(chainId, (calls.get(chainId) ?? 0) + 1)
+            return source.fetchRows(options)
+          },
+        } satisfies Activities.Provider,
+      }
+    })
+
+    const result = await Activities.listZones({
+      address: viewer,
+      group: true,
+      limit: 2,
+      providers,
+      store: store(),
+    })
+
+    expect(result.items.map((item) => item.timestamp)).toStrictEqual([
+      '1970-01-01T00:10:00.000Z',
+      '1970-01-01T00:08:20.000Z',
+      '1970-01-01T00:06:40.000Z',
+      '1970-01-01T00:05:00.000Z',
+      '1970-01-01T00:03:20.000Z',
+      '1970-01-01T00:01:40.000Z',
+    ])
+    expect([...calls]).toStrictEqual([
+      [10, 2],
+      [20, 2],
+    ])
+    expect(result.nextCursor).toBeNull()
+  })
+
+  test('does not fold access-key activity across Zones', async () => {
+    const signer = '0x3333333333333333333333333333333333333333' as Address.Address
+    const providers = [10, 20].map((chainId) => ({
+      chainId,
+      provider: pagedProvider([
+        {
+          ...unknownRow({ blockNum: chainId, blockTimestamp: 300, hash: String(chainId / 10) }),
+          feePayer: viewer,
+          txSender: signer,
+        },
+      ]),
+    }))
+    const result = await Activities.listZones({
+      address: viewer,
+      providers,
+      store: store(),
+    })
+    const grouped = Activities.groupByAccessKey(
+      result.items.map((item) => Activities.schema.Item.parse(item)),
+    )
+
+    expect(grouped.map((item) => [item.chainId, item.type])).toStrictEqual([
+      [10, 'unknown'],
+      [20, 'unknown'],
+    ])
+  })
+
   test('classifies an unrecognized Q1 tx as `unknown` with decoded events', async () => {
     // A gas-fee Transfer to the fee manager decodes as a known `Transfer`
     // event, but the classifier excludes fee-manager transfers, so the tx has