tapimo 0.10.2 → 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'
@@ -35,8 +35,6 @@ const liveAccounts = {
   channel: '0x5217c502adf3c96a9551770af4caa5f5144a6984',
   // TokenCreated + Mint + Transfer.
   creator: '0x253fb3bf1e3d75ad6ee1554f68f4ea0568f7d24e',
-  // Token burns.
-  burner: '0x69519497b59bd64e109d993157d45f14455cc7e6',
   // KeyAuthorized + KeyRevoked + Approval (+ transfer/mint/exchange).
   keychain: '0xfe776fd28e06ecc71a157398b2c9991318f1ea2e',
   // Swaps through the stablecoin DEX (output kept, so it stays a plain `swap`).
@@ -50,27 +48,29 @@ const accounts =
     ? {
         channel: localAccounts.keychain,
         creator: localAccounts.creator,
-        burner: localAccounts.burner,
         keychain: localAccounts.keychain,
         swapper: localAccounts.swapper,
       }
     : liveAccounts
 
-/** The account expected to surface each activity type. */
+/**
+ * The account expected to surface each activity type. Burns are seeded per run
+ * instead: a live burner keeps accruing activity until its last burn falls off
+ * the first page.
+ */
 const coverage =
-  runtime.mode === 'localnet'
+  runtime.mode === 'localnet' && localAccounts
     ? {
-        approval: accounts.keychain,
-        burn: accounts.burner,
-        mint: accounts.creator,
-        'token-created': accounts.creator,
-        transfer: accounts.creator,
+        approval: localAccounts.keychain,
+        burn: localAccounts.burner,
+        mint: localAccounts.creator,
+        'token-created': localAccounts.creator,
+        transfer: localAccounts.creator,
       }
     : {
         'access-key-created': accounts.keychain,
         'access-key-revoked': accounts.keychain,
         approval: accounts.keychain,
-        burn: accounts.burner,
         mint: accounts.creator,
         'session-closed': accounts.channel,
         swap: accounts.swapper,
@@ -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 () => {
@@ -165,6 +168,54 @@ describe('GET /addresses/:address/activities', () => {
     expect(find(body.data, type)).toBeDefined()
   })
 
+  // Localnet seeds its burner through the shared fixtures, so this covers the
+  // hosted testnet, where no address stays burn-topped for long.
+  test.skipIf(runtime.mode === 'localnet')(
+    'classifies a seeded burn',
+    async () => {
+      const account = Tempo.accounts[11]
+      const wallet = Tempo.getClient({ account })
+      await Actions.faucet.fundSync(Tempo.client, { account, timeout: 60_000 })
+
+      // Burning needs the `issuer` role, so the account burns a token it owns.
+      const { token } = await Actions.token.createSync(wallet, {
+        currency: 'USD',
+        name: 'Seeded Burn USD',
+        symbol: 'SBUSD',
+      })
+      await sendTransactionSync(wallet, {
+        account,
+        calls: [
+          Actions.token.grantRoles.call(wallet, { role: 'issuer', to: account.address, token }),
+          Actions.token.mint.call(wallet, { amount: 1_000_000n, to: account.address, token }),
+        ],
+      })
+      const { receipt } = await Actions.token.burnSync(wallet, { amount: 100_000n, token })
+
+      const deadline = Date.now() + 90_000
+      let burn: Activities.Entry | undefined
+      while (Date.now() < deadline) {
+        const response = await client.v1.addresses[':address'].activities.$get(
+          { param: { address: account.address }, query: { limit: '50' } },
+          { headers: { 'cache-control': 'no-store', ...TestApp.auth.headers } },
+        )
+        if (response.status === 200) {
+          const body = await TestApp.json(response, Activities.schema.getAddressActivities.Response)
+          burn = find(body.data, 'burn')
+          if (burn?.type === 'burn' && burn.transactionHash === receipt.transactionHash) break
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500))
+      }
+      expect(burn?.type).toBe('burn')
+      if (burn?.type !== 'burn') return
+      expect(burn.transactionHash).toBe(receipt.transactionHash)
+      expect(burn.data.sender.toLowerCase()).toBe(account.address.toLowerCase())
+      expect(burn.data.sourceToken.address.toLowerCase()).toBe(token.toLowerCase())
+      expect(burn.data.sourceAmount.baseUnits).toBe('100000')
+    },
+    180_000,
+  )
+
   test('transfer data mirrors the `Transfer` resource', async () => {
     const transfer = find((await activities(accounts.creator)).data, 'transfer')
     expect(transfer?.type).toBe('transfer')
@@ -488,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)
@@ -559,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', () => {
@@ -579,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
@@ -666,6 +1041,54 @@ describe('Activities.list classification', () => {
     expect(log.data).toBe('0x1234')
     expect(log.topics).toEqual([unknownSelector, pad(viewer)])
   })
+
+  test('degrades a topic-encoded approval with a fee transfer to `unknown`', async () => {
+    const approvalToken = '0x4120c7ec7e9ead9dcf44b35b5134ebdbfc6e3de9' as Address.Address
+    const feeToken = '0x20c0000000000000000000000000000000000000' as Address.Address
+    const feeManager = '0xfeec000000000000000000000000000000000000'
+    const approvalSelector = '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925'
+    const transferSelector = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
+    const pad = (value: string) => `0x${value.slice(2).padStart(64, '0')}`
+    const txHash = '0xd2439ad8016d4ffd6aebe835734ee4d118a688714a4f9aebcc11f87a2b22e896' as Hex.Hex
+    const common = {
+      blockNum: 15_781_805,
+      blockTimestamp: 1_776_703_284,
+      feePayer: viewer,
+      source: 'q1' as const,
+      txHash,
+      txIdx: 0,
+      txSender: viewer,
+    }
+    const { items } = await Activities.list(
+      provider([
+        {
+          ...common,
+          data: '0x',
+          logAddress: approvalToken,
+          logIdx: 0,
+          selector: approvalSelector,
+          topic1: pad(viewer),
+          topic2: pad('0x6063259f720ee125e5bff693779ab8118b0118a7'),
+          topic3: '0x2a9063ed52b7d417e441f378325359c9ce274f5d6c3ecf11b7d42f24b9c90b7f',
+        },
+        {
+          ...common,
+          data: `0x${(5_815).toString(16).padStart(64, '0')}`,
+          logAddress: feeToken,
+          logIdx: 1,
+          selector: transferSelector,
+          topic1: pad(viewer),
+          topic2: pad(feeManager),
+          topic3: null,
+        },
+      ]),
+      { address: viewer, store: store() },
+    )
+
+    expect(items).toHaveLength(1)
+    expect(items[0]?.type).toBe('unknown')
+    expect(items[0]?.events).toHaveLength(2)
+  })
 })
 
 describe('Activities.list precompile classification', () => {