tapimo 0.12.0 → 0.13.0

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

@@ -655,7 +655,7 @@ describe('GET /transactions/:transactionHash/activities', () => {
         account: account.address,
         token: Addresses.pathUsd,
       })
-      await Actions.zone.depositSync(Tempo.getClient({ account }), {
+      const zoneDeposit = await Actions.zone.depositSync(Tempo.getClient({ account }), {
         amount: 1_000_000n,
         portalAddress: zoneCreated.args.portal,
         token: Addresses.pathUsd,
@@ -721,6 +721,48 @@ describe('GET /transactions/:transactionHash/activities', () => {
       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(
@@ -760,10 +802,14 @@ describe('GET /transactions/:transactionHash/activities', () => {
               response,
               Activities.schema.getAddressActivities.Response,
             )
+            const hashes = body.data.flatMap((item) =>
+              item.type === 'group'
+                ? item.data.items.map(({ transactionHash }) => transactionHash)
+                : [item.transactionHash],
+            )
             if (
-              body.data.some(
-                (item) => item.type !== 'group' && item.transactionHash === receipt.transactionHash,
-              )
+              hashes.includes(receipt.transactionHash) &&
+              hashes.includes(zoneDeposit.receipt.transactionHash)
             )
               return { body, response }
           }
@@ -776,6 +822,35 @@ describe('GET /transactions/:transactionHash/activities', () => {
       )
       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,
   )
@@ -841,7 +916,38 @@ describe('Activities.list classification', () => {
     }
   }
 
-  test('merges Zone pages and retains each provider cursor', async () => {
+  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,
@@ -855,13 +961,13 @@ describe('Activities.list classification', () => {
         provider: pagedProvider([unknownRow({ blockNum: 20, blockTimestamp: 200, hash: 'b' })]),
       },
     ]
-    const first = await Activities.listZones({
+    const first = await Activities.listChains({
       address: viewer,
       limit: 2,
       providers,
       store: store(),
     })
-    const second = await Activities.listZones({
+    const second = await Activities.listChains({
       address: viewer,
       cursor: first.nextCursor!,
       limit: 2,
@@ -878,7 +984,7 @@ describe('Activities.list classification', () => {
     expect(second.nextCursor).toBeNull()
   })
 
-  test('retains unused Zone buffers while filling a grouped page', async () => {
+  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 = [
@@ -904,7 +1010,7 @@ describe('Activities.list classification', () => {
       }
     })
 
-    const result = await Activities.listZones({
+    const result = await Activities.listChains({
       address: viewer,
       group: true,
       limit: 2,
@@ -927,7 +1033,7 @@ describe('Activities.list classification', () => {
     expect(result.nextCursor).toBeNull()
   })
 
-  test('does not fold access-key activity across Zones', async () => {
+  test('does not fold access-key activity across chains', async () => {
     const signer = '0x3333333333333333333333333333333333333333' as Address.Address
     const providers = [10, 20].map((chainId) => ({
       chainId,
@@ -939,7 +1045,7 @@ describe('Activities.list classification', () => {
         },
       ]),
     }))
-    const result = await Activities.listZones({
+    const result = await Activities.listChains({
       address: viewer,
       providers,
       store: store(),
@@ -1122,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[]
     }
@@ -1810,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',
+    })
+  })
 })