tapimo 0.11.0 → 0.13.0

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

@@ -22,6 +22,7 @@ import * as Ttl from '../../../internal/Ttl.js'
 import * as Value from '../../../internal/Value.js'
 import * as VerifiedTokens from '../../../internal/VerifiedTokens.js'
 import * as FxOracle from '../FxOracle.js'
+import * as ZoneSelection from '../ZoneSelection.js'
 import * as Tokens from './tokens.js'
 import * as Transfers from './transfers.js'
 import * as Valuation from './valuation.js'
@@ -29,7 +30,7 @@ import * as Valuation from './valuation.js'
 /** Example transaction hash surfaced in OpenAPI docs. */
 const exampleHash = '0x4845ae2098724ab26a5d89370dce5124d044be6a5acc164afc348662de67d474'
 
-const tokenFields = ['token.logoUri', 'token.verified'] as const
+const includeFields = ['token.logoUri', 'token.verified', 'zones'] as const
 
 // TIP-20 tokens live at deterministic `0x20c0…` addresses. Other contracts
 // can emit the same `Transfer` signature but do not expose TIP-20 metadata.
@@ -45,47 +46,49 @@ export namespace schema {
     )
 
   /** A token with required RPC metadata and optional curated fields. */
-  export const Token = Schema.describe(
-    Tokens.schema.TokenReference,
-    'A token referenced by an activity item.',
+  export const Token = OpenApi.component(
+    Schema.describe(Tokens.schema.TokenReference, 'A token referenced by an activity item.'),
+    'ActivityToken',
   )
 
-  /** A token amount carrying its nominal value in the requested denomination. */
-  const ValuedAmount = z.extend(Schema.TokenAmount, {
-    valuation: z
-      .optional(z.nullable(Valuation.schema.Value))
-      .check(
-        z.describe(
-          'The amount’s nominal value in the requested `valuation.currency`. `null` when the token is ' +
-            'unverified, its display currency has no rate, or rates were unavailable.',
+  const ValuedAmount = Schema.describe(
+    z.extend(Schema.TokenAmount, {
+      valuation: z
+        .optional(z.nullable(Valuation.schema.Value))
+        .check(
+          z.describe(
+            'The amount’s nominal value in the requested `valuation.currency`. `null` when the token is ' +
+              'unverified, its display currency has no rate, or rates were unavailable.',
+          ),
         ),
-      ),
-  })
-
-  /** Self-contained amount for a destination token. */
-  const DestinationAmount = ValuedAmount.check(
-    z.describe('Amount associated with `destinationToken`.'),
+    }),
+    'A token amount carrying its nominal value in the requested denomination.',
   )
 
-  /** Self-contained amount for a refunded token. */
-  const RefundAmount = ValuedAmount.check(z.describe('Amount associated with `refund`.'))
+  const valuedAmount = OpenApi.component(ValuedAmount, 'ActivityValuedAmount')
+
+  const DestinationAmount = valuedAmount
+
+  const RefundAmount = valuedAmount
 
-  /** Self-contained amount for a source token. */
-  const SourceAmount = ValuedAmount.check(z.describe('Amount associated with `sourceToken`.'))
+  const SourceAmount = valuedAmount
 
   /** Page-level resources: valuation rate provenance. */
-  export const Meta = z
-    .object({
-      valuation: z
-        .optional(Valuation.schema.Pricing)
-        .check(
-          z.describe(
-            'Rate provenance for amount valuations. Present when conversion rates were ' +
-              'consulted; absent when every value was identity-valued or rates were unavailable.',
+  export const Meta = OpenApi.component(
+    z
+      .object({
+        valuation: z
+          .optional(Valuation.schema.Pricing)
+          .check(
+            z.describe(
+              'Rate provenance for amount valuations. Present when conversion rates were ' +
+                'consulted; absent when every value was identity-valued or rates were unavailable.',
+            ),
           ),
-        ),
-    })
-    .check(z.describe('Page-level resources attached to this response.'))
+      })
+      .check(z.describe('Page-level resources attached to this response.')),
+    'ActivityMeta',
+  )
 
   /** A token transfer with subject-relative direction and signer fields. */
   export const Transfer = z
@@ -159,6 +162,8 @@ export namespace schema {
       z.describe('One token transfer involving the requested address.'),
     )
 
+  const activityTransfer = OpenApi.component(Transfer, 'ActivityTransfer')
+
   /**
    * One transaction log, decoded into a known Tempo event when possible. The
    * raw fields (`address`/`data`/`logIndex`/`topics`) are always present so no
@@ -195,6 +200,8 @@ export namespace schema {
       ),
     )
 
+  const activityEvent = OpenApi.component(event, 'ActivityEvent')
+
   /**
    * Fields shared by every activity item. `transactionHash`/`timestamp` identify and sort
    * the entry; `data` carries the type-specific payload — shaped like the
@@ -202,6 +209,12 @@ export namespace schema {
    * transfer's `direction`/`memo`/`attribution`/`signer`) the resource lacks.
    */
   const base = {
+    chainId: z
+      .optional(Schema.ChainId)
+      .check(
+        z.describe('Chain ID containing this activity. Returned when `include=zones`.'),
+        z.meta({ examples: [421700001] }),
+      ),
     perspective: z
       .enum(['incoming', 'outgoing'])
       .check(
@@ -210,7 +223,7 @@ export namespace schema {
         ),
       ),
     events: z
-      .optional(z.array(event))
+      .optional(z.array(activityEvent))
       .check(
         z.describe(
           'Every log in the transaction, decoded when possible, so nothing is hidden. Returned only when the request sets `logs=true`, except on `unknown` items where it is always present.',
@@ -246,8 +259,7 @@ export namespace schema {
     transactionHash: Schema.Hash.check(z.describe('Transaction hash for this activity.')),
   }
 
-  /** The classified activity item variants (discriminated by `type`). */
-  export const items = [
+  const itemSchemas = [
     z
       .object({
         ...base,
@@ -391,7 +403,7 @@ export namespace schema {
     z
       .object({
         ...base,
-        data: Transfer.check(
+        data: activityTransfer.check(
           z.describe('Transfer details with feed-relative direction and signer fields.'),
         ),
         type: z
@@ -989,9 +1001,7 @@ export namespace schema {
             logoUri: z.string().check(
               z.describe('New logo URL for the token.'),
               z.meta({
-                examples: [
-                  'https://api.tempo.xyz/data/4217/icons/0x20c0000000000000000000008f5425160ebe5525.svg',
-                ],
+                examples: [Tokens.tokenExample.logoUri],
               }),
             ),
             signer: Signer,
@@ -1474,14 +1484,31 @@ export namespace schema {
       .check(z.meta({ title: 'Unknown' })),
   ] as const
 
+  /** The classified activity item variants (discriminated by `type`). */
+  export const items = itemSchemas.map((item) => {
+    const [type] = item.shape.type.def.values
+    if (typeof type !== 'string') throw new Error('Activity item schemas require a string type.')
+    const name = `ActivityItem${type
+      .replace(/[^A-Za-z0-9]+(.)/g, (_, character: string) => character.toUpperCase())
+      .replace(/^(.)/, (character) => character.toUpperCase())}`
+    return OpenApi.component(item, name)
+  }) as unknown as typeof itemSchemas
+
   /** A single classified activity item. */
-  export const Item = z
-    .union(items)
-    .check(z.describe('One classified activity item in the address feed.'))
+  export const Item = OpenApi.component(
+    z.union(items).check(z.describe('One classified activity item in the address feed.')),
+    'ActivityItem',
+  )
 
   /** A folded access-key group: consecutive same-signer items on one UTC day. */
   export const Group = z
     .object({
+      chainId: z
+        .optional(Schema.ChainId)
+        .check(
+          z.describe('Chain ID containing this activity group. Returned when `include=zones`.'),
+          z.meta({ examples: [421700001] }),
+        ),
       data: z
         .object({
           items: z.array(Item).check(z.describe('Activity items included in this group.')),
@@ -1518,20 +1545,27 @@ export namespace schema {
       z.describe('A group of consecutive activity items signed by the same access key.'),
     )
 
+  const activityGroup = OpenApi.component(Group, 'ActivityGroup')
+
   /** A single activity item, or a folded access-key group. */
-  export const Entry = z
-    .union([...items, Group])
-    .check(z.describe('Either one activity item, or a grouped set of access-key activity items.'))
+  export const Entry = OpenApi.component(
+    z
+      .union([Item, activityGroup])
+      .check(
+        z.describe('Either one activity item, or a grouped set of access-key activity items.'),
+      ),
+    'ActivityEntry',
+  )
 
-  /** Optional token fields that require sources beyond RPC metadata. */
+  /** Optional activity resources and selection modes. */
   export const Include = z
-    .enum(tokenFields)
-    .check(z.describe('Additional token fields to include in activity responses.'))
+    .enum(includeFields)
+    .check(z.describe('Additional activity resources and selection modes to include.'))
 
-  /** Parses comma-separated optional token fields. */
+  /** Parses comma-separated optional activity resources and selection modes. */
   export const includeQuery = Schema.includeQuery(
     Include,
-    'Comma-separated token fields to include, such as `token.logoUri,token.verified`.',
+    'Comma-separated activity options. `zones` combines the selected parent chain with every readable Zone.',
   )
 
   /** Schemas for the getAddressActivities operation. */
@@ -1585,15 +1619,18 @@ export namespace schema {
      * `group=true`) plus the root `nextCursor` pagination field shared with
      * other list endpoints.
      */
-    export const Response = z
-      .object({
-        data: z.array(Entry).check(z.describe('Activity feed entries for the address.')),
-        meta: z
-          .optional(schema.Meta)
-          .check(z.describe('Page-level resources, such as valuation rate provenance.')),
-        nextCursor: Schema.NextCursor,
-      })
-      .check(z.describe('A page of human-readable activity for the address.'))
+    export const Response = OpenApi.component(
+      z
+        .object({
+          data: z.array(Entry).check(z.describe('Activity feed entries for the address.')),
+          meta: z
+            .optional(schema.Meta)
+            .check(z.describe('Page-level resources, such as valuation rate provenance.')),
+          nextCursor: Schema.NextCursor,
+        })
+        .check(z.describe('A page of human-readable activity for the address.')),
+      'AddressActivityList',
+    )
   }
 
   /** Schemas for the getTransactionActivities operation. */
@@ -1629,19 +1666,26 @@ export namespace schema {
       .check(z.describe('Query parameters for the transaction activity request.'))
 
     /**
-     * The classified activity for one transaction: a list of `data` items
-     * (usually one headline item, occasionally more) describing what the
-     * transaction did onchain. Unpaginated — a single transaction is finite —
-     * so there is no `nextCursor`.
+     * The classified activity for one transaction: a list of `data` items,
+     * one per independent activity, describing what the transaction did
+     * onchain. Unpaginated (a single transaction is finite), so there is no
+     * `nextCursor`.
      */
-    export const Response = z
-      .object({
-        data: z.array(Item).check(z.describe('Activity items classified from the transaction.')),
-        meta: z
-          .optional(schema.Meta)
-          .check(z.describe('Page-level resources, such as valuation rate provenance.')),
-      })
-      .check(z.describe('The human-readable activity that happened on a transaction.'))
+    export const Response = OpenApi.component(
+      z
+        .object({
+          chainId: Schema.ChainId.check(
+            z.describe('Chain ID containing the transaction.'),
+            z.meta({ examples: [4217] }),
+          ),
+          data: z.array(Item).check(z.describe('Activity items classified from the transaction.')),
+          meta: z
+            .optional(schema.Meta)
+            .check(z.describe('Page-level resources, such as valuation rate provenance.')),
+        })
+        .check(z.describe('The human-readable activity that happened on a transaction.')),
+      'TransactionActivityList',
+    )
   }
 }
 
@@ -1773,6 +1817,7 @@ const titleByEventName: Record<string, string> = {
   BlacklistUpdated: 'Blacklist updated',
   Burn: 'Token burned',
   BurnBlocked: 'Burn blocked',
+  Deposit: 'Assets deposited',
   Deposited: 'Assets deposited',
   EarnDeposit: 'Private assets deposited',
   EarnRedeem: 'Private shares redeemed',
@@ -1781,6 +1826,7 @@ const titleByEventName: Record<string, string> = {
   RedeemRequested: 'Share redemption requested',
   Redeemed: 'Shares redeemed',
   VenueSharesDeposited: 'Shares deposited',
+  Withdraw: 'Assets withdrawn',
   WithdrewExact: 'Assets withdrawn',
   ChannelClosed: 'Channel closed',
   ChannelOpened: 'Channel opened',
@@ -1848,6 +1894,33 @@ const accessKeySpendSelector = '0xe0815e3aaadddf4dd75bde97fc060f0c38afe18e87a169
 /** TIP-20 / ERC-20 `Transfer` event signature for the decoded CTE. */
 const transferSignature = 'event Transfer(address indexed from, address indexed to, uint256 value)'
 
+// Standard ERC-4626 vault events, absent from the merged `viem/tempo` ABI.
+// Decoding them lets external vault deposits/withdrawals classify instead of
+// falling through to the share-token mint/burn legs.
+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
+
 // TIP-20 payment-channel reserve precompile. Not exported by `viem/tempo`
 // `Addresses`, so the known address is pinned here: channel events
 // (`ChannelOpened`/`Settled`/`TopUp`/`ChannelClosed`) are emitted here, and
@@ -1855,6 +1928,14 @@ const transferSignature = 'event Transfer(address indexed from, address indexed
 // is how `channel-funded`/`channel-settled`/`channel-closed` recover the token.
 const tip20ChannelReserve = '0x4d50500000000000000000000000000000000000' as Address.Address
 
+// Tempo system addresses other than the DEX are never swap-route
+// counterparties; a newly shipped precompile joins the exclusion automatically.
+const nonRouteSystemAddresses = new Set(
+  [...Object.values(Addresses), tip20ChannelReserve]
+    .filter((value) => value !== Addresses.stablecoinDex)
+    .map((value) => value.toLowerCase()),
+)
+
 /** Number of grouped entries to target before stopping the page-fetch loop. */
 const minGroupEntries = 5
 
@@ -1981,7 +2062,12 @@ export function addresses(options: addresses.Options = {}) {
         'Get a human-readable feed of what an address has been doing onchain, including payments sent and received, swaps, approvals, and more.',
       operationId: 'getAddressActivities',
       responses: OpenApi.responses({
-        errors: { 502: 'Tempo could not read activity or token data from an upstream service.' },
+        errors: {
+          400: {
+            codes: ['address_invalid', 'chain_id_invalid', 'chain_id_unsupported', 'query_invalid'],
+          },
+          502: 'Tempo could not read activity or token data from an upstream service.',
+        },
         success: {
           description: 'A page of address activity entries.',
           schema: schema.getAddressActivities.Response,
@@ -1991,7 +2077,7 @@ export function addresses(options: addresses.Options = {}) {
       tags: ['Activities'],
     }),
     Cache.response<App.Environment>({
-      cacheControl: Cache.policies.feed,
+      cacheControl: Cache.policies.noStore,
       name: 'tempo-api:addresses:v1',
       key: (c) => Cache.urlKey(c, schema.getAddressActivities.Query),
     }),
@@ -2011,19 +2097,19 @@ export function addresses(options: addresses.Options = {}) {
       const { address } = c.req.valid('param')
       const query = c.req.valid('query')
 
-      // Cursor pages can carry current valuations and curated verification data.
-      if (query.cursor !== undefined) Cache.setPolicy(c, Cache.policies.metadata)
+      if (!query.include.includes('zones'))
+        Cache.setPolicy(
+          c,
+          query.cursor === undefined ? Cache.policies.feed : Cache.policies.metadata,
+        )
 
       try {
         const chainId = query.chainId ?? c.get('chainId')
-        const provider = tidx({ chainId, tidx: c.get('getTidx')(chainId) })
-        const { items: unenrichedItems, nextCursor } = await Timing.time(
-          c,
-          'address_activities',
-          () =>
-            Store.memoize(
-              () =>
-                list(provider, {
+        const listed = await Timing.time(c, 'address_activities', async () => {
+          if (!query.include.includes('zones')) {
+            const result = await Store.memoize(
+              (signal) =>
+                list(tidx({ chainId, signal, tidx: c.get('getTidx')(chainId) }), {
                   address: address as Hex.Hex,
                   cursor: query.cursor,
                   group: query.group,
@@ -2036,18 +2122,56 @@ export function addresses(options: addresses.Options = {}) {
                 store: c.get('store'),
                 ttl: Ttl.seconds(15),
               },
-            ),
-        )
+            )
+            return { chainId, kind: 'chain' as const, ...result }
+          }
 
-        // Build immutable token and structured amount copies from RPC metadata.
-        const { items, rates } = await enrichTokens(c, {
-          chainId,
-          denomination: query['valuation.currency'],
-          include: query.include,
-          items: unenrichedItems,
-          oracle,
+          const zoneChainIds = c.get('zoneChainIds')
+          if (!zoneChainIds) throw new Error('Inferred Zone selection was not resolved.')
+          const chainIds = [chainId, ...zoneChainIds]
+          const result = await Store.memoize(
+            (signal) =>
+              listChains({
+                address: address as Hex.Hex,
+                cursor: query.cursor,
+                group: query.group,
+                limit: query.limit,
+                logs: query.logs,
+                providers: chainIds.map((chainId) => ({
+                  chainId,
+                  provider: tidx({
+                    chainId,
+                    signal,
+                    tidx: c.get('getTidx')(chainId),
+                  }),
+                })),
+                store: c.get('store'),
+              }),
+            {
+              key: `activities:zones:v2:${chainIds.join(',')}:${address.toLowerCase()}:${query.group ?? false}:${query.logs ?? false}:${query.cursor ?? 'head'}:${query.limit}`,
+              store: c.get('store'),
+              ttl: Ttl.seconds(15),
+            },
+          )
+          return { kind: 'zones' as const, ...result }
         })
 
+        const { items, rates } =
+          listed.kind === 'zones'
+            ? await enrichChainTokens(c, {
+                denomination: query['valuation.currency'],
+                include: query.include,
+                items: listed.items,
+                oracle,
+              })
+            : await enrichTokens(c, {
+                chainId: listed.chainId,
+                denomination: query['valuation.currency'],
+                include: query.include,
+                items: listed.items,
+                oracle,
+              })
+
         // Fold consecutive access-key-signed items into `group` entries only
         // when requested; otherwise every item is returned at the root.
         const data = query.group ? groupByAccessKey(items) : items
@@ -2056,7 +2180,7 @@ export function addresses(options: addresses.Options = {}) {
           Response.validated(schema.getAddressActivities.Response, {
             data,
             ...(rates ? { meta: { valuation: Valuation.pricing(rates, oracle) } } : {}),
-            nextCursor,
+            nextCursor: listed.nextCursor,
           }),
           200,
         )
@@ -2084,7 +2208,7 @@ export declare namespace addresses {
  * Runs the same `groupByTx` → `classifyGroup` pipeline the address feed uses
  * over a single transaction's logs, anchored on the transaction sender as the
  * viewer (a transaction-scoped feed has no subject account). Returns the
- * classified item(s) — usually one headline activity — with the full per-tx
+ * classified items (one per independent activity) with the full per-tx
  * event set available via `logs=true`.
  */
 export function transactions(options: transactions.Options = {}) {
@@ -2106,10 +2230,22 @@ export function transactions(options: transactions.Options = {}) {
       operationId: 'getTransactionActivities',
       responses: OpenApi.responses({
         errors: {
+          400: {
+            codes: [
+              'chain_id_invalid',
+              'chain_id_unsupported',
+              'query_invalid',
+              'transaction_invalid',
+            ],
+          },
           404: {
             description: 'No mined transaction was found for that hash.',
             codes: ['transaction_not_found'],
           },
+          409: {
+            description: 'More than one readable chain contains that transaction hash.',
+            codes: ['transaction_ambiguous'],
+          },
           502: 'Tempo could not read activity or token data from an upstream service.',
         },
         success: {
@@ -2142,48 +2278,126 @@ export function transactions(options: transactions.Options = {}) {
 
       const { transactionHash } = c.req.valid('param')
       const query = c.req.valid('query')
-      const chainId = query.chainId ?? c.get('chainId')
 
       try {
-        const unenrichedItems = await Timing.time(c, 'transaction_activities', () =>
-          Store.memoize(
-            () =>
-              getTransactionActivities({
-                chainId,
-                logs: query.logs,
+        const result = await Timing.time(c, 'transaction_activities', async () => {
+          const selected = await (async () => {
+            if (!query.include.includes('zones'))
+              return {
+                chainId: query.chainId ?? c.get('chainId'),
+                kind: 'selected' as const,
+                receipt: null,
+              }
+
+            const zoneChainIds = c.get('zoneChainIds')
+            if (!zoneChainIds) throw new Error('Inferred Zone selection was not resolved.')
+            const chainIds = [query.chainId ?? c.get('chainId'), ...zoneChainIds]
+            // Cache only positive resolution. Missing transactions must remain
+            // visible as soon as any selected indexer catches up.
+            const match = await Store.memoize(
+              async () => {
+                const probes: readonly ZoneSelection.uniqueMatch.Probe<TransactionReceipt>[] =
+                  await Promise.all(
+                    chainIds.map(async (chainId) => {
+                      try {
+                        return {
+                          chainId,
+                          value: await getTransactionReceipt({
+                            chainId,
+                            tidx: c.get('getTidx')(chainId),
+                            transactionHash,
+                          }),
+                        }
+                      } catch (cause) {
+                        return { cause, chainId }
+                      }
+                    }),
+                  )
+                return ZoneSelection.uniqueMatch<TransactionReceipt>(probes)
+              },
+              {
+                key: `activities:zones:v2:${chainIds.join(',')}:tx:${transactionHash.toLowerCase()}`,
+                shouldCache: (match) => match.kind === 'selected',
                 store: c.get('store'),
-                tidx: c.get('getTidx')(chainId),
-                transactionHash,
-              }),
+                ttl: Ttl.seconds(15),
+              },
+            )
+            if (match.kind === 'failed') {
+              c.set(
+                'providerFailures',
+                match.failures.map(({ cause, chainId }) => ({
+                  ...Tidx.providerFailure(cause),
+                  chainId,
+                })),
+              )
+              throw match.failures[0]!.cause
+            }
+            if (match.kind !== 'selected') return match
+            return { chainId: match.chainId, kind: 'selected' as const, receipt: match.value }
+          })()
+
+          if (selected.kind !== 'selected') return selected
+          const { chainId } = selected
+          const unenrichedItems = await Store.memoize(
+            () =>
+              selected.receipt === null
+                ? getTransactionActivities_inner({
+                    chainId,
+                    logs: query.logs,
+                    store: c.get('store'),
+                    tidx: c.get('getTidx')(chainId),
+                    time: (name, fn) => Timing.time(c, name, fn),
+                    transactionHash,
+                  })
+                : classifyTransactionActivities({
+                    chainId,
+                    logs: query.logs,
+                    receipt: selected.receipt,
+                    store: c.get('store'),
+                    tidx: c.get('getTidx')(chainId),
+                    time: (name, fn) => Timing.time(c, name, fn),
+                    transactionHash,
+                  }),
             {
               key: `activities:v1:${chainId}:tx:${transactionHash.toLowerCase()}:${query.logs ?? false}`,
               store: c.get('store'),
               ttl: Ttl.seconds(15),
             },
-          ),
-        )
+          )
+          return unenrichedItems === null
+            ? ({ kind: 'not_found' } as const)
+            : ({ chainId, items: unenrichedItems, kind: 'found' } as const)
+        })
 
-        if (unenrichedItems === null)
+        if (result.kind === 'not_found')
           return Response.error(c, {
             code: 'transaction_not_found',
             message: 'Transaction not found',
             status: 404,
           })
+        if (result.kind === 'ambiguous')
+          return Response.error(c, {
+            code: 'transaction_ambiguous',
+            message: 'Transaction hash matched more than one readable chain',
+            status: 409,
+          })
 
         // Mined activity can carry current valuations and verification data.
-        Cache.setPolicy(c, Cache.policies.metadata)
+        if (!query.include.includes('zones')) Cache.setPolicy(c, Cache.policies.metadata)
+        c.set('chainId', result.chainId)
 
         // Build immutable token and structured amount copies from RPC metadata.
         const { items, rates } = await enrichTokens(c, {
-          chainId,
+          chainId: result.chainId,
           denomination: query['valuation.currency'],
           include: query.include,
-          items: unenrichedItems,
+          items: result.items,
           oracle,
         })
 
         return c.json(
           Response.validated(schema.getTransactionActivities.Response, {
+            chainId: result.chainId,
             data: items,
             ...(rates ? { meta: { valuation: Valuation.pricing(rates, oracle) } } : {}),
           }),
@@ -2219,7 +2433,26 @@ export declare namespace transactions {
 export async function getTransactionActivities(
   options: getTransactionActivities.Options,
 ): Promise<UnenrichedItem[] | null> {
-  const { chainId, logs = false, tidx: tidxClient } = options
+  return getTransactionActivities_inner({
+    ...options,
+    time: async (_name, fn) => fn(),
+  })
+}
+
+async function getTransactionActivities_inner(
+  options: TransactionActivityOptions,
+): Promise<UnenrichedItem[] | null> {
+  const receipt = await options.time('transaction_activity_receipt', () =>
+    getTransactionReceipt(options),
+  )
+  if (!receipt) return null
+  return classifyTransactionActivities({ ...options, receipt })
+}
+
+async function getTransactionReceipt(
+  options: getTransactionReceipt.Options,
+): Promise<TransactionReceipt | null> {
+  const { chainId, tidx: tidxClient } = options
   const hash = options.transactionHash.toLowerCase()
 
   // The `receipts` table is indexed by `tx_hash`, so this point lookup needs no
@@ -2234,17 +2467,45 @@ export async function getTransactionActivities(
   const receipt = receiptResult.rows[0]
   if (!receipt) return null
 
-  const blockNum = Number(Value.toNumber(receipt['block_num']))
-  const feePayer = lowerOrNull(receipt['fee_payer'])
-  const txSender = lowerOrNull(receipt['from'])
+  return {
+    blockNum: Number(Value.toNumber(receipt['block_num'])),
+    feePayer: lowerOrNull(receipt['fee_payer']),
+    txSender: lowerOrNull(receipt['from']),
+  }
+}
+
+declare namespace getTransactionReceipt {
+  type Options = Pick<getTransactionActivities.Options, 'chainId' | 'tidx' | 'transactionHash'>
+}
+
+type TransactionReceipt = {
+  /** Block number containing the transaction. */
+  blockNum: number
+  /** Account that paid the transaction fee, when indexed. */
+  feePayer: Address.Address | null
+  /** Account that sent the transaction, when indexed. */
+  txSender: Address.Address | null
+}
+
+async function classifyTransactionActivities(
+  options: classifyTransactionActivities.Options,
+): Promise<UnenrichedItem[]> {
+  const { chainId, logs = false, receipt, tidx: tidxClient } = options
+  const hash = options.transactionHash.toLowerCase()
+  const { blockNum, feePayer, txSender } = receipt
+  const fingerprintMap_promise = options
+    .time('transaction_activity_mpp', () => Mpp.fingerprintMap({ store: options.store }))
+    .catch(() => ({}))
 
   // `logs` is sorted by block position, so a bare `tx_hash =` scans to genesis;
   // pair it with the receipt's block number (see `embedReceipts` in receipts.ts).
-  const logsResult = await tidxClient.fetch({
-    chainId,
-    query:
-      `SELECT tx_hash, block_num, block_timestamp, tx_idx, log_idx, address, selector, topic1, topic2, topic3, data FROM logs WHERE block_num = ${blockNum} AND tx_hash = '${hash}' ORDER BY log_idx ASC` as string,
-  })
+  const logsResult = await options.time('transaction_activity_logs', () =>
+    tidxClient.fetch({
+      chainId,
+      query:
+        `SELECT tx_hash, block_num, block_timestamp, tx_idx, log_idx, address, selector, topic1, topic2, topic3, data FROM logs WHERE block_num = ${blockNum} AND tx_hash = '${hash}' ORDER BY log_idx ASC` as string,
+    }),
+  )
 
   const rows: Row[] = logsResult.rows.map((r) => ({
     blockNum: Number(Value.toNumber(r['block_num'])),
@@ -2269,7 +2530,7 @@ export async function getTransactionActivities(
 
   // Best-effort MPP service directory: a fetch failure yields an empty map, so
   // enrichment never blocks classification.
-  const fingerprintMap = await Mpp.fingerprintMap({ store: options.store }).catch(() => ({}))
+  const fingerprintMap = await fingerprintMap_promise
 
   // Anchor the viewer on the transaction sender: the sender initiated every
   // activity in the transaction, so `perspective` is `outgoing` and `signer`
@@ -2279,6 +2540,13 @@ export async function getTransactionActivities(
   return classifyGroup(group, viewer, fingerprintMap, logs).map(withTitle)
 }
 
+declare namespace classifyTransactionActivities {
+  type Options = TransactionActivityOptions & {
+    /** Indexed receipt fields used to bound the log lookup. */
+    receipt: TransactionReceipt
+  }
+}
+
 export declare namespace getTransactionActivities {
   /** Options for {@link getTransactionActivities}. */
   type Options = {
@@ -2295,11 +2563,18 @@ export declare namespace getTransactionActivities {
   }
 }
 
+type TransactionActivityOptions = getTransactionActivities.Options & {
+  time: <value>(
+    name: 'transaction_activity_logs' | 'transaction_activity_mpp' | 'transaction_activity_receipt',
+    fn: () => Promise<value> | value,
+  ) => Promise<value>
+}
+
 /**
  * Lists classified activity for an address by running the shared pipeline
  * (`groupByTx` → `classifyGroup` → `enrichItem`) over rows from a
- * {@link Provider}. Returns enriched, chain-tagged items plus the next cursor;
- * callers run {@link groupByAccessKey} over the result.
+ * {@link Provider}. Returns classified items plus the next cursor; callers run
+ * {@link groupByAccessKey} over the result.
  */
 export async function list(provider: Provider, options: list.Options): Promise<list.ReturnType> {
   const { address, cursor, group = false, limit = 20, logs = false } = options
@@ -2307,7 +2582,7 @@ export async function list(provider: Provider, options: list.Options): Promise<l
 
   // Best-effort MPP service directory: a fetch failure yields an empty map, so
   // enrichment never blocks the feed.
-  const fingerprintMap = await Mpp.fingerprintMap({ store: options.store }).catch(() => ({}))
+  const fingerprintMap_promise = Mpp.fingerprintMap({ store: options.store }).catch(() => ({}))
 
   let currentCursor: string | undefined = cursor
   const allItems: UnenrichedItem[] = []
@@ -2326,6 +2601,7 @@ export async function list(provider: Provider, options: list.Options): Promise<l
     hasMore = txGroups.length > limit
     const page = txGroups.slice(0, limit)
 
+    const fingerprintMap = await fingerprintMap_promise
     if (page.length === 0) break
 
     allItems.push(
@@ -2374,6 +2650,175 @@ export declare namespace list {
   }
 }
 
+const chainCursorVersion = 2
+
+type ChainPageState = {
+  /** Chain ID backing this page state. */
+  chainId: number
+  /** Whether the current buffer reaches the end of this chain feed. */
+  exhausted: boolean
+  /** Unconsumed transaction groups already fetched from this chain. */
+  groups: TxGroup[]
+  /** Activity data source for this chain. */
+  provider: Provider
+}
+
+/**
+ * Lists address activity across multiple chains in one stable timestamp-ordered
+ * feed. Its opaque cursor retains each provider's native continuation.
+ */
+export async function listChains(options: listChains.Options): Promise<listChains.ReturnType> {
+  const { address, cursor, limit = 20, logs = false, providers, store } = options
+  const group = options.group ?? false
+  const orderedProviders = [...providers].sort((a, b) => a.chainId - b.chainId)
+  const chainIds = orderedProviders.map(({ chainId }) => chainId)
+  const cursors = decodeChainCursor(cursor, chainIds)
+  const viewer = address.toLowerCase() as Address.Address
+  const fingerprintMap_promise = Mpp.fingerprintMap({ store }).catch(() => ({}))
+  const states: ChainPageState[] = orderedProviders.map(({ chainId, provider }) => ({
+    chainId,
+    exhausted: false,
+    groups: [],
+    provider,
+  }))
+  const allItems: listChains.Item[] = []
+  let hasMore = false
+
+  for (let attempt = 0; attempt < 3; attempt++) {
+    await Promise.all(
+      states.map(async (state) => {
+        if (state.exhausted || state.groups.length > 0) return
+        const { rows } = await state.provider.fetchRows({
+          address: viewer,
+          cursor: cursors.get(state.chainId),
+          limit,
+        })
+        const groups = groupByTx(rows).slice(0, limit + 1)
+        state.exhausted = groups.length <= limit
+        state.groups.push(...groups)
+      }),
+    )
+    const candidates = states
+      .flatMap((state) => state.groups.map((txGroup) => ({ state, txGroup })))
+      .sort((a, b) => {
+        if (a.txGroup.blockTimestamp !== b.txGroup.blockTimestamp)
+          return b.txGroup.blockTimestamp - a.txGroup.blockTimestamp
+        if (a.state.chainId !== b.state.chainId) return a.state.chainId - b.state.chainId
+        if (a.txGroup.blockNum !== b.txGroup.blockNum)
+          return b.txGroup.blockNum - a.txGroup.blockNum
+        return b.txGroup.txIdx - a.txGroup.txIdx
+      })
+    const page = candidates.slice(0, limit)
+    const fingerprintMap = await fingerprintMap_promise
+    if (page.length === 0) break
+
+    for (const { state, txGroup } of page) {
+      state.groups.splice(state.groups.indexOf(txGroup), 1)
+      cursors.set(state.chainId, state.provider.cursorForGroup(txGroup))
+      allItems.push(
+        ...classifyGroup(txGroup, viewer, fingerprintMap, logs).map((item) => ({
+          ...withTitle(item),
+          chainId: state.chainId,
+        })),
+      )
+    }
+
+    hasMore = states.some((state) => !state.exhausted || state.groups.length > 0)
+    const enough = group
+      ? groupByAccessKeyItems(allItems).length >= minGroupEntries
+      : allItems.length >= limit
+    if (enough || !hasMore) break
+  }
+
+  // A consumed sentinel proves only that the provider may have more rows.
+  // Probe drained buffers so `nextCursor` remains the end-of-list signal.
+  await Promise.all(
+    states.map(async (state) => {
+      if (state.exhausted || state.groups.length > 0) return
+      const { rows } = await state.provider.fetchRows({
+        address: viewer,
+        cursor: cursors.get(state.chainId),
+        limit: 1,
+      })
+      const group = groupByTx(rows)[0]
+      if (group) state.groups.push(group)
+      else state.exhausted = true
+    }),
+  )
+  hasMore = states.some((state) => !state.exhausted || state.groups.length > 0)
+
+  return {
+    items: allItems,
+    nextCursor: hasMore ? encodeChainCursor(cursors, chainIds) : null,
+  }
+}
+
+export declare namespace listChains {
+  /** One chain activity provider. */
+  type ChainProvider = {
+    /** Chain ID. */
+    chainId: number
+    /** Activity data source for the chain. */
+    provider: Provider
+  }
+
+  /** A classified item tagged with its chain ID. */
+  type Item = UnenrichedItem & {
+    /** Chain ID containing the activity. */
+    chainId: number
+  }
+
+  /** Options for {@link listChains}. */
+  type Options = {
+    /** Subject account address. */
+    address: Address.Address
+    /** Opaque multi-chain cursor from a previous page. */
+    cursor?: string | undefined
+    /** Whether the caller will fold access-key items. */
+    group?: boolean | undefined
+    /** Target number of transaction groups per page. */
+    limit?: number | undefined
+    /** Attach each item's full transaction event capture. */
+    logs?: boolean | undefined
+    /** Chain providers participating in the merged feed. */
+    providers: readonly ChainProvider[]
+    /** Cache store for the MPP fingerprint-directory lookup. */
+    store: Store.Store
+  }
+
+  /** Multi-chain classified page before token enrichment. */
+  type ReturnType = {
+    /** Timestamp-ordered, chain-tagged activity items. */
+    items: Item[]
+    /** Opaque continuation for every chain, or null at the end. */
+    nextCursor: string | null
+  }
+}
+
+function decodeChainCursor(cursor: string | undefined, chainIds: readonly number[]) {
+  const fields: Cursor.Field[] = ['int']
+  for (const _chainId of chainIds) fields.push('int', 'id')
+  const decoded = cursor ? Cursor.decode(cursor, fields) : undefined
+  const cursors = new Map<number, string>()
+  if (!decoded || decoded[0] !== chainCursorVersion) return cursors
+
+  for (let index = 0; index < chainIds.length; index++) {
+    const chainId = chainIds[index]!
+    const offset = index * 2 + 1
+    if (decoded[offset] !== chainId) return new Map()
+    const value = decoded[offset + 1] as string
+    if (value !== 'head') cursors.set(chainId, value)
+  }
+  return cursors
+}
+
+function encodeChainCursor(cursors: ReadonlyMap<number, string>, chainIds: readonly number[]) {
+  return Cursor.encode([
+    chainCursorVersion,
+    ...chainIds.flatMap((chainId) => [chainId, cursors.get(chainId) ?? 'head']),
+  ])
+}
+
 /**
  * Creates a TIDX-backed {@link Provider} that runs three sub-queries in
  * parallel and merges them:
@@ -2384,7 +2829,18 @@ export declare namespace list {
  *   (catches access-key-signed sends where `tx.from` differs from the address).
  */
 export function tidx(deps: tidx.Deps): Provider {
-  const { chainId, tidx: tidxClient } = deps
+  const { chainId, signal, tidx: tidxClient } = deps
+
+  const fetch: Tidx.Client['fetch'] = (options) => {
+    const requestSignal =
+      signal && options.signal
+        ? AbortSignal.any([signal, options.signal])
+        : (signal ?? options.signal)
+    return tidxClient.fetch({
+      ...options,
+      ...(requestSignal ? { signal: requestSignal } : {}),
+    })
+  }
 
   function parseCursor(cursor: string): { blockNum: number; txIdx: number } | undefined {
     // Opaque `[blockNum, txIdx]` keyset cursor, the same encoding every other
@@ -2410,7 +2866,7 @@ export function tidx(deps: tidx.Deps): Provider {
       : ''
     const queryLimit = limit + 1
     const fetchReceipts = (side: 'fee_payer' | 'from') =>
-      tidxClient.fetch({
+      fetch({
         chainId,
         // Raw-table query (no signature-decoded CTE), so the inline SQL is cast
         // to `string`.
@@ -2454,7 +2910,7 @@ export function tidx(deps: tidx.Deps): Provider {
 
     // `logs` is not keyed by transaction hash, so pair the bounded hash list
     // with the selected receipts' block range to avoid a full archive scan.
-    const logs = await tidxClient.fetch({
+    const logs = await fetch({
       chainId,
       // Raw-table query (no signature-decoded CTE), so the inline SQL is cast
       // to `string`.
@@ -2514,7 +2970,7 @@ export function tidx(deps: tidx.Deps): Provider {
       `
     const result = await (async () => {
       try {
-        return await tidxClient.fetch({
+        return await fetch({
           chainId,
           query: query('block_num'),
           signatures: [transferSignature],
@@ -2523,14 +2979,14 @@ export function tidx(deps: tidx.Deps): Provider {
         if (!Tidx.isDeterministicError(error)) throw error
         try {
           // The expression blocks a mis-selected block-ordered top-N walk.
-          return await tidxClient.fetch({
+          return await fetch({
             chainId,
             query: query('block_num + 0'),
             signatures: [transferSignature],
           })
         } catch (fallbackError) {
           if (!Tidx.isDeterministicError(fallbackError)) throw fallbackError
-          const result = await tidxClient.fetch({
+          const result = await fetch({
             chainId,
             query: query(),
             signatures: [transferSignature],
@@ -2585,6 +3041,8 @@ export declare namespace tidx {
   type Deps = {
     /** Source chain id. */
     chainId: number
+    /** Optional deadline signal shared by this provider's TIDX reads. */
+    signal?: AbortSignal | undefined
     /** TIDX query client. */
     tidx: Tidx.Client
   }
@@ -2599,8 +3057,10 @@ export function mergeAndSort(q1: readonly Row[], q2: readonly Row[], q3: readonl
   const q1Hashes = new Set(q1.map((r) => r.txHash))
   const filteredQ2 = q2.filter((r) => !q1Hashes.has(r.txHash))
   const filteredQ3 = q3.filter((r) => !q1Hashes.has(r.txHash))
-  const q2Hashes = new Set(filteredQ2.map((r) => r.txHash))
-  const dedupedQ3 = filteredQ3.filter((r) => !q2Hashes.has(r.txHash))
+  // Dedup by row, not transaction: a tx that both credits and debits the
+  // viewer keeps its rows from both sides, one item each.
+  const q2Keys = new Set(filteredQ2.map((r) => `${r.txHash}:${r.logIdx}`))
+  const dedupedQ3 = filteredQ3.filter((r) => !q2Keys.has(`${r.txHash}:${r.logIdx}`))
   return [...q1, ...filteredQ2, ...dedupedQ3].sort((a, b) => {
     if (a.blockNum !== b.blockNum) return b.blockNum - a.blockNum
     return b.txIdx - a.txIdx
@@ -2677,34 +3137,38 @@ function classifyGroup(
       viewer,
     })
 
-  // Q2-only — a transfer row without a joined receipt. Classify by comparing
-  // `from`/`to` against the viewer (zero-address sides are mints/burns).
-  if (q2Rows.length > 0) {
-    const r = q2Rows[0]!
-    const base = itemBase(r.logIdx)
-    const from = r.transferFrom!
-    const to = r.transferTo!
-    const sourceToken = token(r.transferAmount, r.transferToken!)
-    if (Address.isEqual(from, zeroAddress as Address.Address))
-      return [{ ...base, data: { recipient: viewer, sourceToken }, type: 'mint' }]
-    if (Address.isEqual(to, zeroAddress as Address.Address))
-      return [{ ...base, data: { sender: from, signer, sourceToken }, type: 'burn' }]
-    // Q2-only rows carry no memo, so MPP service attribution is unavailable
-    // here; `attribution` is resolved only on the log-bearing (Q1) path.
-    if (Address.isEqual(from, viewer))
-      return [
-        transfer(base, blockNum, {
-          direction: 'out',
-          recipient: to,
-          sender: viewer,
-          signer,
+  // Q2-only: transfer rows without a joined receipt, one item per row so a
+  // batch paying the viewer several times surfaces every payment. Classify by
+  // comparing `from`/`to` against the viewer (zero-address sides mint/burn).
+  if (q2Rows.length > 0)
+    return [...q2Rows]
+      .sort((a, b) => a.logIdx - b.logIdx)
+      .map((r) => {
+        const base = itemBase(r.logIdx)
+        const from = r.transferFrom!
+        const to = r.transferTo!
+        const sourceToken = token(r.transferAmount, r.transferToken!)
+        if (Address.isEqual(from, zeroAddress as Address.Address))
+          return { ...base, data: { recipient: viewer, sourceToken }, type: 'mint' }
+        if (Address.isEqual(to, zeroAddress as Address.Address))
+          return { ...base, data: { sender: from, signer, sourceToken }, type: 'burn' }
+        // Q2-only rows carry no memo, so MPP service attribution is unavailable
+        // here; `attribution` is resolved only on the log-bearing (Q1) path.
+        if (Address.isEqual(from, viewer))
+          return transfer(base, blockNum, {
+            direction: 'out',
+            recipient: to,
+            sender: viewer,
+            signer,
+            sourceToken,
+          })
+        return transfer(base, blockNum, {
+          direction: 'in',
+          recipient: viewer,
+          sender: from,
           sourceToken,
-        }),
-      ]
-    return [
-      transfer(base, blockNum, { direction: 'in', recipient: viewer, sender: from, sourceToken }),
-    ]
-  }
+        })
+      })
 
   // Fallback — should not happen (a group with neither q1 nor q2 rows).
   return [
@@ -2743,7 +3207,7 @@ function classifyFromLogs(
   })()
   // When the caller requested raw logs, attach the full per-transaction log set
   // (decoded when possible) to every classified item so no co-located log is
-  // hidden behind the headline. `unknown` items already carry it.
+  // hidden. `unknown` items already carry it.
   if (!ctx.includeLogs) return items
   const events = buildTxEvents(rows, decoded)
   return items.map((item) => (item.type === 'unknown' ? item : { ...item, events }))
@@ -2767,7 +3231,11 @@ function signerForRows(
     : options.fallback
 }
 
-/** Classifies a Q1 (log-bearing) group via `parseEventLogs`, picking one headline item. */
+/**
+ * Classifies every activity in a Q1 (log-bearing) transaction. Recognizers run
+ * in priority order over a pool of decoded events, each emitting one item per
+ * matched anchor and claiming the exact logs backing it.
+ */
 function classifyFromLogsCore(
   rows: Row[],
   ctx: {
@@ -2785,97 +3253,196 @@ function classifyFromLogsCore(
 
   const minLogIndex = Math.min(...rows.map((r) => r.logIdx))
 
-  // Payment-channel settlement: a CloseRequested topic plus an optional refund
-  // transfer back to the viewer.
-  const hasCloseRequested = rows.some((r) => r.selector === closeRequestedSelector)
-  if (hasCloseRequested) {
-    const closeRequestedLogIndex =
-      rows.find((r) => r.selector === closeRequestedSelector)?.logIdx ?? minLogIndex
-    const refundTransfer = events.find(
-      (e) =>
-        (e.eventName === 'Transfer' || e.eventName === 'TransferWithMemo') &&
-        'to' in e.args &&
-        Address.isEqual((e.args as { to: Address.Address }).to, viewer),
-    )
-    const refund = refundTransfer
-      ? token(
-          (refundTransfer.args as { amount: bigint }).amount,
-          refundTransfer.address as Address.Address,
-        )
-      : undefined
-    return [
-      {
-        ...itemBase(closeRequestedLogIndex),
-        data: { ...(refund ? { refund } : {}), signer },
-        type: 'session-closed',
-      },
-    ]
-  }
-
-  // Dedup preference: TransferWithMemo beats Transfer; Mint/Burn beat
-  // zero-address Transfer.
-  const preferenceMap = new Map<string, string>()
+  // Pair folds are counted: each TransferWithMemo folds one matching plain
+  // Transfer and each Mint/Burn event folds one zero-address transfer, so an
+  // extra identical payment survives as its own item. Keys require the full
+  // event shape; a malformed event must not fold away a classifiable leg.
+  const foldCounts = new Map<string, number>()
+  const addFold = (key: string) => foldCounts.set(key, (foldCounts.get(key) ?? 0) + 1)
   for (const event of events) {
     if (event.eventName === 'TransferWithMemo' && 'from' in event.args && 'to' in event.args) {
       const args = event.args as { amount: bigint; from: Address.Address; to: Address.Address }
-      preferenceMap.set(`${args.from}:${args.to}:${args.amount}`, 'TransferWithMemo')
+      addFold(`${event.address}:${args.from}:${args.to}:${args.amount}`)
     }
-    if (event.eventName === 'Mint' && 'amount' in event.args)
-      preferenceMap.set(
-        `mint:${event.address}:${(event.args as { amount: bigint }).amount}`,
-        'Mint',
-      )
-    if (event.eventName === 'Burn' && 'amount' in event.args)
-      preferenceMap.set(
-        `burn:${event.address}:${(event.args as { amount: bigint }).amount}`,
-        'Burn',
-      )
+    if (event.eventName === 'Mint' && 'amount' in event.args && 'to' in event.args)
+      addFold(`mint:${event.address}:${(event.args as { amount: bigint }).amount}`)
+    if (event.eventName === 'Burn' && 'amount' in event.args && 'from' in event.args)
+      addFold(`burn:${event.address}:${(event.args as { amount: bigint }).amount}`)
+  }
+  const takeFold = (key: string) => {
+    const count = foldCounts.get(key) ?? 0
+    if (count === 0) return false
+    foldCounts.set(key, count - 1)
+    return true
   }
 
-  const dedupedEvents = events.filter((event) => {
-    if (event.eventName !== 'Transfer') return true
+  const finalEvents = events.filter((event) => {
+    if (event.eventName !== 'Transfer' && event.eventName !== 'TransferWithMemo') return true
+    if (!('from' in event.args) || !('to' in event.args)) return true
     const args = event.args as { amount: bigint; from: Address.Address; to: Address.Address }
-    if (preferenceMap.has(`${args.from}:${args.to}:${args.amount}`)) return false
-    if (
-      Address.isEqual(args.from, zeroAddress as Address.Address) &&
-      preferenceMap.has(`mint:${event.address}:${args.amount}`)
-    )
-      return false
     if (
-      Address.isEqual(args.to, zeroAddress as Address.Address) &&
-      preferenceMap.has(`burn:${event.address}:${args.amount}`)
+      event.eventName === 'Transfer' &&
+      takeFold(`${event.address}:${args.from}:${args.to}:${args.amount}`)
     )
       return false
-    return true
-  })
-
-  const finalEvents = dedupedEvents.filter((event) => {
-    if (event.eventName !== 'TransferWithMemo') return true
-    const args = event.args as { amount: bigint; from: Address.Address; to: Address.Address }
     if (
       Address.isEqual(args.from, zeroAddress as Address.Address) &&
-      preferenceMap.has(`mint:${event.address}:${args.amount}`)
+      takeFold(`mint:${event.address}:${args.amount}`)
     )
       return false
     if (
       Address.isEqual(args.to, zeroAddress as Address.Address) &&
-      preferenceMap.has(`burn:${event.address}:${args.amount}`)
+      takeFold(`burn:${event.address}:${args.amount}`)
     )
       return false
     return true
   })
 
-  const transfers = finalEvents.filter(
-    (e) =>
-      (e.eventName === 'Transfer' || e.eventName === 'TransferWithMemo') &&
-      'to' in e.args &&
-      'from' in e.args &&
-      'amount' in e.args,
+  type Decoded = (typeof finalEvents)[number]
+
+  const pool = [...finalEvents].sort((a, b) => a.logIndex - b.logIndex)
+  const claimed = new Set<number>()
+  const items: RawItem[] = []
+  // Claims made while building an item are journaled, so a build that throws
+  // on a malformed event releases its legs and consumes only the anchor.
+  let journal: number[] | undefined
+  const claim = (event: Decoded) => {
+    claimed.add(event.logIndex)
+    journal?.push(event.logIndex)
+  }
+  // A predicate throwing on a malformed decode must not discard the whole
+  // transaction; treat that event as a non-match instead.
+  const unclaimed = (predicate?: (event: Decoded) => boolean) =>
+    pool.filter((event) => {
+      if (claimed.has(event.logIndex)) return false
+      if (!predicate) return true
+      try {
+        return predicate(event)
+      } catch {
+        return false
+      }
+    })
+  const lc = (value: Address.Address) => value.toLowerCase() as Address.Address
+  const hx = (value: Hex.Hex) => value.toLowerCase() as Hex.Hex
+
+  // Non-strict decoding can surface Transfer-shaped events with malformed
+  // args; validating (once per event) keeps predicate comparisons throw-free.
+  const transferIndexes = new Set(
+    pool
+      .filter((event) => {
+        if (event.eventName !== 'Transfer' && event.eventName !== 'TransferWithMemo') return false
+        const args = event.args as { amount?: unknown; from?: unknown; to?: unknown }
+        return (
+          typeof args.amount === 'bigint' &&
+          typeof args.from === 'string' &&
+          Address.validate(args.from) &&
+          typeof args.to === 'string' &&
+          Address.validate(args.to)
+        )
+      })
+      .map((event) => event.logIndex),
   )
+  const isTransfer = (event: Decoded) => transferIndexes.has(event.logIndex)
+  const transferArgs = (event: Decoded) =>
+    event.args as {
+      amount: bigint
+      from: Address.Address
+      memo?: Hex.Hex | undefined
+      to: Address.Address
+    }
+  // Finds and claims the first unclaimed event matching `predicate`, so a
+  // later identical anchor pairs with the next matching leg instead of
+  // reusing this one.
+  const takeEvent = (predicate: (event: Decoded) => boolean) => {
+    for (const event of pool) {
+      if (claimed.has(event.logIndex)) continue
+      const match = (() => {
+        try {
+          return predicate(event)
+        } catch {
+          return false
+        }
+      })()
+      if (!match) continue
+      claim(event)
+      return event
+    }
+    return undefined
+  }
+  const takeTransfer = (predicate: (event: Decoded) => boolean) =>
+    takeEvent((event) => isTransfer(event) && predicate(event))
+
+  // Runs `build` once per unclaimed matching event, in log order; `build`
+  // claims its legs and returns the item(s) to emit, or nothing for
+  // fold-only recognitions. A throwing build consumes only its anchor.
+  const recognize = (
+    predicate: (event: Decoded) => boolean,
+    build: (event: Decoded) => RawItem | readonly RawItem[] | undefined,
+  ) => {
+    for (const anchor of unclaimed(predicate)) {
+      // A build may claim a later anchor of the same pass (or a log decoded
+      // into duplicate ABI copies); never process a claimed anchor again.
+      if (claimed.has(anchor.logIndex)) continue
+      claim(anchor)
+      journal = []
+      try {
+        const built = build(anchor)
+        if (built) items.push(...(Array.isArray(built) ? built : [built as RawItem]))
+      } catch {
+        // Indexed logs can match a known signature without satisfying that
+        // event's expected shape; release the legs and skip the anchor.
+        for (const index of journal ?? []) claimed.delete(index)
+      } finally {
+        journal = undefined
+      }
+    }
+  }
+  const named = (name: string) => (event: Decoded) => event.eventName === name
+
+  // Claims and returns a vault operation's token legs, matched by role and
+  // amount: asset legs in or out of the vault, share mint/burn legs on it.
+  const claimVaultLegs = (vault: Address.Address, amounts: readonly bigint[]) => {
+    const legs: Decoded[] = []
+    for (const event of unclaimed()) {
+      const isVaultMintBurn =
+        (event.eventName === 'Mint' || event.eventName === 'Burn') &&
+        Address.isEqual(event.address, vault)
+      const isVaultLeg = (() => {
+        if (!isTransfer(event)) return false
+        const args = transferArgs(event)
+        if (Address.isEqual(args.from, vault) || Address.isEqual(args.to, vault)) return true
+        return (
+          Address.isEqual(event.address, vault) &&
+          (Address.isEqual(args.from, zeroAddress as Address.Address) ||
+            Address.isEqual(args.to, zeroAddress as Address.Address))
+        )
+      })()
+      if (!isVaultMintBurn && !isVaultLeg) continue
+      const amount = (event.args as { amount?: bigint }).amount
+      if (amount === undefined || !amounts.includes(amount)) continue
+      claim(event)
+      legs.push(event)
+    }
+    // The allowance granted for this operation (approve+deposit multicall) is
+    // internal: exact amount, spender is the vault, on a token a leg moved.
+    const legTokens = new Set(legs.map((leg) => leg.address.toLowerCase()))
+    for (const event of unclaimed()) {
+      if (event.eventName !== 'Approval' || !('spender' in event.args)) continue
+      if (!legTokens.has(event.address.toLowerCase())) continue
+      if (!Address.isEqual((event.args as { spender: Address.Address }).spender, vault)) continue
+      const amount = (event.args as { amount?: bigint }).amount
+      if (amount === undefined || !amounts.includes(amount)) continue
+      claim(event)
+      legs.push(event)
+    }
+    return legs
+  }
 
-  const privateDeposit = finalEvents.find((event) => event.eventName === 'EarnDeposit')
-  if (privateDeposit) {
-    const args = privateDeposit.args as {
+  // Private Earn router operations. Each wraps a public vault operation on the
+  // vault it names; fold that vault's own event and token legs, leaving vault
+  // activity elsewhere in the batch unclaimed.
+  recognize(named('EarnDeposit'), (event) => {
+    const args = event.args as {
       actionId: Hex.Hex
       earnShares: bigint
       earnVault: Address.Address
@@ -2884,28 +3451,38 @@ function classifyFromLogsCore(
       vaultAssets: bigint
       zoneDepositHash: Hex.Hex
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(privateDeposit)),
-        data: {
-          actionId: args.actionId,
-          assets: args.vaultAssets.toString(),
-          inputAmount: args.inputAmount.toString(),
-          inputToken: args.inputToken.toLowerCase() as Address.Address,
-          shares: args.earnShares.toString(),
-          signer,
-          status: 'completed',
-          vault: args.earnVault.toLowerCase() as Address.Address,
-          zoneDepositHash: args.zoneDepositHash,
-        },
-        type: 'private-assets-deposited',
-      },
-    ]
-  }
+    const vault = lc(args.earnVault)
+    // Parse before claiming so a malformed event consumes nothing but itself.
+    const data = {
+      actionId: args.actionId,
+      assets: args.vaultAssets.toString(),
+      inputAmount: args.inputAmount.toString(),
+      inputToken: lc(args.inputToken),
+      shares: args.earnShares.toString(),
+      signer,
+      status: 'completed' as const,
+      vault,
+      zoneDepositHash: args.zoneDepositHash,
+    }
+    // Fold the vault event this router call produced: the nearest preceding
+    // amount match, so a separate same-vault deposit keeps its own.
+    const nested = unclaimed(
+      (e) =>
+        e.eventName === 'Deposited' &&
+        e.logIndex < event.logIndex &&
+        Address.isEqual(e.address, vault) &&
+        (e.args as { assets?: bigint }).assets === args.vaultAssets,
+    ).at(-1)
+    if (nested) claim(nested)
+    else takeEvent((e) => e.eventName === 'Deposited' && Address.isEqual(e.address, vault))
+    claimVaultLegs(vault, [args.inputAmount, args.vaultAssets, args.earnShares])
+    // The funding leg pays the router (the emitting contract), not the vault.
+    claimVaultLegs(event.address as Address.Address, [args.inputAmount])
+    return { ...itemBase(event.logIndex), data, type: 'private-assets-deposited' }
+  })
 
-  const privateRedeem = finalEvents.find((event) => event.eventName === 'EarnRedeem')
-  if (privateRedeem) {
-    const args = privateRedeem.args as {
+  recognize(named('EarnRedeem'), (event) => {
+    const args = event.args as {
       actionId: Hex.Hex
       earnShares: bigint
       earnVault: Address.Address
@@ -2914,782 +3491,1025 @@ function classifyFromLogsCore(
       vaultAssets: bigint
       zoneDepositHash: Hex.Hex
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(privateRedeem)),
-        data: {
-          actionId: args.actionId,
-          assets: args.vaultAssets.toString(),
-          outputAmount: args.outputAmount.toString(),
-          outputToken: args.outputToken.toLowerCase() as Address.Address,
-          shares: args.earnShares.toString(),
-          signer,
-          status: 'completed',
-          vault: args.earnVault.toLowerCase() as Address.Address,
-          zoneDepositHash: args.zoneDepositHash,
-        },
-        type: 'private-shares-redeemed',
-      },
-    ]
-  }
+    const vault = lc(args.earnVault)
+    // Parse before claiming so a malformed event consumes nothing but itself.
+    const data = {
+      actionId: args.actionId,
+      assets: args.vaultAssets.toString(),
+      outputAmount: args.outputAmount.toString(),
+      outputToken: lc(args.outputToken),
+      shares: args.earnShares.toString(),
+      signer,
+      status: 'completed' as const,
+      vault,
+      zoneDepositHash: args.zoneDepositHash,
+    }
+    // Fold the vault event this router call produced: the nearest preceding
+    // amount match, so a separate same-vault redemption keeps its own.
+    const nested = unclaimed(
+      (e) =>
+        (e.eventName === 'Redeemed' || e.eventName === 'WithdrewExact') &&
+        e.logIndex < event.logIndex &&
+        Address.isEqual(e.address, vault) &&
+        (e.args as { assets?: bigint }).assets === args.vaultAssets,
+    ).at(-1)
+    if (nested) claim(nested)
+    else
+      takeEvent(
+        (e) =>
+          (e.eventName === 'Redeemed' || e.eventName === 'WithdrewExact') &&
+          Address.isEqual(e.address, vault),
+      )
+    claimVaultLegs(vault, [args.outputAmount, args.vaultAssets, args.earnShares])
+    // The payout leg leaves through the router (the emitting contract).
+    claimVaultLegs(event.address as Address.Address, [args.outputAmount])
+    return { ...itemBase(event.logIndex), data, type: 'private-shares-redeemed' }
+  })
 
-  const deposited = finalEvents.find((event) => event.eventName === 'Deposited')
-  if (deposited) {
-    const args = deposited.args as {
+  // Earn vault operations, each claiming its own token legs.
+  recognize(named('Deposited'), (event) => {
+    const args = event.args as {
       assets: bigint
       caller: Address.Address
       earnShares: bigint
       receiver: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(deposited)),
-        data: {
-          assets: args.assets.toString(),
-          caller: args.caller.toLowerCase() as Address.Address,
-          receiver: args.receiver.toLowerCase() as Address.Address,
-          shares: args.earnShares.toString(),
-          signer,
-          status: 'completed',
-          vault: deposited.address.toLowerCase() as Address.Address,
-        },
-        type: 'assets-deposited',
+    claimVaultLegs(event.address as Address.Address, [args.assets, args.earnShares])
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        assets: args.assets.toString(),
+        caller: lc(args.caller),
+        receiver: lc(args.receiver),
+        shares: args.earnShares.toString(),
+        signer,
+        status: 'completed',
+        vault: lc(event.address),
       },
-    ]
-  }
+      type: 'assets-deposited',
+    }
+  })
 
-  const venueDeposit = finalEvents.find((event) => event.eventName === 'VenueSharesDeposited')
-  if (venueDeposit) {
-    const args = venueDeposit.args as {
+  recognize(named('VenueSharesDeposited'), (event) => {
+    const args = event.args as {
       caller: Address.Address
       earnShares: bigint
       receivedEngineShares: bigint
       receiver: Address.Address
       requestedVenueShares: bigint
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(venueDeposit)),
-        data: {
-          caller: args.caller.toLowerCase() as Address.Address,
-          receivedEngineShares: args.receivedEngineShares.toString(),
-          receiver: args.receiver.toLowerCase() as Address.Address,
-          requestedVenueShares: args.requestedVenueShares.toString(),
-          shares: args.earnShares.toString(),
-          signer,
-          status: 'completed',
-          vault: venueDeposit.address.toLowerCase() as Address.Address,
-        },
-        type: 'shares-deposited',
+    claimVaultLegs(event.address as Address.Address, [
+      args.earnShares,
+      args.receivedEngineShares,
+      args.requestedVenueShares,
+    ])
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        caller: lc(args.caller),
+        receivedEngineShares: args.receivedEngineShares.toString(),
+        receiver: lc(args.receiver),
+        requestedVenueShares: args.requestedVenueShares.toString(),
+        shares: args.earnShares.toString(),
+        signer,
+        status: 'completed',
+        vault: lc(event.address),
       },
-    ]
-  }
+      type: 'shares-deposited',
+    }
+  })
 
-  const redeemed = finalEvents.find((event) => event.eventName === 'Redeemed')
-  if (redeemed) {
-    const args = redeemed.args as {
+  recognize(named('Redeemed'), (event) => {
+    const args = event.args as {
       assets: bigint
       caller: Address.Address
       earnShares: bigint
       receiver: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(redeemed)),
-        data: {
-          assets: args.assets.toString(),
-          caller: args.caller.toLowerCase() as Address.Address,
-          receiver: args.receiver.toLowerCase() as Address.Address,
-          shares: args.earnShares.toString(),
-          signer,
-          status: 'completed',
-          vault: redeemed.address.toLowerCase() as Address.Address,
-        },
-        type: 'shares-redeemed',
+    claimVaultLegs(event.address as Address.Address, [args.assets, args.earnShares])
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        assets: args.assets.toString(),
+        caller: lc(args.caller),
+        receiver: lc(args.receiver),
+        shares: args.earnShares.toString(),
+        signer,
+        status: 'completed',
+        vault: lc(event.address),
       },
-    ]
-  }
+      type: 'shares-redeemed',
+    }
+  })
 
-  const withdrew = finalEvents.find((event) => event.eventName === 'WithdrewExact')
-  if (withdrew) {
-    const args = withdrew.args as {
+  recognize(named('WithdrewExact'), (event) => {
+    const args = event.args as {
       assets: bigint
       caller: Address.Address
       earnSharesBurned: bigint
       receiver: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(withdrew)),
-        data: {
-          assets: args.assets.toString(),
-          caller: args.caller.toLowerCase() as Address.Address,
-          sharesBurned: args.earnSharesBurned.toString(),
-          receiver: args.receiver.toLowerCase() as Address.Address,
-          signer,
-          status: 'completed',
-          vault: withdrew.address.toLowerCase() as Address.Address,
-        },
-        type: 'assets-withdrawn',
+    claimVaultLegs(event.address as Address.Address, [args.assets, args.earnSharesBurned])
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        assets: args.assets.toString(),
+        caller: lc(args.caller),
+        receiver: lc(args.receiver),
+        sharesBurned: args.earnSharesBurned.toString(),
+        signer,
+        status: 'completed',
+        vault: lc(event.address),
       },
-    ]
-  }
+      type: 'assets-withdrawn',
+    }
+  })
 
-  const requested = finalEvents.find((event) => event.eventName === 'RedeemRequested')
-  if (requested) {
-    const args = requested.args as {
+  recognize(named('RedeemRequested'), (event) => {
+    const args = event.args as {
       earnShares: bigint
       receiver: Address.Address
       requestId: Hex.Hex
       requester: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(requested)),
-        data: {
-          receiver: args.receiver.toLowerCase() as Address.Address,
-          requestId: args.requestId,
-          requester: args.requester.toLowerCase() as Address.Address,
-          shares: args.earnShares.toString(),
-          signer,
-          status: 'pending',
-          vault: requested.address.toLowerCase() as Address.Address,
-        },
-        type: 'shares-redemption-requested',
+    claimVaultLegs(event.address as Address.Address, [args.earnShares])
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        receiver: lc(args.receiver),
+        requestId: args.requestId,
+        requester: lc(args.requester),
+        shares: args.earnShares.toString(),
+        signer,
+        status: 'pending',
+        vault: lc(event.address),
       },
-    ]
-  }
+      type: 'shares-redemption-requested',
+    }
+  })
 
-  const finalized = finalEvents.find((event) => event.eventName === 'RedeemFinalized')
-  if (finalized) {
-    const args = finalized.args as {
+  recognize(named('RedeemFinalized'), (event) => {
+    const args = event.args as {
       asset: Address.Address
       assets: bigint
       earnShares: bigint
       receiver: Address.Address
       requestId: Hex.Hex
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(finalized)),
-        data: {
-          asset: args.asset.toLowerCase() as Address.Address,
-          assets: args.assets.toString(),
-          receiver: args.receiver.toLowerCase() as Address.Address,
-          requestId: args.requestId,
-          shares: args.earnShares.toString(),
-          signer,
-          status: 'completed',
-          vault: finalized.address.toLowerCase() as Address.Address,
-        },
-        type: 'shares-redemption-finalized',
+    claimVaultLegs(event.address as Address.Address, [args.assets, args.earnShares])
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        asset: lc(args.asset),
+        assets: args.assets.toString(),
+        receiver: lc(args.receiver),
+        requestId: args.requestId,
+        shares: args.earnShares.toString(),
+        signer,
+        status: 'completed',
+        vault: lc(event.address),
       },
-    ]
-  }
+      type: 'shares-redemption-finalized',
+    }
+  })
 
-  const cancelled = finalEvents.find((event) => event.eventName === 'RedeemCancelled')
-  if (cancelled) {
-    const args = cancelled.args as {
+  recognize(named('RedeemCancelled'), (event) => {
+    const args = event.args as {
       earnShares: bigint
       receiver: Address.Address
       requestId: Hex.Hex
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(cancelled)),
-        data: {
-          receiver: args.receiver.toLowerCase() as Address.Address,
-          requestId: args.requestId,
-          shares: args.earnShares.toString(),
-          signer,
-          status: 'cancelled',
-          vault: cancelled.address.toLowerCase() as Address.Address,
-        },
-        type: 'shares-redemption-cancelled',
+    claimVaultLegs(event.address as Address.Address, [args.earnShares])
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        receiver: lc(args.receiver),
+        requestId: args.requestId,
+        shares: args.earnShares.toString(),
+        signer,
+        status: 'cancelled',
+        vault: lc(event.address),
       },
-    ]
-  }
+      type: 'shares-redemption-cancelled',
+    }
+  })
 
-  // Swap: a transfer into the DEX paired with one out of the DEX.
-  const toDex = transfers.find((e) =>
-    Address.isEqual((e.args as { to: Address.Address }).to, Addresses.stablecoinDex),
-  )
-  const fromDex = transfers.find((e) =>
-    Address.isEqual((e.args as { from: Address.Address }).from, Addresses.stablecoinDex),
-  )
-  if (toDex && fromDex) {
-    const swapper = (fromDex.args as { to: Address.Address }).to
-    const destTokenAddress = fromDex.address as Address.Address
-    const sourceToken = token(
-      (toDex.args as { amount: bigint }).amount,
-      toDex.address as Address.Address,
+  // External ERC-4626 vaults. Claim the share and asset legs unconditionally
+  // so nested vault plumbing never resurfaces as burns or transfers, but emit
+  // only operations the viewer is a party to. Fold-only recognitions are
+  // buffered and surface only when nothing else classified.
+  const suppressedVaultItems: RawItem[] = []
+  const viewerInvolved = (parties: readonly Address.Address[], legs: readonly Decoded[]) =>
+    parties.some((party) => Address.isEqual(party, viewer)) ||
+    legs.some(
+      (leg) =>
+        isTransfer(leg) &&
+        (Address.isEqual(transferArgs(leg).from, viewer) ||
+          Address.isEqual(transferArgs(leg).to, viewer)),
     )
+  recognize(named('Withdraw'), (event) => {
+    const args = event.args as {
+      assets: bigint
+      owner: Address.Address
+      receiver: Address.Address
+      sender: Address.Address
+      shares: bigint
+    }
+    const vault = event.address as Address.Address
+    // Parse before claiming so a malformed event consumes nothing but itself.
+    const data = {
+      assets: args.assets.toString(),
+      caller: lc(args.sender),
+      receiver: lc(args.receiver),
+      sharesBurned: args.shares.toString(),
+      signer,
+      status: 'completed' as const,
+      vault: lc(vault),
+    }
+    const legs = claimVaultLegs(vault, [args.assets, args.shares])
+    const item = { ...itemBase(event.logIndex), data, type: 'assets-withdrawn' as const }
+    if (viewerInvolved([args.sender, args.receiver, args.owner], legs)) return item
+    suppressedVaultItems.push(item)
+    return undefined
+  })
 
-    // Cross-token transfer: the swapped-out token is forwarded from the swapper
-    // to a different recipient in the same transaction (the account server's
-    // approve+swap+transfer multicall). Fold the swap and its delivery leg into
-    // one `transfer` carrying both the source token spent into the DEX and the
-    // destination token delivered to the recipient. A swap whose output stays
-    // with the swapper (no onward leg) stays a plain `swap` below.
-    const delivery = transfers.find(
-      (e) =>
-        Address.isEqual(e.address, destTokenAddress) &&
-        Address.isEqual((e.args as { from: Address.Address }).from, swapper) &&
-        !Address.isEqual((e.args as { to: Address.Address }).to, Addresses.stablecoinDex) &&
-        !Address.isEqual((e.args as { to: Address.Address }).to, swapper),
-    )
-    if (delivery) {
-      const args = delivery.args as {
-        amount: bigint
-        from: Address.Address
-        memo?: Hex.Hex | undefined
-        to: Address.Address
-      }
-      const rawMemo = delivery.eventName === 'TransferWithMemo' ? args.memo : undefined
-      const memo = rawMemo ? Transfers.memoToString(rawMemo) : undefined
-      const attribution = Mpp.resolve({ fingerprintMap, memo: rawMemo })
-      return [
-        transfer(itemBase(logIndexOfEvent(delivery)), blockNum, {
-          attribution,
-          destinationToken: token(args.amount, delivery.address as Address.Address),
-          direction: Address.isEqual(args.to, viewer) ? 'in' : 'out',
-          memo,
-          recipient: args.to.toLowerCase() as Address.Address,
-          sender: swapper.toLowerCase() as Address.Address,
-          signer,
-          sourceToken,
-        }),
-      ]
+  recognize(named('Deposit'), (event) => {
+    const args = event.args as {
+      assets: bigint
+      owner: Address.Address
+      sender: Address.Address
+      shares: bigint
+    }
+    const vault = event.address as Address.Address
+    // Parse before claiming so a malformed event consumes nothing but itself.
+    const data = {
+      assets: args.assets.toString(),
+      caller: lc(args.sender),
+      receiver: lc(args.owner),
+      shares: args.shares.toString(),
+      signer,
+      status: 'completed' as const,
+      vault: lc(vault),
     }
+    const legs = claimVaultLegs(vault, [args.assets, args.shares])
+    const item = { ...itemBase(event.logIndex), data, type: 'assets-deposited' as const }
+    if (viewerInvolved([args.sender, args.owner], legs)) return item
+    suppressedVaultItems.push(item)
+    return undefined
+  })
 
-    return [
-      {
-        ...itemBase(Math.min(logIndexOfEvent(toDex), logIndexOfEvent(fromDex))),
-        data: {
-          destinationToken: token((fromDex.args as { amount: bigint }).amount, destTokenAddress),
-          signer,
-          sourceToken,
-        },
-        type: 'swap',
+  // DEX order placed: `OrderPlaced` carries the escrow token/amount and side;
+  // claim the escrow transfer that funded it.
+  const orderPlacedItem = (event: Decoded): RawItem => {
+    const args = event.args as {
+      amount: bigint
+      isBid: boolean
+      orderId: bigint
+      tick: number
+      token: Address.Address
+    }
+    const escrow = (leg: Decoded) =>
+      isTransfer(leg) &&
+      Address.isEqual(leg.address, args.token) &&
+      Address.isEqual(transferArgs(leg).to, event.address as Address.Address)
+    // The escrow funds the placement, so it is the nearest preceding match; a
+    // same-token earlier swap input must not be taken instead.
+    const escrowLeg =
+      unclaimed(
+        (leg) =>
+          escrow(leg) && leg.logIndex < event.logIndex && transferArgs(leg).amount === args.amount,
+      ).at(-1) ?? unclaimed((leg) => escrow(leg) && leg.logIndex < event.logIndex).at(-1)
+    if (escrowLeg) claim(escrowLeg)
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        orderId: args.orderId.toString(),
+        side: args.isBid ? 'bid' : 'ask',
+        signer,
+        sourceToken: token(args.amount, args.token),
+        tick: Number(args.tick),
       },
-    ]
+      type: 'order-placed',
+    }
   }
+  const isFlipOrder = (event: Decoded) =>
+    'isFlipOrder' in event.args && (event.args as { isFlipOrder: boolean }).isFlipOrder === true
+  // Non-flip order escrow legs claim before swap pairing so they cannot
+  // mispair with an unrelated swap's output leg.
+  recognize((event) => event.eventName === 'OrderPlaced' && !isFlipOrder(event), orderPlacedItem)
+
+  // Swap: a transfer into a route paired with a different token coming back
+  // out. The DEX matches any swapper; other routes must be viewer-bounded
+  // with route-emitted logs between the legs.
+  {
+    // Outgoing transfers indexed by lowercase sender, for O(candidates)
+    // destination lookups. Claimed entries are skipped at scan time.
+    const transfersByFrom = new Map<string, Decoded[]>()
+    for (const event of pool) {
+      if (!isTransfer(event)) continue
+      const key = transferArgs(event).from.toLowerCase()
+      const list = transfersByFrom.get(key)
+      if (list) list.push(event)
+      else transfersByFrom.set(key, [event])
+    }
+    // One forward pass: claims only shrink the pool, so a source that finds
+    // no destination now never finds one later, and scanning each source once
+    // keeps the cost linear in sources instead of restarting per pair.
+    for (const source of unclaimed(isTransfer)) {
+      if (claimed.has(source.logIndex)) continue
+      const sourceArgs = transferArgs(source)
+      const route = sourceArgs.to
+      const routeKey = route.toLowerCase()
+      // Tempo system addresses (the reserve, fee manager, outbox, and every
+      // other non-DEX precompile) are never swap routes; new precompiles join
+      // the exclusion automatically.
+      if (nonRouteSystemAddresses.has(routeKey)) continue
+      if (Address.isEqual(route, zeroAddress as Address.Address)) continue
+      if (Address.isEqual(route, viewer)) continue
+      const isDex = Address.isEqual(route, Addresses.stablecoinDex)
+      if (!isDex && !Address.isEqual(sourceArgs.from, viewer)) continue
+      const candidates = (transfersByFrom.get(routeKey) ?? []).filter((event) => {
+        if (claimed.has(event.logIndex) || event.logIndex <= source.logIndex) return false
+        if (Address.isEqual(event.address, source.address)) return false
+        return !Address.isEqual(transferArgs(event).to, Addresses.feeManager)
+      })
+      // Prefer the output paying the swapper back (so interleaved swaps by
+      // different accounts keep their own outputs); otherwise a DEX pairs
+      // first-in-first-out, and a route's last leg is a direct delivery
+      // (earlier different-token legs are intermediate hops).
+      const destination =
+        candidates.find((event) => Address.isEqual(transferArgs(event).to, sourceArgs.from)) ??
+        (isDex ? candidates[0] : candidates.at(-1))
+      if (!destination) continue
+      // Route evidence for non-precompile routes: the route itself emitted a
+      // log between the legs (raw rows, so undecoded router events count). A
+      // counterparty that merely received and later paid back is not a route.
+      if (!isDex) {
+        const evidence = rows.some(
+          (r) =>
+            r.logIdx > source.logIndex &&
+            r.logIdx < destination.logIndex &&
+            r.logAddress.toLowerCase() === routeKey,
+        )
+        if (!evidence) continue
+      }
+      journal = []
+      try {
+        claim(source)
+        claim(destination)
+        const destinationArgs = transferArgs(destination)
+        const swapper = isDex ? destinationArgs.to : sourceArgs.from
+        const destTokenAddress = destination.address as Address.Address
+        const sourceToken = token(sourceArgs.amount, source.address as Address.Address)
+
+        // Router plumbing between the legs: route-touching or zero-address
+        // token moves and router-side approvals, never viewer-party transfers.
+        // DEX-precompile pairs claim nothing here, so an interleaved swap by
+        // another account keeps its own legs.
+        if (!isDex)
+          for (const event of unclaimed()) {
+            if (event.logIndex <= source.logIndex || event.logIndex >= destination.logIndex)
+              continue
+            if (isTransfer(event)) {
+              const args = transferArgs(event)
+              if (Address.isEqual(args.from, viewer) || Address.isEqual(args.to, viewer)) continue
+              if (
+                Address.isEqual(args.from, route) ||
+                Address.isEqual(args.to, route) ||
+                Address.isEqual(args.from, zeroAddress as Address.Address) ||
+                Address.isEqual(args.to, zeroAddress as Address.Address)
+              )
+                claim(event)
+            } else if (
+              event.eventName === 'Approval' &&
+              'owner' in event.args &&
+              !Address.isEqual((event.args as { owner: Address.Address }).owner, viewer)
+            )
+              claim(event)
+          }
 
-  // Mint: explicit `Mint` event (not the fee manager) or a transfer from zero.
-  const mintEvent = finalEvents.find(
-    (e) =>
-      e.eventName === 'Mint' &&
-      'amount' in e.args &&
-      !Address.isEqual(e.address, Addresses.feeManager),
-  )
-  if (mintEvent) {
-    const args = mintEvent.args as { amount: bigint; to: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(mintEvent)),
-        data: {
-          recipient: args.to.toLowerCase() as Address.Address,
-          sourceToken: token(args.amount, mintEvent.address as Address.Address),
-        },
-        type: 'mint',
-      },
-    ]
+        // The allowance granted for this swap: same token, owner, and amount,
+        // and causally tied to the input leg (spender is the route, or the
+        // approval immediately precedes it). Unrelated approvals stay.
+        unclaimed(
+          (event) =>
+            event.eventName === 'Approval' &&
+            'amount' in event.args &&
+            'owner' in event.args &&
+            'spender' in event.args &&
+            Address.isEqual(event.address, source.address) &&
+            Address.isEqual((event.args as { owner: Address.Address }).owner, sourceArgs.from) &&
+            (event.args as { amount: bigint }).amount === sourceArgs.amount &&
+            event.logIndex < source.logIndex &&
+            (Address.isEqual((event.args as { spender: Address.Address }).spender, route) ||
+              event.logIndex === source.logIndex - 1),
+        )
+          .slice(-1)
+          .forEach(claim)
+
+        // DEX bookkeeping this swap produced: fills against resting orders and
+        // the auto-flip re-placement, acted by the swapper or its route account.
+        // A fill of the viewer's own resting order stays its own item.
+        const isBookkeepingActor = (value: Address.Address) =>
+          Address.isEqual(value, swapper) || Address.isEqual(value, route)
+        unclaimed(
+          (event) =>
+            (Address.isEqual(event.address, route) ||
+              Address.isEqual(event.address, Addresses.stablecoinDex)) &&
+            ((event.eventName === 'OrderFilled' &&
+              'taker' in event.args &&
+              isBookkeepingActor((event.args as { taker: Address.Address }).taker) &&
+              !(
+                'maker' in event.args &&
+                Address.isEqual((event.args as { maker: Address.Address }).maker, viewer)
+              )) ||
+              (event.eventName === 'OrderPlaced' &&
+                isFlipOrder(event) &&
+                'maker' in event.args &&
+                isBookkeepingActor((event.args as { maker: Address.Address }).maker))),
+        ).forEach(claim)
+
+        // Cross-token transfer: the swapped-out token is forwarded whole from
+        // the swapper to a new recipient after the swap (the account server's
+        // approve+swap+transfer multicall), or the route delivered it to the
+        // recipient directly; fold both shapes into one `transfer`. A leg
+        // whose recipient later forwards a different token is the input of a
+        // chained swap, not a delivery.
+        const forwardsOn = (candidate: Decoded) => {
+          const args = transferArgs(candidate)
+          return (transfersByFrom.get(args.to.toLowerCase()) ?? []).some(
+            (onward) =>
+              !claimed.has(onward.logIndex) &&
+              onward.logIndex > candidate.logIndex &&
+              !Address.isEqual(onward.address, candidate.address),
+          )
+        }
+        const delivery =
+          !isDex && !Address.isEqual(destinationArgs.to, viewer)
+            ? destination
+            : takeTransfer((event) => {
+                const args = transferArgs(event)
+                return (
+                  event.logIndex > destination.logIndex &&
+                  Address.isEqual(event.address, destTokenAddress) &&
+                  Address.isEqual(args.from, swapper) &&
+                  args.amount === destinationArgs.amount &&
+                  !Address.isEqual(args.to, route) &&
+                  !Address.isEqual(args.to, swapper) &&
+                  !forwardsOn(event)
+                )
+              })
+        // A malformed delivery memo degrades to a plain swap item; the claimed
+        // legs must still produce an activity.
+        const item = (() => {
+          if (!delivery) return undefined
+          try {
+            const args = transferArgs(delivery)
+            const rawMemo = delivery.eventName === 'TransferWithMemo' ? args.memo : undefined
+            const memo = rawMemo ? Transfers.memoToString(rawMemo) : undefined
+            const attribution = Mpp.resolve({ fingerprintMap, memo: rawMemo })
+            return transfer(itemBase(delivery.logIndex), blockNum, {
+              attribution,
+              destinationToken: token(args.amount, delivery.address as Address.Address),
+              direction: Address.isEqual(args.to, viewer) ? ('in' as const) : ('out' as const),
+              memo,
+              recipient: lc(args.to),
+              sender: lc(swapper),
+              signer,
+              sourceToken,
+            })
+          } catch {
+            return undefined
+          }
+        })()
+        items.push(
+          item ?? {
+            ...itemBase(source.logIndex),
+            data: {
+              destinationToken: token(destinationArgs.amount, destTokenAddress),
+              signer,
+              sourceToken,
+            },
+            type: 'swap',
+          },
+        )
+      } catch {
+        // A malformed leg costs only this pair; release its claims so the
+        // legs fall through to the later recognizers.
+        for (const index of journal ?? []) claimed.delete(index)
+      } finally {
+        journal = undefined
+      }
+    }
   }
-  const zeroTransferIn = transfers.find((e) =>
-    Address.isEqual((e.args as { from: Address.Address }).from, zeroAddress as Address.Address),
+
+  // Mint: explicit `Mint` events (not the fee manager) and remaining transfers
+  // from the zero address (the dedup above already folded event/transfer pairs).
+  const mintItem = (event: Decoded, args: { amount: bigint; to: Address.Address }): RawItem => ({
+    ...itemBase(event.logIndex),
+    data: {
+      recipient: lc(args.to),
+      sourceToken: token(args.amount, event.address as Address.Address),
+    },
+    type: 'mint',
+  })
+  recognize(
+    (event) =>
+      event.eventName === 'Mint' &&
+      'amount' in event.args &&
+      'to' in event.args &&
+      !Address.isEqual(event.address, Addresses.feeManager),
+    (event) => mintItem(event, event.args as { amount: bigint; to: Address.Address }),
+  )
+  recognize(
+    (event) =>
+      isTransfer(event) &&
+      Address.isEqual(transferArgs(event).from, zeroAddress as Address.Address),
+    (event) => mintItem(event, transferArgs(event)),
   )
-  if (zeroTransferIn) {
-    const args = zeroTransferIn.args as { amount: bigint; to: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(zeroTransferIn)),
-        data: {
-          recipient: (args.to as string).toLowerCase() as Address.Address,
-          sourceToken: token(args.amount, zeroTransferIn.address as Address.Address),
-        },
-        type: 'mint',
-      },
-    ]
-  }
 
   // Burn blocked: a compliance burn of receive-policy-blocked funds. It also
-  // emits a zero-address `Transfer` that would otherwise classify as `burn`, so
-  // detect the distinct `BurnBlocked` event first.
-  const burnBlockedEvent = finalEvents.find((e) => e.eventName === 'BurnBlocked')
-  if (burnBlockedEvent) {
-    const args = burnBlockedEvent.args as { amount: bigint; from: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(burnBlockedEvent)),
-        data: {
-          sender: args.from.toLowerCase() as Address.Address,
-          signer,
-          sourceToken: token(args.amount, burnBlockedEvent.address as Address.Address),
-        },
-        type: 'burn-blocked',
+  // emits a zero-address `Transfer`; claim that paired leg so it cannot
+  // classify as a plain `burn`.
+  recognize(named('BurnBlocked'), (event) => {
+    const args = event.args as { amount: bigint; from: Address.Address }
+    takeTransfer(
+      (leg) =>
+        Address.isEqual(leg.address, event.address) &&
+        Address.isEqual(transferArgs(leg).to, zeroAddress as Address.Address) &&
+        transferArgs(leg).amount === args.amount,
+    )
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        sender: lc(args.from),
+        signer,
+        sourceToken: token(args.amount, event.address as Address.Address),
       },
-    ]
-  }
+      type: 'burn-blocked',
+    }
+  })
 
-  // Burn: explicit `Burn` event or a transfer to zero.
-  const burnEvent = finalEvents.find((e) => e.eventName === 'Burn' && 'amount' in e.args)
-  if (burnEvent) {
-    const args = burnEvent.args as { amount: bigint; from: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(burnEvent)),
-        data: {
-          sender: args.from.toLowerCase() as Address.Address,
-          signer,
-          sourceToken: token(args.amount, burnEvent.address as Address.Address),
-        },
-        type: 'burn',
-      },
-    ]
-  }
-  const zeroTransferOut = transfers.find((e) =>
-    Address.isEqual((e.args as { to: Address.Address }).to, zeroAddress as Address.Address),
+  // Burn: explicit `Burn` events and remaining transfers to the zero address.
+  const burnItem = (event: Decoded, args: { amount: bigint; from: Address.Address }): RawItem => ({
+    ...itemBase(event.logIndex),
+    data: {
+      sender: lc(args.from),
+      signer,
+      sourceToken: token(args.amount, event.address as Address.Address),
+    },
+    type: 'burn',
+  })
+  recognize(
+    (event) => event.eventName === 'Burn' && 'amount' in event.args && 'from' in event.args,
+    (event) => burnItem(event, event.args as { amount: bigint; from: Address.Address }),
+  )
+  recognize(
+    (event) =>
+      isTransfer(event) && Address.isEqual(transferArgs(event).to, zeroAddress as Address.Address),
+    (event) => burnItem(event, transferArgs(event)),
   )
-  if (zeroTransferOut) {
-    const args = zeroTransferOut.args as { amount: bigint; from: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(zeroTransferOut)),
-        data: {
-          sender: (args.from as string).toLowerCase() as Address.Address,
-          signer,
-          sourceToken: token(args.amount, zeroTransferOut.address as Address.Address),
-        },
-        type: 'burn',
-      },
-    ]
-  }
 
-  // Approval (excluding zone-outbox spenders).
-  const approvalEvent = finalEvents.find(
-    (e) =>
-      e.eventName === 'Approval' &&
-      // ERC-721 uses the same selector but indexes its token ID as topic3. In
-      // non-strict mode viem otherwise decodes the missing ERC-20 amount as zero.
+  // Approval (excluding zone-outbox spenders): only viewer-party approvals
+  // surface here; the rest stay for the nothing-else-classified fallback.
+  const isErc20Approval = (event: Decoded) => {
+    if (event.eventName !== 'Approval') return false
+    const args = event.args as { spender?: unknown }
+    if (typeof args.spender !== 'string' || !Address.validate(args.spender)) return false
+    // ERC-721 uses the same selector but indexes its token ID as topic3. In
+    // non-strict mode viem otherwise decodes the missing ERC-20 amount as zero.
+    return (
       rows.some(
         (row) =>
-          row.logIdx === e.logIndex &&
+          row.logIdx === event.logIndex &&
           row.topic3 === null &&
           /^0x[0-9a-fA-F]{64}$/.test(row.data ?? ''),
-      ) &&
-      !Address.isEqual((e.args as { spender: Address.Address }).spender, Addresses.zoneOutbox),
-  )
-  if (approvalEvent) {
-    const args = approvalEvent.args as { amount: bigint; spender: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(approvalEvent)),
-        data: {
-          signer,
-          sourceToken: token(args.amount, approvalEvent.address as Address.Address),
-          spender: args.spender.toLowerCase() as Address.Address,
-        },
-        type: 'approval',
+      ) && !Address.isEqual(args.spender as Address.Address, Addresses.zoneOutbox)
+    )
+  }
+  const approvalItem = (event: Decoded): RawItem => {
+    const args = event.args as { amount: bigint; spender: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        signer,
+        sourceToken: token(args.amount, event.address as Address.Address),
+        spender: lc(args.spender),
       },
-    ]
+      type: 'approval',
+    }
   }
+  recognize(
+    (event) =>
+      isErc20Approval(event) &&
+      'owner' in event.args &&
+      (Address.isEqual((event.args as { owner: Address.Address }).owner, viewer) ||
+        Address.isEqual((event.args as { spender: Address.Address }).spender, viewer)),
+    approvalItem,
+  )
 
-  // Precompile-event activities. These run before the generic transfer
-  // fallback because each is emitted alongside a co-located TIP-20 `Transfer`
-  // whose counterparty is the precompile (the DEX, the channel reserve, the fee
-  // manager, the token itself), which would otherwise classify as a plain
-  // transfer. They are grouped by (transaction + precompile counterparty), not
-  // by log adjacency.
-
-  // Payment channel opened: `ChannelOpened` carries the deposit token/amount
-  // directly, so no paired-transfer lookup is needed.
-  const channelOpened = finalEvents.find((e) => e.eventName === 'ChannelOpened')
-  if (channelOpened) {
-    const args = channelOpened.args as {
+  // Payment channels. The reserve doesn't put the token on `TopUp`/`Settled`/
+  // `ChannelClosed`, so each anchor claims its own reserve leg to recover it;
+  // batched channel operations pair with their own legs one at a time.
+  recognize(named('ChannelOpened'), (event) => {
+    const args = event.args as {
       channelId: Hex.Hex
       deposit: bigint
       payee: Address.Address
       payer: Address.Address
       token: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(channelOpened)),
-        data: {
-          channelId: args.channelId.toLowerCase() as Hex.Hex,
-          payee: args.payee.toLowerCase() as Address.Address,
-          payer: args.payer.toLowerCase() as Address.Address,
-          signer,
-          sourceToken: token(args.deposit, args.token),
-        },
-        type: 'channel-opened',
+    takeTransfer(
+      (leg) =>
+        Address.isEqual(leg.address, args.token) &&
+        Address.isEqual(transferArgs(leg).to, tip20ChannelReserve) &&
+        transferArgs(leg).amount === args.deposit,
+    )
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        channelId: hx(args.channelId),
+        payee: lc(args.payee),
+        payer: lc(args.payer),
+        signer,
+        sourceToken: token(args.deposit, args.token),
       },
-    ]
-  }
+      type: 'channel-opened',
+    }
+  })
 
-  // The channel reserve doesn't put the token on `TopUp`/`Settled`/
-  // `ChannelClosed`, so recover it from the co-located funding/payout transfer.
-  const reserveInflow = transfers.find((e) =>
-    Address.isEqual((e.args as { to: Address.Address }).to, tip20ChannelReserve),
-  )
-  const reserveOutflowTo = (recipient: Address.Address) =>
-    transfers.find(
+  recognize(named('TopUp'), (event) => {
+    const args = event.args as { additionalDeposit: bigint; channelId: Hex.Hex }
+    const inflow =
+      takeTransfer(
+        (leg) =>
+          Address.isEqual(transferArgs(leg).to, tip20ChannelReserve) &&
+          transferArgs(leg).amount === args.additionalDeposit,
+      ) ?? takeTransfer((leg) => Address.isEqual(transferArgs(leg).to, tip20ChannelReserve))
+    // A top-up cancels any pending close request on the channel; fold the
+    // cancellation event it bundles.
+    unclaimed(
       (e) =>
-        Address.isEqual((e.args as { from: Address.Address }).from, tip20ChannelReserve) &&
-        Address.isEqual((e.args as { to: Address.Address }).to, recipient),
+        e.eventName === 'CloseRequestCancelled' &&
+        'channelId' in e.args &&
+        (e.args as { channelId: Hex.Hex }).channelId === args.channelId,
     )
-
-  // Payment channel topped up: `additionalDeposit` from the event, token from
-  // the inbound funding transfer to the reserve.
-  const topUp = finalEvents.find((e) => e.eventName === 'TopUp')
-  if (topUp) {
-    const args = topUp.args as { additionalDeposit: bigint; channelId: Hex.Hex }
-    const tokenAddress = reserveInflow
-      ? (reserveInflow.address as Address.Address)
+      .slice(0, 1)
+      .forEach(claim)
+    const tokenAddress = inflow
+      ? (inflow.address as Address.Address)
       : (zeroAddress as Address.Address)
-    return [
-      {
-        ...itemBase(logIndexOfEvent(topUp)),
-        data: {
-          channelId: args.channelId.toLowerCase() as Hex.Hex,
-          signer,
-          sourceToken: token(args.additionalDeposit, tokenAddress),
-        },
-        type: 'channel-funded',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        channelId: hx(args.channelId),
+        signer,
+        sourceToken: token(args.additionalDeposit, tokenAddress),
       },
-    ]
-  }
+      type: 'channel-funded',
+    }
+  })
 
-  // Payment channel settled: `deltaPaid` from the event, token from the payout
-  // transfer out of the reserve to the payee.
-  const settled = finalEvents.find((e) => e.eventName === 'Settled')
-  if (settled) {
-    const args = settled.args as {
+  recognize(named('Settled'), (event) => {
+    const args = event.args as {
       channelId: Hex.Hex
       deltaPaid: bigint
       payee: Address.Address
       payer: Address.Address
     }
-    const payeeLeg = reserveOutflowTo(args.payee.toLowerCase() as Address.Address)
+    const payout = (leg: Decoded) =>
+      Address.isEqual(transferArgs(leg).from, tip20ChannelReserve) &&
+      Address.isEqual(transferArgs(leg).to, args.payee)
+    // Prefer the amount-matched payout so batched channel operations sharing
+    // a payee keep their own legs.
+    const payeeLeg =
+      takeTransfer((leg) => payout(leg) && transferArgs(leg).amount === args.deltaPaid) ??
+      takeTransfer(payout)
     const tokenAddress = payeeLeg
       ? (payeeLeg.address as Address.Address)
       : (zeroAddress as Address.Address)
-    return [
-      {
-        ...itemBase(logIndexOfEvent(settled)),
-        data: {
-          channelId: args.channelId.toLowerCase() as Hex.Hex,
-          payee: args.payee.toLowerCase() as Address.Address,
-          payer: args.payer.toLowerCase() as Address.Address,
-          signer,
-          sourceToken: token(args.deltaPaid, tokenAddress),
-        },
-        type: 'channel-settled',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        channelId: hx(args.channelId),
+        payee: lc(args.payee),
+        payer: lc(args.payer),
+        signer,
+        sourceToken: token(args.deltaPaid, tokenAddress),
       },
-    ]
-  }
+      type: 'channel-settled',
+    }
+  })
 
-  // Payment channel closed: payout to the payee and refund to the payer arrive
-  // as up to two transfers out of the reserve; attach whichever are present.
-  const channelClosed = finalEvents.find((e) => e.eventName === 'ChannelClosed')
-  if (channelClosed) {
-    const args = channelClosed.args as {
+  recognize(named('ChannelClosed'), (event) => {
+    const args = event.args as {
       channelId: Hex.Hex
       payee: Address.Address
       payer: Address.Address
       refundedToPayer: bigint
       settledToPayee: bigint
     }
-    const payeeLeg = reserveOutflowTo(args.payee.toLowerCase() as Address.Address)
-    const payerLeg = reserveOutflowTo(args.payer.toLowerCase() as Address.Address)
-    return [
-      {
-        ...itemBase(logIndexOfEvent(channelClosed)),
-        data: {
-          channelId: args.channelId.toLowerCase() as Hex.Hex,
-          payee: args.payee.toLowerCase() as Address.Address,
-          payer: args.payer.toLowerCase() as Address.Address,
-          ...(payerLeg && args.refundedToPayer > 0n
-            ? { refund: token(args.refundedToPayer, payerLeg.address as Address.Address) }
-            : {}),
-          signer,
-          ...(payeeLeg
-            ? { sourceToken: token(args.settledToPayee, payeeLeg.address as Address.Address) }
-            : {}),
-        },
-        type: 'channel-closed',
+    // A zero settlement or refund has no leg; claiming one would steal it
+    // from a batched sibling operation.
+    const reserveLegTo = (to: Address.Address, amount: bigint) => {
+      if (amount === 0n) return undefined
+      const payout = (leg: Decoded) =>
+        Address.isEqual(transferArgs(leg).from, tip20ChannelReserve) &&
+        Address.isEqual(transferArgs(leg).to, to)
+      return (
+        takeTransfer((leg) => payout(leg) && transferArgs(leg).amount === amount) ??
+        takeTransfer(payout)
+      )
+    }
+    const payeeLeg = reserveLegTo(args.payee, args.settledToPayee)
+    const payerLeg = reserveLegTo(args.payer, args.refundedToPayer)
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        channelId: hx(args.channelId),
+        payee: lc(args.payee),
+        payer: lc(args.payer),
+        ...(payerLeg && args.refundedToPayer > 0n
+          ? { refund: token(args.refundedToPayer, payerLeg.address as Address.Address) }
+          : {}),
+        signer,
+        ...(payeeLeg
+          ? { sourceToken: token(args.settledToPayee, payeeLeg.address as Address.Address) }
+          : {}),
       },
-    ]
-  }
+      type: 'channel-closed',
+    }
+  })
 
-  // Payment channel close cancelled: the payer revoked a pending close request.
-  // When bundled with a top-up the `TopUp` classifier above wins; on its own
-  // this carries no transfer, so the event itself is the signal.
-  const closeCancelled = finalEvents.find((e) => e.eventName === 'CloseRequestCancelled')
-  if (closeCancelled) {
-    const args = closeCancelled.args as {
+  // Payment channel close cancelled: carries no transfer, so the event itself
+  // is the signal. Cancellations bundled into a top-up were claimed above.
+  recognize(named('CloseRequestCancelled'), (event) => {
+    const args = event.args as {
       channelId: Hex.Hex
       payee: Address.Address
       payer: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(closeCancelled)),
-        data: {
-          channelId: args.channelId.toLowerCase() as Hex.Hex,
-          payee: args.payee.toLowerCase() as Address.Address,
-          payer: args.payer.toLowerCase() as Address.Address,
-          signer,
-        },
-        type: 'channel-close-cancelled',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        channelId: hx(args.channelId),
+        payee: lc(args.payee),
+        payer: lc(args.payer),
+        signer,
       },
-    ]
-  }
-
-  // DEX order placed: `OrderPlaced` carries the escrow token/amount and side.
-  // (Auto-flip re-places are inside swaps, which already returned above.)
-  const orderPlaced = finalEvents.find((e) => e.eventName === 'OrderPlaced')
-  if (orderPlaced) {
-    const args = orderPlaced.args as {
-      amount: bigint
-      isBid: boolean
-      orderId: bigint
-      tick: number
-      token: Address.Address
+      type: 'channel-close-cancelled',
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(orderPlaced)),
-        data: {
-          orderId: args.orderId.toString(),
-          side: args.isBid ? 'bid' : 'ask',
-          signer,
-          sourceToken: token(args.amount, args.token),
-          tick: Number(args.tick),
-        },
-        type: 'order-placed',
-      },
-    ]
+  })
+
+  // Payment-channel close requested: matched on the raw selector (the event
+  // is not in the merged ABI). Runs after the channel recognizers claimed
+  // their own reserve legs, then takes the leftover refund back to the viewer.
+  for (const row of rows.filter((r) => r.selector === closeRequestedSelector)) {
+    const refundLeg = takeTransfer((event) => {
+      const args = transferArgs(event)
+      if (!Address.isEqual(args.to, viewer)) return false
+      return (
+        Address.isEqual(args.from, tip20ChannelReserve) ||
+        Address.isEqual(args.from, row.logAddress)
+      )
+    })
+    const refund = refundLeg
+      ? token(transferArgs(refundLeg).amount, refundLeg.address as Address.Address)
+      : undefined
+    items.push({
+      ...itemBase(row.logIdx),
+      data: { ...(refund ? { refund } : {}), signer },
+      type: 'session-closed',
+    })
   }
 
+  // Auto-flip order placements not folded into a swap above.
+  recognize(named('OrderPlaced'), orderPlacedItem)
+
   // DEX order cancelled: refund is credited to the internal DEX balance, so
-  // there is no co-located transfer — the `OrderCancelled` event is the signal.
-  const orderCancelled = finalEvents.find((e) => e.eventName === 'OrderCancelled')
-  if (orderCancelled) {
-    const args = orderCancelled.args as { orderId: bigint }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(orderCancelled)),
-        data: { orderId: args.orderId.toString(), signer },
-        type: 'order-cancelled',
-      },
-    ]
-  }
+  // there is no co-located transfer; the event itself is the signal.
+  recognize(named('OrderCancelled'), (event) => {
+    const args = event.args as { orderId: bigint }
+    return {
+      ...itemBase(event.logIndex),
+      data: { orderId: args.orderId.toString(), signer },
+      type: 'order-cancelled',
+    }
+  })
 
-  // Fee-AMM rebalance swap: `validatorToken` in, `userToken` out.
-  const rebalanceSwap = finalEvents.find((e) => e.eventName === 'RebalanceSwap')
-  if (rebalanceSwap) {
-    const args = rebalanceSwap.args as {
+  // Fee-AMM rebalance swap: `validatorToken` in, `userToken` out; claim both
+  // fee-manager legs so neither resurfaces as a plain transfer.
+  recognize(named('RebalanceSwap'), (event) => {
+    const args = event.args as {
       amountIn: bigint
       amountOut: bigint
       swapper: Address.Address
       userToken: Address.Address
       validatorToken: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(rebalanceSwap)),
-        data: {
-          destinationToken: token(args.amountOut, args.userToken),
-          signer,
-          sourceToken: token(args.amountIn, args.validatorToken),
-          swapper: args.swapper.toLowerCase() as Address.Address,
-        },
-        type: 'fee-rebalance-swap',
+    takeTransfer(
+      (leg) =>
+        Address.isEqual(leg.address, args.validatorToken) &&
+        Address.isEqual(transferArgs(leg).from, args.swapper) &&
+        Address.isEqual(transferArgs(leg).to, Addresses.feeManager) &&
+        transferArgs(leg).amount === args.amountIn,
+    )
+    takeTransfer(
+      (leg) =>
+        Address.isEqual(leg.address, args.userToken) &&
+        Address.isEqual(transferArgs(leg).from, Addresses.feeManager) &&
+        Address.isEqual(transferArgs(leg).to, args.swapper) &&
+        transferArgs(leg).amount === args.amountOut,
+    )
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        destinationToken: token(args.amountOut, args.userToken),
+        signer,
+        sourceToken: token(args.amountIn, args.validatorToken),
+        swapper: lc(args.swapper),
       },
-    ]
-  }
+      type: 'fee-rebalance-swap',
+    }
+  })
 
-  // Validator fees distributed.
-  const feesDistributed = finalEvents.find((e) => e.eventName === 'FeesDistributed')
-  if (feesDistributed) {
-    const args = feesDistributed.args as {
+  // Validator fees distributed; claim the fee-manager payout leg.
+  recognize(named('FeesDistributed'), (event) => {
+    const args = event.args as {
       amount: bigint
       token: Address.Address
       validator: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(feesDistributed)),
-        data: {
-          signer,
-          sourceToken: token(args.amount, args.token),
-          validator: args.validator.toLowerCase() as Address.Address,
-        },
-        type: 'fees-distributed',
+    takeTransfer(
+      (leg) =>
+        Address.isEqual(leg.address, args.token) &&
+        Address.isEqual(transferArgs(leg).from, Addresses.feeManager) &&
+        Address.isEqual(transferArgs(leg).to, args.validator) &&
+        transferArgs(leg).amount === args.amount,
+    )
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        signer,
+        sourceToken: token(args.amount, args.token),
+        validator: lc(args.validator),
       },
-    ]
-  }
+      type: 'fees-distributed',
+    }
+  })
 
-  // Reward pool funded: the funded token is the emitting token contract itself.
-  const rewardDistributed = finalEvents.find((e) => e.eventName === 'RewardDistributed')
-  if (rewardDistributed) {
-    const args = rewardDistributed.args as { amount: bigint; funder: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(rewardDistributed)),
-        data: {
-          funder: args.funder.toLowerCase() as Address.Address,
-          signer,
-          sourceToken: token(args.amount, rewardDistributed.address as Address.Address),
-        },
-        type: 'reward-distributed',
+  // Reward pool funded: the funded token is the emitting contract itself;
+  // claim the funding transfer.
+  recognize(named('RewardDistributed'), (event) => {
+    const args = event.args as { amount: bigint; funder: Address.Address }
+    takeTransfer(
+      (leg) =>
+        Address.isEqual(leg.address, event.address as Address.Address) &&
+        Address.isEqual(transferArgs(leg).from, args.funder) &&
+        Address.isEqual(transferArgs(leg).to, event.address as Address.Address) &&
+        transferArgs(leg).amount === args.amount,
+    )
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        funder: lc(args.funder),
+        signer,
+        sourceToken: token(args.amount, event.address as Address.Address),
       },
-    ]
-  }
+      type: 'reward-distributed',
+    }
+  })
 
   // Reward recipient redirected.
-  const rewardRecipientSet = finalEvents.find((e) => e.eventName === 'RewardRecipientSet')
-  if (rewardRecipientSet) {
-    const args = rewardRecipientSet.args as { holder: Address.Address; recipient: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(rewardRecipientSet)),
-        data: {
-          holder: args.holder.toLowerCase() as Address.Address,
-          recipient: args.recipient.toLowerCase() as Address.Address,
-          signer,
-        },
-        type: 'reward-recipient-set',
+  recognize(named('RewardRecipientSet'), (event) => {
+    const args = event.args as { holder: Address.Address; recipient: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        holder: lc(args.holder),
+        recipient: lc(args.recipient),
+        signer,
       },
-    ]
-  }
+      type: 'reward-recipient-set',
+    }
+  })
 
   // Access-key spending limit updated: `newLimit` is carried as the token
   // amount so it enriches with the token's metadata.
-  const spendingLimitUpdated = finalEvents.find((e) => e.eventName === 'SpendingLimitUpdated')
-  if (spendingLimitUpdated) {
-    const args = spendingLimitUpdated.args as {
+  recognize(named('SpendingLimitUpdated'), (event) => {
+    const args = event.args as {
       account: Address.Address
       newLimit: bigint
       publicKey: Address.Address
       token: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(spendingLimitUpdated)),
-        data: {
-          account: args.account.toLowerCase() as Address.Address,
-          publicKey: args.publicKey.toLowerCase() as Address.Address,
-          signer,
-          sourceToken: token(args.newLimit, args.token),
-        },
-        type: 'spending-limit-updated',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        account: lc(args.account),
+        publicKey: lc(args.publicKey),
+        signer,
+        sourceToken: token(args.newLimit, args.token),
       },
-    ]
-  }
+      type: 'spending-limit-updated',
+    }
+  })
 
-  // Access-key lifecycle events — emitted alongside any co-located transfer.
-  const accessKeyItems: RawItem[] = []
-  for (const event of finalEvents) {
-    if (
+  // Access-key lifecycle events.
+  recognize(
+    (event) =>
       event.eventName === 'KeyAuthorized' &&
-      Address.isEqual(event.address, Addresses.accountKeychain)
-    ) {
+      Address.isEqual(event.address, Addresses.accountKeychain),
+    (event) => {
       const args = event.args as {
         account: Address.Address
         expiry: bigint
         publicKey: Address.Address
         signatureType: number
       }
-      accessKeyItems.push({
-        ...itemBase(logIndexOfEvent(event)),
+      return {
+        ...itemBase(event.logIndex),
         data: {
-          account: args.account.toLowerCase() as Address.Address,
+          account: lc(args.account),
           expiry: Number(args.expiry),
-          publicKey: args.publicKey.toLowerCase() as Address.Address,
+          publicKey: lc(args.publicKey),
           signatureType: Number(args.signatureType),
         },
         type: 'access-key-created',
-      })
-    } else if (
-      event.eventName === 'KeyRevoked' &&
-      Address.isEqual(event.address, Addresses.accountKeychain)
-    ) {
+      }
+    },
+  )
+  recognize(
+    (event) =>
+      event.eventName === 'KeyRevoked' && Address.isEqual(event.address, Addresses.accountKeychain),
+    (event) => {
       const args = event.args as { account: Address.Address; publicKey: Address.Address }
-      accessKeyItems.push({
-        ...itemBase(logIndexOfEvent(event)),
+      return {
+        ...itemBase(event.logIndex),
         data: {
-          account: args.account.toLowerCase() as Address.Address,
-          publicKey: args.publicKey.toLowerCase() as Address.Address,
+          account: lc(args.account),
+          publicKey: lc(args.publicKey),
         },
         type: 'access-key-revoked',
-      })
-    }
-  }
-
-  // Token creation.
-  const tokenCreated = finalEvents.find(
-    (e) => e.eventName === 'TokenCreated' && Address.isEqual(e.address, Addresses.tip20Factory),
+      }
+    },
   )
-  if (tokenCreated) {
-    const args = tokenCreated.args as {
-      currency: string
-      name: string
-      symbol: string
-      token: Address.Address
-    }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(tokenCreated)),
+
+  // Token creation. Factory initialization (role grants, config) precedes the
+  // creation event; claim those, leaving later admin actions on the token as
+  // independent activities.
+  recognize(
+    (event) =>
+      event.eventName === 'TokenCreated' && Address.isEqual(event.address, Addresses.tip20Factory),
+    (event) => {
+      const args = event.args as {
+        currency: string
+        name: string
+        symbol: string
+        token: Address.Address
+      }
+      unclaimed(
+        (e) => e.logIndex < event.logIndex && Address.isEqual(e.address, args.token),
+      ).forEach(claim)
+      return {
+        ...itemBase(event.logIndex),
         data: {
-          address: args.token.toLowerCase() as Address.Address,
+          address: lc(args.token),
           currency: args.currency,
           name: args.name,
           symbol: args.symbol,
         },
         type: 'token-created',
-      },
-      ...accessKeyItems,
-    ]
-  }
+      }
+    },
+  )
 
   // Governance / admin / DEX-bookkeeping events. Each maps a single decoded
-  // event to a typed item. Checked after token creation (a token-creation tx
-  // also emits `RoleMembershipUpdated`) and before the plain-transfer fallback;
-  // these carry no token movement, so the event itself is the whole signal.
-  const lc = (value: Address.Address) => value.toLowerCase() as Address.Address
-  const hx = (value: Hex.Hex) => value.toLowerCase() as Hex.Hex
-  const findEvent = (name: string) => finalEvents.find((e) => e.eventName === name)
-
-  // DEX bookkeeping (taker swaps and `OrderPlaced` already returned above).
-  const orderFilled = findEvent('OrderFilled')
-  if (orderFilled) {
-    const a = orderFilled.args as {
+  // event to a typed item; every remaining occurrence emits. These carry no
+  // token movement, so the event itself is the whole signal.
+  recognize(named('OrderFilled'), (event) => {
+    const a = event.args as {
       amountFilled: bigint
       maker: Address.Address
       orderId: bigint
       partialFill: boolean
       taker: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(orderFilled)),
-        data: {
-          amountFilled: a.amountFilled.toString(),
-          maker: lc(a.maker),
-          orderId: a.orderId.toString(),
-          partialFill: a.partialFill,
-          signer,
-          taker: lc(a.taker),
-        },
-        type: 'order-filled',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        amountFilled: a.amountFilled.toString(),
+        maker: lc(a.maker),
+        orderId: a.orderId.toString(),
+        partialFill: a.partialFill,
+        signer,
+        taker: lc(a.taker),
       },
-    ]
-  }
-  const orderFlipped = findEvent('OrderFlipped')
-  if (orderFlipped) {
-    const a = orderFlipped.args as {
+      type: 'order-filled',
+    }
+  })
+  recognize(named('OrderFlipped'), (event) => {
+    const a = event.args as {
       amount: bigint
       flipTick: number
       isBid: boolean
@@ -3698,342 +4518,299 @@ function classifyFromLogsCore(
       tick: number
       token: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(orderFlipped)),
-        data: {
-          flipTick: Number(a.flipTick),
-          maker: lc(a.maker),
-          orderId: a.orderId.toString(),
-          side: a.isBid ? 'bid' : 'ask',
-          signer,
-          sourceToken: token(a.amount, a.token),
-          tick: Number(a.tick),
-        },
-        type: 'order-flipped',
-      },
-    ]
-  }
-  const pairCreated = findEvent('PairCreated')
-  if (pairCreated) {
-    const a = pairCreated.args as { base: Address.Address; key: Hex.Hex; quote: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(pairCreated)),
-        data: { base: lc(a.base), key: hx(a.key), quote: lc(a.quote), signer },
-        type: 'pair-created',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        flipTick: Number(a.flipTick),
+        maker: lc(a.maker),
+        orderId: a.orderId.toString(),
+        side: a.isBid ? 'bid' : 'ask',
+        signer,
+        sourceToken: token(a.amount, a.token),
+        tick: Number(a.tick),
       },
-    ]
-  }
+      type: 'order-flipped',
+    }
+  })
+  recognize(named('PairCreated'), (event) => {
+    const a = event.args as { base: Address.Address; key: Hex.Hex; quote: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: { base: lc(a.base), key: hx(a.key), quote: lc(a.quote), signer },
+      type: 'pair-created',
+    }
+  })
 
   // TIP-20 token configuration / admin.
-  const pauseStateUpdate = findEvent('PauseStateUpdate')
-  if (pauseStateUpdate) {
-    const a = pauseStateUpdate.args as { isPaused: boolean; updater: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(pauseStateUpdate)),
-        data: { paused: a.isPaused, signer, updater: lc(a.updater) },
-        type: 'token-pause-set',
-      },
-    ]
-  }
-  const supplyCapUpdate = findEvent('SupplyCapUpdate')
-  if (supplyCapUpdate) {
-    const a = supplyCapUpdate.args as { newSupplyCap: bigint; updater: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(supplyCapUpdate)),
-        data: { signer, supplyCap: a.newSupplyCap.toString(), updater: lc(a.updater) },
-        type: 'token-supply-cap-set',
-      },
-    ]
-  }
-  const transferPolicyUpdate = findEvent('TransferPolicyUpdate')
-  if (transferPolicyUpdate) {
-    const a = transferPolicyUpdate.args as { newPolicyId: bigint; updater: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(transferPolicyUpdate)),
-        data: { policyId: a.newPolicyId.toString(), signer, updater: lc(a.updater) },
-        type: 'token-transfer-policy-set',
-      },
-    ]
-  }
-  const quoteTokenUpdate = findEvent('QuoteTokenUpdate')
-  if (quoteTokenUpdate) {
-    const a = quoteTokenUpdate.args as { newQuoteToken: Address.Address; updater: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(quoteTokenUpdate)),
-        data: { quoteToken: lc(a.newQuoteToken), signer, updater: lc(a.updater) },
-        type: 'token-quote-token-set',
-      },
-    ]
-  }
-  const nextQuoteTokenSet = findEvent('NextQuoteTokenSet')
-  if (nextQuoteTokenSet) {
-    const a = nextQuoteTokenSet.args as {
-      nextQuoteToken: Address.Address
-      updater: Address.Address
+  recognize(named('PauseStateUpdate'), (event) => {
+    const a = event.args as { isPaused: boolean; updater: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: { paused: a.isPaused, signer, updater: lc(a.updater) },
+      type: 'token-pause-set',
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(nextQuoteTokenSet)),
-        data: { nextQuoteToken: lc(a.nextQuoteToken), signer, updater: lc(a.updater) },
-        type: 'token-next-quote-token-set',
-      },
-    ]
-  }
-  const logoUriUpdated = findEvent('LogoURIUpdated')
-  if (logoUriUpdated) {
-    const a = logoUriUpdated.args as { newLogoURI: string; updater: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(logoUriUpdated)),
-        data: { logoUri: a.newLogoURI, signer, updater: lc(a.updater) },
-        type: 'token-logo-set',
-      },
-    ]
-  }
-  const roleMembershipUpdated = findEvent('RoleMembershipUpdated')
-  if (roleMembershipUpdated) {
-    const a = roleMembershipUpdated.args as {
+  })
+  recognize(named('SupplyCapUpdate'), (event) => {
+    const a = event.args as { newSupplyCap: bigint; updater: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: { signer, supplyCap: a.newSupplyCap.toString(), updater: lc(a.updater) },
+      type: 'token-supply-cap-set',
+    }
+  })
+  recognize(named('TransferPolicyUpdate'), (event) => {
+    const a = event.args as { newPolicyId: bigint; updater: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: { policyId: a.newPolicyId.toString(), signer, updater: lc(a.updater) },
+      type: 'token-transfer-policy-set',
+    }
+  })
+  recognize(named('QuoteTokenUpdate'), (event) => {
+    const a = event.args as { newQuoteToken: Address.Address; updater: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: { quoteToken: lc(a.newQuoteToken), signer, updater: lc(a.updater) },
+      type: 'token-quote-token-set',
+    }
+  })
+  recognize(named('NextQuoteTokenSet'), (event) => {
+    const a = event.args as { nextQuoteToken: Address.Address; updater: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: { nextQuoteToken: lc(a.nextQuoteToken), signer, updater: lc(a.updater) },
+      type: 'token-next-quote-token-set',
+    }
+  })
+  recognize(named('LogoURIUpdated'), (event) => {
+    const a = event.args as { newLogoURI: string; updater: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: { logoUri: a.newLogoURI, signer, updater: lc(a.updater) },
+      type: 'token-logo-set',
+    }
+  })
+  recognize(named('RoleMembershipUpdated'), (event) => {
+    const a = event.args as {
       account: Address.Address
       hasRole: boolean
       role: Hex.Hex
       sender: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(roleMembershipUpdated)),
-        data: {
-          account: lc(a.account),
-          granted: a.hasRole,
-          role: hx(a.role),
-          sender: lc(a.sender),
-          signer,
-        },
-        type: 'role-membership-set',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        account: lc(a.account),
+        granted: a.hasRole,
+        role: hx(a.role),
+        sender: lc(a.sender),
+        signer,
       },
-    ]
-  }
-  const roleAdminUpdated = findEvent('RoleAdminUpdated')
-  if (roleAdminUpdated) {
-    const a = roleAdminUpdated.args as {
+      type: 'role-membership-set',
+    }
+  })
+  recognize(named('RoleAdminUpdated'), (event) => {
+    const a = event.args as {
       newAdminRole: Hex.Hex
       role: Hex.Hex
       sender: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(roleAdminUpdated)),
-        data: {
-          newAdminRole: hx(a.newAdminRole),
-          role: hx(a.role),
-          sender: lc(a.sender),
-          signer,
-        },
-        type: 'role-admin-set',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        newAdminRole: hx(a.newAdminRole),
+        role: hx(a.role),
+        sender: lc(a.sender),
+        signer,
       },
-    ]
-  }
+      type: 'role-admin-set',
+    }
+  })
 
   // Fee-manager token configuration.
-  const userTokenSet = findEvent('UserTokenSet')
-  if (userTokenSet) {
-    const a = userTokenSet.args as { token: Address.Address; user: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(userTokenSet)),
-        data: { signer, token: lc(a.token), user: lc(a.user) },
-        type: 'fee-user-token-set',
-      },
-    ]
-  }
-  const validatorTokenSet = findEvent('ValidatorTokenSet')
-  if (validatorTokenSet) {
-    const a = validatorTokenSet.args as { token: Address.Address; validator: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(validatorTokenSet)),
-        data: { signer, token: lc(a.token), validator: lc(a.validator) },
-        type: 'fee-validator-token-set',
-      },
-    ]
-  }
+  recognize(named('UserTokenSet'), (event) => {
+    const a = event.args as { token: Address.Address; user: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: { signer, token: lc(a.token), user: lc(a.user) },
+      type: 'fee-user-token-set',
+    }
+  })
+  recognize(named('ValidatorTokenSet'), (event) => {
+    const a = event.args as { token: Address.Address; validator: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: { signer, token: lc(a.token), validator: lc(a.validator) },
+      type: 'fee-validator-token-set',
+    }
+  })
 
-  // TIP-403 policy registry (create wins over the member events it bundles).
-  const compoundPolicyCreated = findEvent('CompoundPolicyCreated')
-  if (compoundPolicyCreated) {
-    const a = compoundPolicyCreated.args as {
+  // TIP-403 policy registry. Creation events claim the member events they
+  // bundle (which precede the anchor); later member updates stay independent.
+  recognize(named('CompoundPolicyCreated'), (event) => {
+    const a = event.args as {
       creator: Address.Address
       mintRecipientPolicyId: bigint
       policyId: bigint
       recipientPolicyId: bigint
       senderPolicyId: bigint
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(compoundPolicyCreated)),
-        data: {
-          creator: lc(a.creator),
-          mintRecipientPolicyId: a.mintRecipientPolicyId.toString(),
-          policyId: a.policyId.toString(),
-          recipientPolicyId: a.recipientPolicyId.toString(),
-          senderPolicyId: a.senderPolicyId.toString(),
-          signer,
-        },
-        type: 'compound-policy-created',
+    const componentIds = new Set(
+      [a.mintRecipientPolicyId, a.recipientPolicyId, a.senderPolicyId].map(String),
+    )
+    unclaimed(
+      (e) =>
+        e.logIndex < event.logIndex &&
+        Address.isEqual(e.address, event.address) &&
+        ['BlacklistUpdated', 'PolicyAdminUpdated', 'PolicyCreated', 'WhitelistUpdated'].includes(
+          e.eventName,
+        ) &&
+        'policyId' in e.args &&
+        componentIds.has(String((e.args as { policyId: bigint }).policyId)),
+    ).forEach(claim)
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        creator: lc(a.creator),
+        mintRecipientPolicyId: a.mintRecipientPolicyId.toString(),
+        policyId: a.policyId.toString(),
+        recipientPolicyId: a.recipientPolicyId.toString(),
+        senderPolicyId: a.senderPolicyId.toString(),
+        signer,
       },
-    ]
-  }
-  const policyCreated = findEvent('PolicyCreated')
-  if (policyCreated) {
-    const a = policyCreated.args as {
+      type: 'compound-policy-created',
+    }
+  })
+  recognize(named('PolicyCreated'), (event) => {
+    const a = event.args as {
       policyId: bigint
       policyType: number
       updater: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(policyCreated)),
-        data: {
-          policyId: a.policyId.toString(),
-          policyType: Number(a.policyType),
-          signer,
-          updater: lc(a.updater),
-        },
-        type: 'policy-created',
+    unclaimed(
+      (e) =>
+        e.logIndex < event.logIndex &&
+        Address.isEqual(e.address, event.address) &&
+        ['BlacklistUpdated', 'PolicyAdminUpdated', 'WhitelistUpdated'].includes(e.eventName) &&
+        'policyId' in e.args &&
+        (e.args as { policyId: bigint }).policyId === a.policyId,
+    ).forEach(claim)
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        policyId: a.policyId.toString(),
+        policyType: Number(a.policyType),
+        signer,
+        updater: lc(a.updater),
       },
-    ]
-  }
-  const policyAdminUpdated = findEvent('PolicyAdminUpdated')
-  if (policyAdminUpdated) {
-    const a = policyAdminUpdated.args as {
+      type: 'policy-created',
+    }
+  })
+  recognize(named('PolicyAdminUpdated'), (event) => {
+    const a = event.args as {
       admin: Address.Address
       policyId: bigint
       updater: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(policyAdminUpdated)),
-        data: {
-          admin: lc(a.admin),
-          policyId: a.policyId.toString(),
-          signer,
-          updater: lc(a.updater),
-        },
-        type: 'policy-admin-set',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        admin: lc(a.admin),
+        policyId: a.policyId.toString(),
+        signer,
+        updater: lc(a.updater),
       },
-    ]
-  }
-  const whitelistUpdated = findEvent('WhitelistUpdated')
-  if (whitelistUpdated) {
-    const a = whitelistUpdated.args as {
+      type: 'policy-admin-set',
+    }
+  })
+  recognize(named('WhitelistUpdated'), (event) => {
+    const a = event.args as {
       account: Address.Address
       allowed: boolean
       policyId: bigint
       updater: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(whitelistUpdated)),
-        data: {
-          account: lc(a.account),
-          allowed: a.allowed,
-          policyId: a.policyId.toString(),
-          signer,
-          updater: lc(a.updater),
-        },
-        type: 'whitelist-updated',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        account: lc(a.account),
+        allowed: a.allowed,
+        policyId: a.policyId.toString(),
+        signer,
+        updater: lc(a.updater),
       },
-    ]
-  }
-  const blacklistUpdated = findEvent('BlacklistUpdated')
-  if (blacklistUpdated) {
-    const a = blacklistUpdated.args as {
+      type: 'whitelist-updated',
+    }
+  })
+  recognize(named('BlacklistUpdated'), (event) => {
+    const a = event.args as {
       account: Address.Address
       policyId: bigint
       restricted: boolean
       updater: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(blacklistUpdated)),
-        data: {
-          account: lc(a.account),
-          policyId: a.policyId.toString(),
-          restricted: a.restricted,
-          signer,
-          updater: lc(a.updater),
-        },
-        type: 'blacklist-updated',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        account: lc(a.account),
+        policyId: a.policyId.toString(),
+        restricted: a.restricted,
+        signer,
+        updater: lc(a.updater),
       },
-    ]
-  }
+      type: 'blacklist-updated',
+    }
+  })
 
   // Address / nonce registry.
-  const masterRegistered = findEvent('MasterRegistered')
-  if (masterRegistered) {
-    const a = masterRegistered.args as { masterAddress: Address.Address; masterId: Hex.Hex }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(masterRegistered)),
-        data: { masterAddress: lc(a.masterAddress), masterId: hx(a.masterId), signer },
-        type: 'master-registered',
-      },
-    ]
-  }
-  const nonceIncremented = findEvent('NonceIncremented')
-  if (nonceIncremented) {
-    const a = nonceIncremented.args as {
+  recognize(named('MasterRegistered'), (event) => {
+    const a = event.args as { masterAddress: Address.Address; masterId: Hex.Hex }
+    return {
+      ...itemBase(event.logIndex),
+      data: { masterAddress: lc(a.masterAddress), masterId: hx(a.masterId), signer },
+      type: 'master-registered',
+    }
+  })
+  recognize(named('NonceIncremented'), (event) => {
+    const a = event.args as {
       account: Address.Address
       newNonce: bigint
       nonceKey: bigint
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(nonceIncremented)),
-        data: {
-          account: lc(a.account),
-          nonce: a.newNonce.toString(),
-          nonceKey: a.nonceKey.toString(),
-          signer,
-        },
-        type: 'nonce-incremented',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        account: lc(a.account),
+        nonce: a.newNonce.toString(),
+        nonceKey: a.nonceKey.toString(),
+        signer,
       },
-    ]
-  }
+      type: 'nonce-incremented',
+    }
+  })
 
   // Access-key authorization witnesses.
-  const witnessRecorded = findEvent('KeyAuthorizationWitness')
-  if (witnessRecorded) {
-    const a = witnessRecorded.args as { account: Address.Address; witness: Hex.Hex }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(witnessRecorded)),
-        data: { account: lc(a.account), signer, witness: hx(a.witness) },
-        type: 'key-authorization-witness',
-      },
-    ]
-  }
-  const witnessBurned = findEvent('KeyAuthorizationWitnessBurned')
-  if (witnessBurned) {
-    const a = witnessBurned.args as { account: Address.Address; witness: Hex.Hex }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(witnessBurned)),
-        data: { account: lc(a.account), signer, witness: hx(a.witness) },
-        type: 'key-authorization-witness-burned',
-      },
-    ]
-  }
+  recognize(named('KeyAuthorizationWitness'), (event) => {
+    const a = event.args as { account: Address.Address; witness: Hex.Hex }
+    return {
+      ...itemBase(event.logIndex),
+      data: { account: lc(a.account), signer, witness: hx(a.witness) },
+      type: 'key-authorization-witness',
+    }
+  })
+  recognize(named('KeyAuthorizationWitnessBurned'), (event) => {
+    const a = event.args as { account: Address.Address; witness: Hex.Hex }
+    return {
+      ...itemBase(event.logIndex),
+      data: { account: lc(a.account), signer, witness: hx(a.witness) },
+      type: 'key-authorization-witness-burned',
+    }
+  })
 
-  // Validator configuration (rotation supersedes the add/deactivate it bundles).
-  const validatorRotated = findEvent('ValidatorRotated')
-  if (validatorRotated) {
-    const a = validatorRotated.args as {
+  // Validator configuration. Rotation claims the add/deactivate pair it
+  // bundles, matched by validator index.
+  recognize(named('ValidatorRotated'), (event) => {
+    const a = event.args as {
       caller: Address.Address
       deactivatedIndex: bigint
       egress: string
@@ -4043,27 +4820,32 @@ function classifyFromLogsCore(
       oldPublicKey: Hex.Hex
       validatorAddress: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(validatorRotated)),
-        data: {
-          caller: lc(a.caller),
-          deactivatedIndex: a.deactivatedIndex.toString(),
-          egress: a.egress,
-          index: a.index.toString(),
-          ingress: a.ingress,
-          newPublicKey: hx(a.newPublicKey),
-          oldPublicKey: hx(a.oldPublicKey),
-          signer,
-          validator: lc(a.validatorAddress),
-        },
-        type: 'validator-rotated',
+    unclaimed((e) => {
+      if (!('index' in e.args)) return false
+      const index = (e.args as { index: bigint }).index
+      return (
+        (e.eventName === 'ValidatorAdded' && index === a.index) ||
+        (e.eventName === 'ValidatorDeactivated' && index === a.deactivatedIndex)
+      )
+    }).forEach(claim)
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        caller: lc(a.caller),
+        deactivatedIndex: a.deactivatedIndex.toString(),
+        egress: a.egress,
+        index: a.index.toString(),
+        ingress: a.ingress,
+        newPublicKey: hx(a.newPublicKey),
+        oldPublicKey: hx(a.oldPublicKey),
+        signer,
+        validator: lc(a.validatorAddress),
       },
-    ]
-  }
-  const validatorAdded = findEvent('ValidatorAdded')
-  if (validatorAdded) {
-    const a = validatorAdded.args as {
+      type: 'validator-rotated',
+    }
+  })
+  recognize(named('ValidatorAdded'), (event) => {
+    const a = event.args as {
       egress: string
       feeRecipient: Address.Address
       index: bigint
@@ -4071,236 +4853,207 @@ function classifyFromLogsCore(
       publicKey: Hex.Hex
       validatorAddress: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(validatorAdded)),
-        data: {
-          egress: a.egress,
-          feeRecipient: lc(a.feeRecipient),
-          index: a.index.toString(),
-          ingress: a.ingress,
-          publicKey: hx(a.publicKey),
-          signer,
-          validator: lc(a.validatorAddress),
-        },
-        type: 'validator-added',
-      },
-    ]
-  }
-  const validatorDeactivated = findEvent('ValidatorDeactivated')
-  if (validatorDeactivated) {
-    const a = validatorDeactivated.args as { index: bigint; validatorAddress: Address.Address }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(validatorDeactivated)),
-        data: { index: a.index.toString(), signer, validator: lc(a.validatorAddress) },
-        type: 'validator-deactivated',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        egress: a.egress,
+        feeRecipient: lc(a.feeRecipient),
+        index: a.index.toString(),
+        ingress: a.ingress,
+        publicKey: hx(a.publicKey),
+        signer,
+        validator: lc(a.validatorAddress),
       },
-    ]
-  }
-  const validatorMigrated = findEvent('ValidatorMigrated')
-  if (validatorMigrated) {
-    const a = validatorMigrated.args as {
+      type: 'validator-added',
+    }
+  })
+  recognize(named('ValidatorDeactivated'), (event) => {
+    const a = event.args as { index: bigint; validatorAddress: Address.Address }
+    return {
+      ...itemBase(event.logIndex),
+      data: { index: a.index.toString(), signer, validator: lc(a.validatorAddress) },
+      type: 'validator-deactivated',
+    }
+  })
+  recognize(named('ValidatorMigrated'), (event) => {
+    const a = event.args as {
       index: bigint
       publicKey: Hex.Hex
       validatorAddress: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(validatorMigrated)),
-        data: {
-          index: a.index.toString(),
-          publicKey: hx(a.publicKey),
-          signer,
-          validator: lc(a.validatorAddress),
-        },
-        type: 'validator-migrated',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        index: a.index.toString(),
+        publicKey: hx(a.publicKey),
+        signer,
+        validator: lc(a.validatorAddress),
       },
-    ]
-  }
-  const validatorMigrationSkipped = findEvent('SkippedValidatorMigration')
-  if (validatorMigrationSkipped) {
-    const a = validatorMigrationSkipped.args as {
+      type: 'validator-migrated',
+    }
+  })
+  recognize(named('SkippedValidatorMigration'), (event) => {
+    const a = event.args as {
       index: bigint
       publicKey: Hex.Hex
       validatorAddress: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(validatorMigrationSkipped)),
-        data: {
-          index: a.index.toString(),
-          publicKey: hx(a.publicKey),
-          signer,
-          validator: lc(a.validatorAddress),
-        },
-        type: 'validator-migration-skipped',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        index: a.index.toString(),
+        publicKey: hx(a.publicKey),
+        signer,
+        validator: lc(a.validatorAddress),
       },
-    ]
-  }
-  const feeRecipientUpdated = findEvent('FeeRecipientUpdated')
-  if (feeRecipientUpdated) {
-    const a = feeRecipientUpdated.args as {
+      type: 'validator-migration-skipped',
+    }
+  })
+  recognize(named('FeeRecipientUpdated'), (event) => {
+    const a = event.args as {
       caller: Address.Address
       feeRecipient: Address.Address
       index: bigint
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(feeRecipientUpdated)),
-        data: {
-          caller: lc(a.caller),
-          feeRecipient: lc(a.feeRecipient),
-          index: a.index.toString(),
-          signer,
-        },
-        type: 'validator-fee-recipient-set',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        caller: lc(a.caller),
+        feeRecipient: lc(a.feeRecipient),
+        index: a.index.toString(),
+        signer,
       },
-    ]
-  }
-  const ipAddressesUpdated = findEvent('IpAddressesUpdated')
-  if (ipAddressesUpdated) {
-    const a = ipAddressesUpdated.args as {
+      type: 'validator-fee-recipient-set',
+    }
+  })
+  recognize(named('IpAddressesUpdated'), (event) => {
+    const a = event.args as {
       caller: Address.Address
       egress: string
       index: bigint
       ingress: string
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(ipAddressesUpdated)),
-        data: {
-          caller: lc(a.caller),
-          egress: a.egress,
-          index: a.index.toString(),
-          ingress: a.ingress,
-          signer,
-        },
-        type: 'validator-ip-set',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        caller: lc(a.caller),
+        egress: a.egress,
+        index: a.index.toString(),
+        ingress: a.ingress,
+        signer,
       },
-    ]
-  }
-  const validatorOwnershipTransferred = findEvent('ValidatorOwnershipTransferred')
-  if (validatorOwnershipTransferred) {
-    const a = validatorOwnershipTransferred.args as {
+      type: 'validator-ip-set',
+    }
+  })
+  recognize(named('ValidatorOwnershipTransferred'), (event) => {
+    const a = event.args as {
       caller: Address.Address
       index: bigint
       newAddress: Address.Address
       oldAddress: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(validatorOwnershipTransferred)),
-        data: {
-          caller: lc(a.caller),
-          index: a.index.toString(),
-          newAddress: lc(a.newAddress),
-          oldAddress: lc(a.oldAddress),
-          signer,
-        },
-        type: 'validator-ownership-transferred',
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        caller: lc(a.caller),
+        index: a.index.toString(),
+        newAddress: lc(a.newAddress),
+        oldAddress: lc(a.oldAddress),
+        signer,
       },
-    ]
-  }
-  const ownershipTransferred = findEvent('OwnershipTransferred')
-  if (ownershipTransferred) {
-    const a = ownershipTransferred.args as {
+      type: 'validator-ownership-transferred',
+    }
+  })
+  recognize(named('OwnershipTransferred'), (event) => {
+    const a = event.args as {
       newOwner: Address.Address
       oldOwner: Address.Address
     }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(ownershipTransferred)),
-        data: { newOwner: lc(a.newOwner), oldOwner: lc(a.oldOwner), signer },
-        type: 'ownership-transferred',
-      },
-    ]
-  }
-  const rotationEpochSet = findEvent('NetworkIdentityRotationEpochSet')
-  if (rotationEpochSet) {
-    const a = rotationEpochSet.args as { nextEpoch: bigint; previousEpoch: bigint }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(rotationEpochSet)),
-        data: {
-          nextEpoch: a.nextEpoch.toString(),
-          previousEpoch: a.previousEpoch.toString(),
-          signer,
-        },
-        type: 'network-identity-rotation-epoch-set',
-      },
-    ]
-  }
-  const initialized = findEvent('Initialized')
-  if (initialized) {
-    const a = initialized.args as { height: bigint }
-    return [
-      {
-        ...itemBase(logIndexOfEvent(initialized)),
-        data: { height: a.height.toString(), signer },
-        type: 'initialized',
+    return {
+      ...itemBase(event.logIndex),
+      data: { newOwner: lc(a.newOwner), oldOwner: lc(a.oldOwner), signer },
+      type: 'ownership-transferred',
+    }
+  })
+  recognize(named('NetworkIdentityRotationEpochSet'), (event) => {
+    const a = event.args as { nextEpoch: bigint; previousEpoch: bigint }
+    return {
+      ...itemBase(event.logIndex),
+      data: {
+        nextEpoch: a.nextEpoch.toString(),
+        previousEpoch: a.previousEpoch.toString(),
+        signer,
       },
-    ]
-  }
-
-  // Default: plain transfer (excluding transfers to the fee manager).
-  const userTransfers = transfers.filter(
-    (e) => !Address.isEqual((e.args as { to: Address.Address }).to, Addresses.feeManager),
-  )
-  if (userTransfers.length > 0) {
-    const t = userTransfers[0]!
-    const args = t.args as {
-      amount: bigint
-      from: Address.Address
-      memo?: Hex.Hex | undefined
-      to: Address.Address
+      type: 'network-identity-rotation-epoch-set',
+    }
+  })
+  recognize(named('Initialized'), (event) => {
+    const a = event.args as { height: bigint }
+    return {
+      ...itemBase(event.logIndex),
+      data: { height: a.height.toString(), signer },
+      type: 'initialized',
     }
-    const to = args.to.toLowerCase() as Address.Address
-    const from = args.from.toLowerCase() as Address.Address
-    const rawMemo = t.eventName === 'TransferWithMemo' ? args.memo : undefined
+  })
+
+  // Plain transfers: every remaining viewer-party transfer is its own
+  // activity. Non-viewer transfers are internal legs of what classified
+  // above and surface only via the fallback below.
+  const buildTransfer = (event: Decoded): RawItem => {
+    const args = transferArgs(event)
+    const to = lc(args.to)
+    const from = lc(args.from)
+    const rawMemo = event.eventName === 'TransferWithMemo' ? args.memo : undefined
     // The raw memo (not the suppressed display string) carries the MPP
     // attribution fingerprint, so resolve the service name from it.
     const memo = rawMemo ? Transfers.memoToString(rawMemo) : undefined
     const attribution = Mpp.resolve({ fingerprintMap, memo: rawMemo })
-    const sourceToken = token(args.amount, t.address as Address.Address)
+    const sourceToken = token(args.amount, event.address as Address.Address)
     if (Address.isEqual(to, viewer))
-      return [
-        transfer(itemBase(logIndexOfEvent(t)), blockNum, {
-          attribution,
-          direction: 'in',
-          memo,
-          recipient: viewer,
-          sender: from,
-          sourceToken,
-        }),
-        ...accessKeyItems,
-      ]
-    return [
-      transfer(itemBase(logIndexOfEvent(t)), blockNum, {
+      return transfer(itemBase(event.logIndex), blockNum, {
         attribution,
-        direction: 'out',
+        direction: 'in',
         memo,
-        recipient: to,
+        recipient: viewer,
         sender: from,
-        signer,
         sourceToken,
-      }),
-      ...accessKeyItems,
-    ]
+      })
+    return transfer(itemBase(event.logIndex), blockNum, {
+      attribution,
+      direction: 'out',
+      memo,
+      recipient: to,
+      sender: from,
+      signer,
+      sourceToken,
+    })
   }
+  const isUserTransfer = (event: Decoded) =>
+    isTransfer(event) && !Address.isEqual(transferArgs(event).to, Addresses.feeManager)
+  recognize(
+    (event) =>
+      isUserTransfer(event) &&
+      (Address.isEqual(transferArgs(event).from, viewer) ||
+        Address.isEqual(transferArgs(event).to, viewer)),
+    buildTransfer,
+  )
 
-  // Pure access-key tx (no transfer / mint / burn / etc.).
-  if (accessKeyItems.length > 0) return accessKeyItems
+  // Fallback when nothing viewer-facing classified: surface fold-only vault
+  // items, third-party approvals, and transfers (e.g. a sponsored batch)
+  // instead of reporting `unknown`.
+  if (items.length === 0) {
+    items.push(...suppressedVaultItems)
+    recognize(isErc20Approval, approvalItem)
+    recognize(isUserTransfer, buildTransfer)
+  }
 
-  // Unclassified: a tx the address sent or paid for whose logs matched no known
-  // classifier. Surface it honestly as an `unknown` item carrying every log
-  // (decoded when possible), rather than fabricating a zero transfer.
-  return [unknown(itemBase(minLogIndex), { events: buildTxEvents(rows, events), signer })]
-}
+  // Unclassified: a tx the address sent or paid for whose logs matched no
+  // known classifier. Surface it honestly as an `unknown` item carrying every
+  // log (decoded when possible), rather than fabricating a zero transfer.
+  if (items.length === 0)
+    return [unknown(itemBase(minLogIndex), { events: buildTxEvents(rows, events), signer })]
 
-/** Extracts the block-wide log index from a decoded viem event. */
-function logIndexOfEvent(event: { logIndex: number }): number {
-  return event.logIndex
+  return items.sort((a, b) => a.logIndex - b.logIndex)
 }
 
 /**
@@ -4364,8 +5117,8 @@ function unknown(
 
 /** Decodes a group's raw rows into `viem/tempo` events via `parseEventLogs` (non-strict). */
 function decodeRows(rows: readonly Row[]) {
-  return rows.flatMap((r) => {
-    const log: Log = {
+  const logs = rows.map(
+    (r): Log => ({
       address: r.logAddress as `0x${string}`,
       blockHash: '0x0' as Hex.Hex,
       blockNumber: BigInt(r.blockNum),
@@ -4375,17 +5128,21 @@ function decodeRows(rows: readonly Row[]) {
       topics: [r.selector, r.topic1, r.topic2, r.topic3].filter(Boolean) as [Hex.Hex, ...Hex.Hex[]],
       transactionHash: r.txHash as `0x${string}`,
       transactionIndex: r.txIdx,
-    }
-    try {
-      return parseEventLogs({
-        abi: [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault],
-        logs: [log],
-        strict: false,
-      })
-    } catch {
-      return []
-    }
-  })
+    }),
+  )
+  try {
+    // One batched call: viem re-processes the merged ABI per invocation, so
+    // per-row calls cost ~55x more. Non-strict decoding skips undecodable
+    // logs per log and can yield `args: undefined`; normalize so `in`-guards
+    // never throw.
+    return parseEventLogs({
+      abi: [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault, ...erc4626Events],
+      logs,
+      strict: false,
+    }).map((event) => ({ ...event, args: event.args ?? {} }))
+  } catch {
+    return []
+  }
 }
 
 /**
@@ -4521,49 +5278,63 @@ async function enrichTokens(
   for (const item of items) collectTokens(item, addresses)
   const includeLogoUri = include.includes('token.logoUri')
   const includeVerified = include.includes('token.verified')
+  const resolved_promise =
+    addresses.size > 0
+      ? Timing.time(c, 'tokens', () =>
+          Promise.all(
+            [...addresses].map(async (address) => {
+              const [logoUri, metadata] = await Promise.all([
+                includeLogoUri
+                  ? Tokens.getTokenLogo(c, { address, chainId }).catch(() => undefined)
+                  : undefined,
+                getActivityTokenMetadata(c, { address, chainId }),
+              ])
+              return { address: address.toLowerCase(), logoUri, metadata }
+            }),
+          ),
+        )
+      : undefined
   // Curated data is needed only for requested valuation or token fields.
-  const snapshot =
+  const snapshot_promise =
     addresses.size > 0 && (denomination !== undefined || includeLogoUri || includeVerified)
-      ? await VerifiedTokens.snapshot(c, chainId).catch(() => undefined)
-      : undefined
-  const rates = denomination
-    ? await Valuation.ratesFor(c, {
-        currencies: snapshot
-          ? [...addresses].flatMap((address) => {
-              const held = snapshot.byAddress.get(address)?.currency
-              return held === undefined ? [] : [held]
-            })
-          : [],
-        denomination,
-        oracle,
-      })
-    : undefined
-  if (addresses.size === 0) return { items: items as Item[], rates }
-
-  const resolved = await Timing.time(c, 'tokens', () =>
-    Promise.all(
-      [...addresses].map(async (address) => {
-        const [logoUri, metadata] = await Promise.all([
-          includeLogoUri
-            ? Tokens.getTokenLogo(c, { address, chainId }).catch(() => undefined)
+      ? VerifiedTokens.snapshot(c, chainId).catch(() => undefined)
+      : Promise.resolve(undefined)
+  const rates_promise = (async () => {
+    if (!denomination) return undefined
+    const snapshot = await snapshot_promise
+    return Valuation.ratesFor(c, {
+      currencies: snapshot
+        ? [...addresses].flatMap((address) => {
+            const held = snapshot.byAddress.get(address)?.currency
+            return held === undefined ? [] : [held]
+          })
+        : [],
+      denomination,
+      oracle,
+    })
+  })()
+  if (!resolved_promise) return { items: items as Item[], rates: await rates_promise }
+
+  const [resolved_raw, rates, snapshot] = await Promise.all([
+    resolved_promise,
+    rates_promise,
+    snapshot_promise,
+  ])
+  const resolved = resolved_raw.map(
+    ({ address, logoUri, metadata }) =>
+      [
+        address,
+        {
+          currency: metadata.currency,
+          decimals: metadata.decimals,
+          logoUri: includeLogoUri
+            ? (logoUri ?? snapshot?.byAddress.get(address)?.logoUri ?? metadata.logoUri)
             : undefined,
-          getActivityTokenMetadata(c, { address, chainId }),
-        ])
-        return [
-          address.toLowerCase(),
-          {
-            currency: metadata.currency,
-            decimals: metadata.decimals,
-            logoUri: includeLogoUri
-              ? (logoUri ?? snapshot?.byAddress.get(address)?.logoUri ?? metadata.logoUri)
-              : undefined,
-            name: metadata.name,
-            symbol: metadata.symbol,
-            verified: includeVerified && snapshot ? snapshot.byAddress.has(address) : undefined,
-          },
-        ] as const
-      }),
-    ),
+          name: metadata.name,
+          symbol: metadata.symbol,
+          verified: includeVerified && snapshot ? snapshot.byAddress.has(address) : undefined,
+        },
+      ] as const,
   )
   const byAddress = new Map(resolved)
   return {
@@ -4584,6 +5355,54 @@ declare namespace enrichTokens {
   }
 }
 
+/** Resolves token metadata on each item's source chain without changing feed order. */
+async function enrichChainTokens(
+  c: Context<App.Environment>,
+  options: enrichChainTokens.Options,
+): Promise<{ items: Item[]; rates: FxOracle.RateSet | undefined }> {
+  const byChain = new Map<number, listChains.Item[]>()
+  for (const item of options.items) {
+    const items = byChain.get(item.chainId) ?? []
+    items.push(item)
+    byChain.set(item.chainId, items)
+  }
+  const results = await Promise.all(
+    [...byChain].map(async ([chainId, items]) => ({
+      chainId,
+      ...(await enrichTokens(c, {
+        chainId,
+        denomination: options.denomination,
+        include: options.include,
+        items,
+        oracle: options.oracle,
+      })),
+    })),
+  )
+  type Bucket = { index: number; items: Item[] }
+  const buckets = new Map<number, Bucket>()
+  for (const result of results) buckets.set(result.chainId, { index: 0, items: result.items })
+  return {
+    items: options.items.map((item) => {
+      const bucket = buckets.get(item.chainId)!
+      return bucket.items[bucket.index++]!
+    }),
+    rates: results.find((result) => result.rates !== undefined)?.rates,
+  }
+}
+
+declare namespace enrichChainTokens {
+  type Options = {
+    /** Currency the amount valuations are denominated in. */
+    denomination?: string | undefined
+    /** Optional token fields to resolve. */
+    include: readonly z.output<typeof schema.Include>[]
+    /** Chain-tagged items awaiting token enrichment. */
+    items: readonly listChains.Item[]
+    /** FX rate oracle backing amount valuation. */
+    oracle: FxOracle.Oracle
+  }
+}
+
 /** Returns an enriched copy of an item without mutating its cached token stubs. */
 function enrichItem(
   item: UnenrichedItem,
@@ -4651,6 +5470,7 @@ export function groupByAccessKey(items: Item[]): Entry[] {
 }
 
 type GroupableItem = {
+  chainId?: number | undefined
   data: object
   id: string
   perspective: 'incoming' | 'outgoing'
@@ -4660,6 +5480,7 @@ type GroupableItem = {
 type GroupedItem<item extends GroupableItem> =
   | item
   | {
+      chainId?: number | undefined
       data: { items: item[]; signer: Address.Address }
       id: string
       perspective: 'incoming' | 'outgoing'
@@ -4678,6 +5499,7 @@ function groupByAccessKeyItems<item extends GroupableItem>(items: item[]): Group
     if (itemSigner !== 'self') {
       if (
         currentGroup &&
+        currentGroup.items[0]!.chainId === item.chainId &&
         Address.isEqual(currentGroup.signer, itemSigner) &&
         sameCalendarDay(currentGroup.items[0]!.timestamp, item.timestamp)
       ) {
@@ -4717,6 +5539,7 @@ function flushGroup<item extends GroupableItem>(group: {
   const firstItem = group.items[0]!
   const lastItem = group.items[group.items.length - 1]!
   return {
+    ...(firstItem.chainId === undefined ? {} : { chainId: firstItem.chainId }),
     data: { items: group.items, signer: group.signer },
     perspective: firstItem.perspective,
     id: `${firstItem.id}..${lastItem.id}:${group.items.length}`,