@distrohelena/canton-explorer 0.1.0

package/dist/src/grpc/grpc-operations.service.js

@@ -0,0 +1,844 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcOperationsService = void 0;
+const common_1 = require("@nestjs/common");
+const node_config_schema_1 = require("../config/node-config.schema");
+const node_config_service_1 = require("../config/node-config.service");
+const grpc_client_factory_1 = require("./grpc-client.factory");
+const HOLDING_V2_INTERFACE_ID = '#splice-api-token-holding-v2:Splice.Api.Token.HoldingV2:Holding';
+const HOLDING_V2_INTERFACE_MODULE = 'Splice.Api.Token.HoldingV2';
+const HOLDING_V2_INTERFACE_ENTITY = 'Holding';
+const HOLDING_V2_PAGE_SIZE = 500;
+let GrpcOperationsService = class GrpcOperationsService {
+    clientFactory;
+    nodeConfigService;
+    topologySdkPromise;
+    constructor(clientFactory, nodeConfigService) {
+        this.clientFactory = clientFactory;
+        this.nodeConfigService = nodeConfigService;
+    }
+    async fetchOperationalInfo(node) {
+        if (node.mode !== 'pqs_with_grpc') {
+            return {
+                target: null,
+                reachable: false,
+                healthCheckImplemented: false,
+                servingStatus: null,
+            };
+        }
+        return this.withClient(node, async (client) => {
+            const response = await client.healthService.checkAsync({ service: '' });
+            const servingStatus = this.mapHealthStatus(response?.status);
+            return {
+                target: node.grpc.ledgerTarget,
+                reachable: true,
+                healthCheckImplemented: servingStatus !== null,
+                servingStatus,
+            };
+        });
+    }
+    async listLocalParties(node) {
+        if (node.mode !== 'pqs_with_grpc') {
+            return [];
+        }
+        return this.withClient(node, async (client) => this.listLocalPartiesWithClient(client));
+    }
+    async listKnownPartyFingerprints(node) {
+        if (node.mode !== 'pqs_with_grpc') {
+            return [];
+        }
+        return this.withClient(node, async (client) => {
+            const [partyTopologyResponse, localParties] = await Promise.all([
+                client.topologyAggregationService.listPartiesAsync({
+                    synchronizerIds: [],
+                }),
+                this.listLocalPartiesWithClient(client),
+            ]);
+            const parties = this.uniqueNonEmptyStrings([
+                ...(partyTopologyResponse.results ?? []).map((result) => result.party),
+                ...localParties,
+            ]);
+            return parties
+                .map((partyId) => this.extractPartyFingerprint(partyId))
+                .filter((fingerprint) => fingerprint !== null)
+                .sort((left, right) => left.localeCompare(right));
+        });
+    }
+    async fetchHoldingV2Tokens(node) {
+        if (node.mode !== 'pqs_with_grpc') {
+            return [];
+        }
+        return this.withClient(node, async (client) => {
+            const activeContracts = await this.fetchHoldingV2ActiveContracts(client);
+            const deduped = new Map();
+            for (const contract of activeContracts) {
+                const token = this.extractHoldingV2TokenSummary(contract);
+                if (token && !deduped.has(token.tokenId)) {
+                    deduped.set(token.tokenId, token);
+                }
+            }
+            return Array.from(deduped.values()).sort((left, right) => left.name.localeCompare(right.name) || left.tokenId.localeCompare(right.tokenId));
+        });
+    }
+    async fetchHoldingV2TokenHolders(node) {
+        if (node.mode !== 'pqs_with_grpc') {
+            return [];
+        }
+        return this.withClient(node, async (client) => {
+            const activeContracts = await this.fetchHoldingV2ActiveContracts(client);
+            const deduped = new Map();
+            for (const contract of activeContracts) {
+                const holder = this.extractHoldingV2TokenHolder(node, contract);
+                if (!holder) {
+                    continue;
+                }
+                const dedupeKey = holder.contractId ?? `${holder.tokenId}\u0000${holder.partyId}\u0000${holder.amount ?? ''}`;
+                if (!deduped.has(dedupeKey)) {
+                    deduped.set(dedupeKey, holder);
+                }
+            }
+            return Array.from(deduped.values());
+        });
+    }
+    async fetchPartyTopology(node, partyId) {
+        if (node.mode !== 'pqs_with_grpc') {
+            return {
+                nodeId: node.id,
+                label: node.label,
+                status: 'grpc_not_configured',
+                errorMessage: null,
+                isLocalParty: null,
+                partyToParticipants: [],
+                partyToKeyMappings: [],
+            };
+        }
+        try {
+            return await this.withClient(node, async (client) => {
+                const [partyTopologyResponse, keyOwnerResponse, rawPartyToParticipantResponse] = await Promise.all([
+                    client.topologyAggregationService.listPartiesAsync({
+                        filterParty: partyId,
+                        synchronizerIds: [],
+                    }),
+                    client.topologyAggregationService.listKeyOwnersAsync({
+                        filterKeyOwnerUid: partyId,
+                        synchronizerIds: [],
+                    }),
+                    this.tryListRawPartyToParticipant(client, partyId),
+                ]);
+                const aggregatedParticipantMappings = (partyTopologyResponse.results ?? [])
+                    .filter((result) => result.party === partyId)
+                    .flatMap((result) => (result.participants ?? []).map((participant) => ({
+                    participantId: this.extractParticipantId(participant.participantUid),
+                    participantUid: this.nullIfEmptyString(participant.participantUid),
+                    permission: this.joinDistinctValues((participant.synchronizers ?? []).map((synchronizer) => synchronizer.permission)),
+                    threshold: null,
+                    synchronizerIds: this.uniqueNonEmptyStrings((participant.synchronizers ?? []).map((synchronizer) => synchronizer.synchronizerId ?? synchronizer.physicalSynchronizerId)),
+                })));
+                const rawPartyMappings = (rawPartyToParticipantResponse?.results ?? [])
+                    .map((result) => result.item)
+                    .filter((item) => item !== undefined && item !== null)
+                    .filter((item) => item.party === partyId);
+                const rawTopologySynchronizerId = this.extractRawTopologySynchronizerId(rawPartyToParticipantResponse?.storeId);
+                const rawParticipantMappings = rawPartyMappings.flatMap((item) => (item.participants ?? []).map((participant) => ({
+                    participantId: this.extractParticipantId(participant.participantUid),
+                    participantUid: this.nullIfEmptyString(participant.participantUid),
+                    permission: this.nullIfEmptyString(participant.permission),
+                    threshold: typeof item.threshold === 'number' && Number.isFinite(item.threshold)
+                        ? item.threshold
+                        : null,
+                    synchronizerIds: rawTopologySynchronizerId ? [rawTopologySynchronizerId] : [],
+                })));
+                const aggregatedKeyMappings = (keyOwnerResponse.results ?? [])
+                    .filter((result) => result.keyOwner === partyId)
+                    .flatMap((result) => [
+                    ...(result.signingKeys ?? []).map((signingKey) => ({
+                        keyFingerprint: this.nullIfEmptyString(signingKey.fingerprint)
+                            ?? this.computePublicKeyFingerprint(client, signingKey.publicKey, signingKey.format),
+                        publicKey: this.bytesToHex(signingKey.publicKey),
+                        purpose: this.joinDistinctValues(signingKey.usage ?? []),
+                        keyType: this.nullIfEmptyString(signingKey.scheme),
+                        keyFormat: this.nullIfEmptyString(signingKey.format),
+                        keySpec: this.nullIfEmptyString(signingKey.keySpec),
+                        threshold: null,
+                        synchronizerIds: this.uniqueNonEmptyStrings([
+                            result.synchronizerId ?? result.physicalSynchronizerId,
+                        ]),
+                    })),
+                    ...(result.encryptionKeys ?? []).map((encryptionKey) => ({
+                        keyFingerprint: this.nullIfEmptyString(encryptionKey.fingerprint)
+                            ?? this.computePublicKeyFingerprint(client, encryptionKey.publicKey, encryptionKey.format),
+                        publicKey: this.bytesToHex(encryptionKey.publicKey),
+                        purpose: 'encryption',
+                        keyType: this.nullIfEmptyString(encryptionKey.scheme),
+                        keyFormat: this.nullIfEmptyString(encryptionKey.format),
+                        keySpec: this.nullIfEmptyString(encryptionKey.keySpec),
+                        threshold: null,
+                        synchronizerIds: this.uniqueNonEmptyStrings([
+                            result.synchronizerId ?? result.physicalSynchronizerId,
+                        ]),
+                    })),
+                ]);
+                const rawSigningKeyMappings = rawPartyMappings.flatMap((item) => (item.partySigningKeys?.keys ?? []).map((signingKey) => ({
+                    keyFingerprint: this.computePublicKeyFingerprint(client, signingKey.publicKey, signingKey.format),
+                    publicKey: this.bytesToHex(signingKey.publicKey),
+                    purpose: this.joinDistinctValues(signingKey.usage ?? []),
+                    keyType: this.nullIfEmptyString(signingKey.scheme),
+                    keyFormat: this.nullIfEmptyString(signingKey.format),
+                    keySpec: this.nullIfEmptyString(signingKey.keySpec),
+                    threshold: typeof item.partySigningKeys?.threshold === 'number'
+                        && Number.isFinite(item.partySigningKeys.threshold)
+                        ? item.partySigningKeys.threshold
+                        : null,
+                    synchronizerIds: rawTopologySynchronizerId ? [rawTopologySynchronizerId] : [],
+                })));
+                return {
+                    nodeId: node.id,
+                    label: node.label,
+                    status: 'ok',
+                    errorMessage: null,
+                    isLocalParty: null,
+                    partyToParticipants: this.mergePartyTopologyParticipants([
+                        ...aggregatedParticipantMappings,
+                        ...rawParticipantMappings,
+                    ]),
+                    partyToKeyMappings: this.mergePartyTopologyKeyMappings([
+                        ...aggregatedKeyMappings,
+                        ...rawSigningKeyMappings,
+                    ]),
+                };
+            });
+        }
+        catch (error) {
+            return {
+                nodeId: node.id,
+                label: node.label,
+                status: 'grpc_error',
+                errorMessage: error instanceof Error ? error.message : 'Unknown gRPC error',
+                isLocalParty: null,
+                partyToParticipants: [],
+                partyToKeyMappings: [],
+            };
+        }
+    }
+    async fetchParticipantStatus(node) {
+        if (node.mode !== 'pqs_with_grpc') {
+            throw new Error(`Node ${node.id} does not define grpc settings`);
+        }
+        return this.withClient(node, async (client) => {
+            const response = await client.participantStatusService.getParticipantStatusAsync({});
+            const status = response.status;
+            if (status) {
+                return {
+                    participantStatus: {
+                        uid: this.nullIfEmptyString(status.uid),
+                        uptime: this.formatDuration(status.uptime),
+                        ports: status.ports ?? {},
+                        active: status.active,
+                        commonStatusActive: typeof status.active === 'boolean' ? status.active : null,
+                        version: this.nullIfEmptyString(status.version),
+                        supportedProtocolVersions: status.supportedProtocolVersions ?? [],
+                        topologyQueues: status.topologyQueues
+                            ? {
+                                manager: status.topologyQueues.manager,
+                                dispatcher: status.topologyQueues.dispatcher,
+                                clients: status.topologyQueues.clients,
+                            }
+                            : null,
+                        components: (status.components ?? []).map((component) => this.mapComponentStatus(component)),
+                        connectedSynchronizers: (status.connectedSynchronizers ?? []).map((synchronizer) => ({
+                            physicalSynchronizerId: this.nullIfEmptyString(synchronizer.physicalSynchronizerId),
+                            health: this.mapSynchronizerHealth(synchronizer.health),
+                        })),
+                    },
+                    notInitialized: null,
+                };
+            }
+            if (response.notInitialized) {
+                return {
+                    participantStatus: null,
+                    notInitialized: {
+                        active: response.notInitialized.active,
+                        waitingForExternalInput: this.mapWaitingForExternalInput(response.notInitialized.waitingForExternalInput),
+                        version: this.nullIfEmptyString(response.notInitialized.version),
+                    },
+                };
+            }
+            return {
+                participantStatus: null,
+                notInitialized: {
+                    active: false,
+                    waitingForExternalInput: 'unspecified',
+                    version: null,
+                },
+            };
+        });
+    }
+    async fetchPackageRefs(node) {
+        if (node.mode !== 'pqs_with_grpc') {
+            return [];
+        }
+        return this.withClient(node, async (client) => {
+            try {
+                const response = await client.participantPackageService.listPackagesAsync({});
+                return (response.packageDescriptions ?? [])
+                    .map((description) => ({
+                    packageId: description.packageId,
+                    mainPackageId: description.packageId,
+                    name: description.name || null,
+                    version: description.version || null,
+                    uploadedAt: description.uploadedAt?.toISOString() ?? null,
+                    packageSize: description.size ?? null,
+                }))
+                    .sort((left, right) => left.packageId.localeCompare(right.packageId));
+            }
+            catch (error) {
+                if (!this.shouldFallbackToLedgerPackageListing(error)) {
+                    throw error;
+                }
+            }
+            const fallbackResponse = await client.packageService.listPackagesAsync({});
+            const packageRefs = await Promise.all((fallbackResponse.packageIds ?? []).map(async (packageId) => {
+                const packageResponse = await client.packageService.getPackageAsync({ packageId });
+                const archivePayload = Buffer.from(packageResponse.archivePayload);
+                const metadata = await this.decodePackageArchiveMetadata(archivePayload);
+                return {
+                    packageId,
+                    mainPackageId: packageId,
+                    name: metadata.name,
+                    version: metadata.version,
+                    uploadedAt: null,
+                    packageSize: archivePayload.length,
+                };
+            }));
+            return packageRefs.sort((left, right) => left.packageId.localeCompare(right.packageId));
+        });
+    }
+    async fetchPackagesByRefs(node, packageRefs) {
+        if (node.mode !== 'pqs_with_grpc' || packageRefs.length === 0) {
+            return [];
+        }
+        return this.withClient(node, async (client) => {
+            return Promise.all(packageRefs.map(async (packageRef) => {
+                const response = await client.packageService.getPackageAsync({
+                    packageId: packageRef.packageId,
+                });
+                return {
+                    packageId: packageRef.packageId,
+                    name: packageRef.name,
+                    version: packageRef.version,
+                    uploadedAt: packageRef.uploadedAt,
+                    packageSize: packageRef.packageSize,
+                    data: Buffer.from(response.archivePayload),
+                };
+            }));
+        });
+    }
+    mapHealthStatus(status) {
+        switch (status) {
+            case 'serving':
+                return 'SERVING';
+            case 'notServing':
+                return 'NOT_SERVING';
+            case 'serviceUnknown':
+                return 'SERVICE_UNKNOWN';
+            case 'unknown':
+                return 'UNKNOWN';
+            default:
+                return null;
+        }
+    }
+    shouldFallbackToLedgerPackageListing(error) {
+        if (!(error instanceof Error)) {
+            return false;
+        }
+        return error.message.includes('Method not found:') && error.message.includes('PackageService/ListPackages');
+    }
+    loadTopologySdk() {
+        this.topologySdkPromise ??= (() => {
+            const sdkModulePath = '@distrohelena/canton-typescript-sdk';
+            return import(sdkModulePath);
+        })();
+        return this.topologySdkPromise;
+    }
+    buildTopologyStoreId(sdk, store) {
+        switch (store.kind) {
+            case 'authorized':
+                return new sdk.TopologyStoreId({
+                    kind: sdk.TopologyStoreKind.authorized,
+                    authorized: new sdk.TopologyStoreAuthorized(),
+                });
+            case 'synchronizer':
+                return new sdk.TopologyStoreId({
+                    kind: sdk.TopologyStoreKind.synchronizer,
+                    synchronizer: new sdk.TopologyStoreSynchronizer({
+                        id: store.synchronizer?.id,
+                        physicalId: store.synchronizer?.physicalId,
+                    }),
+                });
+            case 'temporary':
+                if (!store.temporary?.name) {
+                    return undefined;
+                }
+                return new sdk.TopologyStoreId({
+                    kind: sdk.TopologyStoreKind.temporary,
+                    temporary: new sdk.TopologyStoreTemporary({
+                        name: store.temporary.name,
+                    }),
+                });
+            default:
+                return undefined;
+        }
+    }
+    async fetchHoldingV2ActiveContracts(client) {
+        const localParties = await this.listLocalPartiesWithClient(client);
+        const contracts = [];
+        for (const partyId of localParties) {
+            let nextPageToken;
+            do {
+                const response = await client.stateService.getActiveContractsPageAsync({
+                    party: partyId,
+                    interfaceId: HOLDING_V2_INTERFACE_ID,
+                    includeInterfaceView: true,
+                    maxPageSize: HOLDING_V2_PAGE_SIZE,
+                    pageToken: nextPageToken,
+                });
+                contracts.push(...(response.contracts ?? []));
+                nextPageToken =
+                    response.nextPageToken && response.nextPageToken.length > 0
+                        ? response.nextPageToken
+                        : undefined;
+            } while (nextPageToken);
+        }
+        return contracts;
+    }
+    extractHoldingV2TokenSummary(contract) {
+        const view = this.findHoldingV2View(contract);
+        if (!view) {
+            return null;
+        }
+        const issuer = this.readLedgerNestedScalarField(view, ['instrumentId', 'admin']);
+        const intrinsicId = this.readLedgerNestedScalarField(view, ['instrumentId', 'id']);
+        if (!issuer || !intrinsicId) {
+            return null;
+        }
+        const name = this.readConfiguredLedgerTokenMetadata(view, 'name') ?? intrinsicId;
+        const symbol = this.readConfiguredLedgerTokenMetadata(view, 'symbol');
+        return {
+            tokenId: `${issuer}::${intrinsicId}`,
+            name,
+            symbol,
+            issuer,
+            source: 'grpc',
+        };
+    }
+    extractHoldingV2TokenHolder(node, contract) {
+        const view = this.findHoldingV2View(contract);
+        if (!view) {
+            return null;
+        }
+        const issuer = this.readLedgerNestedScalarField(view, ['instrumentId', 'admin']);
+        const intrinsicId = this.readLedgerNestedScalarField(view, ['instrumentId', 'id']);
+        const partyId = this.readLedgerNestedScalarField(view, ['account', 'owner']);
+        if (!issuer || !intrinsicId || !partyId) {
+            return null;
+        }
+        return {
+            contractId: this.nullIfEmptyString(contract.createdEvent?.contractId),
+            nodeId: node.id,
+            label: node.label,
+            tokenId: `${issuer}::${intrinsicId}`,
+            partyId,
+            amount: this.readLedgerScalarField(view, 'amount'),
+        };
+    }
+    findHoldingV2View(contract) {
+        for (const interfaceView of contract.createdEvent?.interfaceViews ?? []) {
+            if (interfaceView.interfaceId?.moduleName !== HOLDING_V2_INTERFACE_MODULE
+                || interfaceView.interfaceId?.entityName !== HOLDING_V2_INTERFACE_ENTITY) {
+                continue;
+            }
+            if ((interfaceView.viewStatus?.code ?? 0) !== 0) {
+                continue;
+            }
+            return interfaceView.viewValue ?? null;
+        }
+        return null;
+    }
+    findLedgerField(record, label) {
+        return record?.fields?.find((field) => field.label === label)?.value;
+    }
+    isLedgerRecordValue(value) {
+        return (typeof value === 'object'
+            && value !== null
+            && 'sum' in value
+            && typeof value.sum === 'object'
+            && value.sum?.oneofKind === 'record');
+    }
+    readLedgerScalar(value) {
+        if (!value || typeof value !== 'object' || !('sum' in value)) {
+            return null;
+        }
+        const sum = value.sum;
+        switch (sum?.oneofKind) {
+            case 'party':
+                return this.nullIfEmptyString(sum.party);
+            case 'text':
+                return this.nullIfEmptyString(sum.text);
+            case 'numeric':
+                return this.nullIfEmptyString(sum.numeric);
+            case 'int64':
+                return this.nullIfEmptyString(sum.int64);
+            case 'contractId':
+                return this.nullIfEmptyString(sum.contractId);
+            case 'bool':
+                return typeof sum.bool === 'boolean' ? String(sum.bool) : null;
+            case 'optional':
+                return this.readLedgerScalar(sum.optional?.value);
+            case 'enum':
+                return this.nullIfEmptyString(sum.enum?.constructor);
+            case 'variant':
+                return this.nullIfEmptyString(sum.variant?.constructor);
+            default:
+                return null;
+        }
+    }
+    readLedgerScalarField(record, label) {
+        return this.readLedgerScalar(this.findLedgerField(record, label));
+    }
+    readLedgerNestedScalarField(record, path) {
+        return this.readLedgerScalar(this.getLedgerFieldValueAtPath(record, path));
+    }
+    readLedgerTextMapEntryField(record, path, entryKey) {
+        const targetValue = this.getLedgerFieldValueAtPath(record, path);
+        if (!targetValue || typeof targetValue !== 'object' || !('sum' in targetValue)) {
+            return null;
+        }
+        const textMapEntries = targetValue.sum;
+        if (textMapEntries?.oneofKind !== 'textMap') {
+            return null;
+        }
+        const matchingEntry = textMapEntries.textMap?.entries?.find((entry) => entry.key === entryKey);
+        return this.readLedgerScalar(matchingEntry?.value);
+    }
+    readConfiguredLedgerTokenMetadata(record, field) {
+        const keys = this.getTokenMetadataConfig()[field === 'name' ? 'nameKeys' : 'symbolKeys'];
+        for (const key of keys) {
+            const value = this.readLedgerTextMapEntryField(record, ['meta', 'values'], key);
+            if (value) {
+                return value;
+            }
+        }
+        return null;
+    }
+    getTokenMetadataConfig() {
+        return this.nodeConfigService?.getTokenMetadataConfig() ?? {
+            nameKeys: [...node_config_schema_1.DEFAULT_TOKEN_METADATA_CONFIG.nameKeys],
+            symbolKeys: [...node_config_schema_1.DEFAULT_TOKEN_METADATA_CONFIG.symbolKeys],
+        };
+    }
+    getLedgerFieldValueAtPath(record, path) {
+        let currentRecord = record;
+        for (let index = 0; index < path.length; index += 1) {
+            const fieldValue = this.findLedgerField(currentRecord, path[index] ?? '');
+            if (fieldValue === undefined) {
+                return null;
+            }
+            if (index === path.length - 1) {
+                return fieldValue;
+            }
+            if (!this.isLedgerRecordValue(fieldValue)) {
+                return null;
+            }
+            currentRecord = fieldValue.sum?.record ?? null;
+        }
+        return null;
+    }
+    nullIfEmptyString(value) {
+        return typeof value === 'string' && value.trim().length > 0 ? value : null;
+    }
+    async tryListRawPartyToParticipant(client, partyId) {
+        if (!client.topologyManagerReadService?.listPartyToParticipantAsync
+            || !client.topologyManagerReadService.listAvailableStoresAsync) {
+            return null;
+        }
+        try {
+            const sdk = await this.loadTopologySdk();
+            const availableStores = await client.topologyManagerReadService.listAvailableStoresAsync({});
+            const synchronizerStores = (availableStores.storeIds ?? []).filter((store) => store.kind === 'synchronizer' && store.synchronizer !== undefined);
+            for (const storeId of synchronizerStores) {
+                try {
+                    const response = await client.topologyManagerReadService.listPartyToParticipantAsync(new sdk.ListPartyToParticipantRequest({
+                        filterParty: partyId,
+                        baseQuery: new sdk.TopologyBaseQuery({
+                            storeId: this.buildTopologyStoreId(sdk, storeId),
+                            headState: true,
+                        }),
+                    }));
+                    if ((response.results ?? []).length > 0) {
+                        return {
+                            storeId,
+                            results: response.results,
+                        };
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
+    uniqueNonEmptyStrings(values) {
+        return Array.from(new Set(values
+            .map((value) => this.nullIfEmptyString(value))
+            .filter((value) => value !== null)));
+    }
+    joinDistinctValues(values) {
+        const normalizedValues = this.uniqueNonEmptyStrings(values);
+        return normalizedValues.length > 0 ? normalizedValues.join(', ') : null;
+    }
+    mergePartyTopologyParticipants(mappings) {
+        const merged = new Map();
+        for (const mapping of mappings) {
+            const key = mapping.participantUid ?? mapping.participantId ?? JSON.stringify(mapping);
+            const existing = merged.get(key);
+            if (!existing) {
+                merged.set(key, {
+                    participantId: mapping.participantId,
+                    participantUid: mapping.participantUid,
+                    permission: mapping.permission,
+                    threshold: mapping.threshold,
+                    synchronizerIds: [...mapping.synchronizerIds],
+                });
+                continue;
+            }
+            existing.participantId ??= mapping.participantId;
+            existing.participantUid ??= mapping.participantUid;
+            existing.permission ??= mapping.permission;
+            existing.threshold ??= mapping.threshold;
+            existing.synchronizerIds = this.uniqueNonEmptyStrings([
+                ...existing.synchronizerIds,
+                ...mapping.synchronizerIds,
+            ]);
+        }
+        return Array.from(merged.values()).filter((mapping) => mapping.participantId !== null
+            || mapping.participantUid !== null
+            || mapping.permission !== null
+            || mapping.threshold !== null
+            || mapping.synchronizerIds.length > 0);
+    }
+    mergePartyTopologyKeyMappings(mappings) {
+        const merged = new Map();
+        for (const mapping of mappings) {
+            const key = mapping.keyFingerprint ?? JSON.stringify(mapping);
+            const existing = merged.get(key);
+            if (!existing) {
+                merged.set(key, {
+                    keyFingerprint: mapping.keyFingerprint,
+                    publicKey: mapping.publicKey,
+                    purpose: mapping.purpose,
+                    keyType: mapping.keyType,
+                    keyFormat: mapping.keyFormat,
+                    keySpec: mapping.keySpec,
+                    threshold: mapping.threshold,
+                    synchronizerIds: [...mapping.synchronizerIds],
+                });
+                continue;
+            }
+            existing.keyFingerprint ??= mapping.keyFingerprint;
+            existing.publicKey ??= mapping.publicKey;
+            existing.purpose ??= mapping.purpose;
+            existing.keyType ??= mapping.keyType;
+            existing.keyFormat ??= mapping.keyFormat;
+            existing.keySpec ??= mapping.keySpec;
+            existing.threshold ??= mapping.threshold;
+            existing.synchronizerIds = this.uniqueNonEmptyStrings([
+                ...existing.synchronizerIds,
+                ...mapping.synchronizerIds,
+            ]);
+        }
+        return Array.from(merged.values()).filter((mapping) => mapping.keyFingerprint !== null
+            || mapping.publicKey !== null
+            || mapping.purpose !== null
+            || mapping.keyType !== null
+            || mapping.keyFormat !== null
+            || mapping.keySpec !== null
+            || mapping.threshold !== null
+            || mapping.synchronizerIds.length > 0);
+    }
+    bytesToHex(value) {
+        if (!value || value.length === 0) {
+            return null;
+        }
+        return Buffer.from(value).toString('hex');
+    }
+    computePublicKeyFingerprint(client, publicKey, format) {
+        if (!publicKey || publicKey.length === 0) {
+            return null;
+        }
+        return this.nullIfEmptyString(client.hashing?.computePublicKeyFingerprint(publicKey, this.nullIfEmptyString(format) ?? undefined));
+    }
+    extractParticipantId(participantUid) {
+        const normalizedParticipantUid = this.nullIfEmptyString(participantUid);
+        if (!normalizedParticipantUid) {
+            return null;
+        }
+        const separatorIndex = normalizedParticipantUid.indexOf('::');
+        if (separatorIndex === -1) {
+            return normalizedParticipantUid;
+        }
+        return normalizedParticipantUid.slice(0, separatorIndex) || null;
+    }
+    async listLocalPartiesWithClient(client) {
+        const parties = [];
+        let nextPageToken;
+        do {
+            const response = await client.partyManagementService.listKnownPartiesAsync({
+                pageSize: 1000,
+                pageToken: nextPageToken,
+            });
+            for (const partyDetail of response.partyDetails ?? []) {
+                if (partyDetail.isLocal) {
+                    parties.push(partyDetail.party);
+                }
+            }
+            nextPageToken = response.nextPageToken;
+        } while (nextPageToken);
+        return parties.sort((left, right) => left.localeCompare(right));
+    }
+    extractPartyFingerprint(partyId) {
+        const normalizedPartyId = this.nullIfEmptyString(partyId);
+        if (!normalizedPartyId) {
+            return null;
+        }
+        const separatorIndex = normalizedPartyId.indexOf('::');
+        if (separatorIndex === -1) {
+            return normalizedPartyId;
+        }
+        const fingerprint = normalizedPartyId.slice(separatorIndex + 2).trim();
+        return fingerprint.length > 0 ? fingerprint : null;
+    }
+    extractRawTopologySynchronizerId(storeId) {
+        if (storeId?.kind !== 'synchronizer') {
+            return null;
+        }
+        return this.nullIfEmptyString(storeId.synchronizer?.id ?? storeId.synchronizer?.physicalId);
+    }
+    formatDuration(duration) {
+        if (!duration) {
+            return null;
+        }
+        const seconds = duration.seconds === undefined || duration.seconds === null
+            ? null
+            : typeof duration.seconds === 'bigint'
+                ? duration.seconds.toString()
+                : String(duration.seconds);
+        const nanos = typeof duration.nanos === 'number' ? duration.nanos : 0;
+        if (seconds === null) {
+            return nanos > 0 ? `${nanos}ns` : null;
+        }
+        return nanos > 0 ? `${seconds}s ${nanos}ns` : `${seconds}s`;
+    }
+    mapComponentStatus(component) {
+        switch (component.kind) {
+            case 'ok':
+                return {
+                    name: component.name,
+                    severity: 'ok',
+                    description: component.description ?? null,
+                };
+            case 'degraded':
+                return {
+                    name: component.name,
+                    severity: 'degraded',
+                    description: component.description ?? null,
+                };
+            case 'failed':
+                return {
+                    name: component.name,
+                    severity: 'failed',
+                    description: component.description ?? null,
+                };
+            case 'fatal':
+                return {
+                    name: component.name,
+                    severity: 'fatal',
+                    description: component.description ?? null,
+                };
+            default:
+                return {
+                    name: component.name,
+                    severity: 'failed',
+                    description: null,
+                };
+        }
+    }
+    mapSynchronizerHealth(health) {
+        switch (health) {
+            case 'healthy':
+            case 1:
+                return 'healthy';
+            case 'unhealthy':
+            case 2:
+                return 'unhealthy';
+            case 'unspecified':
+            case 0:
+                return 'unspecified';
+            default:
+                return 'unspecified';
+        }
+    }
+    mapWaitingForExternalInput(value) {
+        switch (value) {
+            case 'id':
+                return 'id';
+            case 'nodeTopology':
+                return 'node_topology';
+            case 'initialization':
+                return 'initialization';
+            default:
+                return 'unspecified';
+        }
+    }
+    async decodePackageArchiveMetadata(archivePayload) {
+        const sdk = await import('@distrohelena/canton-typescript-sdk/daml-lf');
+        const packageLoader = new sdk.DamlLfPackageLoader();
+        const decodedPackage = packageLoader.loadPackageOrThrow(archivePayload);
+        return {
+            name: decodedPackage.packageName || null,
+            version: decodedPackage.packageVersion || null,
+        };
+    }
+    async withClient(node, run) {
+        const client = await this.clientFactory.create(node);
+        try {
+            return await run(client);
+        }
+        finally {
+            await client.disposeAsync?.();
+        }
+    }
+};
+exports.GrpcOperationsService = GrpcOperationsService;
+exports.GrpcOperationsService = GrpcOperationsService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [grpc_client_factory_1.GrpcClientFactory,
+        node_config_service_1.NodeConfigService])
+], GrpcOperationsService);
+//# sourceMappingURL=grpc-operations.service.js.map