@distrohelena/canton-explorer 0.1.0

package/dist/src/grpc/grpc-client.factory.d.ts

@@ -0,0 +1,297 @@
+import type { NodeConfig } from '../config/node-config.schema';
+type LedgerHealthResponse = {
+    status?: unknown;
+};
+type LedgerPartyDetail = {
+    party: string;
+    isLocal: boolean;
+};
+type ParticipantPackageDescription = {
+    packageId: string;
+    name?: string;
+    version?: string;
+    uploadedAt?: Date;
+    size?: number;
+};
+type TopologyMappingContext = {
+    signedByFingerprints?: string[];
+};
+type TopologyStoreSynchronizer = {
+    id?: string;
+    physicalId?: string;
+};
+type TopologyStoreId = {
+    kind?: 'authorized' | 'synchronizer' | 'temporary';
+    synchronizer?: TopologyStoreSynchronizer;
+};
+type TopologyParticipant = {
+    participantUid?: string;
+    permission?: unknown;
+};
+type TopologySigningPublicKey = {
+    format?: string;
+    publicKey?: Uint8Array;
+    scheme?: string;
+    usage?: string[];
+    keySpec?: string;
+};
+type TopologySigningKeysWithThreshold = {
+    threshold?: number;
+    keys?: TopologySigningPublicKey[];
+};
+type TopologyPartyToParticipantItem = {
+    party?: string;
+    threshold?: number;
+    participants?: TopologyParticipant[];
+    partySigningKeys?: TopologySigningKeysWithThreshold;
+};
+type TopologySigningKey = {
+    format?: string;
+    usage?: string[];
+    scheme?: string;
+    keySpec?: string;
+};
+type TopologyPartyToKeyMappingItem = {
+    party?: string;
+    signingKeys?: TopologySigningKey[];
+};
+type AggregatedTopologyPartySynchronizer = {
+    synchronizerId?: string;
+    permission?: unknown;
+    physicalSynchronizerId?: string;
+};
+type AggregatedTopologyPartyParticipant = {
+    participantUid?: string;
+    synchronizers?: AggregatedTopologyPartySynchronizer[];
+};
+type AggregatedTopologyPartyResult = {
+    party?: string;
+    participants?: AggregatedTopologyPartyParticipant[];
+};
+type AggregatedTopologySigningKey = {
+    fingerprint?: string;
+    format?: string;
+    usage?: string[];
+    scheme?: string;
+    keySpec?: string;
+    publicKey?: Uint8Array;
+};
+type AggregatedTopologyEncryptionKey = {
+    fingerprint?: string;
+    format?: string;
+    scheme?: string;
+    keySpec?: string;
+    publicKey?: Uint8Array;
+};
+type AggregatedTopologyKeyOwnerResult = {
+    keyOwner?: string;
+    synchronizerId?: string;
+    physicalSynchronizerId?: string;
+    signingKeys?: AggregatedTopologySigningKey[];
+    encryptionKeys?: AggregatedTopologyEncryptionKey[];
+};
+type LedgerPackageResponse = {
+    archivePayload: Uint8Array;
+};
+type LedgerIdentifier = {
+    packageId?: string;
+    moduleName?: string;
+    entityName?: string;
+};
+type LedgerValue = {
+    sum?: {
+        oneofKind?: string;
+        unit?: unknown;
+        bool?: boolean;
+        int64?: string;
+        numeric?: string;
+        party?: string;
+        text?: string;
+        contractId?: string;
+        optional?: {
+            value?: LedgerValue;
+        };
+        list?: {
+            elements?: LedgerValue[];
+        };
+        textMap?: {
+            entries?: Array<{
+                key?: string;
+                value?: LedgerValue;
+            }>;
+        };
+        genMap?: {
+            entries?: Array<{
+                key?: LedgerValue;
+                value?: LedgerValue;
+            }>;
+        };
+        record?: LedgerRecord;
+        variant?: {
+            constructor?: string;
+            value?: LedgerValue;
+        };
+        enum?: {
+            constructor?: string;
+        };
+    };
+};
+type LedgerRecordField = {
+    label?: string;
+    value?: LedgerValue;
+};
+type LedgerRecord = {
+    fields?: LedgerRecordField[];
+};
+type LedgerInterfaceView = {
+    interfaceId?: LedgerIdentifier;
+    viewStatus?: {
+        code?: number;
+        message?: string;
+    };
+    viewValue?: LedgerRecord;
+    implementationPackageId?: string;
+};
+type LedgerCreatedEvent = {
+    contractId?: string;
+    interfaceViews?: LedgerInterfaceView[];
+};
+type LedgerActiveContract = {
+    createdEvent?: LedgerCreatedEvent;
+    synchronizerId?: string;
+};
+type SdkCantonClient = {
+    hashing: {
+        computePublicKeyFingerprint(publicKey: Uint8Array, format?: string): string;
+    };
+    healthService: {
+        checkAsync(input: {
+            service?: string;
+        }): Promise<LedgerHealthResponse>;
+    };
+    partyManagementService: {
+        listKnownPartiesAsync(input: {
+            pageSize: number;
+            pageToken?: string;
+        }): Promise<{
+            partyDetails?: LedgerPartyDetail[];
+            nextPageToken?: string;
+        }>;
+    };
+    participantPackageService: {
+        listPackagesAsync(input: Record<string, never>): Promise<{
+            packageDescriptions?: ParticipantPackageDescription[];
+        }>;
+    };
+    participantStatusService: {
+        getParticipantStatusAsync(input: Record<string, never>): Promise<{
+            status?: {
+                uid: string;
+                uptime?: {
+                    seconds: string;
+                    nanos: number;
+                };
+                ports: Record<string, number>;
+                active: boolean;
+                topologyQueues?: {
+                    manager: number;
+                    dispatcher: number;
+                    clients: number;
+                };
+                components: Array<{
+                    name: string;
+                    kind: 'unknown' | 'ok' | 'degraded' | 'failed' | 'fatal';
+                    description?: string;
+                }>;
+                version: string;
+                connectedSynchronizers: Array<{
+                    physicalSynchronizerId: string;
+                    health: 'unspecified' | 'healthy' | 'unhealthy';
+                }>;
+                supportedProtocolVersions: number[];
+            };
+            notInitialized?: {
+                active: boolean;
+                waitingForExternalInput: 'unspecified' | 'id' | 'nodeTopology' | 'initialization';
+                version: string;
+            };
+        }>;
+    };
+    packageService: {
+        listPackagesAsync(input: Record<string, never>): Promise<{
+            packageIds?: string[];
+        }>;
+        getPackageAsync(input: {
+            packageId: string;
+        }): Promise<LedgerPackageResponse>;
+    };
+    stateService: {
+        getActiveContractsPageAsync(input: {
+            party: string;
+            templateId?: string;
+            interfaceId?: string;
+            includeInterfaceView?: boolean;
+            includeCreatedEventBlob?: boolean;
+            activeAtOffset?: string;
+            maxPageSize?: number;
+            pageToken?: Uint8Array;
+        }): Promise<{
+            contracts?: LedgerActiveContract[];
+            activeAtOffset?: string;
+            nextPageToken?: Uint8Array;
+        }>;
+    };
+    topologyManagerReadService?: {
+        listAvailableStoresAsync(input: Record<string, never>): Promise<{
+            storeIds?: TopologyStoreId[];
+        }>;
+        listPartyToParticipantAsync(input: {
+            baseQuery?: {
+                storeId?: TopologyStoreId;
+                headState?: boolean;
+            };
+            filterParty?: string;
+            filterParticipant?: string;
+        }): Promise<{
+            results?: Array<{
+                context?: TopologyMappingContext;
+                item?: TopologyPartyToParticipantItem;
+            }>;
+        }>;
+        listPartyToKeyMappingAsync(input: {
+            filterParty?: string;
+        }): Promise<{
+            results?: Array<{
+                context?: TopologyMappingContext;
+                item?: TopologyPartyToKeyMappingItem;
+            }>;
+        }>;
+    };
+    topologyAggregationService: {
+        listPartiesAsync(input: {
+            asOf?: Date;
+            limit?: number;
+            synchronizerIds: string[];
+            filterParty?: string;
+            filterParticipant?: string;
+        }): Promise<{
+            results?: AggregatedTopologyPartyResult[];
+        }>;
+        listKeyOwnersAsync(input: {
+            asOf?: Date;
+            limit?: number;
+            synchronizerIds: string[];
+            filterKeyOwnerType?: string;
+            filterKeyOwnerUid?: string;
+        }): Promise<{
+            results?: AggregatedTopologyKeyOwnerResult[];
+        }>;
+    };
+    disposeAsync?(): Promise<void>;
+};
+export declare class GrpcClientFactory {
+    create(node: NodeConfig): Promise<SdkCantonClient>;
+    private loadSdk;
+    private createAuthProvider;
+}
+export {};

package/dist/src/grpc/grpc-client.factory.js

@@ -0,0 +1,67 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcClientFactory = void 0;
+const common_1 = require("@nestjs/common");
+const shared_secret_jwt_1 = require("./shared-secret-jwt");
+let GrpcClientFactory = class GrpcClientFactory {
+    async create(node) {
+        if (node.mode !== 'pqs_with_grpc') {
+            throw new Error(`Node ${node.id} does not define grpc settings`);
+        }
+        const sdk = await this.loadSdk();
+        const authProvider = this.createAuthProvider(node, sdk);
+        return new sdk.CantonClient(new sdk.CantonClientOptions({
+            transportKind: sdk.TransportKind.grpc,
+            ledgerEndpoint: node.grpc.ledgerTarget,
+            ledgerAdminEndpoint: node.grpc.ledgerAdminTarget,
+            participantAdminEndpoint: node.grpc.participantAdminTarget,
+            defaultRequestTimeoutMs: node.grpc.connectTimeoutMs,
+            grpcConnectTimeoutMs: node.grpc.connectTimeoutMs,
+            grpcChannelSecurity: node.grpc.useTls
+                ? sdk.GrpcChannelSecurity.tls
+                : sdk.GrpcChannelSecurity.insecure,
+            ledgerGrpcChannelSecurity: node.grpc.useTls
+                ? sdk.GrpcChannelSecurity.tls
+                : sdk.GrpcChannelSecurity.insecure,
+            ledgerAdminGrpcChannelSecurity: node.grpc.useTls
+                ? sdk.GrpcChannelSecurity.tls
+                : sdk.GrpcChannelSecurity.insecure,
+            participantAdminGrpcChannelSecurity: node.grpc.useTls
+                ? sdk.GrpcChannelSecurity.tls
+                : sdk.GrpcChannelSecurity.insecure,
+            ledgerAuthProvider: authProvider,
+            ledgerAdminAuthProvider: authProvider,
+            participantAdminAuthProvider: authProvider,
+        }));
+    }
+    async loadSdk() {
+        const sdkModulePath = '@distrohelena/canton-typescript-sdk';
+        return import(sdkModulePath);
+    }
+    createAuthProvider(node, sdk) {
+        if (!node.grpc.auth) {
+            return undefined;
+        }
+        switch (node.grpc.auth.kind) {
+            case 'shared_secret_jwt':
+                return new sdk.BearerTokenAuthProvider((0, shared_secret_jwt_1.createSharedSecretJwt)({
+                    user: node.grpc.auth.user,
+                    audience: node.grpc.auth.audience,
+                    secret: node.grpc.auth.secret,
+                }));
+            default:
+                return undefined;
+        }
+    }
+};
+exports.GrpcClientFactory = GrpcClientFactory;
+exports.GrpcClientFactory = GrpcClientFactory = __decorate([
+    (0, common_1.Injectable)()
+], GrpcClientFactory);
+//# sourceMappingURL=grpc-client.factory.js.map

package/dist/src/grpc/grpc-client.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpc-client.factory.js","sourceRoot":"","sources":["../../../src/grpc/grpc-client.factory.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAA4C;AAE5C,2DAA4D;AAqRrD,IAAM,iBAAiB,GAAvB,MAAM,iBAAiB;IAC5B,KAAK,CAAC,MAAM,CAAC,IAAgB;QAC3B,IAAI,IAAI,CAAC,IAAI,KAAK,eAAe,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,EAAE,gCAAgC,CAAC,CAAC;QACnE,CAAC;QAED,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACjC,MAAM,YAAY,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAExD,OAAO,IAAI,GAAG,CAAC,YAAY,CACzB,IAAI,GAAG,CAAC,mBAAmB,CAAC;YAC1B,aAAa,EAAE,GAAG,CAAC,aAAa,CAAC,IAAI;YACrC,cAAc,EAAE,IAAI,CAAC,IAAI,CAAC,YAAY;YACtC,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB;YAChD,wBAAwB,EAAE,IAAI,CAAC,IAAI,CAAC,sBAAsB;YAC1D,uBAAuB,EAAE,IAAI,CAAC,IAAI,CAAC,gBAAgB;YACnD,oBAAoB,EAAE,IAAI,CAAC,IAAI,CAAC,gBAAgB;YAChD,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM;gBACnC,CAAC,CAAC,GAAG,CAAC,mBAAmB,CAAC,GAAG;gBAC7B,CAAC,CAAC,GAAG,CAAC,mBAAmB,CAAC,QAAQ;YACpC,yBAAyB,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM;gBACzC,CAAC,CAAC,GAAG,CAAC,mBAAmB,CAAC,GAAG;gBAC7B,CAAC,CAAC,GAAG,CAAC,mBAAmB,CAAC,QAAQ;YACpC,8BAA8B,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM;gBAC9C,CAAC,CAAC,GAAG,CAAC,mBAAmB,CAAC,GAAG;gBAC7B,CAAC,CAAC,GAAG,CAAC,mBAAmB,CAAC,QAAQ;YACpC,mCAAmC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM;gBACnD,CAAC,CAAC,GAAG,CAAC,mBAAmB,CAAC,GAAG;gBAC7B,CAAC,CAAC,GAAG,CAAC,mBAAmB,CAAC,QAAQ;YACpC,kBAAkB,EAAE,YAAY;YAChC,uBAAuB,EAAE,YAAY;YACrC,4BAA4B,EAAE,YAAY;SAC3C,CAAC,CACH,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,OAAO;QACnB,MAAM,aAAa,GAAG,qCAAqC,CAAC;QAC5D,OAAO,MAAM,CAAC,aAAa,CAAuB,CAAC;IACrD,CAAC;IAEO,kBAAkB,CACxB,IAAoD,EACpD,GAA+C;QAE/C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACpB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YAC5B,KAAK,mBAAmB;gBACtB,OAAO,IAAI,GAAG,CAAC,uBAAuB,CACpC,IAAA,yCAAqB,EAAC;oBACpB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;oBACzB,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ;oBACjC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM;iBAC9B,CAAC,CACH,CAAC;YACJ;gBACE,OAAO,SAAS,CAAC;QACrB,CAAC;IACH,CAAC;CACF,CAAA;AA9DY,8CAAiB;4BAAjB,iBAAiB;IAD7B,IAAA,mBAAU,GAAE;GACA,iBAAiB,CA8D7B"}

package/dist/src/grpc/grpc-error.util.d.ts

@@ -0,0 +1,7 @@
+export interface GrpcErrorDescription {
+    message: string;
+    code: string | null;
+    details: string | null;
+    tid: string | null;
+}
+export declare function describeGrpcError(error: unknown): GrpcErrorDescription;

package/dist/src/grpc/grpc-error.util.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeGrpcError = describeGrpcError;
+function describeGrpcError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const candidate = error;
+    const details = typeof candidate?.details === 'string' && candidate.details.length > 0
+        ? candidate.details
+        : message || null;
+    const tidSource = details ?? message;
+    return {
+        message,
+        code: normalizeCode(candidate?.code),
+        details,
+        tid: extractTid(tidSource),
+    };
+}
+function normalizeCode(code) {
+    if (typeof code === 'number' || typeof code === 'string') {
+        return String(code);
+    }
+    return null;
+}
+function extractTid(value) {
+    if (!value) {
+        return null;
+    }
+    const match = value.match(/\btid\s+([A-Za-z0-9-]+)/i);
+    return match?.[1] ?? null;
+}
+//# sourceMappingURL=grpc-error.util.js.map

package/dist/src/grpc/grpc-error.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpc-error.util.js","sourceRoot":"","sources":["../../../src/grpc/grpc-error.util.ts"],"names":[],"mappings":";;AAOA,8CAkBC;AAlBD,SAAgB,iBAAiB,CAAC,KAAc;IAC9C,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACvE,MAAM,SAAS,GAAG,KAGV,CAAC;IACT,MAAM,OAAO,GACX,OAAO,SAAS,EAAE,OAAO,KAAK,QAAQ,IAAI,SAAS,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;QACpE,CAAC,CAAC,SAAS,CAAC,OAAO;QACnB,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC;IACtB,MAAM,SAAS,GAAG,OAAO,IAAI,OAAO,CAAC;IAErC,OAAO;QACL,OAAO;QACP,IAAI,EAAE,aAAa,CAAC,SAAS,EAAE,IAAI,CAAC;QACpC,OAAO;QACP,GAAG,EAAE,UAAU,CAAC,SAAS,CAAC;KAC3B,CAAC;AACJ,CAAC;AAED,SAAS,aAAa,CAAC,IAAa;IAClC,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QACzD,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,UAAU,CAAC,KAAoB;IACtC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC;IACtD,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;AAC5B,CAAC"}

package/dist/src/grpc/grpc-operations.service.d.ts

@@ -0,0 +1,96 @@
+import { NodeConfigService } from '../config/node-config.service';
+import type { NodeConfig } from '../config/node-config.schema';
+import type { NodeParticipantNotInitializedSummary, NodeParticipantStatusSummary, ServiceInfo, TokenSummary } from '../domain/node.types';
+import type { CachedPackageBlob, CachedPackageRef } from '../packages/package-cache.service';
+import { GrpcClientFactory } from './grpc-client.factory';
+export interface GrpcPartyTopologyParticipantMapping {
+    participantId: string | null;
+    participantUid: string | null;
+    permission: string | null;
+    threshold: number | null;
+    synchronizerIds: string[];
+}
+export interface GrpcPartyTopologyKeyMapping {
+    keyFingerprint: string | null;
+    publicKey: string | null;
+    purpose: string | null;
+    keyType: string | null;
+    keyFormat: string | null;
+    keySpec: string | null;
+    threshold: number | null;
+    synchronizerIds: string[];
+}
+export type GrpcPartyTopologyStatus = 'ok' | 'grpc_not_configured' | 'grpc_error';
+export interface GrpcPartyTopologyNodeEntry {
+    nodeId: string;
+    label: string;
+    status: GrpcPartyTopologyStatus;
+    errorMessage: string | null;
+    isLocalParty?: boolean | null;
+    partyToParticipants: GrpcPartyTopologyParticipantMapping[];
+    partyToKeyMappings: GrpcPartyTopologyKeyMapping[];
+}
+export interface GrpcTokenHolderObservation {
+    contractId: string | null;
+    nodeId: string;
+    label: string;
+    tokenId: string;
+    partyId: string;
+    amount: string | null;
+}
+export declare class GrpcOperationsService {
+    private readonly clientFactory;
+    private readonly nodeConfigService?;
+    private topologySdkPromise?;
+    constructor(clientFactory: GrpcClientFactory, nodeConfigService?: NodeConfigService | undefined);
+    fetchOperationalInfo(node: NodeConfig): Promise<ServiceInfo>;
+    listLocalParties(node: NodeConfig): Promise<string[]>;
+    listKnownPartyFingerprints(node: NodeConfig): Promise<string[]>;
+    fetchHoldingV2Tokens(node: NodeConfig): Promise<TokenSummary[]>;
+    fetchHoldingV2TokenHolders(node: NodeConfig): Promise<GrpcTokenHolderObservation[]>;
+    fetchPartyTopology(node: NodeConfig, partyId: string): Promise<GrpcPartyTopologyNodeEntry>;
+    fetchParticipantStatus(node: NodeConfig): Promise<{
+        participantStatus: NodeParticipantStatusSummary;
+        notInitialized: null;
+    } | {
+        participantStatus: null;
+        notInitialized: NodeParticipantNotInitializedSummary;
+    }>;
+    fetchPackageRefs(node: NodeConfig): Promise<CachedPackageRef[]>;
+    fetchPackagesByRefs(node: NodeConfig, packageRefs: CachedPackageRef[]): Promise<CachedPackageBlob[]>;
+    private mapHealthStatus;
+    private shouldFallbackToLedgerPackageListing;
+    private loadTopologySdk;
+    private buildTopologyStoreId;
+    private fetchHoldingV2ActiveContracts;
+    private extractHoldingV2TokenSummary;
+    private extractHoldingV2TokenHolder;
+    private findHoldingV2View;
+    private findLedgerField;
+    private isLedgerRecordValue;
+    private readLedgerScalar;
+    private readLedgerScalarField;
+    private readLedgerNestedScalarField;
+    private readLedgerTextMapEntryField;
+    private readConfiguredLedgerTokenMetadata;
+    private getTokenMetadataConfig;
+    private getLedgerFieldValueAtPath;
+    private nullIfEmptyString;
+    private tryListRawPartyToParticipant;
+    private uniqueNonEmptyStrings;
+    private joinDistinctValues;
+    private mergePartyTopologyParticipants;
+    private mergePartyTopologyKeyMappings;
+    private bytesToHex;
+    private computePublicKeyFingerprint;
+    private extractParticipantId;
+    private listLocalPartiesWithClient;
+    private extractPartyFingerprint;
+    private extractRawTopologySynchronizerId;
+    private formatDuration;
+    private mapComponentStatus;
+    private mapSynchronizerHealth;
+    private mapWaitingForExternalInput;
+    private decodePackageArchiveMetadata;
+    private withClient;
+}