tapimo 0.11.0 → 0.13.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,249 @@ 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,
+      })
+      const zoneDeposit = 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 zoneOnlyTransaction = await client.v1.transactions[':transactionHash'].activities.$get(
+        {
+          param: { transactionHash: receipt.transactionHash },
+          query: { chainId: String(runtime.zone.chainId) },
+        },
+        { headers: { authorization: `Bearer ${zoneReader.token}` } },
+      )
+      const zoneOnlyTransactionBody = await TestApp.json(
+        zoneOnlyTransaction,
+        Activities.schema.getTransactionActivities.Response,
+      )
+      expect(zoneOnlyTransaction.status).toBe(200)
+      expect(zoneOnlyTransactionBody.chainId).toBe(runtime.zone.chainId)
+
+      let parentTransaction = await client.v1.transactions[':transactionHash'].activities.$get(
+        {
+          param: { transactionHash: zoneDeposit.receipt.transactionHash },
+          query: { chainId: String(runtime.chainId), include: 'zones' },
+        },
+        { headers: { authorization: `Bearer ${zoneReader.token}` } },
+      )
+      const parentDeadline = Date.now() + 60_000
+      while (
+        (parentTransaction.status === 404 || parentTransaction.status === 502) &&
+        Date.now() < parentDeadline
+      ) {
+        await new Promise((resolve) => setTimeout(resolve, 500))
+        parentTransaction = await client.v1.transactions[':transactionHash'].activities.$get(
+          {
+            param: { transactionHash: zoneDeposit.receipt.transactionHash },
+            query: { chainId: String(runtime.chainId), include: 'zones' },
+          },
+          { headers: { authorization: `Bearer ${zoneReader.token}` } },
+        )
+      }
+      const parentTransactionBody = await TestApp.json(
+        parentTransaction,
+        Activities.schema.getTransactionActivities.Response,
+      )
+      expect(parentTransaction.status).toBe(200)
+      expect(parentTransactionBody.chainId).toBe(runtime.chainId)
+
+      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,
+            )
+            const hashes = body.data.flatMap((item) =>
+              item.type === 'group'
+                ? item.data.items.map(({ transactionHash }) => transactionHash)
+                : [item.transactionHash],
+            )
+            if (
+              hashes.includes(receipt.transactionHash) &&
+              hashes.includes(zoneDeposit.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)
+      const parentActivity = zoneAddressActivities.body.data.find(
+        (item) =>
+          item.type !== 'group' && item.transactionHash === zoneDeposit.receipt.transactionHash,
+      )
+      expect(parentActivity?.chainId).toBe(runtime.chainId)
+
+      const zoneOnlyActivities = await client.v1.addresses[':address'].activities.$get(
+        {
+          param: { address: account.address },
+          query: { chainId: String(runtime.zone.chainId), limit: '50' },
+        },
+        { headers: { authorization: `Bearer ${zoneReader.token}` } },
+      )
+      const zoneOnlyActivitiesBody = await TestApp.json(
+        zoneOnlyActivities,
+        Activities.schema.getAddressActivities.Response,
+      )
+      expect(zoneOnlyActivities.status).toBe(200)
+      expect(
+        zoneOnlyActivitiesBody.data.some(
+          (item) => item.type !== 'group' && item.transactionHash === receipt.transactionHash,
+        ),
+      ).toBe(true)
+      expect(
+        zoneOnlyActivitiesBody.data.some(
+          (item) =>
+            item.type !== 'group' && item.transactionHash === zoneDeposit.receipt.transactionHash,
+        ),
+      ).toBe(false)
+    },
+    180_000,
+  )
 })
 
 describe('Activities.list classification', () => {
@@ -627,6 +874,192 @@ 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('classifies every transfer row of a receipt-less (Q2) transaction', async () => {
+    const sender = '0x9999999999999999999999999999999999999999' as Address.Address
+    const token = '0x2222222222222222222222222222222222222222' as Address.Address
+    const q2Row = (options: { amount: bigint; logIdx: number }): Activities.Row => ({
+      blockNum: 100,
+      blockTimestamp: 1_700_000_000,
+      data: null,
+      feePayer: null,
+      logAddress: token,
+      logIdx: options.logIdx,
+      selector: null,
+      source: 'q2',
+      topic1: null,
+      topic2: null,
+      topic3: null,
+      transferAmount: options.amount,
+      transferFrom: sender,
+      transferTo: viewer,
+      transferToken: token,
+      txHash: `0x${'e'.repeat(64)}` as Hex.Hex,
+      txIdx: 0,
+      txSender: sender,
+    })
+    const { items } = await Activities.list(
+      provider([q2Row({ amount: 10n, logIdx: 0 }), q2Row({ amount: 20n, logIdx: 1 })]),
+      { address: viewer, store: store() },
+    )
+    expect(items.map((item) => item.type)).toEqual(['transfer', 'transfer'])
+    expect(new Set(items.map((item) => item.id)).size).toBe(2)
+  })
+
+  test('merges chain 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.listChains({
+      address: viewer,
+      limit: 2,
+      providers,
+      store: store(),
+    })
+    const second = await Activities.listChains({
+      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 chain 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.listChains({
+      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 chains', 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.listChains({
+      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
@@ -795,7 +1228,31 @@ describe('Activities.list precompile classification', () => {
     logIdx: number
   }): Activities.Row {
     type Param = { indexed?: boolean; name?: string; type: string }
-    const abi = [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault]
+    // Standard ERC-4626 events, mirrored from the classifier's decode ABI.
+    const erc4626Events = [
+      {
+        inputs: [
+          { indexed: true, name: 'sender', type: 'address' },
+          { indexed: true, name: 'owner', type: 'address' },
+          { indexed: false, name: 'assets', type: 'uint256' },
+          { indexed: false, name: 'shares', type: 'uint256' },
+        ],
+        name: 'Deposit',
+        type: 'event',
+      },
+      {
+        inputs: [
+          { indexed: true, name: 'sender', type: 'address' },
+          { indexed: true, name: 'receiver', type: 'address' },
+          { indexed: true, name: 'owner', type: 'address' },
+          { indexed: false, name: 'assets', type: 'uint256' },
+          { indexed: false, name: 'shares', type: 'uint256' },
+        ],
+        name: 'Withdraw',
+        type: 'event',
+      },
+    ] as const
+    const abi = [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault, ...erc4626Events]
     const event = abi.find((a) => a.type === 'event' && a.name === options.eventName) as {
       inputs: readonly Param[]
     }
@@ -1483,4 +1940,1388 @@ describe('Activities.list precompile classification', () => {
     if (items[0]!.type !== 'initialized') return
     expect(items[0]!.data.height).toBe('42')
   })
+
+  test('keeps duplicate identical payments as separate activities', async () => {
+    const recipient = '0x7777777777777777777777777777777777777777' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: recipient, token: tokenA, value: 10n }),
+      transferRow({ from: viewer, logIdx: 1, to: recipient, token: tokenA, value: 10n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer', 'transfer'])
+    expect(new Set(items.map((item) => item.id)).size).toBe(2)
+  })
+
+  test('folds zero-address transfer duplicates into explicit mint and burn events', async () => {
+    const zero = '0x0000000000000000000000000000000000000000' as Address.Address
+    const minted = await classify([
+      transferRow({ from: zero, logIdx: 0, to: viewer, token: tokenA, value: 10n }),
+      logRow({ address: tokenA, args: { amount: 10n, to: viewer }, eventName: 'Mint', logIdx: 1 }),
+    ])
+    const burned = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: zero, token: tokenA, value: 10n }),
+      logRow({
+        address: tokenA,
+        args: { amount: 10n, from: viewer },
+        eventName: 'Burn',
+        logIdx: 1,
+      }),
+    ])
+    expect(minted.map((item) => item.type)).toEqual(['mint'])
+    expect(burned.map((item) => item.type)).toEqual(['burn'])
+  })
+
+  test('classifies a sender-initiated mint to another recipient', async () => {
+    const recipient = '0x7777777777777777777777777777777777777777' as Address.Address
+    const items = await classify([
+      logRow({
+        address: tokenA,
+        args: { amount: 10n, to: recipient },
+        eventName: 'Mint',
+        logIdx: 0,
+      }),
+    ])
+    expect(items).toHaveLength(1)
+    expect(items[0]?.type === 'mint' && items[0].data.recipient).toBe(recipient)
+  })
+
+  test('keeps a payment batched after a share-burn withdrawal', async () => {
+    const asset = '0x5555555555555555555555555555555555555555' as Address.Address
+    const recipient = '0x7777777777777777777777777777777777777777' as Address.Address
+    const zero = '0x0000000000000000000000000000000000000000' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: zero, token: tokenA, value: 100n }),
+      transferRow({ from: tokenA, logIdx: 1, to: viewer, token: asset, value: 100n }),
+      transferRow({ from: viewer, logIdx: 2, to: recipient, token: asset, value: 100n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['burn', 'transfer', 'transfer'])
+    const payment = items[2]
+    expect(payment?.type).toBe('transfer')
+    if (payment?.type !== 'transfer') return
+    expect(payment.data.direction).toBe('out')
+    expect(payment.data.recipient).toBe(recipient)
+  })
+
+  test('folds vault token legs without hiding an independent payment', async () => {
+    const asset = '0x4444444444444444444444444444444444444444' as Address.Address
+    const recipient = '0x5555555555555555555555555555555555555555' as Address.Address
+    const zero = '0x0000000000000000000000000000000000000000' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: tokenA, token: asset, value: 100n }),
+      transferRow({ from: zero, logIdx: 1, to: viewer, token: tokenA, value: 90n }),
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 2,
+      }),
+      transferRow({ from: viewer, logIdx: 3, to: recipient, token: asset, value: 10n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['assets-deposited', 'transfer'])
+    expect(items[1]?.type === 'transfer' && items[1].data.recipient).toBe(recipient)
+  })
+
+  test('keeps an independent vault deposit beside a private Earn deposit', async () => {
+    const actionId = `0x${'c'.repeat(64)}` as Hex.Hex
+    const vaultB = '0x4444444444444444444444444444444444444444' as Address.Address
+    const items = await classify([
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 0,
+      }),
+      logRow({
+        address: tokenA,
+        args: {
+          actionId,
+          earnShares: 90n,
+          earnVault: tokenA,
+          inputAmount: 100n,
+          inputToken: tokenA,
+          vaultAssets: 100n,
+          zoneDepositHash: actionId,
+        },
+        eventName: 'EarnDeposit',
+        logIdx: 1,
+      }),
+      logRow({
+        address: vaultB,
+        args: { assets: 50n, caller: viewer, earnShares: 45n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 2,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['private-assets-deposited', 'assets-deposited'])
+    expect(items[1]?.type === 'assets-deposited' && items[1].data.vault).toBe(vaultB)
+  })
+
+  test('keeps two identical swaps through the same route distinct', async () => {
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: stablecoinDex, token: tokenA, value: 1_000n }),
+      transferRow({ from: stablecoinDex, logIdx: 1, to: viewer, token: tokenB, value: 990n }),
+      transferRow({ from: viewer, logIdx: 2, to: stablecoinDex, token: tokenA, value: 1_000n }),
+      transferRow({ from: stablecoinDex, logIdx: 3, to: viewer, token: tokenB, value: 990n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['swap', 'swap'])
+    expect(new Set(items.map((item) => item.id)).size).toBe(2)
+  })
+
+  test('keeps an independent approval beside a swap', async () => {
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const tokenC = '0x6666666666666666666666666666666666666666' as Address.Address
+    const spender = '0x7777777777777777777777777777777777777777' as Address.Address
+    const items = await classify([
+      logRow({
+        address: tokenA,
+        args: { amount: 1_000n, owner: viewer, spender },
+        eventName: 'Approval',
+        logIdx: 0,
+      }),
+      transferRow({ from: viewer, logIdx: 1, to: stablecoinDex, token: tokenA, value: 1_000n }),
+      transferRow({ from: stablecoinDex, logIdx: 2, to: viewer, token: tokenB, value: 990n }),
+      logRow({
+        address: tokenC,
+        args: { amount: 7n, owner: viewer, spender },
+        eventName: 'Approval',
+        logIdx: 3,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['swap', 'approval'])
+    expect(items[1]?.type === 'approval' && items[1].data.sourceToken.address).toBe(tokenC)
+  })
+
+  test('classifies a swap routed through a per-route account', async () => {
+    const router = '0xb92fe925dc43a0ecde6c8b1a2709c170ec4fff4f' as Address.Address
+    const executor = '0xccc88a9d1b4ed6b0eaba998850414b24f1c315be' as Address.Address
+    const pool = '0x8888888888888888888888888888888888888888' as Address.Address
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    // Route evidence: an undecoded event the router emits mid-swap.
+    const routerLog: Activities.Row = {
+      ...transferRow({ from: viewer, logIdx: 2, to: router, token: tokenA, value: 0n }),
+      data: '0x',
+      logAddress: router,
+      selector: `0x${'9'.repeat(64)}`,
+      topic1: null,
+      topic2: null,
+    }
+    const items = await classify([
+      logRow({
+        address: tokenA,
+        args: { amount: 1_105n, owner: viewer, spender: executor },
+        eventName: 'Approval',
+        logIdx: 0,
+      }),
+      transferRow({ from: viewer, logIdx: 1, to: router, token: tokenA, value: 1_105n }),
+      routerLog,
+      transferRow({ from: router, logIdx: 3, to: pool, token: tokenA, value: 1_105n }),
+      transferRow({ from: pool, logIdx: 4, to: router, token: tokenB, value: 1_104n }),
+      transferRow({ from: router, logIdx: 5, to: viewer, token: tokenB, value: 1_104n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['swap'])
+    expect(items[0]?.type).toBe('swap')
+    if (items[0]?.type !== 'swap') return
+    expect(items[0].data.sourceToken).toEqual({ address: tokenA, amount: '1105' })
+    expect(items[0].data.destinationToken).toEqual({ address: tokenB, amount: '1104' })
+  })
+
+  test('keeps payments through a passive counterparty as transfers', async () => {
+    const merchant = '0x7777777777777777777777777777777777777777' as Address.Address
+    const other = '0x9999999999999999999999999999999999999999' as Address.Address
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: merchant, token: tokenA, value: 100n }),
+      transferRow({ from: merchant, logIdx: 1, to: other, token: tokenA, value: 30n }),
+      transferRow({ from: merchant, logIdx: 2, to: viewer, token: tokenB, value: 50n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer', 'transfer'])
+    if (items[0]?.type !== 'transfer' || items[1]?.type !== 'transfer') return
+    expect(items[0].data.direction).toBe('out')
+    expect(items[1].data.direction).toBe('in')
+  })
+
+  test('keeps interleaved DEX swaps by different swappers distinct', async () => {
+    const other = '0x9999999999999999999999999999999999999999' as Address.Address
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: stablecoinDex, token: tokenA, value: 1_000n }),
+      transferRow({ from: other, logIdx: 1, to: stablecoinDex, token: tokenA, value: 500n }),
+      transferRow({ from: stablecoinDex, logIdx: 2, to: viewer, token: tokenB, value: 990n }),
+      transferRow({ from: stablecoinDex, logIdx: 3, to: other, token: tokenB, value: 495n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['swap', 'swap'])
+  })
+
+  test('keeps a share-token payment beside a vault deposit of equal amounts', async () => {
+    const asset = '0x4444444444444444444444444444444444444444' as Address.Address
+    const recipient = '0x7777777777777777777777777777777777777777' as Address.Address
+    const zero = '0x0000000000000000000000000000000000000000' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: recipient, token: tokenA, value: 90n }),
+      transferRow({ from: viewer, logIdx: 1, to: tokenA, token: asset, value: 100n }),
+      transferRow({ from: zero, logIdx: 2, to: viewer, token: tokenA, value: 90n }),
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 3,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer', 'assets-deposited'])
+    expect(items[0]?.type === 'transfer' && items[0].data.recipient).toBe(recipient)
+  })
+
+  test('keeps an inbound payment beside a refundless session close', async () => {
+    const sender = '0x9999999999999999999999999999999999999999' as Address.Address
+    const payment = transferRow({ from: sender, logIdx: 0, to: viewer, token: tokenA, value: 100n })
+    const items = await classify([
+      payment,
+      {
+        ...payment,
+        data: '0x',
+        logAddress: channelReserve,
+        logIdx: 1,
+        selector: '0xf5a36fc00a96cbb9cf1f8f59299165e1d8ffffe94396d82904b4da524d16bbce',
+        topic1: null,
+        topic2: null,
+      },
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer', 'session-closed'])
+    expect(items[1]?.type === 'session-closed' && items[1].data.refund).toBeUndefined()
+  })
+
+  test('folds the router funding leg into a private Earn deposit', async () => {
+    const actionId = `0x${'c'.repeat(64)}` as Hex.Hex
+    const router = '0x9999999999999999999999999999999999999999' as Address.Address
+    const asset = '0x4444444444444444444444444444444444444444' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: router, token: asset, value: 100n }),
+      logRow({
+        address: router,
+        args: {
+          actionId,
+          earnShares: 90n,
+          earnVault: tokenA,
+          inputAmount: 100n,
+          inputToken: asset,
+          vaultAssets: 100n,
+          zoneDepositHash: actionId,
+        },
+        eventName: 'EarnDeposit',
+        logIdx: 1,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['private-assets-deposited'])
+  })
+
+  test('keeps a mint whose paired event decodes without a recipient', async () => {
+    const recipient = '0x7777777777777777777777777777777777777777' as Address.Address
+    const zero = '0x0000000000000000000000000000000000000000' as Address.Address
+    const malformedMint = logRow({
+      address: tokenA,
+      args: { amount: 10n, to: viewer },
+      eventName: 'Mint',
+      logIdx: 2,
+    })
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: recipient, token: tokenA, value: 5n }),
+      transferRow({ from: zero, logIdx: 1, to: viewer, token: tokenA, value: 10n }),
+      // The indexed recipient topic is stripped, so the Mint decodes without
+      // `to` and must not fold away the zero-address transfer.
+      { ...malformedMint, topic1: null },
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer', 'mint'])
+  })
+
+  test('emits an external vault withdrawal paid out to the viewer', async () => {
+    const other = '0x9999999999999999999999999999999999999999' as Address.Address
+    const asset = '0x4444444444444444444444444444444444444444' as Address.Address
+    const items = await classify([
+      transferRow({ from: tokenA, logIdx: 0, to: viewer, token: asset, value: 100n }),
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, owner: other, receiver: other, sender: other, shares: 90n },
+        eventName: 'Withdraw',
+        logIdx: 1,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['assets-withdrawn'])
+  })
+
+  test('classifies a route delivery to a third party as a cross-token transfer', async () => {
+    const router = '0xb92fe925dc43a0ecde6c8b1a2709c170ec4fff4f' as Address.Address
+    const recipient = '0x7bc2d22a73706758505e222ed9d13a1a7f251490' as Address.Address
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const routerLog: Activities.Row = {
+      ...transferRow({ from: viewer, logIdx: 1, to: router, token: tokenA, value: 0n }),
+      data: '0x',
+      logAddress: router,
+      selector: `0x${'9'.repeat(64)}`,
+      topic1: null,
+      topic2: null,
+    }
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: router, token: tokenA, value: 38_129n }),
+      routerLog,
+      transferRow({ from: router, logIdx: 2, to: recipient, token: tokenB, value: 38_127n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer'])
+    const payment = items[0]
+    if (payment?.type !== 'transfer') return
+    expect(payment.data.recipient).toBe(recipient)
+    expect(payment.data.sourceToken).toEqual({ address: tokenA, amount: '38129' })
+    expect(payment.data.destinationToken).toEqual({ address: tokenB, amount: '38127' })
+  })
+
+  test('folds the exact allowance granted to a vault into its deposit', async () => {
+    const asset = '0x4444444444444444444444444444444444444444' as Address.Address
+    const zero = '0x0000000000000000000000000000000000000000' as Address.Address
+    const items = await classify([
+      logRow({
+        address: asset,
+        args: { amount: 100n, owner: viewer, spender: tokenA },
+        eventName: 'Approval',
+        logIdx: 0,
+      }),
+      transferRow({ from: viewer, logIdx: 1, to: tokenA, token: asset, value: 100n }),
+      transferRow({ from: zero, logIdx: 2, to: viewer, token: tokenA, value: 90n }),
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 3,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['assets-deposited'])
+  })
+
+  test('keeps a payment and a later refund in another token as transfers', async () => {
+    const merchant = '0x7777777777777777777777777777777777777777' as Address.Address
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: merchant, token: tokenA, value: 100n }),
+      transferRow({ from: merchant, logIdx: 1, to: viewer, token: tokenB, value: 90n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer', 'transfer'])
+  })
+
+  test('folds an auto-flip order placement into its swap', async () => {
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: stablecoinDex, token: tokenA, value: 1_000n }),
+      transferRow({ from: stablecoinDex, logIdx: 1, to: viewer, token: tokenB, value: 990n }),
+      logRow({
+        address: stablecoinDex,
+        args: {
+          amount: 25n,
+          flipTick: 6,
+          isBid: false,
+          isFlipOrder: true,
+          maker: viewer,
+          orderId: 43n,
+          tick: 5,
+          token: tokenA,
+        },
+        eventName: 'OrderPlaced',
+        logIdx: 2,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['swap'])
+  })
+
+  test('folds both fee legs into a RebalanceSwap', async () => {
+    const tokenB = '0x4444444444444444444444444444444444444444' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: feeManager, token: tokenA, value: 10n }),
+      logRow({
+        address: feeManager,
+        args: {
+          amountIn: 10n,
+          amountOut: 9n,
+          swapper: viewer,
+          userToken: tokenB,
+          validatorToken: tokenA,
+        },
+        eventName: 'RebalanceSwap',
+        logIdx: 1,
+      }),
+      transferRow({ from: feeManager, logIdx: 2, to: viewer, token: tokenB, value: 9n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['fee-rebalance-swap'])
+  })
+
+  test('folds a CloseRequested refund into session-closed', async () => {
+    const refund = transferRow({
+      from: channelReserve,
+      logIdx: 0,
+      to: viewer,
+      token: tokenA,
+      value: 25n,
+    })
+    const items = await classify([
+      refund,
+      {
+        ...refund,
+        data: '0x',
+        logAddress: channelReserve,
+        logIdx: 1,
+        selector: '0xf5a36fc00a96cbb9cf1f8f59299165e1d8ffffe94396d82904b4da524d16bbce',
+        topic1: null,
+        topic2: null,
+      },
+    ])
+    expect(items.map((item) => item.type)).toEqual(['session-closed'])
+    expect(items[0]?.type === 'session-closed' && items[0].data.refund?.amount).toBe('25')
+  })
+
+  test('keeps batched channel settlements paired with their own payout legs', async () => {
+    const payee = '0x7777777777777777777777777777777777777777' as Address.Address
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const channelA = `0x${'a'.repeat(64)}` as Hex.Hex
+    const channelB = `0x${'b'.repeat(64)}` as Hex.Hex
+    const items = await classify([
+      transferRow({ from: channelReserve, logIdx: 0, to: payee, token: tokenA, value: 250n }),
+      logRow({
+        address: channelReserve,
+        args: {
+          channelId: channelA,
+          cumulativeAmount: 250n,
+          deltaPaid: 250n,
+          newSettled: 250n,
+          payee,
+          payer: viewer,
+        },
+        eventName: 'Settled',
+        logIdx: 1,
+      }),
+      transferRow({ from: channelReserve, logIdx: 2, to: payee, token: tokenB, value: 300n }),
+      logRow({
+        address: channelReserve,
+        args: {
+          channelId: channelB,
+          cumulativeAmount: 300n,
+          deltaPaid: 300n,
+          newSettled: 300n,
+          payee,
+          payer: viewer,
+        },
+        eventName: 'Settled',
+        logIdx: 3,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['channel-settled', 'channel-settled'])
+    if (items[0]?.type !== 'channel-settled' || items[1]?.type !== 'channel-settled') return
+    expect(items[0].data.sourceToken.address).toBe(tokenA)
+    expect(items[1].data.sourceToken.address).toBe(tokenB)
+  })
+
+  test('keeps a role grant made after token creation', async () => {
+    const otherAccount = '0x7777777777777777777777777777777777777777' as Address.Address
+    const items = await classify([
+      logRow({
+        address: tokenA,
+        args: { account: viewer, hasRole: true, role: `0x${'1'.repeat(64)}`, sender: viewer },
+        eventName: 'RoleMembershipUpdated',
+        logIdx: 0,
+      }),
+      logRow({
+        address: tip20Factory,
+        args: {
+          admin: viewer,
+          currency: 'USD',
+          name: 'Test',
+          quoteToken: tokenA,
+          salt: `0x${'0'.repeat(64)}`,
+          symbol: 'TST',
+          token: tokenA,
+        },
+        eventName: 'TokenCreated',
+        logIdx: 1,
+      }),
+      logRow({
+        address: tokenA,
+        args: {
+          account: otherAccount,
+          hasRole: true,
+          role: `0x${'2'.repeat(64)}`,
+          sender: viewer,
+        },
+        eventName: 'RoleMembershipUpdated',
+        logIdx: 2,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['token-created', 'role-membership-set'])
+    expect(items[1]?.type === 'role-membership-set' && items[1].data.account).toBe(otherAccount)
+  })
+
+  test('keeps a whitelist update made after its policy was created', async () => {
+    const account = '0x7777777777777777777777777777777777777777' as Address.Address
+    const items = await classify([
+      logRow({
+        address: tokenA,
+        args: { account, allowed: true, policyId: 9n, updater: viewer },
+        eventName: 'WhitelistUpdated',
+        logIdx: 0,
+      }),
+      logRow({
+        address: tokenA,
+        args: { policyId: 9n, policyType: 1, updater: viewer },
+        eventName: 'PolicyCreated',
+        logIdx: 1,
+      }),
+      logRow({
+        address: tokenA,
+        args: { account, allowed: false, policyId: 9n, updater: viewer },
+        eventName: 'WhitelistUpdated',
+        logIdx: 2,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['policy-created', 'whitelist-updated'])
+  })
+
+  test('keeps an unrelated validator addition beside a rotation', async () => {
+    const validator = '0x9999999999999999999999999999999999999999' as Address.Address
+    const feeRecipient = '0xabababababababababababababababababababab' as Address.Address
+    const items = await classify([
+      logRow({
+        address: accountKeychain,
+        args: { index: 1n, validatorAddress: viewer },
+        eventName: 'ValidatorDeactivated',
+        logIdx: 0,
+      }),
+      logRow({
+        address: accountKeychain,
+        args: {
+          egress: 'https://v.example.com:2',
+          feeRecipient,
+          index: 2n,
+          ingress: 'https://v.example.com:1',
+          publicKey: `0x${'2'.repeat(64)}`,
+          validatorAddress: validator,
+        },
+        eventName: 'ValidatorAdded',
+        logIdx: 1,
+      }),
+      logRow({
+        address: accountKeychain,
+        args: {
+          caller: viewer,
+          deactivatedIndex: 1n,
+          egress: 'https://v.example.com:2',
+          index: 2n,
+          ingress: 'https://v.example.com:1',
+          newPublicKey: `0x${'2'.repeat(64)}`,
+          oldPublicKey: `0x${'1'.repeat(64)}`,
+          validatorAddress: validator,
+        },
+        eventName: 'ValidatorRotated',
+        logIdx: 2,
+      }),
+      logRow({
+        address: accountKeychain,
+        args: {
+          egress: 'https://v.example.com:4',
+          feeRecipient,
+          index: 3n,
+          ingress: 'https://v.example.com:3',
+          publicKey: `0x${'4'.repeat(64)}`,
+          validatorAddress: feeRecipient,
+        },
+        eventName: 'ValidatorAdded',
+        logIdx: 3,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['validator-rotated', 'validator-added'])
+  })
+
+  test('keeps an access-key authorization beside a vault deposit', async () => {
+    const publicKey = '0x9999999999999999999999999999999999999999' as Address.Address
+    const items = await classify([
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 0,
+      }),
+      logRow({
+        address: accountKeychain,
+        args: { account: viewer, expiry: 1_800_000_000n, publicKey, signatureType: 1 },
+        eventName: 'KeyAuthorized',
+        logIdx: 1,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['assets-deposited', 'access-key-created'])
+  })
+
+  test('keeps both directions of a receipt-less transaction', async () => {
+    const other = '0x9999999999999999999999999999999999999999' as Address.Address
+    const q2 = transferRow({ from: other, logIdx: 0, to: viewer, token: tokenA, value: 10n })
+    const q3 = transferRow({ from: viewer, logIdx: 1, to: other, token: tokenA, value: 5n })
+    const merged = Activities.mergeAndSort([], [q2], [q3])
+    expect(merged.map((row) => row.logIdx)).toEqual([0, 1])
+  })
+
+  test('keeps duplicate payments when one carries a memo', async () => {
+    const recipient = '0x7777777777777777777777777777777777777777' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: recipient, token: tokenA, value: 10n }),
+      logRow({
+        address: tokenA,
+        args: { amount: 10n, from: viewer, memo: `0x${'1'.repeat(64)}`, to: recipient },
+        eventName: 'TransferWithMemo',
+        logIdx: 1,
+      }),
+      transferRow({ from: viewer, logIdx: 2, to: recipient, token: tokenA, value: 10n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer', 'transfer'])
+  })
+
+  test('keeps a settlement payout beside a refundless session close', async () => {
+    const payee = viewer
+    const closeRow = {
+      ...transferRow({ from: channelReserve, logIdx: 0, to: viewer, token: tokenA, value: 0n }),
+      data: '0x',
+      logAddress: channelReserve,
+      logIdx: 0,
+      selector: '0xf5a36fc00a96cbb9cf1f8f59299165e1d8ffffe94396d82904b4da524d16bbce',
+      topic1: null,
+      topic2: null,
+    }
+    const items = await classify([
+      closeRow,
+      transferRow({ from: channelReserve, logIdx: 1, to: payee, token: tokenA, value: 250n }),
+      logRow({
+        address: channelReserve,
+        args: {
+          channelId: `0x${'c'.repeat(64)}`,
+          cumulativeAmount: 250n,
+          deltaPaid: 250n,
+          newSettled: 250n,
+          payee,
+          payer: viewer,
+        },
+        eventName: 'Settled',
+        logIdx: 2,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['session-closed', 'channel-settled'])
+    if (items[0]?.type !== 'session-closed' || items[1]?.type !== 'channel-settled') return
+    expect(items[0].data.refund).toBeUndefined()
+    expect(items[1].data.sourceToken.address).toBe(tokenA)
+  })
+
+  test('keeps an order placement beside a swap in one batch', async () => {
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const tokenC = '0x6666666666666666666666666666666666666666' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: stablecoinDex, token: tokenA, value: 500n }),
+      logRow({
+        address: stablecoinDex,
+        args: {
+          amount: 500n,
+          flipTick: 0,
+          isBid: true,
+          isFlipOrder: false,
+          maker: viewer,
+          orderId: 7n,
+          tick: 3,
+          token: tokenA,
+        },
+        eventName: 'OrderPlaced',
+        logIdx: 1,
+      }),
+      transferRow({ from: viewer, logIdx: 2, to: stablecoinDex, token: tokenB, value: 1_000n }),
+      transferRow({ from: stablecoinDex, logIdx: 3, to: viewer, token: tokenC, value: 990n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['order-placed', 'swap'])
+    if (items[1]?.type !== 'swap') return
+    expect(items[1].data.sourceToken).toEqual({ address: tokenB, amount: '1000' })
+  })
+
+  test("keeps the viewer's own fill beside a third-party swap", async () => {
+    const other = '0x9999999999999999999999999999999999999999' as Address.Address
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const items = await classify([
+      transferRow({ from: other, logIdx: 0, to: stablecoinDex, token: tokenA, value: 1_000n }),
+      logRow({
+        address: stablecoinDex,
+        args: {
+          amountFilled: 1_000n,
+          maker: viewer,
+          orderId: 7n,
+          partialFill: false,
+          taker: other,
+        },
+        eventName: 'OrderFilled',
+        logIdx: 1,
+      }),
+      transferRow({ from: stablecoinDex, logIdx: 2, to: other, token: tokenB, value: 990n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['swap', 'order-filled'])
+  })
+
+  test('folds the amount-matched vault event into a private Earn deposit', async () => {
+    const actionId = `0x${'c'.repeat(64)}` as Hex.Hex
+    const items = await classify([
+      logRow({
+        address: tokenA,
+        args: { assets: 50n, caller: viewer, earnShares: 45n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 0,
+      }),
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 1,
+      }),
+      logRow({
+        address: tokenA,
+        args: {
+          actionId,
+          earnShares: 90n,
+          earnVault: tokenA,
+          inputAmount: 100n,
+          inputToken: tokenA,
+          vaultAssets: 100n,
+          zoneDepositHash: actionId,
+        },
+        eventName: 'EarnDeposit',
+        logIdx: 2,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['assets-deposited', 'private-assets-deposited'])
+    expect(items[0]?.type === 'assets-deposited' && items[0].data.assets).toBe('50')
+  })
+
+  test('surfaces a fold-only vault operation when nothing else classified', async () => {
+    const other = '0x9999999999999999999999999999999999999999' as Address.Address
+    const asset = '0x4444444444444444444444444444444444444444' as Address.Address
+    const zero = '0x0000000000000000000000000000000000000000' as Address.Address
+    const items = await classify([
+      transferRow({ from: other, logIdx: 0, to: zero, token: tokenA, value: 90n }),
+      transferRow({ from: tokenA, logIdx: 1, to: other, token: asset, value: 100n }),
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, owner: other, receiver: other, sender: other, shares: 90n },
+        eventName: 'Withdraw',
+        logIdx: 2,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['assets-withdrawn'])
+  })
+
+  test('releases claimed legs when an anchor is partially malformed', async () => {
+    const asset = '0x4444444444444444444444444444444444444444' as Address.Address
+    const corrupted = logRow({
+      address: tokenA,
+      args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+      eventName: 'Deposited',
+      logIdx: 1,
+    })
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: tokenA, token: asset, value: 100n }),
+      // Valid amounts with the indexed parties stripped: the builder throws
+      // after claiming the asset leg, which must be released.
+      { ...corrupted, topic1: null, topic2: null },
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer'])
+  })
+
+  test('keeps a cross-token payment beside a same-amount memo payment', async () => {
+    const recipient = '0x7777777777777777777777777777777777777777' as Address.Address
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: recipient, token: tokenB, value: 10n }),
+      logRow({
+        address: tokenA,
+        args: { amount: 10n, from: viewer, memo: `0x${'1'.repeat(64)}`, to: recipient },
+        eventName: 'TransferWithMemo',
+        logIdx: 1,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer', 'transfer'])
+  })
+
+  test('keeps chained swaps through two routes distinct', async () => {
+    const routeA = '0xb92fe925dc43a0ecde6c8b1a2709c170ec4fff4f' as Address.Address
+    const routeB = '0xcafe000000000000000000000000000000000001' as Address.Address
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const tokenC = '0x6666666666666666666666666666666666666666' as Address.Address
+    const routeLog = (route: Address.Address, logIdx: number): Activities.Row => ({
+      ...transferRow({ from: viewer, logIdx, to: route, token: tokenA, value: 0n }),
+      data: '0x',
+      logAddress: route,
+      selector: `0x${'9'.repeat(64)}`,
+      topic1: null,
+      topic2: null,
+    })
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: routeA, token: tokenA, value: 1_000n }),
+      routeLog(routeA, 1),
+      transferRow({ from: routeA, logIdx: 2, to: viewer, token: tokenB, value: 990n }),
+      transferRow({ from: viewer, logIdx: 3, to: routeB, token: tokenB, value: 990n }),
+      routeLog(routeB, 4),
+      transferRow({ from: routeB, logIdx: 5, to: viewer, token: tokenC, value: 980n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['swap', 'swap'])
+  })
+
+  test('keeps an approval to an unrelated spender beside a swap', async () => {
+    const spender = '0x7777777777777777777777777777777777777777' as Address.Address
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const gap: Activities.Row = {
+      ...transferRow({ from: viewer, logIdx: 1, to: spender, token: tokenA, value: 0n }),
+      data: '0x',
+      logAddress: accountKeychain,
+      selector: `0x${'8'.repeat(64)}`,
+      topic1: null,
+      topic2: null,
+    }
+    const items = await classify([
+      logRow({
+        address: tokenA,
+        args: { amount: 1_000n, owner: viewer, spender },
+        eventName: 'Approval',
+        logIdx: 0,
+      }),
+      gap,
+      transferRow({ from: viewer, logIdx: 2, to: stablecoinDex, token: tokenA, value: 1_000n }),
+      transferRow({ from: stablecoinDex, logIdx: 3, to: viewer, token: tokenB, value: 990n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['approval', 'swap'])
+  })
+
+  test('keeps a settlement leg away from a zero-value channel close', async () => {
+    const payee = viewer
+    const channelA = `0x${'a'.repeat(64)}` as Hex.Hex
+    const channelB = `0x${'b'.repeat(64)}` as Hex.Hex
+    const items = await classify([
+      logRow({
+        address: channelReserve,
+        args: {
+          channelId: channelA,
+          payee,
+          payer: viewer,
+          refundedToPayer: 0n,
+          settledToPayee: 0n,
+        },
+        eventName: 'ChannelClosed',
+        logIdx: 0,
+      }),
+      transferRow({ from: channelReserve, logIdx: 1, to: payee, token: tokenA, value: 250n }),
+      logRow({
+        address: channelReserve,
+        args: {
+          channelId: channelB,
+          cumulativeAmount: 250n,
+          deltaPaid: 250n,
+          newSettled: 250n,
+          payee,
+          payer: viewer,
+        },
+        eventName: 'Settled',
+        logIdx: 2,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['channel-closed', 'channel-settled'])
+    if (items[1]?.type !== 'channel-settled') return
+    expect(items[1].data.sourceToken.address).toBe(tokenA)
+  })
+
+  test('keeps an inbound fee-manager payment beside a fee distribution', async () => {
+    const validator = '0xcccccccc00000000000000000000000000000000' as Address.Address
+    const items = await classify([
+      transferRow({ from: feeManager, logIdx: 0, to: viewer, token: tokenA, value: 77n }),
+      transferRow({ from: feeManager, logIdx: 1, to: validator, token: tokenA, value: 77n }),
+      logRow({
+        address: feeManager,
+        args: { amount: 77n, token: tokenA, validator },
+        eventName: 'FeesDistributed',
+        logIdx: 2,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer', 'fees-distributed'])
+  })
+
+  test('keeps a same-amount payment beside a reward funding', async () => {
+    const other = '0x7777777777777777777777777777777777777777' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: other, token: tokenA, value: 77n }),
+      transferRow({ from: viewer, logIdx: 1, to: tokenA, token: tokenA, value: 77n }),
+      logRow({
+        address: tokenA,
+        args: { amount: 77n, funder: viewer },
+        eventName: 'RewardDistributed',
+        logIdx: 2,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer', 'reward-distributed'])
+  })
+
+  test('pairs an order with its own escrow after a same-token swap', async () => {
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: stablecoinDex, token: tokenA, value: 500n }),
+      transferRow({ from: stablecoinDex, logIdx: 1, to: viewer, token: tokenB, value: 495n }),
+      transferRow({ from: viewer, logIdx: 2, to: stablecoinDex, token: tokenA, value: 500n }),
+      logRow({
+        address: stablecoinDex,
+        args: {
+          amount: 500n,
+          flipTick: 0,
+          isBid: true,
+          isFlipOrder: false,
+          maker: viewer,
+          orderId: 7n,
+          tick: 3,
+          token: tokenA,
+        },
+        eventName: 'OrderPlaced',
+        logIdx: 3,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['swap', 'order-placed'])
+  })
+
+  test('pairs interleaved DEX swaps with their own outputs', async () => {
+    const other = '0x9999999999999999999999999999999999999999' as Address.Address
+    const tokenB = '0x5555555555555555555555555555555555555555' as Address.Address
+    const items = await classify([
+      transferRow({ from: other, logIdx: 0, to: stablecoinDex, token: tokenA, value: 1_000n }),
+      transferRow({ from: viewer, logIdx: 1, to: stablecoinDex, token: tokenA, value: 500n }),
+      transferRow({ from: stablecoinDex, logIdx: 2, to: viewer, token: tokenB, value: 495n }),
+      transferRow({ from: stablecoinDex, logIdx: 3, to: other, token: tokenB, value: 990n }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['swap', 'swap'])
+    if (items[0]?.type !== 'swap' || items[1]?.type !== 'swap') return
+    expect(items[0].data.destinationToken.amount).toBe('990')
+    expect(items[1].data.destinationToken.amount).toBe('495')
+  })
+
+  test('keeps an unrelated-token approval to the vault beside a deposit', async () => {
+    const asset = '0x4444444444444444444444444444444444444444' as Address.Address
+    const tokenC = '0x6666666666666666666666666666666666666666' as Address.Address
+    const zero = '0x0000000000000000000000000000000000000000' as Address.Address
+    const items = await classify([
+      logRow({
+        address: tokenC,
+        args: { amount: 100n, owner: viewer, spender: tokenA },
+        eventName: 'Approval',
+        logIdx: 0,
+      }),
+      transferRow({ from: viewer, logIdx: 1, to: tokenA, token: asset, value: 100n }),
+      transferRow({ from: zero, logIdx: 2, to: viewer, token: tokenA, value: 90n }),
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 3,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['approval', 'assets-deposited'])
+  })
+
+  test('folds the nearest preceding vault event into a private Earn deposit', async () => {
+    const actionId = `0x${'c'.repeat(64)}` as Hex.Hex
+    const items = await classify([
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 0,
+      }),
+      logRow({
+        address: tokenA,
+        args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+        eventName: 'Deposited',
+        logIdx: 1,
+      }),
+      logRow({
+        address: tokenA,
+        args: {
+          actionId,
+          earnShares: 90n,
+          earnVault: tokenA,
+          inputAmount: 100n,
+          inputToken: tokenA,
+          vaultAssets: 100n,
+          zoneDepositHash: actionId,
+        },
+        eventName: 'EarnDeposit',
+        logIdx: 2,
+      }),
+    ])
+    expect(items.map((item) => item.type)).toEqual(['assets-deposited', 'private-assets-deposited'])
+    expect(items[0]?.id.endsWith('-0')).toBe(true)
+  })
+
+  test('keeps earlier activities when a later event is malformed', async () => {
+    const recipient = '0x7777777777777777777777777777777777777777' as Address.Address
+    const corrupted = logRow({
+      address: tokenA,
+      args: { assets: 100n, caller: viewer, earnShares: 90n, receiver: viewer },
+      eventName: 'Deposited',
+      logIdx: 1,
+    })
+    const items = await classify([
+      transferRow({ from: viewer, logIdx: 0, to: recipient, token: tokenA, value: 10n }),
+      // Valid topics with truncated data: the event decodes but its builder
+      // cannot read the amounts, which must not discard the whole transaction.
+      { ...corrupted, data: '0x' },
+    ])
+    expect(items.map((item) => item.type)).toEqual(['transfer'])
+  })
+})
+
+/**
+ * Replays real Tempo mainnet receipts (raw logs, topics, and data) through the
+ * classifier, covering batch transactions whose activities the old headline
+ * classifier collapsed or misread.
+ */
+describe('Activities.list receipt replays', () => {
+  const viewer = '0x03ef854275a0f914a0f34db6756a59f20c821989' as Address.Address
+  const txHash = `0x${'d'.repeat(64)}` as Hex.Hex
+
+  function store() {
+    const store = Store.memory()
+    void store.put('mpp-services:v1', JSON.stringify({}))
+    return store
+  }
+
+  type ReceiptLog = {
+    address: string
+    data: string
+    logIdx: number
+    topics: readonly string[]
+  }
+
+  /** Maps a raw receipt log to a Q1 row, viewer as the transaction sender. */
+  function receiptRow(log: ReceiptLog): Activities.Row {
+    return {
+      blockNum: 100,
+      blockTimestamp: 1_700_000_000,
+      data: log.data,
+      feePayer: null,
+      logAddress: log.address as Address.Address,
+      logIdx: log.logIdx,
+      selector: log.topics[0] ?? null,
+      source: 'q1',
+      topic1: log.topics[1] ?? null,
+      topic2: log.topics[2] ?? null,
+      topic3: log.topics[3] ?? null,
+      txHash,
+      txIdx: 0,
+      txSender: viewer,
+    }
+  }
+
+  async function classify(logs: readonly ReceiptLog[]) {
+    const provider: Activities.Provider = {
+      cursorForGroup: (group) => `${group.blockNum}:${group.txIdx}`,
+      fetchRows: async () => ({ rows: logs.map(receiptRow) }),
+    }
+    const { items } = await Activities.list(provider, { address: viewer, store: store() })
+    return items
+  }
+
+  const routerSwapLogs = [
+    {
+      address: '0x20c000000000000000000000b9537d11c60e8b50',
+      data: '0x000000000000000000000000000000000000000000000000000000000010dc68',
+      logIdx: 0,
+      topics: [
+        '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925',
+        '0x00000000000000000000000003ef854275a0f914a0f34db6756a59f20c821989',
+        '0x000000000000000000000000ccc88a9d1b4ed6b0eaba998850414b24f1c315be',
+      ],
+    },
+    {
+      address: '0x20c000000000000000000000b9537d11c60e8b50',
+      data: '0x000000000000000000000000000000000000000000000000000000000010dc68',
+      logIdx: 1,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x00000000000000000000000003ef854275a0f914a0f34db6756a59f20c821989',
+        '0x000000000000000000000000b92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+      ],
+    },
+    {
+      address: '0xccc88a9d1b4ed6b0eaba998850414b24f1c315be',
+      data: '0x00000000000000000000000003ef854275a0f914a0f34db6756a59f20c821989000000000000000000000000b92fe925dc43a0ecde6c8b1a2709c170ec4fff4f00000000000000000000000020c000000000000000000000b9537d11c60e8b50000000000000000000000000000000000000000000000000000000000010dc6800000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000217eb7a8dfb83149821d35b62fbd7880e2fe6e29f04133156c1adb203c95d7e2a40000000000000000000000000000000000000000000000000000000000000000',
+      logIdx: 2,
+      topics: ['0xafbab204e8271965231d37baed9b1abca8725b7409c70314455f68bc89142b91'],
+    },
+    {
+      address: '0x20c000000000000000000000b9537d11c60e8b50',
+      data: '0x000000000000000000000000000000000000000000000000000000000010dc68',
+      logIdx: 3,
+      topics: [
+        '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925',
+        '0x000000000000000000000000b92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+        '0x0000000000000000000000000000000000001ff3684f28c67538d4d072c22734',
+      ],
+    },
+    {
+      address: '0xb92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+      data: '0x00000000000000000000000020c000000000000000000000b9537d11c60e8b50000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044095ea7b30000000000000000000000000000000000001ff3684f28c67538d4d072c22734000000000000000000000000000000000000000000000000000000000010dc6800000000000000000000000000000000000000000000000000000000',
+      logIdx: 4,
+      topics: ['0x93485dcd31a905e3ffd7b012abe3438fa8fa77f98ddc9f50e879d3fa7ccdc324'],
+    },
+    {
+      address: '0x20c000000000000000000000b9537d11c60e8b50',
+      data: '0x00000000000000000000000000000000000000000000000000000000000003ab',
+      logIdx: 5,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x000000000000000000000000b92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+        '0x000000000000000000000000f70da97812cb96acdf810712aa562db8dfa3dbef',
+      ],
+    },
+    {
+      address: '0xb92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+      data: '0x000000000000000000000000b92fe925dc43a0ecde6c8b1a2709c170ec4fff4f000000000000000000000000f70da97812cb96acdf810712aa562db8dfa3dbef00000000000000000000000020c000000000000000000000b9537d11c60e8b5000000000000000000000000000000000000000000000000000000000000003ab00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000217eb7a8dfb83149821d35b62fbd7880e2fe6e29f04133156c1adb203c95d7e2a40100000000000000000000000000000000000000000000000000000000000000',
+      logIdx: 6,
+      topics: ['0xafbab204e8271965231d37baed9b1abca8725b7409c70314455f68bc89142b91'],
+    },
+    {
+      address: '0xb92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+      data: '0x000000000000000000000000b92fe925dc43a0ecde6c8b1a2709c170ec4fff4f0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001a49bb43718000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000000100000000000000000000000020c000000000000000000000b9537d11c60e8b500000000000000000000000000000000000000000000000000000000000000001000000000000000000000000f70da97812cb96acdf810712aa562db8dfa3dbef000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000003ab00000000000000000000000000000000000000000000000000000000000000217eb7a8dfb83149821d35b62fbd7880e2fe6e29f04133156c1adb203c95d7e2a4010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      logIdx: 7,
+      topics: ['0x93485dcd31a905e3ffd7b012abe3438fa8fa77f98ddc9f50e879d3fa7ccdc324'],
+    },
+    {
+      address: '0x33620f62c5b9b2086dd6b62f4a297a9f30347029',
+      data: '0x000000000000000000000000000000000000000000000000000000000010d8dcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffef27430000000000000000000000000000000000000000fffbc94d34a6b108b32b149a00000000000000000000000000000000000000000000000000001d36428c070cfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0000000000000000000000000000000000000000000000000000000000000064',
+      logIdx: 8,
+      topics: [
+        '0x40e9cecb9f5f1f1c5b9c97dec2917b7ee92e57ba5563708daca94dd84ad7112f',
+        '0xbd170b4ccb7f5da2565e00d5bbfa4777187b20ffb824412766463c162a47d78a',
+        '0x000000000000000000000000e59f2f6ace8b9f985900f14462fbaa40385ce441',
+      ],
+    },
+    {
+      address: '0x20c0000000000000000000000000000000000000',
+      data: '0x000000000000000000000000000000000000000000000000000000000010d8dc',
+      logIdx: 9,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x00000000000000000000000033620f62c5b9b2086dd6b62f4a297a9f30347029',
+        '0x000000000000000000000000e59f2f6ace8b9f985900f14462fbaa40385ce441',
+      ],
+    },
+    {
+      address: '0x20c000000000000000000000b9537d11c60e8b50',
+      data: '0x000000000000000000000000000000000000000000000000000000000010d8bd',
+      logIdx: 10,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x000000000000000000000000b92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+        '0x00000000000000000000000033620f62c5b9b2086dd6b62f4a297a9f30347029',
+      ],
+    },
+    {
+      address: '0x20c0000000000000000000000000000000000000',
+      data: '0x000000000000000000000000000000000000000000000000000000000010d8dc',
+      logIdx: 11,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x000000000000000000000000e59f2f6ace8b9f985900f14462fbaa40385ce441',
+        '0x000000000000000000000000b92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+      ],
+    },
+    {
+      address: '0xb92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+      data: '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',
+      logIdx: 12,
+      topics: ['0x93485dcd31a905e3ffd7b012abe3438fa8fa77f98ddc9f50e879d3fa7ccdc324'],
+    },
+    {
+      address: '0x20c0000000000000000000000000000000000000',
+      data: '0x000000000000000000000000000000000000000000000000000000000010d8dc',
+      logIdx: 13,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x000000000000000000000000b92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+        '0x00000000000000000000000003ef854275a0f914a0f34db6756a59f20c821989',
+      ],
+    },
+    {
+      address: '0xb92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+      data: '0x000000000000000000000000b92fe925dc43a0ecde6c8b1a2709c170ec4fff4f00000000000000000000000003ef854275a0f914a0f34db6756a59f20c82198900000000000000000000000020c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010d8dc00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000217eb7a8dfb83149821d35b62fbd7880e2fe6e29f04133156c1adb203c95d7e2a40000000000000000000000000000000000000000000000000000000000000000',
+      logIdx: 14,
+      topics: ['0xafbab204e8271965231d37baed9b1abca8725b7409c70314455f68bc89142b91'],
+    },
+    {
+      address: '0xb92fe925dc43a0ecde6c8b1a2709c170ec4fff4f',
+      data: '0x000000000000000000000000b92fe925dc43a0ecde6c8b1a2709c170ec4fff4f0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001a49bb43718000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000000100000000000000000000000020c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000003ef854275a0f914a0f34db6756a59f20c8219890000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000217eb7a8dfb83149821d35b62fbd7880e2fe6e29f04133156c1adb203c95d7e2a4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      logIdx: 15,
+      topics: ['0x93485dcd31a905e3ffd7b012abe3438fa8fa77f98ddc9f50e879d3fa7ccdc324'],
+    },
+    {
+      address: '0x20c0000000000000000000000000000000000000',
+      data: '0x00000000000000000000000000000000000000000000000000000000000000ab',
+      logIdx: 16,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x00000000000000000000000058aa7ce42e1d13b2919e2ac7e006c4fbc171442c',
+        '0x000000000000000000000000feec000000000000000000000000000000000000',
+      ],
+    },
+  ]
+
+  const vaultWithdrawLogs = [
+    {
+      address: '0x0ec811f25e8fc247fe98faf32b90a48683d62f05',
+      data: '0x00000000000000000000000000000000000000000000000000000000156963bb00000000000000000000000000000000000000000000000000000000156963bb00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      logIdx: 0,
+      topics: ['0x4dec04e750ca11537cabcd8a9eab06494de08da3735bc8871cd41250e190bc04'],
+    },
+    {
+      address: '0x9a044ae05e5e6290dcf56afd69548565e957a626',
+      data: '0x000000000000000000000000000000000000000000000000000014bc099ff380000000000000000000000000000000000000000000000000000014bc09a0344000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      logIdx: 1,
+      topics: ['0x4dec04e750ca11537cabcd8a9eab06494de08da3735bc8871cd41250e190bc04'],
+    },
+    {
+      address: '0x9a044ae05e5e6290dcf56afd69548565e957a626',
+      data: '0x00000000000000000000000000000000000000000000000000b1bcfa85011524',
+      logIdx: 2,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x000000000000000000000000004ad9220bce494c1f1892ee4965972fde188d51',
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
+      ],
+    },
+    {
+      address: '0x20c0000000000000000000000000000000000000',
+      data: '0x00000000000000000000000000000000000000000000000000000000000186a0',
+      logIdx: 3,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x0000000000000000000000009a044ae05e5e6290dcf56afd69548565e957a626',
+        '0x000000000000000000000000004ad9220bce494c1f1892ee4965972fde188d51',
+      ],
+    },
+    {
+      address: '0x9a044ae05e5e6290dcf56afd69548565e957a626',
+      data: '0x00000000000000000000000000000000000000000000000000000000000186a000000000000000000000000000000000000000000000000000b1bcfa85011524',
+      logIdx: 4,
+      topics: [
+        '0xfbde797d201c681b91056529119e0b02407c7bb96a4a2c75c01fc9667232c8db',
+        '0x000000000000000000000000004ad9220bce494c1f1892ee4965972fde188d51',
+        '0x000000000000000000000000004ad9220bce494c1f1892ee4965972fde188d51',
+        '0x000000000000000000000000004ad9220bce494c1f1892ee4965972fde188d51',
+      ],
+    },
+    {
+      address: '0x20c0000000000000000000000000000000000000',
+      data: '0x00000000000000000000000000000000000000000000000000000000000186a0',
+      logIdx: 5,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x000000000000000000000000004ad9220bce494c1f1892ee4965972fde188d51',
+        '0x0000000000000000000000000ec811f25e8fc247fe98faf32b90a48683d62f05',
+      ],
+    },
+    {
+      address: '0x0ec811f25e8fc247fe98faf32b90a48683d62f05',
+      data: '0x00000000000000000000000000000000000000000000000000000000000186a00000000000000000000000000000000000000000000000000000000000000060fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe79600000000000000000000000000000000000000000000000000000000000000001cad5f244418b485269ca822a1e213ac83a6fed12d0c16e0741eb94e4545b05e8',
+      logIdx: 6,
+      topics: [
+        '0xd602b36fb24934aef1bc2a658de029b486fa4c664a6e45de1f48e3fd1be25dd9',
+        '0x00000000000000000000000003ef854275a0f914a0f34db6756a59f20c821989',
+        '0x000000000000000000000000004ad9220bce494c1f1892ee4965972fde188d51',
+      ],
+    },
+    {
+      address: '0x0ec811f25e8fc247fe98faf32b90a48683d62f05',
+      data: '0x00000000000000000000000000000000000000000000000001634373939b29b4',
+      logIdx: 7,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x00000000000000000000000003ef854275a0f914a0f34db6756a59f20c821989',
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
+      ],
+    },
+    {
+      address: '0x20c0000000000000000000000000000000000000',
+      data: '0x00000000000000000000000000000000000000000000000000000000000186a0',
+      logIdx: 8,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x0000000000000000000000000ec811f25e8fc247fe98faf32b90a48683d62f05',
+        '0x00000000000000000000000003ef854275a0f914a0f34db6756a59f20c821989',
+      ],
+    },
+    {
+      address: '0x0ec811f25e8fc247fe98faf32b90a48683d62f05',
+      data: '0x00000000000000000000000000000000000000000000000000000000000186a000000000000000000000000000000000000000000000000001634373939b29b4',
+      logIdx: 9,
+      topics: [
+        '0xfbde797d201c681b91056529119e0b02407c7bb96a4a2c75c01fc9667232c8db',
+        '0x00000000000000000000000003ef854275a0f914a0f34db6756a59f20c821989',
+        '0x00000000000000000000000003ef854275a0f914a0f34db6756a59f20c821989',
+        '0x00000000000000000000000003ef854275a0f914a0f34db6756a59f20c821989',
+      ],
+    },
+    {
+      address: '0x20c0000000000000000000000000000000000000',
+      data: '0x00000000000000000000000000000000000000000000000000000000000186a0',
+      logIdx: 10,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x00000000000000000000000003ef854275a0f914a0f34db6756a59f20c821989',
+        '0x00000000000000000000000076a21038ea44d8942c0765175f05d34fcfb838ab',
+      ],
+    },
+    {
+      address: '0x20c0000000000000000000000000000000000000',
+      data: '0x0000000000000000000000000000000000000000000000000000000000000096',
+      logIdx: 11,
+      topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x00000000000000000000000058aa7ce42e1d13b2919e2ac7e006c4fbc171442c',
+        '0x000000000000000000000000feec000000000000000000000000000000000000',
+      ],
+    },
+  ]
+
+  test('classifies a router swap instead of a lonely approval', async () => {
+    // 0xd8be4bfb370d4395c45fb587686b0bd83b01228871896926e92d66d15f25838b
+    // (chain 4217): 1.105 USDC.e swapped to pathUSD through a route account.
+    const items = await classify(routerSwapLogs)
+    expect(items.map((item) => item.type)).toEqual(['swap'])
+    const swap = items[0]
+    if (swap?.type !== 'swap') return
+    expect(swap.data.sourceToken).toEqual({
+      address: '0x20c000000000000000000000b9537d11c60e8b50',
+      amount: '1105000',
+    })
+    expect(swap.data.destinationToken).toEqual({
+      address: '0x20c0000000000000000000000000000000000000',
+      amount: '1104092',
+    })
+  })
+
+  test('classifies a batched vault withdrawal and payment separately', async () => {
+    // 0xf438783016504c10273a74631730fef8bfd5209a655c3e1ea7a87848d6406a7c
+    // (chain 4217): ERC-4626 withdraw of 0.10 pathUSD, then a 0.10 pathUSD
+    // payment. The old classifier reported a single `burn`.
+    const items = await classify(vaultWithdrawLogs)
+    expect(items.map((item) => item.type)).toEqual(['assets-withdrawn', 'transfer'])
+    const withdrawal = items[0]
+    if (withdrawal?.type !== 'assets-withdrawn') return
+    expect(withdrawal.data.vault).toBe('0x0ec811f25e8fc247fe98faf32b90a48683d62f05')
+    expect(withdrawal.data.assets).toBe('100000')
+    expect(withdrawal.data.receiver).toBe(viewer)
+    const payment = items[1]
+    if (payment?.type !== 'transfer') return
+    expect(payment.data.direction).toBe('out')
+    expect(payment.data.recipient).toBe('0x76a21038ea44d8942c0765175f05d34fcfb838ab')
+    expect(payment.data.sourceToken).toEqual({
+      address: '0x20c0000000000000000000000000000000000000',
+      amount: '100000',
+    })
+  })
 })