tapimo 0.11.0 → 0.13.0

package/dist/apps/data/routes/activities.js

@@ -19,12 +19,13 @@ 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';
 /** Example transaction hash surfaced in OpenAPI docs. */
 const exampleHash = '0x4845ae2098724ab26a5d89370dce5124d044be6a5acc164afc348662de67d474';
-const tokenFields = ['token.logoUri', 'token.verified'];
+const includeFields = ['token.logoUri', 'token.verified', 'zones'];
 // TIP-20 tokens live at deterministic `0x20c0…` addresses. Other contracts
 // can emit the same `Transfer` signature but do not expose TIP-20 metadata.
 const tip20AddressPrefix = '0x20c0';
@@ -36,29 +37,26 @@ export var schema;
         .union([z.literal('self'), Schema.Address])
         .check(z.describe('Who signed the activity: `self`, or the access-key address used to sign it.'));
     /** A token with required RPC metadata and optional curated fields. */
-    schema.Token = Schema.describe(Tokens.schema.TokenReference, 'A token referenced by an activity item.');
-    /** A token amount carrying its nominal value in the requested denomination. */
-    const ValuedAmount = z.extend(Schema.TokenAmount, {
+    schema.Token = OpenApi.component(Schema.describe(Tokens.schema.TokenReference, 'A token referenced by an activity item.'), 'ActivityToken');
+    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`.'));
-    /** Self-contained amount for a refunded token. */
-    const RefundAmount = ValuedAmount.check(z.describe('Amount associated with `refund`.'));
-    /** Self-contained amount for a source token. */
-    const SourceAmount = ValuedAmount.check(z.describe('Amount associated with `sourceToken`.'));
+    }), 'A token amount carrying its nominal value in the requested denomination.');
+    const valuedAmount = OpenApi.component(ValuedAmount, 'ActivityValuedAmount');
+    const DestinationAmount = valuedAmount;
+    const RefundAmount = valuedAmount;
+    const SourceAmount = valuedAmount;
     /** Page-level resources: valuation rate provenance. */
-    schema.Meta = z
+    schema.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. */
     schema.Transfer = z
         .object({
@@ -96,6 +94,7 @@ export var schema;
         error: '`destinationAmount` and `destinationToken` must be returned together.',
         path: ['destinationAmount'],
     }), z.describe('One token transfer involving the requested address.'));
+    const activityTransfer = OpenApi.component(schema.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
@@ -123,6 +122,7 @@ export var schema;
             .check(z.describe('Raw log topics; the first topic is the event signature hash.')),
     })
         .check(z.describe('One transaction log. Decoded fields (`eventName`/`args`/`title`) are present when it matched a known Tempo ABI; otherwise only the raw fields are set.'));
+    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
@@ -130,11 +130,14 @@ export var 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(z.describe('Your role in the transaction: `outgoing` when you sent or paid for it, `incoming` when it happened to you (someone else initiated it). For a `transfer`, `data.direction` is the finer-grained token-flow view.')),
         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.')),
         id: z.string().check(z.describe('Stable activity ID built from the transaction hash and log index (`${transactionHash}-${logIndex}`).'), z.meta({
             examples: ['0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-3'],
@@ -150,8 +153,7 @@ export var schema;
             .check(z.describe('Human-readable label for the activity `type`, suitable for display in a feed. Past-tense, sentence case (e.g. `Token transferred`, `Tokens swapped`, `Burn blocked`).'), z.meta({ examples: ['Token transferred'] })),
         transactionHash: Schema.Hash.check(z.describe('Transaction hash for this activity.')),
     };
-    /** The classified activity item variants (discriminated by `type`). */
-    schema.items = [
+    const itemSchemas = [
         z
             .object({
             ...base,
@@ -295,7 +297,7 @@ export var schema;
         z
             .object({
             ...base,
-            data: schema.Transfer.check(z.describe('Transfer details with feed-relative direction and signer fields.')),
+            data: activityTransfer.check(z.describe('Transfer details with feed-relative direction and signer fields.')),
             type: z
                 .literal('transfer')
                 .check(z.describe('Activity type that tells you which `data` shape this entry uses.')),
@@ -820,9 +822,7 @@ export var schema;
             data: z
                 .object({
                 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,
                 updater: Schema.Address.check(z.describe('Address that changed the logo.')),
@@ -1254,13 +1254,24 @@ export var schema;
         })
             .check(z.meta({ title: 'Unknown' })),
     ];
+    /** The classified activity item variants (discriminated by `type`). */
+    schema.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) => character.toUpperCase())
+            .replace(/^(.)/, (character) => character.toUpperCase())}`;
+        return OpenApi.component(item, name);
+    });
     /** A single classified activity item. */
-    schema.Item = z
-        .union(schema.items)
-        .check(z.describe('One classified activity item in the address feed.'));
+    schema.Item = OpenApi.component(z.union(schema.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. */
     schema.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(schema.Item).check(z.describe('Activity items included in this group.')),
@@ -1284,16 +1295,17 @@ export var schema;
         type: z.literal('group'),
     })
         .check(z.meta({ title: 'Group' }), z.describe('A group of consecutive activity items signed by the same access key.'));
+    const activityGroup = OpenApi.component(schema.Group, 'ActivityGroup');
     /** A single activity item, or a folded access-key group. */
-    schema.Entry = z
-        .union([...schema.items, schema.Group])
-        .check(z.describe('Either one activity item, or a grouped set of access-key activity items.'));
-    /** Optional token fields that require sources beyond RPC metadata. */
+    schema.Entry = OpenApi.component(z
+        .union([schema.Item, activityGroup])
+        .check(z.describe('Either one activity item, or a grouped set of access-key activity items.')), 'ActivityEntry');
+    /** Optional activity resources and selection modes. */
     schema.Include = z
-        .enum(tokenFields)
-        .check(z.describe('Additional token fields to include in activity responses.'));
-    /** Parses comma-separated optional token fields. */
-    schema.includeQuery = Schema.includeQuery(schema.Include, 'Comma-separated token fields to include, such as `token.logoUri,token.verified`.');
+        .enum(includeFields)
+        .check(z.describe('Additional activity resources and selection modes to include.'));
+    /** Parses comma-separated optional activity resources and selection modes. */
+    schema.includeQuery = Schema.includeQuery(schema.Include, 'Comma-separated activity options. `zones` combines the selected parent chain with every readable Zone.');
     /** Schemas for the getAddressActivities operation. */
     let getAddressActivities;
     (function (getAddressActivities) {
@@ -1328,7 +1340,7 @@ export var schema;
          * `group=true`) plus the root `nextCursor` pagination field shared with
          * other list endpoints.
          */
-        getAddressActivities.Response = z
+        getAddressActivities.Response = OpenApi.component(z
             .object({
             data: z.array(schema.Entry).check(z.describe('Activity feed entries for the address.')),
             meta: z
@@ -1336,7 +1348,7 @@ export var schema;
                 .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.'));
+            .check(z.describe('A page of human-readable activity for the address.')), 'AddressActivityList');
     })(getAddressActivities = schema.getAddressActivities || (schema.getAddressActivities = {}));
     /** Schemas for the getTransactionActivities operation. */
     let getTransactionActivities;
@@ -1361,19 +1373,20 @@ export var 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`.
          */
-        getTransactionActivities.Response = z
+        getTransactionActivities.Response = OpenApi.component(z
             .object({
+            chainId: Schema.ChainId.check(z.describe('Chain ID containing the transaction.'), z.meta({ examples: [4217] })),
             data: z.array(schema.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.'));
+            .check(z.describe('The human-readable activity that happened on a transaction.')), 'TransactionActivityList');
     })(getTransactionActivities = schema.getTransactionActivities || (schema.getTransactionActivities = {}));
 })(schema || (schema = {}));
 /**
@@ -1462,6 +1475,7 @@ const titleByEventName = {
     BlacklistUpdated: 'Blacklist updated',
     Burn: 'Token burned',
     BurnBlocked: 'Burn blocked',
+    Deposit: 'Assets deposited',
     Deposited: 'Assets deposited',
     EarnDeposit: 'Private assets deposited',
     EarnRedeem: 'Private shares redeemed',
@@ -1470,6 +1484,7 @@ const titleByEventName = {
     RedeemRequested: 'Share redemption requested',
     Redeemed: 'Shares redeemed',
     VenueSharesDeposited: 'Shares deposited',
+    Withdraw: 'Assets withdrawn',
     WithdrewExact: 'Assets withdrawn',
     ChannelClosed: 'Channel closed',
     ChannelOpened: 'Channel opened',
@@ -1533,12 +1548,43 @@ const closeRequestedSelector = '0xf5a36fc00a96cbb9cf1f8f59299165e1d8ffffe94396d8
 const accessKeySpendSelector = '0xe0815e3aaadddf4dd75bde97fc060f0c38afe18e87a169be86a3f5c28247f192';
 /** 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',
+    },
+];
 // 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
 // their paired TIP-20 `Transfer` legs use it as the funding counterparty, which
 // is how `channel-funded`/`channel-settled`/`channel-closed` recover the token.
 const tip20ChannelReserve = '0x4d50500000000000000000000000000000000000';
+// 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;
 /** Largest number of items folded into a single access-key group. */
@@ -1590,7 +1636,12 @@ export function addresses(options = {}) {
         description: '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,
@@ -1599,7 +1650,7 @@ export function addresses(options = {}) {
         summary: 'List address activities',
         tags: ['Activities'],
     }), Cache.response({
-        cacheControl: Cache.policies.feed,
+        cacheControl: Cache.policies.noStore,
         name: 'tempo-api:addresses:v1',
         key: (c) => Cache.urlKey(c, schema.getAddressActivities.Query),
     }), async (c) => {
@@ -1617,39 +1668,73 @@ export function 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, {
-                address: address,
-                cursor: query.cursor,
-                group: query.group,
-                limit: query.limit,
-                logs: query.logs,
-                store: c.get('store'),
-            }), {
-                key: `activities:v1:${chainId}:${address.toLowerCase()}:${query.group ?? false}:${query.logs ?? false}:${query.cursor ?? 'head'}:${query.limit}`,
-                store: c.get('store'),
-                ttl: Ttl.seconds(15),
-            }));
-            // 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 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,
+                        cursor: query.cursor,
+                        group: query.group,
+                        limit: query.limit,
+                        logs: query.logs,
+                        store: c.get('store'),
+                    }), {
+                        key: `activities:v1:${chainId}:${address.toLowerCase()}:${query.group ?? false}:${query.logs ?? false}:${query.cursor ?? 'head'}:${query.limit}`,
+                        store: c.get('store'),
+                        ttl: Ttl.seconds(15),
+                    });
+                    return { chainId, kind: 'chain', ...result };
+                }
+                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,
+                    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', ...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;
             return c.json(Response.validated(schema.getAddressActivities.Response, {
                 data,
                 ...(rates ? { meta: { valuation: Valuation.pricing(rates, oracle) } } : {}),
-                nextCursor,
+                nextCursor: listed.nextCursor,
             }), 200);
         }
         catch (cause) {
@@ -1666,7 +1751,7 @@ export function addresses(options = {}) {
  * 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 = {}) {
@@ -1682,10 +1767,22 @@ export function 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: {
@@ -1716,36 +1813,110 @@ export function 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,
-                store: c.get('store'),
-                tidx: c.get('getTidx')(chainId),
-                transactionHash,
-            }), {
-                key: `activities:v1:${chainId}:tx:${transactionHash.toLowerCase()}:${query.logs ?? false}`,
-                store: c.get('store'),
-                ttl: Ttl.seconds(15),
-            }));
-            if (unenrichedItems === null)
+            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',
+                            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 = 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(probes);
+                    }, {
+                        key: `activities:zones:v2:${chainIds.join(',')}:tx:${transactionHash.toLowerCase()}`,
+                        shouldCache: (match) => match.kind === 'selected',
+                        store: c.get('store'),
+                        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', 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' }
+                    : { chainId, items: unenrichedItems, kind: 'found' };
+            });
+            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) } } : {}),
             }), 200);
@@ -1768,7 +1939,19 @@ export function transactions(options = {}) {
  * Items carry stub tokens; the caller enriches them via {@link enrichTokens}.
  */
 export async function getTransactionActivities(options) {
-    const { chainId, logs = false, tidx: tidxClient } = options;
+    return getTransactionActivities_inner({
+        ...options,
+        time: async (_name, fn) => fn(),
+    });
+}
+async function getTransactionActivities_inner(options) {
+    const receipt = await options.time('transaction_activity_receipt', () => getTransactionReceipt(options));
+    if (!receipt)
+        return null;
+    return classifyTransactionActivities({ ...options, receipt });
+}
+async function getTransactionReceipt(options) {
+    const { chainId, tidx: tidxClient } = options;
     const hash = options.transactionHash.toLowerCase();
     // The `receipts` table is indexed by `tx_hash`, so this point lookup needs no
     // block bound; it also yields the block number the `logs` lookup requires.
@@ -1781,15 +1964,25 @@ export async function getTransactionActivities(options) {
     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']),
+    };
+}
+async function classifyTransactionActivities(options) {
+    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({
+    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`,
-    });
+    }));
     const rows = logsResult.rows.map((r) => ({
         blockNum: Number(Value.toNumber(r['block_num'])),
         blockTimestamp: Number(Value.toNumber(r['block_timestamp'])),
@@ -1812,7 +2005,7 @@ export async function getTransactionActivities(options) {
         return [];
     // 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`
     // resolves to `self`. Fall back to the zero address when the sender is absent.
@@ -1823,15 +2016,15 @@ export async function getTransactionActivities(options) {
 /**
  * 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, options) {
     const { address, cursor, group = false, limit = 20, logs = false } = options;
     const viewer = address.toLowerCase();
     // 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 = cursor;
     const allItems = [];
     let hasMore = false;
@@ -1846,6 +2039,7 @@ export async function list(provider, options) {
         const txGroups = grouped.slice(0, limit + 1);
         hasMore = txGroups.length > limit;
         const page = txGroups.slice(0, limit);
+        const fingerprintMap = await fingerprintMap_promise;
         if (page.length === 0)
             break;
         allItems.push(...page.flatMap((txGroup) => classifyGroup(txGroup, viewer, fingerprintMap, logs).map(withTitle)));
@@ -1865,6 +2059,117 @@ export async function list(provider, options) {
     // public token references and structured amounts via {@link enrichTokens}.
     return { items: allItems, nextCursor };
 }
+const chainCursorVersion = 2;
+/**
+ * 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) {
+    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();
+    const fingerprintMap_promise = Mpp.fingerprintMap({ store }).catch(() => ({}));
+    const states = orderedProviders.map(({ chainId, provider }) => ({
+        chainId,
+        exhausted: false,
+        groups: [],
+        provider,
+    }));
+    const allItems = [];
+    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,
+    };
+}
+function decodeChainCursor(cursor, chainIds) {
+    const fields = ['int'];
+    for (const _chainId of chainIds)
+        fields.push('int', 'id');
+    const decoded = cursor ? Cursor.decode(cursor, fields) : undefined;
+    const cursors = new Map();
+    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];
+        if (value !== 'head')
+            cursors.set(chainId, value);
+    }
+    return cursors;
+}
+function encodeChainCursor(cursors, chainIds) {
+    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:
@@ -1875,7 +2180,16 @@ export async function list(provider, options) {
  *   (catches access-key-signed sends where `tx.from` differs from the address).
  */
 export function tidx(deps) {
-    const { chainId, tidx: tidxClient } = deps;
+    const { chainId, signal, tidx: tidxClient } = deps;
+    const 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) {
         // Opaque `[blockNum, txIdx]` keyset cursor, the same encoding every other
         // list endpoint uses; a malformed/forged cursor decodes to `undefined` and
@@ -1895,7 +2209,7 @@ export function tidx(deps) {
             ? `AND block_num <= ${cursor.blockNum} AND (block_num < ${cursor.blockNum} OR tx_idx < ${cursor.txIdx})`
             : '';
         const queryLimit = limit + 1;
-        const fetchReceipts = (side) => tidxClient.fetch({
+        const fetchReceipts = (side) => fetch({
             chainId,
             // Raw-table query (no signature-decoded CTE), so the inline SQL is cast
             // to `string`.
@@ -1939,7 +2253,7 @@ export function tidx(deps) {
         const txHashes = receipts.map((receipt) => `'${receipt.txHash}'`).join(', ');
         // `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`.
@@ -1992,7 +2306,7 @@ export function tidx(deps) {
       `;
         const result = await (async () => {
             try {
-                return await tidxClient.fetch({
+                return await fetch({
                     chainId,
                     query: query('block_num'),
                     signatures: [transferSignature],
@@ -2003,7 +2317,7 @@ export function tidx(deps) {
                     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],
@@ -2012,7 +2326,7 @@ export function tidx(deps) {
                 catch (fallbackError) {
                     if (!Tidx.isDeterministicError(fallbackError))
                         throw fallbackError;
-                    const result = await tidxClient.fetch({
+                    const result = await fetch({
                         chainId,
                         query: query(),
                         signatures: [transferSignature],
@@ -2070,8 +2384,10 @@ export function mergeAndSort(q1, q2, q3) {
     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;
@@ -2136,34 +2452,38 @@ function classifyGroup(group, viewer, fingerprintMap, includeLogs = false) {
             signer,
             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))
-            return [{ ...base, data: { recipient: viewer, sourceToken }, type: 'mint' }];
-        if (Address.isEqual(to, zeroAddress))
-            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, {
+    // 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))
+                return { ...base, data: { recipient: viewer, sourceToken }, type: 'mint' };
+            if (Address.isEqual(to, zeroAddress))
+                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 [
         unknown(itemBase(Math.min(...group.rows.map((r) => r.logIdx))), {
@@ -2191,7 +2511,7 @@ function classifyFromLogs(rows, ctx) {
     })();
     // 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);
@@ -2208,1214 +2528,1453 @@ function signerForRows(rows, options) {
         ? accessKeySigner
         : 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, ctx, events = decodeRows(rows)) {
     const { blockNum, fingerprintMap, itemBase, viewer } = ctx;
     const signer = signerForRows(rows, { fallback: ctx.signer, viewer });
     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.to, viewer));
-        const refund = refundTransfer
-            ? token(refundTransfer.args.amount, refundTransfer.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();
+    // 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();
+    const addFold = (key) => 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;
-            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.amount}`, 'Mint');
-        if (event.eventName === 'Burn' && 'amount' in event.args)
-            preferenceMap.set(`burn:${event.address}:${event.args.amount}`, 'Burn');
+        if (event.eventName === 'Mint' && 'amount' in event.args && 'to' in event.args)
+            addFold(`mint:${event.address}:${event.args.amount}`);
+        if (event.eventName === 'Burn' && 'amount' in event.args && 'from' in event.args)
+            addFold(`burn:${event.address}:${event.args.amount}`);
     }
-    const dedupedEvents = events.filter((event) => {
-        if (event.eventName !== 'Transfer')
+    const takeFold = (key) => {
+        const count = foldCounts.get(key) ?? 0;
+        if (count === 0)
+            return false;
+        foldCounts.set(key, count - 1);
+        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;
-        if (preferenceMap.has(`${args.from}:${args.to}:${args.amount}`))
+        if (event.eventName === 'Transfer' &&
+            takeFold(`${event.address}:${args.from}:${args.to}:${args.amount}`))
             return false;
         if (Address.isEqual(args.from, zeroAddress) &&
-            preferenceMap.has(`mint:${event.address}:${args.amount}`))
+            takeFold(`mint:${event.address}:${args.amount}`))
             return false;
         if (Address.isEqual(args.to, zeroAddress) &&
-            preferenceMap.has(`burn:${event.address}:${args.amount}`))
+            takeFold(`burn:${event.address}:${args.amount}`))
             return false;
         return true;
     });
-    const finalEvents = dedupedEvents.filter((event) => {
-        if (event.eventName !== 'TransferWithMemo')
+    const pool = [...finalEvents].sort((a, b) => a.logIndex - b.logIndex);
+    const claimed = new Set();
+    const items = [];
+    // 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;
+    const claim = (event) => {
+        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) => pool.filter((event) => {
+        if (claimed.has(event.logIndex))
+            return false;
+        if (!predicate)
             return true;
-        const args = event.args;
-        if (Address.isEqual(args.from, zeroAddress) &&
-            preferenceMap.has(`mint:${event.address}:${args.amount}`))
+        try {
+            return predicate(event);
+        }
+        catch {
             return false;
-        if (Address.isEqual(args.to, zeroAddress) &&
-            preferenceMap.has(`burn:${event.address}:${args.amount}`))
+        }
+    });
+    const lc = (value) => value.toLowerCase();
+    const hx = (value) => value.toLowerCase();
+    // 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;
-        return true;
+        const args = event.args;
+        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) => transferIndexes.has(event.logIndex);
+    const transferArgs = (event) => event.args;
+    // 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) => {
+        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) => 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, build) => {
+        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]));
+            }
+            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) => (event) => 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, amounts) => {
+        const legs = [];
+        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) ||
+                        Address.isEqual(args.to, zeroAddress)));
+            })();
+            if (!isVaultMintBurn && !isVaultLeg)
+                continue;
+            const amount = event.args.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.spender, vault))
+                continue;
+            const amount = event.args.amount;
+            if (amount === undefined || !amounts.includes(amount))
+                continue;
+            claim(event);
+            legs.push(event);
+        }
+        return legs;
+    };
+    // 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;
+        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',
+            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.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, [args.inputAmount]);
+        return { ...itemBase(event.logIndex), data, type: 'private-assets-deposited' };
     });
-    const transfers = finalEvents.filter((e) => (e.eventName === 'Transfer' || e.eventName === 'TransferWithMemo') &&
-        'to' in e.args &&
-        'from' in e.args &&
-        'amount' in e.args);
-    const privateDeposit = finalEvents.find((event) => event.eventName === 'EarnDeposit');
-    if (privateDeposit) {
-        const args = privateDeposit.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(privateDeposit)),
-                data: {
-                    actionId: args.actionId,
-                    assets: args.vaultAssets.toString(),
-                    inputAmount: args.inputAmount.toString(),
-                    inputToken: args.inputToken.toLowerCase(),
-                    shares: args.earnShares.toString(),
-                    signer,
-                    status: 'completed',
-                    vault: args.earnVault.toLowerCase(),
-                    zoneDepositHash: args.zoneDepositHash,
-                },
-                type: 'private-assets-deposited',
-            },
-        ];
-    }
-    const privateRedeem = finalEvents.find((event) => event.eventName === 'EarnRedeem');
-    if (privateRedeem) {
-        const args = privateRedeem.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(privateRedeem)),
-                data: {
-                    actionId: args.actionId,
-                    assets: args.vaultAssets.toString(),
-                    outputAmount: args.outputAmount.toString(),
-                    outputToken: args.outputToken.toLowerCase(),
-                    shares: args.earnShares.toString(),
-                    signer,
-                    status: 'completed',
-                    vault: args.earnVault.toLowerCase(),
-                    zoneDepositHash: args.zoneDepositHash,
-                },
-                type: 'private-shares-redeemed',
+    recognize(named('EarnRedeem'), (event) => {
+        const args = event.args;
+        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',
+            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.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, [args.outputAmount]);
+        return { ...itemBase(event.logIndex), data, type: 'private-shares-redeemed' };
+    });
+    // Earn vault operations, each claiming its own token legs.
+    recognize(named('Deposited'), (event) => {
+        const args = event.args;
+        claimVaultLegs(event.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),
             },
-        ];
-    }
-    const deposited = finalEvents.find((event) => event.eventName === 'Deposited');
-    if (deposited) {
-        const args = deposited.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(deposited)),
-                data: {
-                    assets: args.assets.toString(),
-                    caller: args.caller.toLowerCase(),
-                    receiver: args.receiver.toLowerCase(),
-                    shares: args.earnShares.toString(),
-                    signer,
-                    status: 'completed',
-                    vault: deposited.address.toLowerCase(),
-                },
-                type: 'assets-deposited',
+            type: 'assets-deposited',
+        };
+    });
+    recognize(named('VenueSharesDeposited'), (event) => {
+        const args = event.args;
+        claimVaultLegs(event.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),
             },
-        ];
-    }
-    const venueDeposit = finalEvents.find((event) => event.eventName === 'VenueSharesDeposited');
-    if (venueDeposit) {
-        const args = venueDeposit.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(venueDeposit)),
-                data: {
-                    caller: args.caller.toLowerCase(),
-                    receivedEngineShares: args.receivedEngineShares.toString(),
-                    receiver: args.receiver.toLowerCase(),
-                    requestedVenueShares: args.requestedVenueShares.toString(),
-                    shares: args.earnShares.toString(),
-                    signer,
-                    status: 'completed',
-                    vault: venueDeposit.address.toLowerCase(),
-                },
-                type: 'shares-deposited',
+            type: 'shares-deposited',
+        };
+    });
+    recognize(named('Redeemed'), (event) => {
+        const args = event.args;
+        claimVaultLegs(event.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),
             },
-        ];
-    }
-    const redeemed = finalEvents.find((event) => event.eventName === 'Redeemed');
-    if (redeemed) {
-        const args = redeemed.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(redeemed)),
-                data: {
-                    assets: args.assets.toString(),
-                    caller: args.caller.toLowerCase(),
-                    receiver: args.receiver.toLowerCase(),
-                    shares: args.earnShares.toString(),
-                    signer,
-                    status: 'completed',
-                    vault: redeemed.address.toLowerCase(),
-                },
-                type: 'shares-redeemed',
+            type: 'shares-redeemed',
+        };
+    });
+    recognize(named('WithdrewExact'), (event) => {
+        const args = event.args;
+        claimVaultLegs(event.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),
             },
-        ];
-    }
-    const withdrew = finalEvents.find((event) => event.eventName === 'WithdrewExact');
-    if (withdrew) {
-        const args = withdrew.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(withdrew)),
-                data: {
-                    assets: args.assets.toString(),
-                    caller: args.caller.toLowerCase(),
-                    sharesBurned: args.earnSharesBurned.toString(),
-                    receiver: args.receiver.toLowerCase(),
-                    signer,
-                    status: 'completed',
-                    vault: withdrew.address.toLowerCase(),
-                },
-                type: 'assets-withdrawn',
+            type: 'assets-withdrawn',
+        };
+    });
+    recognize(named('RedeemRequested'), (event) => {
+        const args = event.args;
+        claimVaultLegs(event.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),
             },
-        ];
-    }
-    const requested = finalEvents.find((event) => event.eventName === 'RedeemRequested');
-    if (requested) {
-        const args = requested.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(requested)),
-                data: {
-                    receiver: args.receiver.toLowerCase(),
-                    requestId: args.requestId,
-                    requester: args.requester.toLowerCase(),
-                    shares: args.earnShares.toString(),
-                    signer,
-                    status: 'pending',
-                    vault: requested.address.toLowerCase(),
-                },
-                type: 'shares-redemption-requested',
+            type: 'shares-redemption-requested',
+        };
+    });
+    recognize(named('RedeemFinalized'), (event) => {
+        const args = event.args;
+        claimVaultLegs(event.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),
             },
-        ];
-    }
-    const finalized = finalEvents.find((event) => event.eventName === 'RedeemFinalized');
-    if (finalized) {
-        const args = finalized.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(finalized)),
-                data: {
-                    asset: args.asset.toLowerCase(),
-                    assets: args.assets.toString(),
-                    receiver: args.receiver.toLowerCase(),
-                    requestId: args.requestId,
-                    shares: args.earnShares.toString(),
-                    signer,
-                    status: 'completed',
-                    vault: finalized.address.toLowerCase(),
-                },
-                type: 'shares-redemption-finalized',
+            type: 'shares-redemption-finalized',
+        };
+    });
+    recognize(named('RedeemCancelled'), (event) => {
+        const args = event.args;
+        claimVaultLegs(event.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),
             },
-        ];
-    }
-    const cancelled = finalEvents.find((event) => event.eventName === 'RedeemCancelled');
-    if (cancelled) {
-        const args = cancelled.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(cancelled)),
-                data: {
-                    receiver: args.receiver.toLowerCase(),
-                    requestId: args.requestId,
-                    shares: args.earnShares.toString(),
-                    signer,
-                    status: 'cancelled',
-                    vault: cancelled.address.toLowerCase(),
-                },
-                type: 'shares-redemption-cancelled',
+            type: 'shares-redemption-cancelled',
+        };
+    });
+    // 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 = [];
+    const viewerInvolved = (parties, legs) => 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;
+        const vault = event.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',
+            vault: lc(vault),
+        };
+        const legs = claimVaultLegs(vault, [args.assets, args.shares]);
+        const item = { ...itemBase(event.logIndex), data, type: 'assets-withdrawn' };
+        if (viewerInvolved([args.sender, args.receiver, args.owner], legs))
+            return item;
+        suppressedVaultItems.push(item);
+        return undefined;
+    });
+    recognize(named('Deposit'), (event) => {
+        const args = event.args;
+        const vault = event.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',
+            vault: lc(vault),
+        };
+        const legs = claimVaultLegs(vault, [args.assets, args.shares]);
+        const item = { ...itemBase(event.logIndex), data, type: 'assets-deposited' };
+        if (viewerInvolved([args.sender, args.owner], legs))
+            return item;
+        suppressedVaultItems.push(item);
+        return undefined;
+    });
+    // DEX order placed: `OrderPlaced` carries the escrow token/amount and side;
+    // claim the escrow transfer that funded it.
+    const orderPlacedItem = (event) => {
+        const args = event.args;
+        const escrow = (leg) => isTransfer(leg) &&
+            Address.isEqual(leg.address, args.token) &&
+            Address.isEqual(transferArgs(leg).to, event.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),
             },
-        ];
-    }
-    // Swap: a transfer into the DEX paired with one out of the DEX.
-    const toDex = transfers.find((e) => Address.isEqual(e.args.to, Addresses.stablecoinDex));
-    const fromDex = transfers.find((e) => Address.isEqual(e.args.from, Addresses.stablecoinDex));
-    if (toDex && fromDex) {
-        const swapper = fromDex.args.to;
-        const destTokenAddress = fromDex.address;
-        const sourceToken = token(toDex.args.amount, toDex.address);
-        // 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.from, swapper) &&
-            !Address.isEqual(e.args.to, Addresses.stablecoinDex) &&
-            !Address.isEqual(e.args.to, swapper));
-        if (delivery) {
-            const args = delivery.args;
-            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),
-                    direction: Address.isEqual(args.to, viewer) ? 'in' : 'out',
-                    memo,
-                    recipient: args.to.toLowerCase(),
-                    sender: swapper.toLowerCase(),
-                    signer,
-                    sourceToken,
-                }),
-            ];
+            type: 'order-placed',
+        };
+    };
+    const isFlipOrder = (event) => 'isFlipOrder' in event.args && event.args.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();
+        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))
+                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;
+                const sourceToken = token(sourceArgs.amount, source.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) ||
+                                Address.isEqual(args.to, zeroAddress))
+                                claim(event);
+                        }
+                        else if (event.eventName === 'Approval' &&
+                            'owner' in event.args &&
+                            !Address.isEqual(event.args.owner, viewer))
+                            claim(event);
+                    }
+                // 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.owner, sourceArgs.from) &&
+                    event.args.amount === sourceArgs.amount &&
+                    event.logIndex < source.logIndex &&
+                    (Address.isEqual(event.args.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.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.taker) &&
+                        !('maker' in event.args &&
+                            Address.isEqual(event.args.maker, viewer))) ||
+                        (event.eventName === 'OrderPlaced' &&
+                            isFlipOrder(event) &&
+                            'maker' in event.args &&
+                            isBookkeepingActor(event.args.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) => {
+                    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),
+                            direction: Address.isEqual(args.to, viewer) ? 'in' : 'out',
+                            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;
+            }
         }
-        return [
-            {
-                ...itemBase(Math.min(logIndexOfEvent(toDex), logIndexOfEvent(fromDex))),
-                data: {
-                    destinationToken: token(fromDex.args.amount, destTokenAddress),
-                    signer,
-                    sourceToken,
-                },
-                type: 'swap',
-            },
-        ];
-    }
-    // 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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(mintEvent)),
-                data: {
-                    recipient: args.to.toLowerCase(),
-                    sourceToken: token(args.amount, mintEvent.address),
-                },
-                type: 'mint',
-            },
-        ];
-    }
-    const zeroTransferIn = transfers.find((e) => Address.isEqual(e.args.from, zeroAddress));
-    if (zeroTransferIn) {
-        const args = zeroTransferIn.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(zeroTransferIn)),
-                data: {
-                    recipient: args.to.toLowerCase(),
-                    sourceToken: token(args.amount, zeroTransferIn.address),
-                },
-                type: 'mint',
-            },
-        ];
     }
+    // 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, args) => ({
+        ...itemBase(event.logIndex),
+        data: {
+            recipient: lc(args.to),
+            sourceToken: token(args.amount, event.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));
+    recognize((event) => isTransfer(event) &&
+        Address.isEqual(transferArgs(event).from, zeroAddress), (event) => mintItem(event, transferArgs(event)));
     // 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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(burnBlockedEvent)),
-                data: {
-                    sender: args.from.toLowerCase(),
-                    signer,
-                    sourceToken: token(args.amount, burnBlockedEvent.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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(burnEvent)),
-                data: {
-                    sender: args.from.toLowerCase(),
-                    signer,
-                    sourceToken: token(args.amount, burnEvent.address),
-                },
-                type: 'burn',
-            },
-        ];
-    }
-    const zeroTransferOut = transfers.find((e) => Address.isEqual(e.args.to, zeroAddress));
-    if (zeroTransferOut) {
-        const args = zeroTransferOut.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(zeroTransferOut)),
-                data: {
-                    sender: args.from.toLowerCase(),
-                    signer,
-                    sourceToken: token(args.amount, zeroTransferOut.address),
-                },
-                type: 'burn',
+    // 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;
+        takeTransfer((leg) => Address.isEqual(leg.address, event.address) &&
+            Address.isEqual(transferArgs(leg).to, zeroAddress) &&
+            transferArgs(leg).amount === args.amount);
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                sender: lc(args.from),
+                signer,
+                sourceToken: token(args.amount, event.address),
             },
-        ];
-    }
-    // Approval (excluding zone-outbox spenders).
-    const approvalEvent = finalEvents.find((e) => e.eventName === 'Approval' &&
+            type: 'burn-blocked',
+        };
+    });
+    // Burn: explicit `Burn` events and remaining transfers to the zero address.
+    const burnItem = (event, args) => ({
+        ...itemBase(event.logIndex),
+        data: {
+            sender: lc(args.from),
+            signer,
+            sourceToken: token(args.amount, event.address),
+        },
+        type: 'burn',
+    });
+    recognize((event) => event.eventName === 'Burn' && 'amount' in event.args && 'from' in event.args, (event) => burnItem(event, event.args));
+    recognize((event) => isTransfer(event) && Address.isEqual(transferArgs(event).to, zeroAddress), (event) => burnItem(event, transferArgs(event)));
+    // Approval (excluding zone-outbox spenders): only viewer-party approvals
+    // surface here; the rest stay for the nothing-else-classified fallback.
+    const isErc20Approval = (event) => {
+        if (event.eventName !== 'Approval')
+            return false;
+        const args = event.args;
+        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.
-        rows.some((row) => row.logIdx === e.logIndex &&
+        return (rows.some((row) => row.logIdx === event.logIndex &&
             row.topic3 === null &&
-            /^0x[0-9a-fA-F]{64}$/.test(row.data ?? '')) &&
-        !Address.isEqual(e.args.spender, Addresses.zoneOutbox));
-    if (approvalEvent) {
-        const args = approvalEvent.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(approvalEvent)),
-                data: {
-                    signer,
-                    sourceToken: token(args.amount, approvalEvent.address),
-                    spender: args.spender.toLowerCase(),
-                },
-                type: 'approval',
+            /^0x[0-9a-fA-F]{64}$/.test(row.data ?? '')) && !Address.isEqual(args.spender, Addresses.zoneOutbox));
+    };
+    const approvalItem = (event) => {
+        const args = event.args;
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                signer,
+                sourceToken: token(args.amount, event.address),
+                spender: lc(args.spender),
             },
-        ];
-    }
-    // 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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(channelOpened)),
-                data: {
-                    channelId: args.channelId.toLowerCase(),
-                    payee: args.payee.toLowerCase(),
-                    payer: args.payer.toLowerCase(),
-                    signer,
-                    sourceToken: token(args.deposit, args.token),
-                },
-                type: 'channel-opened',
+            type: 'approval',
+        };
+    };
+    recognize((event) => isErc20Approval(event) &&
+        'owner' in event.args &&
+        (Address.isEqual(event.args.owner, viewer) ||
+            Address.isEqual(event.args.spender, viewer)), approvalItem);
+    // 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;
+        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),
             },
-        ];
-    }
-    // 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.to, tip20ChannelReserve));
-    const reserveOutflowTo = (recipient) => transfers.find((e) => Address.isEqual(e.args.from, tip20ChannelReserve) &&
-        Address.isEqual(e.args.to, recipient));
-    // 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;
-        const tokenAddress = reserveInflow
-            ? reserveInflow.address
+            type: 'channel-opened',
+        };
+    });
+    recognize(named('TopUp'), (event) => {
+        const args = event.args;
+        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) => e.eventName === 'CloseRequestCancelled' &&
+            'channelId' in e.args &&
+            e.args.channelId === args.channelId)
+            .slice(0, 1)
+            .forEach(claim);
+        const tokenAddress = inflow
+            ? inflow.address
             : zeroAddress;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(topUp)),
-                data: {
-                    channelId: args.channelId.toLowerCase(),
-                    signer,
-                    sourceToken: token(args.additionalDeposit, tokenAddress),
-                },
-                type: 'channel-funded',
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                channelId: hx(args.channelId),
+                signer,
+                sourceToken: token(args.additionalDeposit, tokenAddress),
             },
-        ];
-    }
-    // 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;
-        const payeeLeg = reserveOutflowTo(args.payee.toLowerCase());
+            type: 'channel-funded',
+        };
+    });
+    recognize(named('Settled'), (event) => {
+        const args = event.args;
+        const payout = (leg) => 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
             : zeroAddress;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(settled)),
-                data: {
-                    channelId: args.channelId.toLowerCase(),
-                    payee: args.payee.toLowerCase(),
-                    payer: args.payer.toLowerCase(),
-                    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;
-        const payeeLeg = reserveOutflowTo(args.payee.toLowerCase());
-        const payerLeg = reserveOutflowTo(args.payer.toLowerCase());
-        return [
-            {
-                ...itemBase(logIndexOfEvent(channelClosed)),
-                data: {
-                    channelId: args.channelId.toLowerCase(),
-                    payee: args.payee.toLowerCase(),
-                    payer: args.payer.toLowerCase(),
-                    ...(payerLeg && args.refundedToPayer > 0n
-                        ? { refund: token(args.refundedToPayer, payerLeg.address) }
-                        : {}),
-                    signer,
-                    ...(payeeLeg
-                        ? { sourceToken: token(args.settledToPayee, payeeLeg.address) }
-                        : {}),
-                },
-                type: 'channel-closed',
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                channelId: hx(args.channelId),
+                payee: lc(args.payee),
+                payer: lc(args.payer),
+                signer,
+                sourceToken: token(args.deltaPaid, tokenAddress),
             },
-        ];
-    }
-    // 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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(closeCancelled)),
-                data: {
-                    channelId: args.channelId.toLowerCase(),
-                    payee: args.payee.toLowerCase(),
-                    payer: args.payer.toLowerCase(),
-                    signer,
-                },
-                type: 'channel-close-cancelled',
+            type: 'channel-settled',
+        };
+    });
+    recognize(named('ChannelClosed'), (event) => {
+        const args = event.args;
+        // A zero settlement or refund has no leg; claiming one would steal it
+        // from a batched sibling operation.
+        const reserveLegTo = (to, amount) => {
+            if (amount === 0n)
+                return undefined;
+            const payout = (leg) => 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) }
+                    : {}),
+                signer,
+                ...(payeeLeg
+                    ? { sourceToken: token(args.settledToPayee, payeeLeg.address) }
+                    : {}),
             },
-        ];
-    }
-    // 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;
-        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',
+            type: 'channel-closed',
+        };
+    });
+    // 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;
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                channelId: hx(args.channelId),
+                payee: lc(args.payee),
+                payer: lc(args.payer),
+                signer,
             },
-        ];
+            type: 'channel-close-cancelled',
+        };
+    });
+    // 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)
+            : 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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(orderCancelled)),
-                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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(rebalanceSwap)),
-                data: {
-                    destinationToken: token(args.amountOut, args.userToken),
-                    signer,
-                    sourceToken: token(args.amountIn, args.validatorToken),
-                    swapper: args.swapper.toLowerCase(),
-                },
-                type: 'fee-rebalance-swap',
+    // there is no co-located transfer; the event itself is the signal.
+    recognize(named('OrderCancelled'), (event) => {
+        const args = event.args;
+        return {
+            ...itemBase(event.logIndex),
+            data: { orderId: args.orderId.toString(), signer },
+            type: 'order-cancelled',
+        };
+    });
+    // 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;
+        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),
             },
-        ];
-    }
-    // Validator fees distributed.
-    const feesDistributed = finalEvents.find((e) => e.eventName === 'FeesDistributed');
-    if (feesDistributed) {
-        const args = feesDistributed.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(feesDistributed)),
-                data: {
-                    signer,
-                    sourceToken: token(args.amount, args.token),
-                    validator: args.validator.toLowerCase(),
-                },
-                type: 'fees-distributed',
+            type: 'fee-rebalance-swap',
+        };
+    });
+    // Validator fees distributed; claim the fee-manager payout leg.
+    recognize(named('FeesDistributed'), (event) => {
+        const args = event.args;
+        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),
             },
-        ];
-    }
-    // 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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(rewardDistributed)),
-                data: {
-                    funder: args.funder.toLowerCase(),
-                    signer,
-                    sourceToken: token(args.amount, rewardDistributed.address),
-                },
-                type: 'reward-distributed',
+            type: 'fees-distributed',
+        };
+    });
+    // Reward pool funded: the funded token is the emitting contract itself;
+    // claim the funding transfer.
+    recognize(named('RewardDistributed'), (event) => {
+        const args = event.args;
+        takeTransfer((leg) => Address.isEqual(leg.address, event.address) &&
+            Address.isEqual(transferArgs(leg).from, args.funder) &&
+            Address.isEqual(transferArgs(leg).to, event.address) &&
+            transferArgs(leg).amount === args.amount);
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                funder: lc(args.funder),
+                signer,
+                sourceToken: token(args.amount, event.address),
             },
-        ];
-    }
+            type: 'reward-distributed',
+        };
+    });
     // Reward recipient redirected.
-    const rewardRecipientSet = finalEvents.find((e) => e.eventName === 'RewardRecipientSet');
-    if (rewardRecipientSet) {
-        const args = rewardRecipientSet.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(rewardRecipientSet)),
-                data: {
-                    holder: args.holder.toLowerCase(),
-                    recipient: args.recipient.toLowerCase(),
-                    signer,
-                },
-                type: 'reward-recipient-set',
+    recognize(named('RewardRecipientSet'), (event) => {
+        const args = event.args;
+        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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(spendingLimitUpdated)),
-                data: {
-                    account: args.account.toLowerCase(),
-                    publicKey: args.publicKey.toLowerCase(),
-                    signer,
-                    sourceToken: token(args.newLimit, args.token),
-                },
-                type: 'spending-limit-updated',
-            },
-        ];
-    }
-    // Access-key lifecycle events — emitted alongside any co-located transfer.
-    const accessKeyItems = [];
-    for (const event of finalEvents) {
-        if (event.eventName === 'KeyAuthorized' &&
-            Address.isEqual(event.address, Addresses.accountKeychain)) {
-            const args = event.args;
-            accessKeyItems.push({
-                ...itemBase(logIndexOfEvent(event)),
-                data: {
-                    account: args.account.toLowerCase(),
-                    expiry: Number(args.expiry),
-                    publicKey: args.publicKey.toLowerCase(),
-                    signatureType: Number(args.signatureType),
-                },
-                type: 'access-key-created',
-            });
-        }
-        else if (event.eventName === 'KeyRevoked' &&
-            Address.isEqual(event.address, Addresses.accountKeychain)) {
-            const args = event.args;
-            accessKeyItems.push({
-                ...itemBase(logIndexOfEvent(event)),
-                data: {
-                    account: args.account.toLowerCase(),
-                    publicKey: args.publicKey.toLowerCase(),
-                },
-                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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(tokenCreated)),
-                data: {
-                    address: args.token.toLowerCase(),
-                    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) => value.toLowerCase();
-    const hx = (value) => value.toLowerCase();
-    const findEvent = (name) => 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;
-        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',
-            },
-        ];
-    }
-    const orderFlipped = findEvent('OrderFlipped');
-    if (orderFlipped) {
-        const a = orderFlipped.args;
-        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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(pairCreated)),
-                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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(pauseStateUpdate)),
-                data: { paused: a.isPaused, signer, updater: lc(a.updater) },
-                type: 'token-pause-set',
+    recognize(named('SpendingLimitUpdated'), (event) => {
+        const args = event.args;
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                account: lc(args.account),
+                publicKey: lc(args.publicKey),
+                signer,
+                sourceToken: token(args.newLimit, args.token),
             },
-        ];
-    }
-    const supplyCapUpdate = findEvent('SupplyCapUpdate');
-    if (supplyCapUpdate) {
-        const a = supplyCapUpdate.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(supplyCapUpdate)),
-                data: { signer, supplyCap: a.newSupplyCap.toString(), updater: lc(a.updater) },
-                type: 'token-supply-cap-set',
+            type: 'spending-limit-updated',
+        };
+    });
+    // Access-key lifecycle events.
+    recognize((event) => event.eventName === 'KeyAuthorized' &&
+        Address.isEqual(event.address, Addresses.accountKeychain), (event) => {
+        const args = event.args;
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                account: lc(args.account),
+                expiry: Number(args.expiry),
+                publicKey: lc(args.publicKey),
+                signatureType: Number(args.signatureType),
             },
-        ];
-    }
-    const transferPolicyUpdate = findEvent('TransferPolicyUpdate');
-    if (transferPolicyUpdate) {
-        const a = transferPolicyUpdate.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(transferPolicyUpdate)),
-                data: { policyId: a.newPolicyId.toString(), signer, updater: lc(a.updater) },
-                type: 'token-transfer-policy-set',
+            type: 'access-key-created',
+        };
+    });
+    recognize((event) => event.eventName === 'KeyRevoked' && Address.isEqual(event.address, Addresses.accountKeychain), (event) => {
+        const args = event.args;
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                account: lc(args.account),
+                publicKey: lc(args.publicKey),
             },
-        ];
-    }
-    const quoteTokenUpdate = findEvent('QuoteTokenUpdate');
-    if (quoteTokenUpdate) {
-        const a = quoteTokenUpdate.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(quoteTokenUpdate)),
-                data: { quoteToken: lc(a.newQuoteToken), signer, updater: lc(a.updater) },
-                type: 'token-quote-token-set',
+            type: 'access-key-revoked',
+        };
+    });
+    // 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;
+        unclaimed((e) => e.logIndex < event.logIndex && Address.isEqual(e.address, args.token)).forEach(claim);
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                address: lc(args.token),
+                currency: args.currency,
+                name: args.name,
+                symbol: args.symbol,
             },
-        ];
-    }
-    const nextQuoteTokenSet = findEvent('NextQuoteTokenSet');
-    if (nextQuoteTokenSet) {
-        const a = nextQuoteTokenSet.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(nextQuoteTokenSet)),
-                data: { nextQuoteToken: lc(a.nextQuoteToken), signer, updater: lc(a.updater) },
-                type: 'token-next-quote-token-set',
+            type: 'token-created',
+        };
+    });
+    // Governance / admin / DEX-bookkeeping events. Each maps a single decoded
+    // 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;
+        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 logoUriUpdated = findEvent('LogoURIUpdated');
-    if (logoUriUpdated) {
-        const a = logoUriUpdated.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(logoUriUpdated)),
-                data: { logoUri: a.newLogoURI, signer, updater: lc(a.updater) },
-                type: 'token-logo-set',
+            type: 'order-filled',
+        };
+    });
+    recognize(named('OrderFlipped'), (event) => {
+        const a = event.args;
+        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),
             },
-        ];
-    }
-    const roleMembershipUpdated = findEvent('RoleMembershipUpdated');
-    if (roleMembershipUpdated) {
-        const a = roleMembershipUpdated.args;
-        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',
+            type: 'order-flipped',
+        };
+    });
+    recognize(named('PairCreated'), (event) => {
+        const a = event.args;
+        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.
+    recognize(named('PauseStateUpdate'), (event) => {
+        const a = event.args;
+        return {
+            ...itemBase(event.logIndex),
+            data: { paused: a.isPaused, signer, updater: lc(a.updater) },
+            type: 'token-pause-set',
+        };
+    });
+    recognize(named('SupplyCapUpdate'), (event) => {
+        const a = event.args;
+        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;
+        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;
+        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;
+        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;
+        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;
+        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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(roleAdminUpdated)),
-                data: {
-                    newAdminRole: hx(a.newAdminRole),
-                    role: hx(a.role),
-                    sender: lc(a.sender),
-                    signer,
-                },
-                type: 'role-admin-set',
+            type: 'role-membership-set',
+        };
+    });
+    recognize(named('RoleAdminUpdated'), (event) => {
+        const a = event.args;
+        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;
-        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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(validatorTokenSet)),
-                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;
-        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',
+    recognize(named('UserTokenSet'), (event) => {
+        const a = event.args;
+        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;
+        return {
+            ...itemBase(event.logIndex),
+            data: { signer, token: lc(a.token), validator: lc(a.validator) },
+            type: 'fee-validator-token-set',
+        };
+    });
+    // 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;
+        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.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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(policyCreated)),
-                data: {
-                    policyId: a.policyId.toString(),
-                    policyType: Number(a.policyType),
-                    signer,
-                    updater: lc(a.updater),
-                },
-                type: 'policy-created',
+            type: 'compound-policy-created',
+        };
+    });
+    recognize(named('PolicyCreated'), (event) => {
+        const a = event.args;
+        unclaimed((e) => e.logIndex < event.logIndex &&
+            Address.isEqual(e.address, event.address) &&
+            ['BlacklistUpdated', 'PolicyAdminUpdated', 'WhitelistUpdated'].includes(e.eventName) &&
+            'policyId' in e.args &&
+            e.args.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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(policyAdminUpdated)),
-                data: {
-                    admin: lc(a.admin),
-                    policyId: a.policyId.toString(),
-                    signer,
-                    updater: lc(a.updater),
-                },
-                type: 'policy-admin-set',
+            type: 'policy-created',
+        };
+    });
+    recognize(named('PolicyAdminUpdated'), (event) => {
+        const a = event.args;
+        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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(whitelistUpdated)),
-                data: {
-                    account: lc(a.account),
-                    allowed: a.allowed,
-                    policyId: a.policyId.toString(),
-                    signer,
-                    updater: lc(a.updater),
-                },
-                type: 'whitelist-updated',
+            type: 'policy-admin-set',
+        };
+    });
+    recognize(named('WhitelistUpdated'), (event) => {
+        const a = event.args;
+        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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(blacklistUpdated)),
-                data: {
-                    account: lc(a.account),
-                    policyId: a.policyId.toString(),
-                    restricted: a.restricted,
-                    signer,
-                    updater: lc(a.updater),
-                },
-                type: 'blacklist-updated',
+            type: 'whitelist-updated',
+        };
+    });
+    recognize(named('BlacklistUpdated'), (event) => {
+        const a = event.args;
+        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;
-        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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(nonceIncremented)),
-                data: {
-                    account: lc(a.account),
-                    nonce: a.newNonce.toString(),
-                    nonceKey: a.nonceKey.toString(),
-                    signer,
-                },
-                type: 'nonce-incremented',
+    recognize(named('MasterRegistered'), (event) => {
+        const a = event.args;
+        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;
+        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;
-        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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(witnessBurned)),
-                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;
-        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',
-            },
-        ];
-    }
-    const validatorAdded = findEvent('ValidatorAdded');
-    if (validatorAdded) {
-        const a = validatorAdded.args;
-        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;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(validatorDeactivated)),
-                data: { index: a.index.toString(), signer, validator: lc(a.validatorAddress) },
-                type: 'validator-deactivated',
-            },
-        ];
-    }
-    const validatorMigrated = findEvent('ValidatorMigrated');
-    if (validatorMigrated) {
-        const a = validatorMigrated.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(validatorMigrated)),
-                data: {
-                    index: a.index.toString(),
-                    publicKey: hx(a.publicKey),
-                    signer,
-                    validator: lc(a.validatorAddress),
-                },
-                type: 'validator-migrated',
+    recognize(named('KeyAuthorizationWitness'), (event) => {
+        const a = event.args;
+        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;
+        return {
+            ...itemBase(event.logIndex),
+            data: { account: lc(a.account), signer, witness: hx(a.witness) },
+            type: 'key-authorization-witness-burned',
+        };
+    });
+    // Validator configuration. Rotation claims the add/deactivate pair it
+    // bundles, matched by validator index.
+    recognize(named('ValidatorRotated'), (event) => {
+        const a = event.args;
+        unclaimed((e) => {
+            if (!('index' in e.args))
+                return false;
+            const index = e.args.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 validatorMigrationSkipped = findEvent('SkippedValidatorMigration');
-    if (validatorMigrationSkipped) {
-        const a = validatorMigrationSkipped.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(validatorMigrationSkipped)),
-                data: {
-                    index: a.index.toString(),
-                    publicKey: hx(a.publicKey),
-                    signer,
-                    validator: lc(a.validatorAddress),
-                },
-                type: 'validator-migration-skipped',
+            type: 'validator-rotated',
+        };
+    });
+    recognize(named('ValidatorAdded'), (event) => {
+        const a = event.args;
+        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 feeRecipientUpdated = findEvent('FeeRecipientUpdated');
-    if (feeRecipientUpdated) {
-        const a = feeRecipientUpdated.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(feeRecipientUpdated)),
-                data: {
-                    caller: lc(a.caller),
-                    feeRecipient: lc(a.feeRecipient),
-                    index: a.index.toString(),
-                    signer,
-                },
-                type: 'validator-fee-recipient-set',
+            type: 'validator-added',
+        };
+    });
+    recognize(named('ValidatorDeactivated'), (event) => {
+        const a = event.args;
+        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;
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                index: a.index.toString(),
+                publicKey: hx(a.publicKey),
+                signer,
+                validator: lc(a.validatorAddress),
             },
-        ];
-    }
-    const ipAddressesUpdated = findEvent('IpAddressesUpdated');
-    if (ipAddressesUpdated) {
-        const a = ipAddressesUpdated.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(ipAddressesUpdated)),
-                data: {
-                    caller: lc(a.caller),
-                    egress: a.egress,
-                    index: a.index.toString(),
-                    ingress: a.ingress,
-                    signer,
-                },
-                type: 'validator-ip-set',
+            type: 'validator-migrated',
+        };
+    });
+    recognize(named('SkippedValidatorMigration'), (event) => {
+        const a = event.args;
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                index: a.index.toString(),
+                publicKey: hx(a.publicKey),
+                signer,
+                validator: lc(a.validatorAddress),
             },
-        ];
-    }
-    const validatorOwnershipTransferred = findEvent('ValidatorOwnershipTransferred');
-    if (validatorOwnershipTransferred) {
-        const a = validatorOwnershipTransferred.args;
-        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',
+            type: 'validator-migration-skipped',
+        };
+    });
+    recognize(named('FeeRecipientUpdated'), (event) => {
+        const a = event.args;
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                caller: lc(a.caller),
+                feeRecipient: lc(a.feeRecipient),
+                index: a.index.toString(),
+                signer,
             },
-        ];
-    }
-    const ownershipTransferred = findEvent('OwnershipTransferred');
-    if (ownershipTransferred) {
-        const a = ownershipTransferred.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(ownershipTransferred)),
-                data: { newOwner: lc(a.newOwner), oldOwner: lc(a.oldOwner), signer },
-                type: 'ownership-transferred',
+            type: 'validator-fee-recipient-set',
+        };
+    });
+    recognize(named('IpAddressesUpdated'), (event) => {
+        const a = event.args;
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                caller: lc(a.caller),
+                egress: a.egress,
+                index: a.index.toString(),
+                ingress: a.ingress,
+                signer,
             },
-        ];
-    }
-    const rotationEpochSet = findEvent('NetworkIdentityRotationEpochSet');
-    if (rotationEpochSet) {
-        const a = rotationEpochSet.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(rotationEpochSet)),
-                data: {
-                    nextEpoch: a.nextEpoch.toString(),
-                    previousEpoch: a.previousEpoch.toString(),
-                    signer,
-                },
-                type: 'network-identity-rotation-epoch-set',
+            type: 'validator-ip-set',
+        };
+    });
+    recognize(named('ValidatorOwnershipTransferred'), (event) => {
+        const a = event.args;
+        return {
+            ...itemBase(event.logIndex),
+            data: {
+                caller: lc(a.caller),
+                index: a.index.toString(),
+                newAddress: lc(a.newAddress),
+                oldAddress: lc(a.oldAddress),
+                signer,
             },
-        ];
-    }
-    const initialized = findEvent('Initialized');
-    if (initialized) {
-        const a = initialized.args;
-        return [
-            {
-                ...itemBase(logIndexOfEvent(initialized)),
-                data: { height: a.height.toString(), signer },
-                type: 'initialized',
+            type: 'validator-ownership-transferred',
+        };
+    });
+    recognize(named('OwnershipTransferred'), (event) => {
+        const a = event.args;
+        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;
+        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.to, Addresses.feeManager));
-    if (userTransfers.length > 0) {
-        const t = userTransfers[0];
-        const args = t.args;
-        const to = args.to.toLowerCase();
-        const from = args.from.toLowerCase();
-        const rawMemo = t.eventName === 'TransferWithMemo' ? args.memo : undefined;
+            type: 'network-identity-rotation-epoch-set',
+        };
+    });
+    recognize(named('Initialized'), (event) => {
+        const a = event.args;
+        return {
+            ...itemBase(event.logIndex),
+            data: { height: a.height.toString(), signer },
+            type: 'initialized',
+        };
+    });
+    // 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) => {
+        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);
+        const sourceToken = token(args.amount, event.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) => 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);
+    // 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);
     }
-    // Pure access-key tx (no transfer / mint / burn / etc.).
-    if (accessKeyItems.length > 0)
-        return accessKeyItems;
-    // 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 })];
-}
-/** Extracts the block-wide log index from a decoded viem event. */
-function logIndexOfEvent(event) {
-    return event.logIndex;
+    // 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 })];
+    return items.sort((a, b) => a.logIndex - b.logIndex);
 }
 /**
  * Builds a `transfer` item whose `data` is the `Transfer` API resource plus the
@@ -3454,29 +4013,31 @@ function unknown(base, data) {
 }
 /** Decodes a group's raw rows into `viem/tempo` events via `parseEventLogs` (non-strict). */
 function decodeRows(rows) {
-    return rows.flatMap((r) => {
-        const log = {
-            address: r.logAddress,
-            blockHash: '0x0',
-            blockNumber: BigInt(r.blockNum),
-            data: (r.data ?? '0x'),
-            logIndex: r.logIdx,
-            removed: false,
-            topics: [r.selector, r.topic1, r.topic2, r.topic3].filter(Boolean),
-            transactionHash: r.txHash,
-            transactionIndex: r.txIdx,
-        };
-        try {
-            return parseEventLogs({
-                abi: [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault],
-                logs: [log],
-                strict: false,
-            });
-        }
-        catch {
-            return [];
-        }
-    });
+    const logs = rows.map((r) => ({
+        address: r.logAddress,
+        blockHash: '0x0',
+        blockNumber: BigInt(r.blockNum),
+        data: (r.data ?? '0x'),
+        logIndex: r.logIdx,
+        removed: false,
+        topics: [r.selector, r.topic1, r.topic2, r.topic3].filter(Boolean),
+        transactionHash: r.txHash,
+        transactionIndex: r.txIdx,
+    }));
+    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 [];
+    }
 }
 /**
  * Builds the full per-transaction `events` capture: one entry per raw log,
@@ -3578,12 +4139,26 @@ async function enrichTokens(c, options) {
         collectTokens(item, addresses);
     const includeLogoUri = include.includes('token.logoUri');
     const includeVerified = include.includes('token.verified');
-    // Curated data is needed only for requested valuation or token fields.
-    const snapshot = addresses.size > 0 && (denomination !== undefined || includeLogoUri || includeVerified)
-        ? await VerifiedTokens.snapshot(c, chainId).catch(() => undefined)
+    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;
-    const rates = denomination
-        ? await Valuation.ratesFor(c, {
+    // Curated data is needed only for requested valuation or token fields.
+    const snapshot_promise = addresses.size > 0 && (denomination !== undefined || includeLogoUri || includeVerified)
+        ? 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;
@@ -3592,37 +4167,63 @@ async function enrichTokens(c, options) {
                 : [],
             denomination,
             oracle,
-        })
-        : undefined;
-    if (addresses.size === 0)
-        return { items: items, 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)
+        });
+    })();
+    if (!resolved_promise)
+        return { items: items, 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,
-            },
-        ];
-    })));
+            name: metadata.name,
+            symbol: metadata.symbol,
+            verified: includeVerified && snapshot ? snapshot.byAddress.has(address) : undefined,
+        },
+    ]);
     const byAddress = new Map(resolved);
     return {
         items: items.map((item) => enrichItem(item, byAddress, { denomination, rates, snapshot })),
         rates,
     };
 }
+/** Resolves token metadata on each item's source chain without changing feed order. */
+async function enrichChainTokens(c, options) {
+    const byChain = new Map();
+    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,
+        })),
+    })));
+    const buckets = new Map();
+    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,
+    };
+}
 /** Returns an enriched copy of an item without mutating its cached token stubs. */
 function enrichItem(item, byAddress, valuation) {
     const source = item.data;
@@ -3680,6 +4281,7 @@ function groupByAccessKeyItems(items) {
         const itemSigner = signerOf(item);
         if (itemSigner !== 'self') {
             if (currentGroup &&
+                currentGroup.items[0].chainId === item.chainId &&
                 Address.isEqual(currentGroup.signer, itemSigner) &&
                 sameCalendarDay(currentGroup.items[0].timestamp, item.timestamp)) {
                 currentGroup.items.push(item);
@@ -3717,6 +4319,7 @@ function flushGroup(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}`,