@distrohelena/canton-typescript-sdk 0.1.0

package/dist/transports/grpc/grpc-transport.js

@@ -0,0 +1,534 @@
+import { AllocatePartyResponse as SdkAllocatePartyResponse } from "../../core/types/responses/allocate-party-response.js";
+import { GetActiveContractsPageResponse } from "../../core/types/responses/get-active-contracts-page-response.js";
+import { GetLedgerApiVersionResponse as SdkGetLedgerApiVersionResponse } from "../../core/types/responses/get-ledger-api-version-response.js";
+import { ListKnownPartiesResponse as SdkListKnownPartiesResponse } from "../../core/types/responses/list-known-parties-response.js";
+import { UploadDarFileResponse as SdkUploadDarFileResponse } from "../../core/types/responses/upload-dar-file-response.js";
+import { NotSupportedError } from "../../core/errors/not-supported-error.js";
+import { TransportError } from "../../core/errors/transport-error.js";
+import { PackageFormat } from "../../core/types/package-format.js";
+import { createGrpcOperations, } from "./grpc-channel-factory.js";
+import { mapGrpcSubmitCommand, mapGrpcSubmitCommandRequest, } from "./mappers/commands-mapper.js";
+import { mapGrpcGetContract, mapGrpcGetContractRequest, mapGrpcQueryContracts, mapGrpcQueryContractsRequest, } from "./mappers/contracts-mapper.js";
+import { mapGrpcCompletionStreamResponse, mapGrpcGetCompletionsRequest, } from "./mappers/command-completion-mapper.js";
+import { mapGrpcGetCommandStatus, mapGrpcGetCommandStatusRequest, } from "./mappers/command-inspection-mapper.js";
+import { mapGrpcGetEventsByContractId, mapGrpcGetEventsByContractIdRequest, } from "./mappers/event-query-mapper.js";
+import { mapGrpcCurrentTime, mapGrpcCurrentTimeRequest, mapGrpcGetId, mapGrpcGetIdRequest, } from "./mappers/identity-initialization-mapper.js";
+import { mapGrpcGetIdentityProviderConfig, mapGrpcGetIdentityProviderConfigRequest, mapGrpcListIdentityProviderConfigs, mapGrpcListIdentityProviderConfigsRequest, } from "./mappers/identity-provider-config-mapper.js";
+import { mapGrpcStreamTransactionsRequest, mapGrpcTransactionEvents, } from "./mappers/events-mapper.js";
+import { mapGrpcGetUpdateByHash, mapGrpcGetUpdateByHashRequest, mapGrpcGetUpdateById, mapGrpcGetUpdateByIdRequest, mapGrpcGetUpdateByOffset, mapGrpcGetUpdateByOffsetRequest, mapGrpcGetUpdatesPage, mapGrpcGetUpdatesPageRequest, } from "./mappers/update-read-mapper.js";
+import { mapGrpcListKnownPackages, mapGrpcListKnownPackagesRequest, mapGrpcGetPackage, mapGrpcGetPackageRequest, mapGrpcGetPackageStatus, mapGrpcGetPackageStatusRequest, mapGrpcGetParticipantPackageContents, mapGrpcGetParticipantPackageContentsRequest, mapGrpcGetParticipantDar, mapGrpcGetParticipantDarContents, mapGrpcGetParticipantDarContentsRequest, mapGrpcGetParticipantDarRequest, mapGrpcGetParticipantPackageReferences, mapGrpcGetParticipantPackageReferencesRequest, mapGrpcListParticipantDars, mapGrpcListParticipantDarsRequest, mapGrpcListPackages, mapGrpcListPackagesRequest, mapGrpcListVettedPackages, mapGrpcListVettedPackagesRequest, mapGrpcParticipantListPackages, mapGrpcParticipantListPackagesRequest, mapGrpcUploadPackage, mapGrpcUploadPackageRequest, } from "./mappers/packages-mapper.js";
+import { mapGrpcGetParticipantStatusRequest, mapGrpcParticipantStatusResponse, } from "./mappers/participant-status-mapper.js";
+import { mapGrpcCountInFlight, mapGrpcCountInFlightRequest, mapGrpcGetConfigForSlowCounterParticipants, mapGrpcGetConfigForSlowCounterParticipantsRequest, mapGrpcGetIntervalsBehindForCounterParticipants, mapGrpcGetIntervalsBehindForCounterParticipantsRequest, mapGrpcInspectCommitmentContracts, mapGrpcInspectCommitmentContractsRequest, mapGrpcLookupReceivedAcsCommitments, mapGrpcLookupReceivedAcsCommitmentsRequest, mapGrpcLookupOffsetByTime, mapGrpcLookupOffsetByTimeRequest, mapGrpcLookupSentAcsCommitments, mapGrpcLookupSentAcsCommitmentsRequest, mapGrpcOpenCommitment, mapGrpcOpenCommitmentRequest, } from "./mappers/participant-inspection-mapper.js";
+import { mapGrpcGetHighestOffsetByTimestamp, mapGrpcGetHighestOffsetByTimestampRequest, } from "./mappers/participant-party-management-mapper.js";
+import { mapGrpcListPendingOperations, mapGrpcListPendingOperationsRequest, } from "./mappers/participant-repair-mapper.js";
+import { mapGrpcGetNoWaitCommitmentsFrom, mapGrpcGetNoWaitCommitmentsFromRequest, mapGrpcGetParticipantPruningSchedule, mapGrpcGetParticipantPruningScheduleRequest, mapGrpcGetPruningSchedule, mapGrpcGetPruningScheduleRequest, mapGrpcGetSafePruningOffset, mapGrpcGetSafePruningOffsetRequest, } from "./mappers/pruning-mapper.js";
+import { mapGrpcGetSynchronizerId, mapGrpcGetSynchronizerIdRequest, mapGrpcListConnectedSynchronizers, mapGrpcListConnectedSynchronizersRequest, mapGrpcListRegisteredSynchronizers, mapGrpcListRegisteredSynchronizersRequest, } from "./mappers/synchronizer-connectivity-mapper.js";
+import { mapGrpcTrafficControlState, mapGrpcTrafficControlStateRequest, } from "./mappers/traffic-control-mapper.js";
+import { mapGrpcCreateParty, mapGrpcCreatePartyRequest, mapGrpcListParties, mapGrpcListPartiesRequest } from "./mappers/parties-mapper.js";
+import { mapGrpcGetParticipantId, mapGrpcGetParticipantIdRequest, mapGrpcGetParties, mapGrpcGetPartiesRequest } from "./mappers/parties-mapper.js";
+import { mapGrpcListKeyOwnersRequest, mapGrpcListKeyOwnersResponse, mapGrpcTopologyListPartiesRequest, mapGrpcTopologyListPartiesResponse, } from "./mappers/topology-aggregation-mapper.js";
+import { mapGrpcGetResourceLimits, mapGrpcGetResourceLimitsRequest, } from "./mappers/resource-management-mapper.js";
+import { mapGrpcGetConnectedSynchronizers, mapGrpcGetConnectedSynchronizersRequest, mapGrpcGetLatestPrunedOffsets, mapGrpcGetLatestPrunedOffsetsRequest, mapGrpcGetLedgerEnd, mapGrpcGetLedgerEndRequest, } from "./mappers/state-read-mapper.js";
+import { mapGrpcListAllRequest, mapGrpcListAllResponse, mapGrpcListAllV2Request, mapGrpcListAllV2Response, mapGrpcListAvailableStoresRequest, mapGrpcListAvailableStoresResponse, mapGrpcListDecentralizedNamespaceDefinitionRequest, mapGrpcListDecentralizedNamespaceDefinitionResponse, mapGrpcListLsuAnnouncementRequest, mapGrpcListLsuAnnouncementResponse, mapGrpcListLsuSequencerConnectionSuccessorRequest, mapGrpcListLsuSequencerConnectionSuccessorResponse, mapGrpcListMediatorSynchronizerStateRequest, mapGrpcListMediatorSynchronizerStateResponse, mapGrpcListNamespaceDelegationRequest, mapGrpcListNamespaceDelegationResponse, mapGrpcListOwnerToKeyMappingRequest, mapGrpcListOwnerToKeyMappingResponse, mapGrpcListParticipantSynchronizerPermissionRequest, mapGrpcListParticipantSynchronizerPermissionResponse, mapGrpcListPartyHostingLimitsRequest, mapGrpcListPartyHostingLimitsResponse, mapGrpcListPartyToKeyMappingRequest, mapGrpcListPartyToKeyMappingResponse, mapGrpcListPartyToParticipantRequest, mapGrpcListPartyToParticipantResponse, mapGrpcListSequencerSynchronizerStateRequest, mapGrpcListSequencerSynchronizerStateResponse, mapGrpcListSequencingParametersStateRequest, mapGrpcListSequencingParametersStateResponse, mapGrpcListSynchronizerParametersStateRequest, mapGrpcListSynchronizerParametersStateResponse, mapGrpcListSynchronizerTrustCertificateRequest, mapGrpcListSynchronizerTrustCertificateResponse, mapGrpcTopologyListVettedPackagesRequest, mapGrpcTopologyListVettedPackagesResponse, } from "./mappers/topology-manager-read-mapper.js";
+import { mapGrpcGetUser, mapGrpcGetUserRequest, mapGrpcGrantUserRights, mapGrpcGrantUserRightsRequest, mapGrpcListUserRights, mapGrpcListUserRightsRequest, mapGrpcListUsers, mapGrpcListUsersRequest, } from "./mappers/users-mapper.js";
+import { mapGrpcHealthCheckResponse } from "./mappers/health-mapper.js";
+import { ObjectDisposedError } from "../../core/errors/object-disposed-error.js";
+export class GrpcTransport {
+    operations;
+    disposed = false;
+    features = {
+        supportsCommandSigning: true,
+    };
+    constructor(operations) {
+        this.operations = operations;
+    }
+    async disposeAsync() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        await this.operations.disposeAsync?.();
+    }
+    async getLedgerApiVersionAsync(_request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getHealthAsync(options);
+        return new SdkGetLedgerApiVersionResponse({
+            version: payload.version ?? "",
+            features: "features" in payload
+                ? payload.features
+                : undefined,
+        });
+    }
+    async checkHealthAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.checkHealthAsync({
+            service: request.service ?? "",
+        }, options);
+        return mapGrpcHealthCheckResponse(payload);
+    }
+    async allocatePartyAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.createPartyAsync(mapGrpcCreatePartyRequest(request), options);
+        const response = mapGrpcCreateParty(payload);
+        return new SdkAllocatePartyResponse({
+            party: response.party,
+        });
+    }
+    async listKnownPartiesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listPartiesAsync(mapGrpcListPartiesRequest(request), options);
+        const response = mapGrpcListParties(payload);
+        return new SdkListKnownPartiesResponse({
+            partyDetails: [...response.partyDetails],
+            nextPageToken: response.nextPageToken,
+        });
+    }
+    async getParticipantIdAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantIdAsync(mapGrpcGetParticipantIdRequest(request), options);
+        return mapGrpcGetParticipantId(payload);
+    }
+    async getPartiesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getPartiesAsync(mapGrpcGetPartiesRequest(request), options);
+        return mapGrpcGetParties(payload);
+    }
+    async grantUserRightsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.grantUserRightsAsync(mapGrpcGrantUserRightsRequest(request), options);
+        return mapGrpcGrantUserRights(payload);
+    }
+    async getCommandStatusAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getCommandStatusAsync(mapGrpcGetCommandStatusRequest(request), options);
+        return mapGrpcGetCommandStatus(payload);
+    }
+    async getUserAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getUserAsync(mapGrpcGetUserRequest(request), options);
+        return mapGrpcGetUser(payload);
+    }
+    async listUsersAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listUsersAsync(mapGrpcListUsersRequest(request), options);
+        return mapGrpcListUsers(payload);
+    }
+    async listUserRightsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listUserRightsAsync(mapGrpcListUserRightsRequest(request), options);
+        return mapGrpcListUserRights(payload);
+    }
+    async uploadDarFileAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.uploadPackageAsync(mapGrpcUploadPackageRequest({
+            bytes: request.bytes,
+            format: PackageFormat.dar,
+        }), options);
+        const response = mapGrpcUploadPackage(payload);
+        return new SdkUploadDarFileResponse({
+            packageId: response.packageId,
+        });
+    }
+    async listPackagesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listPackagesAsync(mapGrpcListPackagesRequest(request), options);
+        return mapGrpcListPackages(payload);
+    }
+    async listKnownPackagesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listKnownPackagesAsync(mapGrpcListKnownPackagesRequest(request), options);
+        return mapGrpcListKnownPackages(payload);
+    }
+    async getIdentityProviderConfigAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getIdentityProviderConfigAsync(mapGrpcGetIdentityProviderConfigRequest(request), options);
+        return mapGrpcGetIdentityProviderConfig(payload);
+    }
+    async listIdentityProviderConfigsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listIdentityProviderConfigsAsync(mapGrpcListIdentityProviderConfigsRequest(request), options);
+        return mapGrpcListIdentityProviderConfigs(payload);
+    }
+    async getPackageAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getPackageAsync(mapGrpcGetPackageRequest(request), options);
+        return mapGrpcGetPackage(payload);
+    }
+    async getPackageStatusAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getPackageStatusAsync(mapGrpcGetPackageStatusRequest(request), options);
+        return mapGrpcGetPackageStatus(payload);
+    }
+    async listVettedPackagesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listVettedPackagesAsync(mapGrpcListVettedPackagesRequest(request), options);
+        return mapGrpcListVettedPackages(payload);
+    }
+    async listParticipantPackagesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listParticipantPackagesAsync(mapGrpcParticipantListPackagesRequest(request), options);
+        return mapGrpcParticipantListPackages(payload);
+    }
+    async getParticipantPackageContentsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantPackageContentsAsync(mapGrpcGetParticipantPackageContentsRequest(request), options);
+        return mapGrpcGetParticipantPackageContents(payload);
+    }
+    async getParticipantPackageReferencesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantPackageReferencesAsync(mapGrpcGetParticipantPackageReferencesRequest(request), options);
+        return mapGrpcGetParticipantPackageReferences(payload);
+    }
+    async getParticipantDarAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantDarAsync(mapGrpcGetParticipantDarRequest(request), options);
+        return mapGrpcGetParticipantDar(payload);
+    }
+    async listParticipantDarsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listParticipantDarsAsync(mapGrpcListParticipantDarsRequest(request), options);
+        return mapGrpcListParticipantDars(payload);
+    }
+    async getParticipantDarContentsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantDarContentsAsync(mapGrpcGetParticipantDarContentsRequest(request), options);
+        return mapGrpcGetParticipantDarContents(payload);
+    }
+    async getParticipantStatusAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantStatusAsync(mapGrpcGetParticipantStatusRequest(request), options);
+        return mapGrpcParticipantStatusResponse(payload);
+    }
+    async lookupOffsetByTimeAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.lookupOffsetByTimeAsync(mapGrpcLookupOffsetByTimeRequest(request), options);
+        return mapGrpcLookupOffsetByTime(payload);
+    }
+    async openCommitmentAsync(request, observer, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.openCommitmentAsync(mapGrpcOpenCommitmentRequest(request), options);
+        for (const item of payload) {
+            await observer.nextAsync(mapGrpcOpenCommitment(item));
+        }
+    }
+    async inspectCommitmentContractsAsync(request, observer, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.inspectCommitmentContractsAsync(mapGrpcInspectCommitmentContractsRequest(request), options);
+        for (const item of payload) {
+            await observer.nextAsync(mapGrpcInspectCommitmentContracts(item));
+        }
+    }
+    async countInFlightAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.countInFlightAsync(mapGrpcCountInFlightRequest(request), options);
+        return mapGrpcCountInFlight(payload);
+    }
+    async getConfigForSlowCounterParticipantsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getConfigForSlowCounterParticipantsAsync(mapGrpcGetConfigForSlowCounterParticipantsRequest(request), options);
+        return mapGrpcGetConfigForSlowCounterParticipants(payload);
+    }
+    async getIntervalsBehindForCounterParticipantsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getIntervalsBehindForCounterParticipantsAsync(mapGrpcGetIntervalsBehindForCounterParticipantsRequest(request), options);
+        return mapGrpcGetIntervalsBehindForCounterParticipants(payload);
+    }
+    async lookupSentAcsCommitmentsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.lookupSentAcsCommitmentsAsync(mapGrpcLookupSentAcsCommitmentsRequest(request), options);
+        return mapGrpcLookupSentAcsCommitments(payload);
+    }
+    async lookupReceivedAcsCommitmentsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.lookupReceivedAcsCommitmentsAsync(mapGrpcLookupReceivedAcsCommitmentsRequest(request), options);
+        return mapGrpcLookupReceivedAcsCommitments(payload);
+    }
+    async getHighestOffsetByTimestampAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getHighestOffsetByTimestampAsync(mapGrpcGetHighestOffsetByTimestampRequest(request), options);
+        return mapGrpcGetHighestOffsetByTimestamp(payload);
+    }
+    async getSafePruningOffsetAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getSafePruningOffsetAsync(mapGrpcGetSafePruningOffsetRequest(request), options);
+        return mapGrpcGetSafePruningOffset(payload);
+    }
+    async getPruningScheduleAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getPruningScheduleAsync(mapGrpcGetPruningScheduleRequest(request), options);
+        return mapGrpcGetPruningSchedule(payload);
+    }
+    async getParticipantPruningScheduleAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantPruningScheduleAsync(mapGrpcGetParticipantPruningScheduleRequest(request), options);
+        return mapGrpcGetParticipantPruningSchedule(payload);
+    }
+    async getNoWaitCommitmentsFromAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getNoWaitCommitmentsFromAsync(mapGrpcGetNoWaitCommitmentsFromRequest(request), options);
+        return mapGrpcGetNoWaitCommitmentsFrom(payload);
+    }
+    async trafficControlStateAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.trafficControlStateAsync(mapGrpcTrafficControlStateRequest(request), options);
+        return mapGrpcTrafficControlState(payload);
+    }
+    async listConnectedSynchronizersAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listConnectedSynchronizersAsync(mapGrpcListConnectedSynchronizersRequest(request), options);
+        return mapGrpcListConnectedSynchronizers(payload);
+    }
+    async getSynchronizerIdAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getSynchronizerIdAsync(mapGrpcGetSynchronizerIdRequest(request), options);
+        return mapGrpcGetSynchronizerId(payload);
+    }
+    async listRegisteredSynchronizersAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listRegisteredSynchronizersAsync(mapGrpcListRegisteredSynchronizersRequest(request), options);
+        return mapGrpcListRegisteredSynchronizers(payload);
+    }
+    async listPendingOperationsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listPendingOperationsAsync(mapGrpcListPendingOperationsRequest(request), options);
+        return mapGrpcListPendingOperations(payload);
+    }
+    async getResourceLimitsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getResourceLimitsAsync(mapGrpcGetResourceLimitsRequest(request), options);
+        return mapGrpcGetResourceLimits(payload);
+    }
+    async getIdAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getIdAsync(mapGrpcGetIdRequest(request), options);
+        return mapGrpcGetId(payload);
+    }
+    async currentTimeAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.currentTimeAsync(mapGrpcCurrentTimeRequest(request), options);
+        return mapGrpcCurrentTime(payload);
+    }
+    async getContractAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getContractAsync(mapGrpcGetContractRequest(request), options);
+        return mapGrpcGetContract(payload);
+    }
+    async getEventsByContractIdAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getEventsByContractIdAsync(mapGrpcGetEventsByContractIdRequest(request), options);
+        return mapGrpcGetEventsByContractId(payload);
+    }
+    async listNamespaceDelegationAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listNamespaceDelegationAsync(mapGrpcListNamespaceDelegationRequest(request), options);
+        return mapGrpcListNamespaceDelegationResponse(payload);
+    }
+    async listDecentralizedNamespaceDefinitionAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listDecentralizedNamespaceDefinitionAsync(mapGrpcListDecentralizedNamespaceDefinitionRequest(request), options);
+        return mapGrpcListDecentralizedNamespaceDefinitionResponse(payload);
+    }
+    async listOwnerToKeyMappingAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listOwnerToKeyMappingAsync(mapGrpcListOwnerToKeyMappingRequest(request), options);
+        return mapGrpcListOwnerToKeyMappingResponse(payload);
+    }
+    async listPartyToKeyMappingAsync(request, options) {
+        this.throwIfDisposed();
+        let payload;
+        try {
+            payload = await this.operations.listPartyToKeyMappingAsync(mapGrpcListPartyToKeyMappingRequest(request), options);
+        }
+        catch (error) {
+            this.throwPartyTopologyReadCompatibilityError(error, "topologyManagerReadService.listPartyToKeyMappingAsync");
+        }
+        return mapGrpcListPartyToKeyMappingResponse(payload);
+    }
+    async listSynchronizerTrustCertificateAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listSynchronizerTrustCertificateAsync(mapGrpcListSynchronizerTrustCertificateRequest(request), options);
+        return mapGrpcListSynchronizerTrustCertificateResponse(payload);
+    }
+    async listParticipantSynchronizerPermissionAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listParticipantSynchronizerPermissionAsync(mapGrpcListParticipantSynchronizerPermissionRequest(request), options);
+        return mapGrpcListParticipantSynchronizerPermissionResponse(payload);
+    }
+    async listPartyHostingLimitsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listPartyHostingLimitsAsync(mapGrpcListPartyHostingLimitsRequest(request), options);
+        return mapGrpcListPartyHostingLimitsResponse(payload);
+    }
+    async topologyListVettedPackagesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.topologyListVettedPackagesAsync(mapGrpcTopologyListVettedPackagesRequest(request), options);
+        return mapGrpcTopologyListVettedPackagesResponse(payload);
+    }
+    async listPartyToParticipantAsync(request, options) {
+        this.throwIfDisposed();
+        let payload;
+        try {
+            payload = await this.operations.listPartyToParticipantAsync(mapGrpcListPartyToParticipantRequest(request), options);
+        }
+        catch (error) {
+            this.throwPartyTopologyReadCompatibilityError(error, "topologyManagerReadService.listPartyToParticipantAsync");
+        }
+        return mapGrpcListPartyToParticipantResponse(payload);
+    }
+    async listSynchronizerParametersStateAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listSynchronizerParametersStateAsync(mapGrpcListSynchronizerParametersStateRequest(request), options);
+        return mapGrpcListSynchronizerParametersStateResponse(payload);
+    }
+    async listSequencingParametersStateAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listSequencingParametersStateAsync(mapGrpcListSequencingParametersStateRequest(request), options);
+        return mapGrpcListSequencingParametersStateResponse(payload);
+    }
+    async listMediatorSynchronizerStateAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listMediatorSynchronizerStateAsync(mapGrpcListMediatorSynchronizerStateRequest(request), options);
+        return mapGrpcListMediatorSynchronizerStateResponse(payload);
+    }
+    async listSequencerSynchronizerStateAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listSequencerSynchronizerStateAsync(mapGrpcListSequencerSynchronizerStateRequest(request), options);
+        return mapGrpcListSequencerSynchronizerStateResponse(payload);
+    }
+    async listLsuAnnouncementAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listLsuAnnouncementAsync(mapGrpcListLsuAnnouncementRequest(request), options);
+        return mapGrpcListLsuAnnouncementResponse(payload);
+    }
+    async listLsuSequencerConnectionSuccessorAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listLsuSequencerConnectionSuccessorAsync(mapGrpcListLsuSequencerConnectionSuccessorRequest(request), options);
+        return mapGrpcListLsuSequencerConnectionSuccessorResponse(payload);
+    }
+    async listAvailableStoresAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listAvailableStoresAsync(mapGrpcListAvailableStoresRequest(request), options);
+        return mapGrpcListAvailableStoresResponse(payload);
+    }
+    async listAllAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listAllAsync(mapGrpcListAllRequest(request), options);
+        return mapGrpcListAllResponse(payload);
+    }
+    async listAllV2Async(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listAllV2Async(mapGrpcListAllV2Request(request), options);
+        return mapGrpcListAllV2Response(payload);
+    }
+    async topologyListPartiesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.topologyListPartiesAsync(mapGrpcTopologyListPartiesRequest(request), options);
+        return mapGrpcTopologyListPartiesResponse(payload);
+    }
+    async listKeyOwnersAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listKeyOwnersAsync(mapGrpcListKeyOwnersRequest(request), options);
+        return mapGrpcListKeyOwnersResponse(payload);
+    }
+    async getActiveContractsPageAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.queryContractsAsync(mapGrpcQueryContractsRequest({
+            party: request.party,
+            templateId: request.templateId,
+        }), options);
+        const response = mapGrpcQueryContracts(payload);
+        return new GetActiveContractsPageResponse({
+            contracts: response.contracts,
+        });
+    }
+    async getConnectedSynchronizersAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getConnectedSynchronizersAsync(mapGrpcGetConnectedSynchronizersRequest(request), options);
+        return mapGrpcGetConnectedSynchronizers(payload);
+    }
+    async getLedgerEndAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getLedgerEndAsync(mapGrpcGetLedgerEndRequest(request), options);
+        return mapGrpcGetLedgerEnd(payload);
+    }
+    async getLatestPrunedOffsetsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getLatestPrunedOffsetsAsync(mapGrpcGetLatestPrunedOffsetsRequest(request), options);
+        return mapGrpcGetLatestPrunedOffsets(payload);
+    }
+    async getActiveContractsAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("StateService.GetActiveContracts is not supported by gRPC transport yet");
+    }
+    async getUpdatesAsync(request, observer, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.streamTransactionsAsync(mapGrpcStreamTransactionsRequest({
+            party: request.party,
+            beginOffset: request.beginOffset,
+            endOffset: request.endOffset,
+            templateId: request.templateId,
+        }), options);
+        const events = mapGrpcTransactionEvents(payload);
+        for (const event of events) {
+            await observer.nextAsync(event);
+        }
+    }
+    async getUpdateByOffsetAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getUpdateByOffsetAsync(mapGrpcGetUpdateByOffsetRequest(request), options);
+        return mapGrpcGetUpdateByOffset(payload);
+    }
+    async getUpdateByIdAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getUpdateByIdAsync(mapGrpcGetUpdateByIdRequest(request), options);
+        return mapGrpcGetUpdateById(payload);
+    }
+    async getUpdateByHashAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getUpdateByHashAsync(mapGrpcGetUpdateByHashRequest(request), options);
+        return mapGrpcGetUpdateByHash(payload);
+    }
+    async getUpdatesPageAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getUpdatesPageAsync(mapGrpcGetUpdatesPageRequest(request), options);
+        return mapGrpcGetUpdatesPage(payload);
+    }
+    async getCompletionsAsync(request, observer, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getCompletionsAsync(mapGrpcGetCompletionsRequest(request), options);
+        for (const response of payload) {
+            await observer.nextAsync(mapGrpcCompletionStreamResponse(response));
+        }
+    }
+    async submitCommandAsync(request, signed, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.submitCommandAsync(mapGrpcSubmitCommandRequest(request, signed), options);
+        return mapGrpcSubmitCommand(payload);
+    }
+    throwIfDisposed() {
+        if (this.disposed) {
+            throw new ObjectDisposedError("The client or transport has been disposed.");
+        }
+    }
+    throwPartyTopologyReadCompatibilityError(error, sdkMethodName) {
+        if (!this.isProtobufDeserializationFailure(error)) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new TransportError(`${sdkMethodName} failed while decoding a raw participant-admin party topology mapping response. `
+            + "This usually indicates a Canton/protobuf compatibility mismatch on low-level topology read payloads. "
+            + "For party-topology summary views, prefer topologyAggregationService.listPartiesAsync() "
+            + "and topologyAggregationService.listKeyOwnersAsync(). "
+            + `Original error: ${message}`);
+    }
+    isProtobufDeserializationFailure(error) {
+        if (!(error instanceof Error)) {
+            return false;
+        }
+        return error.message.includes("PROTO_DESERIALIZATION_FAILURE")
+            || error.message.includes("Deserialization of protobuf message failed");
+    }
+}
+export function createDefaultGrpcTransport(options, endpoint, grpcChannelSecurity) {
+    return new GrpcTransport(createGrpcOperations(options, endpoint, grpcChannelSecurity));
+}

package/dist/transports/grpc/mappers/admin-status-mapper.d.ts

@@ -0,0 +1,9 @@
+import { AdminComponentStatus } from "../../../core/types/admin-component-status.js";
+import { AdminNodeStatus } from "../../../core/types/admin-node-status.js";
+import { AdminNotInitializedStatus } from "../../../core/types/admin-not-initialized-status.js";
+import { AdminTopologyQueueStatus } from "../../../core/types/admin-topology-queue-status.js";
+import { ComponentStatus, NotInitialized, Status, TopologyQueueStatus } from "../generated/canton/com/digitalasset/canton/admin/health/v30/status_service.js";
+export declare function mapGrpcAdminNodeStatus(payload?: Partial<Status>): AdminNodeStatus;
+export declare function mapGrpcAdminNotInitializedStatus(payload?: Partial<NotInitialized>): AdminNotInitializedStatus;
+export declare function mapGrpcAdminTopologyQueueStatus(payload: Partial<TopologyQueueStatus>): AdminTopologyQueueStatus;
+export declare function mapGrpcAdminComponentStatus(payload: Partial<ComponentStatus>): AdminComponentStatus;

package/dist/transports/grpc/mappers/admin-status-mapper.js

@@ -0,0 +1,92 @@
+import { AdminComponentHealthKind } from "../../../core/types/admin-component-health-kind.js";
+import { AdminComponentStatus } from "../../../core/types/admin-component-status.js";
+import { AdminNodeStatus } from "../../../core/types/admin-node-status.js";
+import { AdminNotInitializedExternalInputKind } from "../../../core/types/admin-not-initialized-external-input-kind.js";
+import { AdminNotInitializedStatus } from "../../../core/types/admin-not-initialized-status.js";
+import { AdminTopologyQueueStatus } from "../../../core/types/admin-topology-queue-status.js";
+import { NotInitialized_WaitingForExternalInput, } from "../generated/canton/com/digitalasset/canton/admin/health/v30/status_service.js";
+export function mapGrpcAdminNodeStatus(payload) {
+    return new AdminNodeStatus({
+        uid: payload?.uid ?? "",
+        uptime: mapGrpcDuration(payload?.uptime),
+        ports: { ...(payload?.ports ?? {}) },
+        active: payload?.active ?? false,
+        topologyQueues: payload?.topologyQueues === undefined
+            ? undefined
+            : mapGrpcAdminTopologyQueueStatus(payload.topologyQueues),
+        components: (payload?.components ?? []).map((component) => mapGrpcAdminComponentStatus(component)),
+        version: payload?.version ?? "",
+    });
+}
+export function mapGrpcAdminNotInitializedStatus(payload) {
+    return new AdminNotInitializedStatus({
+        active: payload?.active ?? false,
+        waitingForExternalInput: mapGrpcAdminNotInitializedExternalInputKind(payload?.waitingForExternalInput),
+        version: payload?.version ?? "",
+    });
+}
+export function mapGrpcAdminTopologyQueueStatus(payload) {
+    return new AdminTopologyQueueStatus({
+        manager: payload.manager ?? 0,
+        dispatcher: payload.dispatcher ?? 0,
+        clients: payload.clients ?? 0,
+    });
+}
+export function mapGrpcAdminComponentStatus(payload) {
+    const statusKind = payload.status?.oneofKind;
+    return new AdminComponentStatus({
+        name: payload.name ?? "",
+        kind: mapGrpcAdminComponentHealthKind(statusKind),
+        description: mapGrpcAdminComponentDescription(payload),
+    });
+}
+function mapGrpcAdminComponentHealthKind(statusKind) {
+    switch (statusKind) {
+        case "ok":
+            return AdminComponentHealthKind.ok;
+        case "degraded":
+            return AdminComponentHealthKind.degraded;
+        case "failed":
+            return AdminComponentHealthKind.failed;
+        case "fatal":
+            return AdminComponentHealthKind.fatal;
+        default:
+            return AdminComponentHealthKind.unknown;
+    }
+}
+function mapGrpcAdminNotInitializedExternalInputKind(value) {
+    switch (value) {
+        case NotInitialized_WaitingForExternalInput.ID:
+            return AdminNotInitializedExternalInputKind.id;
+        case NotInitialized_WaitingForExternalInput.NODE_TOPOLOGY:
+            return AdminNotInitializedExternalInputKind.nodeTopology;
+        case NotInitialized_WaitingForExternalInput.INITIALIZATION:
+            return AdminNotInitializedExternalInputKind.initialization;
+        case NotInitialized_WaitingForExternalInput.UNSPECIFIED:
+        default:
+            return AdminNotInitializedExternalInputKind.unspecified;
+    }
+}
+function mapGrpcAdminComponentDescription(payload) {
+    switch (payload.status?.oneofKind) {
+        case "ok":
+            return payload.status.ok.description;
+        case "degraded":
+            return payload.status.degraded.description;
+        case "failed":
+            return payload.status.failed.description;
+        case "fatal":
+            return payload.status.fatal.description;
+        default:
+            return undefined;
+    }
+}
+function mapGrpcDuration(payload) {
+    if (payload === undefined || payload.seconds === undefined) {
+        return undefined;
+    }
+    return {
+        seconds: payload.seconds,
+        nanos: payload.nanos ?? 0,
+    };
+}