tapimo 0.10.2 → 0.12.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';
@@ -130,6 +131,9 @@ 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 for multi-Zone requests.'), 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.')),
@@ -820,9 +824,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.')),
@@ -1261,6 +1263,9 @@ export var schema;
     /** 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 for multi-Zone requests.'), z.meta({ examples: [421700001] })),
         data: z
             .object({
             items: z.array(schema.Item).check(z.describe('Activity items included in this group.')),
@@ -1288,12 +1293,12 @@ export var schema;
     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. */
+    /** 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, such as `zones,token.logoUri,token.verified`.');
     /** Schemas for the getAddressActivities operation. */
     let getAddressActivities;
     (function (getAddressActivities) {
@@ -1368,6 +1373,7 @@ export var schema;
          */
         getTransactionActivities.Response = 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)
@@ -1599,7 +1605,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 +1623,71 @@ 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(() => list(tidx({ chainId, 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 result = await Store.memoize(() => listZones({
+                    address: address,
+                    cursor: query.cursor,
+                    group: query.group,
+                    limit: query.limit,
+                    logs: query.logs,
+                    providers: zoneChainIds.map((zoneChainId) => ({
+                        chainId: zoneChainId,
+                        provider: tidx({
+                            chainId: zoneChainId,
+                            tidx: c.get('getTidx')(zoneChainId),
+                        }),
+                    })),
+                    store: c.get('store'),
+                }), {
+                    key: `activities:zones:v1:${zoneChainIds.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 enrichZoneTokens(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) {
@@ -1686,6 +1724,10 @@ export function transactions(options = {}) {
                     description: 'No mined transaction was found for that hash.',
                     codes: ['transaction_not_found'],
                 },
+                409: {
+                    description: 'More than one readable Zone contains that transaction hash.',
+                    codes: ['transaction_ambiguous'],
+                },
                 502: 'Tempo could not read activity or token data from an upstream service.',
             },
             success: {
@@ -1716,36 +1758,107 @@ 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.');
+                    // Cache only positive resolution. Missing transactions must remain
+                    // visible as soon as their Zone indexer catches up.
+                    const match = await Store.memoize(async () => {
+                        const probes = await Promise.all(zoneChainIds.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:v1:${zoneChainIds.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({
+                        chainId,
+                        logs: query.logs,
+                        store: c.get('store'),
+                        tidx: c.get('getTidx')(chainId),
+                        transactionHash,
+                    })
+                    : classifyTransactionActivities({
+                        chainId,
+                        logs: query.logs,
+                        receipt: selected.receipt,
+                        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),
+                });
+                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 Zone',
+                    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 +1881,13 @@ 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;
+    const receipt = await 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,9 +1900,17 @@ 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 = 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({
@@ -1812,7 +1939,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 +1950,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 +1973,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 +1993,117 @@ export async function list(provider, options) {
     // public token references and structured amounts via {@link enrichTokens}.
     return { items: allItems, nextCursor };
 }
+const zoneCursorVersion = 1;
+/**
+ * Lists address activity across multiple Zones in one stable timestamp-ordered
+ * feed. Its opaque cursor retains each Zone provider's native continuation.
+ */
+export async function listZones(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 = decodeZoneCursor(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 ? encodeZoneCursor(cursors, chainIds) : null,
+    };
+}
+function decodeZoneCursor(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] !== zoneCursorVersion)
+        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 encodeZoneCursor(cursors, chainIds) {
+    return Cursor.encode([
+        zoneCursorVersion,
+        ...chainIds.flatMap((chainId) => [chainId, cursors.get(chainId) ?? 'head']),
+    ]);
+}
 /**
  * Creates a TIDX-backed {@link Provider} that runs three sub-queries in
  * parallel and merges them:
@@ -2174,28 +2413,44 @@ function classifyGroup(group, viewer, fingerprintMap, includeLogs = false) {
 }
 /** Classifies a Q1 (log-bearing) group via `parseEventLogs`. */
 function classifyFromLogs(rows, ctx) {
-    const items = classifyFromLogsCore(rows, ctx);
+    const decoded = decodeRows(rows);
+    const items = (() => {
+        try {
+            return classifyFromLogsCore(rows, ctx, decoded);
+        }
+        catch {
+            // Indexed logs can match a known signature without satisfying that event's expected shape.
+            return [
+                unknown(ctx.itemBase(Math.min(...rows.map((row) => row.logIdx))), {
+                    events: buildTxEvents(rows, decoded),
+                    signer: signerForRows(rows, { fallback: ctx.signer, viewer: ctx.viewer }),
+                }),
+            ];
+        }
+    })();
     // 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.
     if (!ctx.includeLogs)
         return items;
-    const events = buildTxEvents(rows, decodeRows(rows));
+    const events = buildTxEvents(rows, decoded);
     return items.map((item) => (item.type === 'unknown' ? item : { ...item, events }));
 }
-/** Classifies a Q1 (log-bearing) group via `parseEventLogs`, picking one headline item. */
-function classifyFromLogsCore(rows, ctx) {
-    const { blockNum, fingerprintMap, itemBase, viewer } = ctx;
-    // An access-key-signed tx emits AccessKeySpend at the accountKeychain; topic2
-    // is the access-key publicKey. Use it as the signer so successive access-key
-    // actions group together.
-    const accessKeySpendRow = rows.find((r) => r.selector === accessKeySpendSelector &&
-        Address.isEqual(r.logAddress, Addresses.accountKeychain));
+/** Resolves an access-key signer from raw rows, falling back to the transaction signer. */
+function signerForRows(rows, options) {
+    const accessKeySpendRow = rows.find((row) => row.selector === accessKeySpendSelector &&
+        Address.isEqual(row.logAddress, Addresses.accountKeychain));
     const accessKeySigner = accessKeySpendRow?.topic2
         ? `0x${accessKeySpendRow.topic2.slice(-40)}`.toLowerCase()
         : null;
-    const signer = accessKeySigner && !Address.isEqual(accessKeySigner, viewer) ? accessKeySigner : ctx.signer;
-    const events = decodeRows(rows);
+    return accessKeySigner && !Address.isEqual(accessKeySigner, options.viewer)
+        ? accessKeySigner
+        : options.fallback;
+}
+/** Classifies a Q1 (log-bearing) group via `parseEventLogs`, picking one headline item. */
+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.
@@ -2564,6 +2819,11 @@ function classifyFromLogsCore(rows, ctx) {
     }
     // Approval (excluding zone-outbox spenders).
     const approvalEvent = finalEvents.find((e) => e.eventName === 'Approval' &&
+        // ERC-721 uses the same selector but indexes its token ID as topic3. In
+        // non-strict mode viem otherwise decodes the missing ERC-20 amount as zero.
+        rows.some((row) => row.logIdx === e.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;
@@ -3433,21 +3693,28 @@ function unknown(base, data) {
 }
 /** Decodes a group's raw rows into `viem/tempo` events via `parseEventLogs` (non-strict). */
 function decodeRows(rows) {
-    const viemLogs = 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,
-    }));
-    return parseEventLogs({
-        abi: [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault],
-        logs: viemLogs,
-        strict: false,
+    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 [];
+        }
     });
 }
 /**
@@ -3550,12 +3817,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;
@@ -3564,37 +3845,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 Zone without changing feed order. */
+async function enrichZoneTokens(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;
@@ -3652,6 +3959,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);
@@ -3689,6 +3997,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}`,