@distrohelena/canton-explorer 0.1.4 → 0.1.5

package/dist/src/pqs/pqs-summary.service.js

@@ -28,6 +28,12 @@ const CANTON_COIN_TOKEN_ID = 'canton-coin';
 const CANTON_COIN_TOKEN_NAME = 'Canton Coin';
 const CANTON_COIN_TRANSFER_TEMPLATE_ID = 'Splice.AmuletTransferInstruction:AmuletTransferInstruction';
 const CANTON_COIN_AMULET_TEMPLATE_ID = 'Splice.Amulet:Amulet';
+const AMULET_RULES_TEMPLATE_ID = 'Splice.AmuletRules:AmuletRules';
+const NATIVE_AMULET_SUPPORT_TEMPLATE_IDS = [
+    CANTON_COIN_AMULET_TEMPLATE_ID,
+    AMULET_RULES_TEMPLATE_ID,
+    'Splice.Amulet:ValidatorRight',
+];
 const NATIVE_AMULET_INTRINSIC_ID = 'Amulet';
 const CIP56_HOLDING_TEMPLATE_ID = 'Splice.Api.Token.HoldingV1:Holding';
 const CIP56_TRANSFER_TEMPLATE_ID = 'Splice.Api.Token.TransferInstructionV1:Transfer';
@@ -856,13 +862,14 @@ function singleUpdateQuery(node, eventOffset) {
     limit 1
   `;
 }
-function updateEventsQuery(node, updateId) {
+function updateEventsByUpdateIdsQuery(node, updateIds) {
     const relations = pqsCoreRelations(node);
-    const quotedId = `'${escapeSqlLiteral(updateId)}'`;
+    const quotedIds = updateIds.map((updateId) => `'${escapeSqlLiteral(updateId)}'`).join(', ');
     const contractTemplateId = contractTemplateIdentifierExpression('contract_tpe_row');
     const exerciseTemplateId = contractTemplateIdentifierExpression('exercise_contract_tpe_row');
     return `
     select
+      update_id,
       event_kind,
       event_id,
       contract_id,
@@ -876,6 +883,7 @@ function updateEventsQuery(node, updateId) {
       raw
     from (
       select
+        tx.transaction_id::text as update_id,
         'create'::text as event_kind,
         event_row.event_id::text as event_id,
         contract_row.contract_id::text as contract_id,
@@ -903,11 +911,12 @@ function updateEventsQuery(node, updateId) {
         on contract_tpe_row.pk = contract_row.tpe_pk
       left join ${relations.packages} package_row
         on package_row.pk = contract_row.package_pk
-      where tx.transaction_id = ${quotedId}
+      where tx.transaction_id in (${quotedIds})
 
       union all
 
       select
+        tx.transaction_id::text as update_id,
         case
           when exercise_tpe_row.consuming then 'consuming_exercise'::text
           else 'non_consuming_exercise'::text
@@ -941,11 +950,14 @@ function updateEventsQuery(node, updateId) {
         on exercise_tpe_row.pk = exercise_row.tpe_pk
       left join ${relations.packages} package_row
         on package_row.pk = exercise_row.package_pk
-      where tx.transaction_id = ${quotedId}
+      where tx.transaction_id in (${quotedIds})
     ) update_events
-    order by event_id asc nulls last, event_kind asc, contract_id asc, template_id asc
+    order by update_id asc nulls last, event_id asc nulls last, event_kind asc, contract_id asc, template_id asc
   `;
 }
+function updateEventsQuery(node, updateId) {
+    return updateEventsByUpdateIdsQuery(node, [updateId]);
+}
 function rewardCouponInstanceQuery(node, updateId) {
     const relations = pqsCoreRelations(node);
     const quotedId = `'${escapeSqlLiteral(normalizeByteaHex(updateId))}'`;
@@ -971,9 +983,11 @@ function rewardCouponInstanceQuery(node, updateId) {
     limit 1
   `;
 }
-function contractDetailQuery(node, contractId) {
+function contractDetailsQuery(node, contractIds) {
     const relations = pqsCoreRelations(node);
-    const quotedId = `'${escapeSqlLiteral(normalizeByteaHex(contractId))}'`;
+    const quotedIds = contractIds
+        .map((contractId) => `'${escapeSqlLiteral(normalizeByteaHex(contractId))}'`)
+        .join(', ');
     const contractTemplateId = contractTemplateIdentifierExpression('contract_tpe_row');
     return `
     with selected_contract as (
@@ -989,8 +1003,7 @@ function contractDetailQuery(node, contractId) {
         on contract_tpe_row.pk = contract_row.tpe_pk
       left join ${relations.packages} package_row
         on package_row.pk = contract_row.package_pk
-      where contract_row.contract_id = ${quotedId}
-      limit 1
+      where contract_row.contract_id in (${quotedIds})
     )
     select
       contract_row.contract_id,
@@ -1010,6 +1023,9 @@ function contractDetailQuery(node, contractId) {
       on archived_tx.ix = contract_row.archived_at_ix
   `;
 }
+function contractDetailQuery(node, contractId) {
+    return contractDetailsQuery(node, [contractId]);
+}
 function tokenRowsQuery(node, limit, templateIds, templatePatterns = []) {
     const relations = pqsCoreRelations(node);
     const normalizedLimit = Number.isFinite(limit) && Number(limit) > 0 ? Math.trunc(limit) : TOKEN_TRANSFER_CACHE_LIMIT;
@@ -1055,6 +1071,21 @@ function tokenRowsQuery(node, limit, templateIds, templatePatterns = []) {
     limit ${normalizedLimit}
   `;
 }
+function nativeAmuletSupportQuery(node) {
+    const relations = pqsCoreRelations(node);
+    const templateIds = NATIVE_AMULET_SUPPORT_TEMPLATE_IDS
+        .map((templateId) => `'${escapeSqlLiteral(templateId)}'`)
+        .join(',\n        ');
+    const templateId = contractTemplateIdentifierExpression('contract_tpe_row');
+    return `
+    select ${templateId} as template_id
+    from ${relations.contractTpe} contract_tpe_row
+    where ${templateId} in (
+        ${templateIds}
+      )
+    limit 1
+  `;
+}
 function recentCip112MovementUpdateIdsQuery(node, limit) {
     const relations = pqsCoreRelations(node);
     const normalizedLimit = Number.isFinite(limit) && Number(limit) > 0 ? Math.trunc(limit) : TOKEN_TRANSFER_CACHE_LIMIT;
@@ -1284,7 +1315,7 @@ let PqsSummaryService = class PqsSummaryService {
             if (nodesToFetch.length === 0) {
                 break;
             }
-            const responses = await Promise.all(nodesToFetch.map((state) => this.fetchRecentUpdates(state.node, {
+            const settled = await Promise.allSettled(nodesToFetch.map((state) => this.fetchRecentUpdates(state.node, {
                 limit: pageSize,
                 parties,
                 templates,
@@ -1292,8 +1323,25 @@ let PqsSummaryService = class PqsSummaryService {
                 hideSplice,
                 before: state.nextBefore,
             })));
-            responses.forEach((response, index) => {
+            const successfulResponses = [];
+            settled.forEach((result, index) => {
                 const state = nodesToFetch[index];
+                if (!state) {
+                    return;
+                }
+                if (result.status !== 'fulfilled') {
+                    state.exhausted = true;
+                    return;
+                }
+                successfulResponses.push({
+                    state,
+                    response: result.value,
+                });
+            });
+            if (successfulResponses.length === 0) {
+                throw settled.find((result) => result.status === 'rejected')?.reason;
+            }
+            successfulResponses.forEach(({ response, state }) => {
                 for (const update of response.updates) {
                     mergedUpdatesByKey.set(`${state.node.id}:${update.eventOffset}:${update.updateId}`, {
                         nodeId: state.node.id,
@@ -1717,29 +1765,52 @@ let PqsSummaryService = class PqsSummaryService {
     }
     async fetchActiveParties(nodes) {
         return {
-            nodes: await Promise.all(nodes.map(async (node) => ({
+            nodes: await Promise.all(nodes.map(async (node) => this.buildActivePartiesEntry(node))),
+        };
+    }
+    async buildActivePartiesEntry(node) {
+        try {
+            return {
                 nodeId: node.id,
                 label: node.label,
                 mode: node.mode,
                 parties: await this.fetchActivePartiesForNode(node),
-            }))),
-        };
+                activePartiesStatus: 'ok',
+                activePartiesError: null,
+            };
+        }
+        catch (error) {
+            return {
+                nodeId: node.id,
+                label: node.label,
+                mode: node.mode,
+                parties: [],
+                activePartiesStatus: 'pqs_error',
+                activePartiesError: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
     }
     async fetchPartyDetail(nodes, partyId) {
         const normalizedPartyId = this.normalizePartyIdentifier(partyId);
         const grpcOperationsService = this.grpcOperationsService;
-        const activePartiesByNode = await Promise.all(nodes.map(async (node) => ({
+        const activePartiesByNode = (await Promise.allSettled(nodes.map(async (node) => ({
             node,
             parties: await this.fetchActivePartiesForNode(node),
-        })));
-        const recentUpdatesByNode = await Promise.all(nodes.map(async (node) => ({
+        }))))
+            .filter((result) => result.status === 'fulfilled')
+            .map((result) => result.value);
+        const recentUpdatesByNode = (await Promise.allSettled(nodes.map(async (node) => ({
             node,
             updates: await this.fetchPartyRecentUpdatesForNode(node, normalizedPartyId, 10),
-        })));
-        const recentContractsByNode = await Promise.all(nodes.map(async (node) => ({
+        }))))
+            .filter((result) => result.status === 'fulfilled')
+            .map((result) => result.value);
+        const recentContractsByNode = (await Promise.allSettled(nodes.map(async (node) => ({
             node,
             contracts: await this.fetchPartyRecentContractsForNode(node, normalizedPartyId, 10),
-        })));
+        }))))
+            .filter((result) => result.status === 'fulfilled')
+            .map((result) => result.value);
         const localPartiesByNode = grpcOperationsService
             ? await Promise.all(nodes.map(async (node) => {
                 try {
@@ -1847,10 +1918,12 @@ let PqsSummaryService = class PqsSummaryService {
     async fetchNamespaceDetail(nodes, namespaceId) {
         const normalizedNamespaceId = namespaceId.trim();
         const grpcOperationsService = this.grpcOperationsService;
-        const activePartiesByNode = await Promise.all(nodes.map(async (node) => ({
+        const activePartiesByNode = (await Promise.allSettled(nodes.map(async (node) => ({
             node,
             parties: (await this.fetchActivePartiesForNode(node)).filter((partyId) => this.extractNamespaceIdentifier(partyId) === normalizedNamespaceId),
-        })));
+        }))))
+            .filter((result) => result.status === 'fulfilled')
+            .map((result) => result.value);
         const localPartiesByNode = grpcOperationsService
             ? await Promise.all(nodes.map(async (node) => {
                 try {
@@ -1943,7 +2016,9 @@ let PqsSummaryService = class PqsSummaryService {
     async fetchNamespaceParties(nodes, namespaceId, options) {
         const normalizedNamespaceId = namespaceId.trim();
         const matchingParties = new Set();
-        const activePartiesByNode = await Promise.all(nodes.map(async (node) => (await this.fetchActivePartiesForNode(node)).filter((partyId) => this.extractNamespaceIdentifier(partyId) === normalizedNamespaceId)));
+        const activePartiesByNode = (await Promise.allSettled(nodes.map(async (node) => (await this.fetchActivePartiesForNode(node)).filter((partyId) => this.extractNamespaceIdentifier(partyId) === normalizedNamespaceId))))
+            .filter((result) => result.status === 'fulfilled')
+            .map((result) => result.value);
         for (const parties of activePartiesByNode) {
             for (const partyId of parties) {
                 matchingParties.add(partyId);
@@ -2039,7 +2114,7 @@ let PqsSummaryService = class PqsSummaryService {
             if (nodesToFetch.length === 0) {
                 break;
             }
-            const responses = await Promise.all(nodesToFetch.map((state) => this.fetchNodeContracts(state.node, {
+            const settled = await Promise.allSettled(nodesToFetch.map((state) => this.fetchNodeContracts(state.node, {
                 limit: pageSize,
                 before: state.nextBefore,
                 parties: activePartyFilters.length > 0 ? activePartyFilters : undefined,
@@ -2047,8 +2122,25 @@ let PqsSummaryService = class PqsSummaryService {
                 partyMode,
                 hideSplice,
             })));
-            responses.forEach((response, index) => {
+            const successfulResponses = [];
+            settled.forEach((result, index) => {
                 const state = nodesToFetch[index];
+                if (!state) {
+                    return;
+                }
+                if (result.status !== 'fulfilled') {
+                    state.exhausted = true;
+                    return;
+                }
+                successfulResponses.push({
+                    state,
+                    response: result.value,
+                });
+            });
+            if (successfulResponses.length === 0) {
+                throw settled.find((result) => result.status === 'rejected')?.reason;
+            }
+            successfulResponses.forEach(({ response, state }) => {
                 for (const contract of response.contracts) {
                     mergedContractsByKey.set(`${state.node.id}:${contract.contractId}`, {
                         nodeId: state.node.id,
@@ -2129,12 +2221,29 @@ let PqsSummaryService = class PqsSummaryService {
             if (nodesToFetch.length === 0) {
                 break;
             }
-            const responses = await Promise.all(nodesToFetch.map((state) => this.fetchPartyContractsForNode(state.node, normalizedPartyId, {
+            const settled = await Promise.allSettled(nodesToFetch.map((state) => this.fetchPartyContractsForNode(state.node, normalizedPartyId, {
                 limit: pageSize,
                 before: state.nextBefore,
             })));
-            responses.forEach((response, index) => {
+            const successfulResponses = [];
+            settled.forEach((result, index) => {
                 const state = nodesToFetch[index];
+                if (!state) {
+                    return;
+                }
+                if (result.status !== 'fulfilled') {
+                    state.exhausted = true;
+                    return;
+                }
+                successfulResponses.push({
+                    state,
+                    response: result.value,
+                });
+            });
+            if (successfulResponses.length === 0) {
+                throw settled.find((result) => result.status === 'rejected')?.reason;
+            }
+            successfulResponses.forEach(({ response, state }) => {
                 for (const contract of response.contracts) {
                     mergedContractsByKey.set(`${contract.nodeId}:${contract.contractId}`, contract);
                 }
@@ -2190,18 +2299,18 @@ let PqsSummaryService = class PqsSummaryService {
         return this.paginateTokens(filteredTokens.sort(compareGlobalTokens), limit, options);
     }
     async fetchLatestTokenTransfers(nodes, limit = 25, options) {
-        const mergedTransfers = this.filterTokenTransfersByParties(await this.loadMergedTokenTransfers(nodes), options);
+        const mergedTransfers = this.filterTokenTransfers(await this.loadMergedTokenTransfers(nodes), options);
         return this.paginateTokenTransfers(mergedTransfers, limit, options);
     }
     async fetchTokenTransfers(nodes, tokenId, limit = 25, options) {
         const normalizedTokenId = this.normalizeTokenId(tokenId);
         await this.findObservedToken(nodes, normalizedTokenId);
-        const mergedTransfers = this.filterTokenTransfersByParties(await this.loadMergedTokenTransfers(nodes), options);
+        const mergedTransfers = this.filterTokenTransfers(await this.loadMergedTokenTransfers(nodes), options);
         const directTransfers = mergedTransfers.filter((transfer) => transfer.tokenId === normalizedTokenId);
         if (directTransfers.length > 0) {
             return this.paginateTokenTransfers(directTransfers, limit, options);
         }
-        const recoveredTransfers = this.filterTokenTransfersByParties(await this.recoverTokenTransfersFromActiveHolders(nodes, normalizedTokenId), options);
+        const recoveredTransfers = this.filterTokenTransfers(await this.recoverTokenTransfersFromActiveHolders(nodes, normalizedTokenId), options);
         return this.paginateTokenTransfers(recoveredTransfers, limit, options);
     }
     async fetchTokenTransferDetail(nodes, transferId) {
@@ -2341,10 +2450,11 @@ let PqsSummaryService = class PqsSummaryService {
             node,
             transfers: await this.loadCachedTokenTransfers(node),
         })));
-        const successfulTransfers = refreshResults
+        const successfulRefreshes = refreshResults.filter((result) => result.status === 'fulfilled');
+        const successfulTransfers = successfulRefreshes
             .filter((result) => result.status === 'fulfilled')
             .flatMap((result) => result.value.transfers);
-        if (successfulTransfers.length === 0) {
+        if (successfulRefreshes.length === 0) {
             const firstFailure = refreshResults.find((result) => result.status === 'rejected');
             if (firstFailure) {
                 throw firstFailure.reason;
@@ -2364,9 +2474,9 @@ let PqsSummaryService = class PqsSummaryService {
             .filter((holder) => holder.tokenId === tokenId && holder.contractId !== null);
         const recoveredTransfers = [];
         const seenContracts = new Set();
+        const contractIdsByNode = new Map();
         for (const holder of candidateHolders) {
-            const node = nodeById.get(holder.nodeId);
-            if (!node || !holder.contractId) {
+            if (!nodeById.has(holder.nodeId) || !holder.contractId) {
                 continue;
             }
             const dedupeKey = `${holder.nodeId}\u0000${holder.contractId}`;
@@ -2374,19 +2484,38 @@ let PqsSummaryService = class PqsSummaryService {
                 continue;
             }
             seenContracts.add(dedupeKey);
-            const client = this.clientFactory.getClient(node);
-            const contractResult = await client.query(contractDetailQuery(node, holder.contractId));
-            const contractRow = contractResult.rows[0];
-            if (!contractRow || typeof contractRow.created_update_id !== 'string') {
+            const nodeContractIds = contractIdsByNode.get(holder.nodeId);
+            if (nodeContractIds) {
+                nodeContractIds.push(holder.contractId);
+            }
+            else {
+                contractIdsByNode.set(holder.nodeId, [holder.contractId]);
+            }
+        }
+        for (const [nodeId, contractIds] of contractIdsByNode) {
+            const node = nodeById.get(nodeId);
+            if (!node) {
                 continue;
             }
-            const events = await this.fetchEventsByUpdateId(node, client.query.bind(client), contractRow.created_update_id);
-            const inferredTransfers = this.inferCip112TokenMovements(node, {
-                update_id: contractRow.created_update_id,
-                event_offset: contractRow.created_event_offset,
-                record_time: contractRow.created_record_time,
-            }, events).filter((transfer) => transfer.tokenId === tokenId);
-            recoveredTransfers.push(...inferredTransfers);
+            const client = this.clientFactory.getClient(node);
+            const contractRows = await this.fetchContractDetailsByIds(node, client.query.bind(client), contractIds);
+            const eventsByUpdateId = await this.fetchEventsByUpdateIds(node, client.query.bind(client), contractRows
+                .map((contractRow) => contractRow.created_update_id)
+                .filter((updateId) => typeof updateId === 'string'));
+            for (const contractRow of contractRows) {
+                if (typeof contractRow.created_update_id !== 'string') {
+                    continue;
+                }
+                const events = eventsByUpdateId.get(contractRow.created_update_id) ?? [];
+                const inferredTransfers = this.extractCip112TokenMovements(node, {
+                    update_id: contractRow.created_update_id,
+                    event_offset: contractRow.created_event_offset,
+                    record_time: contractRow.created_record_time,
+                }, events, {
+                    canonicalShareTokenId: tokenId,
+                }).filter((transfer) => transfer.tokenId === tokenId);
+                recoveredTransfers.push(...inferredTransfers);
+            }
         }
         return this.mergeTokenTransfers(recoveredTransfers);
     }
@@ -2425,13 +2554,15 @@ let PqsSummaryService = class PqsSummaryService {
             transfers: pagedTransfers,
         };
     }
-    filterTokenTransfersByParties(transfers, options) {
+    filterTokenTransfers(transfers, options) {
         const activeFromParties = normalizePartyFilters(options?.fromParties);
         const activeToParties = normalizePartyFilters(options?.toParties);
+        const activeMovementTypes = this.normalizeTokenTransferMovementTypeFilters(options?.movementTypes);
         const amountGt = options?.amountGt?.trim() || null;
         const amountLt = options?.amountLt?.trim() || null;
         if (activeFromParties.length === 0 &&
             activeToParties.length === 0 &&
+            activeMovementTypes.length === 0 &&
             amountGt === null &&
             amountLt === null) {
             return transfers;
@@ -2441,11 +2572,13 @@ let PqsSummaryService = class PqsSummaryService {
                 (transfer.sender !== null && activeFromParties.includes(transfer.sender));
             const matchesTo = activeToParties.length === 0 ||
                 (transfer.receiver !== null && activeToParties.includes(transfer.receiver));
+            const matchesMovementType = activeMovementTypes.length === 0 ||
+                activeMovementTypes.includes(this.effectiveTokenTransferMovementType(transfer).toLowerCase());
             const matchesAmountGt = amountGt === null ||
                 (transfer.amount !== null && this.compareNumericStrings(transfer.amount, amountGt) > 0);
             const matchesAmountLt = amountLt === null ||
                 (transfer.amount !== null && this.compareNumericStrings(transfer.amount, amountLt) < 0);
-            return matchesFrom && matchesTo && matchesAmountGt && matchesAmountLt;
+            return matchesFrom && matchesTo && matchesMovementType && matchesAmountGt && matchesAmountLt;
         });
     }
     async fetchUpdateDetail(node, eventOffset) {
@@ -2606,16 +2739,15 @@ let PqsSummaryService = class PqsSummaryService {
             return cached.tokens;
         }
         const useGrpcHoldingViews = node.mode === 'pqs_with_grpc' && this.grpcOperationsService !== undefined;
-        const [pqsTokens, grpcTokens] = await Promise.all([
-            this.fetchObservedTokensForNode(node, TOKEN_TRANSFER_CACHE_LIMIT, {
-                includeCip112: !useGrpcHoldingViews,
-            }),
+        const [pqsTokens, grpcTokens, builtinTokens] = await Promise.all([
+            this.fetchObservedTokensForNode(node, TOKEN_TRANSFER_CACHE_LIMIT),
             useGrpcHoldingViews
                 ? this.grpcOperationsService.fetchHoldingV2Tokens(node)
                 : Promise.resolve([]),
+            this.fetchBuiltinTokensForNode(node),
         ]);
         const dedupedTokens = new Map();
-        for (const token of [...pqsTokens, ...grpcTokens]) {
+        for (const token of [...pqsTokens, ...grpcTokens, ...builtinTokens]) {
             if (!dedupedTokens.has(token.tokenId)) {
                 dedupedTokens.set(token.tokenId, token);
             }
@@ -2627,6 +2759,31 @@ let PqsSummaryService = class PqsSummaryService {
         });
         return tokens;
     }
+    async fetchBuiltinTokensForNode(node) {
+        const client = this.clientFactory.getClient(node);
+        const result = await client.query(nativeAmuletSupportQuery(node));
+        const rows = Array.isArray(result.rows) ? result.rows : [];
+        const hasNativeAmuletSupport = rows.some((row) => {
+            if (!row || typeof row !== 'object') {
+                return false;
+            }
+            const templateId = row.template_id;
+            return (typeof templateId === 'string' &&
+                NATIVE_AMULET_SUPPORT_TEMPLATE_IDS.includes(this.normalizeTemplateIdentifier(templateId)));
+        });
+        if (!hasNativeAmuletSupport) {
+            return [];
+        }
+        return [
+            {
+                tokenId: CANTON_COIN_TOKEN_ID,
+                name: CANTON_COIN_TOKEN_NAME,
+                symbol: null,
+                issuer: null,
+                source: 'pqs',
+            },
+        ];
+    }
     async fetchObservedTokensForNode(node, limit, options) {
         const client = this.clientFactory.getClient(node);
         const includeCip112 = options?.includeCip112 ?? true;
@@ -2812,17 +2969,93 @@ let PqsSummaryService = class PqsSummaryService {
         const result = await client.query(recentCip112MovementUpdateIdsQuery(node, limit));
         const rows = result.rows ?? [];
         const transfers = [];
+        const rawUpdateIds = rows
+            .map((row) => (typeof row.update_id === 'string' ? row.update_id : null))
+            .filter((updateId) => Boolean(updateId && this.isHexTokenMovementUpdateId(updateId)));
+        const eventsByUpdateId = await this.fetchEventsByUpdateIds(node, client.query.bind(client), rawUpdateIds);
         for (const row of rows) {
             const rawUpdateId = typeof row.update_id === 'string' ? row.update_id : null;
             if (!rawUpdateId || !this.isHexTokenMovementUpdateId(rawUpdateId)) {
                 continue;
             }
-            const events = await this.fetchEventsByUpdateId(node, client.query.bind(client), rawUpdateId);
-            transfers.push(...this.inferCip112TokenMovements(node, row, events));
+            const events = eventsByUpdateId.get(rawUpdateId) ?? [];
+            transfers.push(...this.extractCip112TokenMovements(node, row, events));
+        }
+        return transfers;
+    }
+    extractCip112TokenMovements(node, update, events, options) {
+        const standardTransfers = this.extractStandardCip112TokenMovements(node, update, events, options);
+        if (standardTransfers.length > 0) {
+            return standardTransfers;
+        }
+        return this.inferCip112TokenMovements(node, update, events, options);
+    }
+    extractStandardCip112TokenMovements(node, update, events, options) {
+        const createTokensById = new Map();
+        for (const event of events) {
+            if (event.eventKind !== 'create' ||
+                !this.isCip112TemplateId(event.templateId) ||
+                event.createData?.status !== 'decoded') {
+                continue;
+            }
+            const token = this.extractObservedTokenSummary(event.templateId, event.createData);
+            if (token) {
+                createTokensById.set(token.tokenId, token);
+            }
+        }
+        const transfers = [];
+        const eventLogExercises = events.filter((event) => event.eventKind === 'non_consuming_exercise' &&
+            (event.choice === 'HoldingsChange' || event.choice === 'EventLog_HoldingsChange') &&
+            event.exerciseData?.argument.status === 'decoded' &&
+            this.isRecordValue(event.exerciseData.argument.value));
+        for (const event of eventLogExercises) {
+            const argument = event.exerciseData?.argument;
+            if (!argument || argument.status !== 'decoded' || !this.isRecordValue(argument.value)) {
+                continue;
+            }
+            const account = this.findRecordField(argument.value, 'account');
+            const transferLegs = this.readListField(argument.value, 'transferLegSides');
+            const admin = this.readScalarField(argument.value, 'admin');
+            if (!account || !admin || transferLegs.length === 0) {
+                continue;
+            }
+            for (const leg of transferLegs) {
+                if (!this.isRecordValue(leg)) {
+                    continue;
+                }
+                const side = this.readConstructorField(leg, 'side');
+                if (side !== 'SenderSide') {
+                    continue;
+                }
+                const transferLegId = this.readScalarField(leg, 'transferLegId');
+                const amount = this.readScalarField(leg, 'amount');
+                const instrumentId = this.readScalarField(leg, 'instrumentId');
+                const otherSideAccount = this.findRecordField(leg, 'otherside');
+                if (!transferLegId || !instrumentId || !otherSideAccount) {
+                    continue;
+                }
+                const token = this.resolveEventLogTokenSummary(admin, instrumentId, createTokensById, options?.canonicalShareTokenId ?? null);
+                const movementType = this.classifyEventLogMovementType(account, otherSideAccount, admin, instrumentId);
+                transfers.push({
+                    rowId: this.buildTokenTransferLegRowId(typeof update.update_id === 'string' ? this.normalizeUpdateId(update.update_id) : '', event.eventId, transferLegId, movementType),
+                    movementType,
+                    source: 'pqs',
+                    nodeId: node.id,
+                    label: node.label,
+                    tokenId: token.tokenId,
+                    tokenName: token.name,
+                    amount,
+                    sender: this.readAccountParty(account),
+                    receiver: this.readAccountParty(otherSideAccount),
+                    eventOffset: this.normalizeOptionalScalar(update.event_offset) ?? '',
+                    updateId: typeof update.update_id === 'string' ? this.normalizeUpdateId(update.update_id) : '',
+                    recordTime: typeof update.record_time === 'string' ? update.record_time : null,
+                });
+            }
         }
         return transfers;
     }
-    inferCip112TokenMovements(node, update, events) {
+    inferCip112TokenMovements(node, update, events, options) {
         const createEvents = events.filter((event) => event.eventKind === 'create' &&
             this.isCip112TemplateId(event.templateId) &&
             event.createData?.status === 'decoded' &&
@@ -2842,10 +3075,11 @@ let PqsSummaryService = class PqsSummaryService {
             ? this.readScalarField(event.createData.value, 'owner')
             : null)
             .find((owner) => Boolean(owner));
-        if (transferExercises.length > 0) {
+        const shouldEmitCreateMovements = transferExercises.length > 0 || (transferExercises.length === 0 && mintExercises.length === 0);
+        if (shouldEmitCreateMovements) {
             for (const event of createEvents) {
                 const movementType = 'Create';
-                const transfer = this.buildInferredCip112Movement(node, update, event, movementType, !this.isShareLikeCip112Template(event.templateId) ? shareOwnerFallback : null);
+                const transfer = this.buildInferredCip112Movement(node, update, event, movementType, !this.isShareLikeCip112Template(event.templateId) ? shareOwnerFallback : null, options?.canonicalShareTokenId);
                 if (transfer) {
                     transfers.push(transfer);
                 }
@@ -2864,7 +3098,7 @@ let PqsSummaryService = class PqsSummaryService {
         }
         return transfers;
     }
-    buildInferredCip112Movement(node, update, event, movementType, receiverFallback = null) {
+    buildInferredCip112Movement(node, update, event, movementType, receiverFallback = null, canonicalShareTokenId = null) {
         if (event.createData?.status !== 'decoded') {
             return null;
         }
@@ -2876,13 +3110,16 @@ let PqsSummaryService = class PqsSummaryService {
         if (!token) {
             return null;
         }
+        const tokenId = canonicalShareTokenId && this.isShareLikeCip112Template(event.templateId)
+            ? canonicalShareTokenId
+            : token.tokenId;
         return {
             rowId: this.buildTokenMovementRowId(typeof update.update_id === 'string' ? update.update_id : this.normalizeUpdateId(''), event.eventId, event.templateId, movementType),
             movementType,
             source: INFERRED_HOLDING_V2_SOURCE,
             nodeId: node.id,
             label: node.label,
-            tokenId: token.tokenId,
+            tokenId,
             tokenName: token.name,
             amount: this.readScalarField(record, 'amount'),
             sender: movementType === 'Mint' ? this.readScalarField(record, 'issuer') : null,
@@ -2984,6 +3221,17 @@ let PqsSummaryService = class PqsSummaryService {
     normalizeTokenId(tokenId) {
         return tokenId.trim();
     }
+    normalizeTokenTransferMovementTypeFilters(movementTypes) {
+        return Array.from(new Set((movementTypes ?? [])
+            .map((movementType) => movementType.trim().toLowerCase())
+            .filter((movementType) => movementType.length > 0)));
+    }
+    effectiveTokenTransferMovementType(transfer) {
+        const normalizedMovementType = transfer.movementType?.trim();
+        return normalizedMovementType && normalizedMovementType.length > 0
+            ? normalizedMovementType
+            : 'Transfer';
+    }
     isCip112TemplateId(templateId) {
         return typeof templateId === 'string' && templateId.includes('.CIP112:');
     }
@@ -3001,6 +3249,33 @@ let PqsSummaryService = class PqsSummaryService {
     buildTokenMovementRowId(updateId, eventId, templateId, movementType) {
         return [updateId, eventId ?? '', templateId ?? '', movementType].join(':');
     }
+    buildTokenTransferLegRowId(updateId, eventId, transferLegId, movementType) {
+        return [updateId, eventId ?? '', transferLegId, movementType].join(':');
+    }
+    resolveEventLogTokenSummary(admin, instrumentId, tokensById, canonicalShareTokenId) {
+        const fallbackToken = this.buildObservedTokenSummary(instrumentId, admin, this.isNativeAmuletIntrinsicId(instrumentId) ? CANTON_COIN_TOKEN_NAME : instrumentId, null);
+        const tokenId = canonicalShareTokenId && fallbackToken.tokenId === this.normalizeShareLikeIntrinsicTokenId(instrumentId)
+            ? canonicalShareTokenId
+            : fallbackToken.tokenId;
+        return tokensById.get(tokenId) ?? tokensById.get(fallbackToken.tokenId) ?? {
+            ...fallbackToken,
+            tokenId,
+        };
+    }
+    classifyEventLogMovementType(senderAccount, receiverAccount, admin, instrumentId) {
+        if (this.isSyntheticEventLogAccount(senderAccount, admin, `${instrumentId}:mint`)) {
+            return 'Mint';
+        }
+        if (this.isSyntheticEventLogAccount(receiverAccount, admin, `${instrumentId}:burn`)) {
+            return 'Burn';
+        }
+        return 'Transfer';
+    }
+    isSyntheticEventLogAccount(account, provider, expectedId) {
+        return (this.readOptionalScalarField(account, 'owner') === null &&
+            this.readOptionalScalarField(account, 'provider') === provider &&
+            this.readScalarField(account, 'id') === expectedId);
+    }
     compareNumericStrings(left, right) {
         const leftValue = left === null ? Number.NEGATIVE_INFINITY : Number(left);
         const rightValue = right === null ? Number.NEGATIVE_INFINITY : Number(right);
@@ -3198,9 +3473,43 @@ let PqsSummaryService = class PqsSummaryService {
         };
     }
     async fetchEventsByUpdateId(node, query, rawUpdateId) {
-        const result = await query(updateEventsQuery(node, rawUpdateId));
+        const eventsByUpdateId = await this.fetchEventsByUpdateIds(node, query, [rawUpdateId]);
+        return eventsByUpdateId.get(rawUpdateId) ?? [];
+    }
+    async fetchEventsByUpdateIds(node, query, rawUpdateIds) {
+        if (rawUpdateIds.length === 0) {
+            return new Map();
+        }
+        const result = await query(updateEventsByUpdateIdsQuery(node, rawUpdateIds));
         const rows = result.rows ?? [];
-        return Promise.all(rows.map((row) => this.normalizeEventRow(node, row)));
+        const onlyRequestedUpdateId = rawUpdateIds.length === 1 ? rawUpdateIds[0] : null;
+        const normalizedRows = await Promise.all(rows.map(async (row) => ({
+            updateId: typeof row.update_id === 'string'
+                ? row.update_id
+                : onlyRequestedUpdateId,
+            event: await this.normalizeEventRow(node, row),
+        })));
+        const eventsByUpdateId = new Map();
+        for (const { updateId, event } of normalizedRows) {
+            if (!updateId) {
+                continue;
+            }
+            const existingEvents = eventsByUpdateId.get(updateId);
+            if (existingEvents) {
+                existingEvents.push(event);
+            }
+            else {
+                eventsByUpdateId.set(updateId, [event]);
+            }
+        }
+        return eventsByUpdateId;
+    }
+    async fetchContractDetailsByIds(node, query, contractIds) {
+        if (contractIds.length === 0) {
+            return [];
+        }
+        const result = await query(contractDetailsQuery(node, contractIds));
+        return result.rows ?? [];
     }
     shouldResolveRewardCoupon(events) {
         return events.some((event) => event.choice === 'ReceiveSvRewardCoupon');
@@ -3497,6 +3806,66 @@ let PqsSummaryService = class PqsSummaryService {
         }
         return null;
     }
+    readOptionalScalarField(value, label) {
+        const field = value.fields.find((candidate) => candidate.label === label)?.value;
+        if (field === null || field === undefined) {
+            return null;
+        }
+        if (typeof field === 'string' || typeof field === 'number' || typeof field === 'boolean') {
+            return String(field);
+        }
+        if (typeof field === 'object' &&
+            field !== null &&
+            'kind' in field &&
+            field.kind === 'contract_id') {
+            return field.value;
+        }
+        if (typeof field !== 'object' || !('kind' in field) || field.kind !== 'optional') {
+            return null;
+        }
+        const innerValue = field.value;
+        if (typeof innerValue === 'string' ||
+            typeof innerValue === 'number' ||
+            typeof innerValue === 'boolean') {
+            return String(innerValue);
+        }
+        if (typeof innerValue === 'object' &&
+            innerValue !== null &&
+            'kind' in innerValue &&
+            innerValue.kind === 'contract_id') {
+            return innerValue.value;
+        }
+        return null;
+    }
+    readConstructorField(value, label) {
+        const field = value.fields.find((candidate) => candidate.label === label)?.value;
+        if (field === null || field === undefined) {
+            return null;
+        }
+        if (typeof field === 'string' || typeof field === 'number' || typeof field === 'boolean') {
+            return String(field);
+        }
+        if (typeof field !== 'object' || !('kind' in field)) {
+            return null;
+        }
+        if (field.kind === 'enum') {
+            return field.constructor;
+        }
+        if (field.kind === 'variant') {
+            return field.constructor;
+        }
+        return null;
+    }
+    readListField(value, label) {
+        const field = value.fields.find((candidate) => candidate.label === label)?.value;
+        if (!field || typeof field !== 'object' || !('kind' in field) || field.kind !== 'list') {
+            return [];
+        }
+        return field.items;
+    }
+    readAccountParty(value) {
+        return this.readOptionalScalarField(value, 'owner') ?? this.readOptionalScalarField(value, 'provider');
+    }
     readTextMapEntryField(value, path, key) {
         let current = value;
         for (const segment of path) {