@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/transports/grpc/grpc-channel-factory.js

@@ -0,0 +1,595 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGrpcOperations = createGrpcOperations;
+const grpc_transport_1 = require("@protobuf-ts/grpc-transport");
+const grpc_transport_error_js_1 = require("../../core/errors/grpc-transport-error.js");
+const package_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/admin/participant/v30/package_service.client.js");
+const party_management_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/admin/participant/v30/party_management_service.client.js");
+const participant_inspection_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/admin/participant/v30/participant_inspection_service.client.js");
+const participant_repair_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/admin/participant/v30/participant_repair_service.client.js");
+const pruning_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/admin/participant/v30/pruning_service.client.js");
+const resource_management_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/admin/participant/v30/resource_management_service.client.js");
+const participant_status_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/admin/participant/v30/participant_status_service.client.js");
+const synchronizer_connectivity_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/admin/participant/v30/synchronizer_connectivity_service.client.js");
+const traffic_control_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/admin/participant/v30/traffic_control_service.client.js");
+const initialization_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/topology/admin/v30/initialization_service.client.js");
+const topology_aggregation_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/topology/admin/v30/topology_aggregation_service.client.js");
+const topology_manager_read_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/topology/admin/v30/topology_manager_read_service.client.js");
+const topology_manager_write_service_client_js_1 = require("./generated/canton/com/digitalasset/canton/topology/admin/v30/topology_manager_write_service.client.js");
+const command_inspection_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/admin/command_inspection_service.client.js");
+const identity_provider_config_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/admin/identity_provider_config_service.client.js");
+const package_management_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/admin/package_management_service.client.js");
+const package_service_client_js_2 = require("./generated/canton/com/daml/ledger/api/v2/package_service.client.js");
+const party_management_service_client_js_2 = require("./generated/canton/com/daml/ledger/api/v2/admin/party_management_service.client.js");
+const user_management_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/admin/user_management_service.client.js");
+const version_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/version_service.client.js");
+const command_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/command_service.client.js");
+const interactive_submission_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/interactive/interactive_submission_service.client.js");
+const command_completion_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/command_completion_service.client.js");
+const contract_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/contract_service.client.js");
+const event_query_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/event_query_service.client.js");
+const state_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/state_service.client.js");
+const update_service_client_js_1 = require("./generated/canton/com/daml/ledger/api/v2/update_service.client.js");
+const health_client_js_1 = require("./generated/canton/google/grpc/health/v1/health.client.js");
+const grpc_call_options_factory_js_1 = require("./grpc-call-options-factory.js");
+function createGrpcOperations(options, endpoint, grpcChannelSecurity, dependencies = {}) {
+    const rpcTransport = new grpc_transport_1.GrpcTransport({
+        host: normalizeGrpcHost(endpoint),
+        channelCredentials: (0, grpc_call_options_factory_js_1.createGrpcChannelCredentials)(grpcChannelSecurity, options.grpcTlsRootCertificates),
+        clientOptions: options.grpcConnectTimeoutMs === undefined
+            ? undefined
+            : {
+                connectTimeoutMs: options.grpcConnectTimeoutMs,
+            },
+    });
+    const versionServiceClient = dependencies.versionServiceClient ?? new version_service_client_js_1.VersionServiceClient(rpcTransport);
+    const healthClient = dependencies.healthClient ?? new health_client_js_1.HealthClient(rpcTransport);
+    const partyManagementServiceClient = dependencies.partyManagementServiceClient
+        ?? new party_management_service_client_js_2.PartyManagementServiceClient(rpcTransport);
+    const userManagementServiceClient = dependencies.userManagementServiceClient
+        ?? new user_management_service_client_js_1.UserManagementServiceClient(rpcTransport);
+    const commandInspectionServiceClient = dependencies.commandInspectionServiceClient
+        ?? new command_inspection_service_client_js_1.CommandInspectionServiceClient(rpcTransport);
+    const identityProviderConfigServiceClient = dependencies.identityProviderConfigServiceClient
+        ?? new identity_provider_config_service_client_js_1.IdentityProviderConfigServiceClient(rpcTransport);
+    const packageManagementServiceClient = dependencies.packageManagementServiceClient
+        ?? new package_management_service_client_js_1.PackageManagementServiceClient(rpcTransport);
+    const ledgerPackageServiceClient = dependencies.ledgerPackageServiceClient
+        ?? new package_service_client_js_2.PackageServiceClient(rpcTransport);
+    const participantPackageServiceClient = dependencies.participantPackageServiceClient
+        ?? new package_service_client_js_1.PackageServiceClient(rpcTransport);
+    const participantInspectionServiceClient = dependencies.participantInspectionServiceClient
+        ?? new participant_inspection_service_client_js_1.ParticipantInspectionServiceClient(rpcTransport);
+    const participantPartyManagementServiceClient = dependencies.participantPartyManagementServiceClient
+        ?? new party_management_service_client_js_1.PartyManagementServiceClient(rpcTransport);
+    const participantRepairServiceClient = dependencies.participantRepairServiceClient
+        ?? new participant_repair_service_client_js_1.ParticipantRepairServiceClient(rpcTransport);
+    const pruningServiceClient = dependencies.pruningServiceClient
+        ?? new pruning_service_client_js_1.PruningServiceClient(rpcTransport);
+    const participantStatusServiceClient = dependencies.participantStatusServiceClient
+        ?? new participant_status_service_client_js_1.ParticipantStatusServiceClient(rpcTransport);
+    const resourceManagementServiceClient = dependencies.resourceManagementServiceClient
+        ?? new resource_management_service_client_js_1.ResourceManagementServiceClient(rpcTransport);
+    const identityInitializationServiceClient = dependencies.identityInitializationServiceClient
+        ?? new initialization_service_client_js_1.IdentityInitializationServiceClient(rpcTransport);
+    const synchronizerConnectivityServiceClient = dependencies.synchronizerConnectivityServiceClient
+        ?? new synchronizer_connectivity_service_client_js_1.SynchronizerConnectivityServiceClient(rpcTransport);
+    const trafficControlServiceClient = dependencies.trafficControlServiceClient
+        ?? new traffic_control_service_client_js_1.TrafficControlServiceClient(rpcTransport);
+    const topologyManagerReadServiceClient = dependencies.topologyManagerReadServiceClient
+        ?? new topology_manager_read_service_client_js_1.TopologyManagerReadServiceClient(rpcTransport);
+    const topologyManagerWriteServiceClient = dependencies.topologyManagerWriteServiceClient
+        ?? new topology_manager_write_service_client_js_1.TopologyManagerWriteServiceClient(rpcTransport);
+    const topologyAggregationServiceClient = dependencies.topologyAggregationServiceClient
+        ?? new topology_aggregation_service_client_js_1.TopologyAggregationServiceClient(rpcTransport);
+    const contractServiceClient = dependencies.contractServiceClient
+        ?? new contract_service_client_js_1.ContractServiceClient(rpcTransport);
+    const eventQueryServiceClient = dependencies.eventQueryServiceClient
+        ?? new event_query_service_client_js_1.EventQueryServiceClient(rpcTransport);
+    const stateServiceClient = dependencies.stateServiceClient ?? new state_service_client_js_1.StateServiceClient(rpcTransport);
+    const updateServiceClient = dependencies.updateServiceClient ?? new update_service_client_js_1.UpdateServiceClient(rpcTransport);
+    const commandCompletionServiceClient = dependencies.commandCompletionServiceClient
+        ?? new command_completion_service_client_js_1.CommandCompletionServiceClient(rpcTransport);
+    const interactiveSubmissionServiceClient = dependencies.interactiveSubmissionServiceClient
+        ?? new interactive_submission_service_client_js_1.InteractiveSubmissionServiceClient(rpcTransport);
+    const commandServiceClient = dependencies.commandServiceClient
+        ?? new command_service_client_js_1.CommandServiceClient(rpcTransport);
+    const operations = {
+        async disposeAsync() {
+            rpcTransport.close();
+        },
+        async checkHealthAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(healthClient.check(request, callOptions));
+        },
+        async getHealthAsync(requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(versionServiceClient.getLedgerApiVersion({}, callOptions));
+        },
+        async createPartyAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(partyManagementServiceClient.allocateParty(request, callOptions));
+        },
+        async listPartiesAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(partyManagementServiceClient.listKnownParties(request, callOptions));
+        },
+        async generateExternalPartyTopologyAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(partyManagementServiceClient.generateExternalPartyTopology(request, callOptions));
+        },
+        async allocateExternalPartyAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(partyManagementServiceClient.allocateExternalParty(request, callOptions));
+        },
+        async getParticipantIdAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(partyManagementServiceClient.getParticipantId(request, callOptions));
+        },
+        async getPartiesAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(partyManagementServiceClient.getParties(request, callOptions));
+        },
+        async grantUserRightsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(userManagementServiceClient.grantUserRights(request, callOptions));
+        },
+        async getCommandStatusAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(commandInspectionServiceClient.getCommandStatus(request, callOptions));
+        },
+        async getUserAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(userManagementServiceClient.getUser(request, callOptions));
+        },
+        async listUsersAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(userManagementServiceClient.listUsers(request, callOptions));
+        },
+        async listUserRightsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(userManagementServiceClient.listUserRights(request, callOptions));
+        },
+        async uploadPackageAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(packageManagementServiceClient.uploadDarFile(request, callOptions));
+        },
+        async listKnownPackagesAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(packageManagementServiceClient.listKnownPackages(request, callOptions));
+        },
+        async getIdentityProviderConfigAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(identityProviderConfigServiceClient.getIdentityProviderConfig(request, callOptions));
+        },
+        async listIdentityProviderConfigsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(identityProviderConfigServiceClient.listIdentityProviderConfigs(request, callOptions));
+        },
+        async listPackagesAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(ledgerPackageServiceClient.listPackages(request, callOptions));
+        },
+        async getPackageAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(ledgerPackageServiceClient.getPackage(request, callOptions));
+        },
+        async getPackageStatusAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(ledgerPackageServiceClient.getPackageStatus(request, callOptions));
+        },
+        async listVettedPackagesAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(ledgerPackageServiceClient.listVettedPackages(request, callOptions));
+        },
+        async listParticipantPackagesAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantPackageServiceClient.listPackages(request, callOptions));
+        },
+        async getParticipantPackageContentsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantPackageServiceClient.getPackageContents(request, callOptions));
+        },
+        async getParticipantPackageReferencesAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantPackageServiceClient.getPackageReferences(request, callOptions));
+        },
+        async getParticipantDarAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantPackageServiceClient.getDar(request, callOptions));
+        },
+        async listParticipantDarsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantPackageServiceClient.listDars(request, callOptions));
+        },
+        async getParticipantDarContentsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantPackageServiceClient.getDarContents(request, callOptions));
+        },
+        async getParticipantStatusAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantStatusServiceClient.participantStatus(request, callOptions));
+        },
+        async lookupOffsetByTimeAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantInspectionServiceClient.lookupOffsetByTime(request, callOptions));
+        },
+        async openCommitmentAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await collectServerResponsesAsync(participantInspectionServiceClient.openCommitment(request, callOptions));
+        },
+        async inspectCommitmentContractsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await collectServerResponsesAsync(participantInspectionServiceClient.inspectCommitmentContracts(request, callOptions));
+        },
+        async countInFlightAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantInspectionServiceClient.countInFlight(request, callOptions));
+        },
+        async getConfigForSlowCounterParticipantsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantInspectionServiceClient.getConfigForSlowCounterParticipants(request, callOptions));
+        },
+        async getIntervalsBehindForCounterParticipantsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantInspectionServiceClient.getIntervalsBehindForCounterParticipants(request, callOptions));
+        },
+        async lookupSentAcsCommitmentsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantInspectionServiceClient.lookupSentAcsCommitments(request, callOptions));
+        },
+        async lookupReceivedAcsCommitmentsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantInspectionServiceClient.lookupReceivedAcsCommitments(request, callOptions));
+        },
+        async addPartyAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantPartyManagementServiceClient.addPartyAsync(request, callOptions));
+        },
+        async clearPartyOnboardingFlagAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantPartyManagementServiceClient.clearPartyOnboardingFlag(request, callOptions));
+        },
+        async getHighestOffsetByTimestampAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantPartyManagementServiceClient.getHighestOffsetByTimestamp(request, callOptions));
+        },
+        async getSafePruningOffsetAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(pruningServiceClient.getSafePruningOffset(request, callOptions));
+        },
+        async getPruningScheduleAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(pruningServiceClient.getSchedule(request, callOptions));
+        },
+        async getParticipantPruningScheduleAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(pruningServiceClient.getParticipantSchedule(request, callOptions));
+        },
+        async getNoWaitCommitmentsFromAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(pruningServiceClient.getNoWaitCommitmentsFrom(request, callOptions));
+        },
+        async trafficControlStateAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(trafficControlServiceClient.trafficControlState(request, callOptions));
+        },
+        async listConnectedSynchronizersAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(synchronizerConnectivityServiceClient.listConnectedSynchronizers(request, callOptions));
+        },
+        async getSynchronizerIdAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(synchronizerConnectivityServiceClient.getSynchronizerId(request, callOptions));
+        },
+        async listRegisteredSynchronizersAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(synchronizerConnectivityServiceClient.listRegisteredSynchronizers(request, callOptions));
+        },
+        async listPendingOperationsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(participantRepairServiceClient.listPendingOperations(request, callOptions));
+        },
+        async getResourceLimitsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(resourceManagementServiceClient.getResourceLimits(request, callOptions));
+        },
+        async getIdAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(identityInitializationServiceClient.getId(request, callOptions));
+        },
+        async currentTimeAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(identityInitializationServiceClient.currentTime(request, callOptions));
+        },
+        async listNamespaceDelegationAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listNamespaceDelegation(request, callOptions));
+        },
+        async listDecentralizedNamespaceDefinitionAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listDecentralizedNamespaceDefinition(request, callOptions));
+        },
+        async listOwnerToKeyMappingAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listOwnerToKeyMapping(request, callOptions));
+        },
+        async listPartyToKeyMappingAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listPartyToKeyMapping(request, callOptions));
+        },
+        async listSynchronizerTrustCertificateAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listSynchronizerTrustCertificate(request, callOptions));
+        },
+        async listParticipantSynchronizerPermissionAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listParticipantSynchronizerPermission(request, callOptions));
+        },
+        async listPartyHostingLimitsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listPartyHostingLimits(request, callOptions));
+        },
+        async topologyListVettedPackagesAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listVettedPackages(request, callOptions));
+        },
+        async listPartyToParticipantAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listPartyToParticipant(request, callOptions));
+        },
+        async listSynchronizerParametersStateAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listSynchronizerParametersState(request, callOptions));
+        },
+        async listSequencingParametersStateAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listSequencingParametersState(request, callOptions));
+        },
+        async listMediatorSynchronizerStateAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listMediatorSynchronizerState(request, callOptions));
+        },
+        async listSequencerSynchronizerStateAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listSequencerSynchronizerState(request, callOptions));
+        },
+        async listLsuAnnouncementAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listLsuAnnouncement(request, callOptions));
+        },
+        async listLsuSequencerConnectionSuccessorAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listLsuSequencerConnectionSuccessor(request, callOptions));
+        },
+        async listAvailableStoresAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listAvailableStores(request, callOptions));
+        },
+        async listAllAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listAll(request, callOptions));
+        },
+        async listAllV2Async(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerReadServiceClient.listAllV2(request, callOptions));
+        },
+        async authorizeTopologyTransactionsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.authorize(request, callOptions));
+        },
+        async addTopologyTransactionsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.addTransactions(request, callOptions));
+        },
+        async importTopologySnapshotAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await sendClientStreamRequestAndReadResponseAsync(topologyManagerWriteServiceClient.importTopologySnapshot(callOptions), request);
+        },
+        async importTopologySnapshotV2Async(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await sendClientStreamRequestAndReadResponseAsync(topologyManagerWriteServiceClient.importTopologySnapshotV2(callOptions), request);
+        },
+        async signTopologyTransactionsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.signTransactions(request, callOptions));
+        },
+        async generateTopologyTransactionsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.generateTransactions(request, callOptions));
+        },
+        async createTemporaryTopologyStoreAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.createTemporaryTopologyStore(request, callOptions));
+        },
+        async dropTemporaryTopologyStoreAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyManagerWriteServiceClient.dropTemporaryTopologyStore(request, callOptions));
+        },
+        async topologyListPartiesAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyAggregationServiceClient.listParties(request, callOptions));
+        },
+        async listKeyOwnersAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(topologyAggregationServiceClient.listKeyOwners(request, callOptions));
+        },
+        async getContractAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(contractServiceClient.getContract(request, callOptions));
+        },
+        async getEventsByContractIdAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(eventQueryServiceClient.getEventsByContractId(request, callOptions));
+        },
+        async queryContractsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(stateServiceClient.getActiveContractsPage(request, callOptions));
+        },
+        async getActiveContractsPageAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(stateServiceClient.getActiveContractsPage(request, callOptions));
+        },
+        async getConnectedSynchronizersAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(stateServiceClient.getConnectedSynchronizers(request, callOptions));
+        },
+        async getLedgerEndAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(stateServiceClient.getLedgerEnd(request, callOptions));
+        },
+        async getLatestPrunedOffsetsAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(stateServiceClient.getLatestPrunedOffsets(request, callOptions));
+        },
+        getUpdatesAsync(request, requestOptions) {
+            return streamServerResponsesAsync(async () => ({
+                call: updateServiceClient.getUpdates(request, await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions)),
+            }));
+        },
+        async getUpdateByOffsetAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(updateServiceClient.getUpdateByOffset(request, callOptions));
+        },
+        async getUpdateByIdAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(updateServiceClient.getUpdateById(request, callOptions));
+        },
+        async getUpdateByHashAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(updateServiceClient.getUpdateByHash(request, callOptions));
+        },
+        async getUpdatesPageAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(updateServiceClient.getUpdatesPage(request, callOptions));
+        },
+        getCompletionsAsync(request, requestOptions) {
+            return streamServerResponsesAsync(async () => ({
+                call: commandCompletionServiceClient.getCompletions(request, await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions)),
+            }));
+        },
+        async submitCommandAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(commandServiceClient.submitAndWait(request, callOptions));
+        },
+        async submitCommandForTransactionAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(commandServiceClient.submitAndWaitForTransaction(request, callOptions));
+        },
+        async prepareSubmissionAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(interactiveSubmissionServiceClient.prepareSubmission(request, callOptions));
+        },
+        async executeSubmissionAndWaitAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(interactiveSubmissionServiceClient.executeSubmissionAndWait(request, callOptions));
+        },
+    };
+    return wrapGrpcOperations(operations, options.onGrpcError);
+}
+async function buildCallOptionsForLedgerSurfaceAsync(options, requestOptions) {
+    return (0, grpc_call_options_factory_js_1.buildGrpcCallOptionsAsync)(options.ledgerAuthProvider, options.defaultRequestTimeoutMs, requestOptions);
+}
+async function buildCallOptionsForLedgerAdminSurfaceAsync(options, requestOptions) {
+    return (0, grpc_call_options_factory_js_1.buildGrpcCallOptionsAsync)(options.ledgerAdminAuthProvider, options.defaultRequestTimeoutMs, requestOptions);
+}
+async function buildCallOptionsForParticipantAdminSurfaceAsync(options, requestOptions) {
+    return (0, grpc_call_options_factory_js_1.buildGrpcCallOptionsAsync)(options.participantAdminAuthProvider, options.defaultRequestTimeoutMs, requestOptions);
+}
+function normalizeGrpcHost(endpoint) {
+    if (endpoint.includes("://")) {
+        return new URL(endpoint).host;
+    }
+    return endpoint;
+}
+function wrapGrpcOperations(operations, onGrpcError) {
+    return new Proxy(operations, {
+        get(target, property, receiver) {
+            const operation = Reflect.get(target, property, receiver);
+            if (typeof operation !== "function") {
+                return operation;
+            }
+            if (property === "getUpdatesAsync" || property === "getCompletionsAsync") {
+                return (...args) => wrapGrpcStream(() => operation.apply(target, args), onGrpcError);
+            }
+            return async (...args) => {
+                try {
+                    return await operation.apply(target, args);
+                }
+                catch (error) {
+                    const parsedError = grpc_transport_error_js_1.GrpcTransportError.fromUnknown(error);
+                    if (parsedError === undefined) {
+                        throw error;
+                    }
+                    try {
+                        onGrpcError?.(parsedError);
+                    }
+                    catch {
+                        // Error observers must not replace the RPC failure.
+                    }
+                    throw parsedError;
+                }
+            };
+        },
+    });
+}
+async function* wrapGrpcStream(createStream, onGrpcError) {
+    try {
+        for await (const response of createStream()) {
+            yield response;
+        }
+    }
+    catch (error) {
+        throw notifyGrpcError(error, onGrpcError);
+    }
+}
+function notifyGrpcError(error, onGrpcError) {
+    const parsedError = grpc_transport_error_js_1.GrpcTransportError.fromUnknown(error);
+    if (parsedError === undefined)
+        return error;
+    try {
+        onGrpcError?.(parsedError);
+    }
+    catch { /* observers do not replace failures */ }
+    return parsedError;
+}
+async function unwrapUnaryResponse(call) {
+    return await call.response;
+}
+async function sendClientStreamRequestAndReadResponseAsync(call, request) {
+    await call.requests.send(request);
+    await call.requests.complete();
+    return await call.response;
+}
+async function collectServerResponsesAsync(call) {
+    const responses = [];
+    for await (const response of call.responses) {
+        responses.push(response);
+    }
+    await call.status;
+    return responses;
+}
+async function* streamServerResponsesAsync(createCall) {
+    let call;
+    let exhausted = false;
+    let iterator;
+    try {
+        ({ call } = await createCall());
+        const responseIterator = call.responses[Symbol.asyncIterator]();
+        iterator = responseIterator;
+        while (true) {
+            const next = await responseIterator.next();
+            if (next.done)
+                break;
+            yield next.value;
+        }
+        exhausted = true;
+        await call.status;
+    }
+    finally {
+        if (!exhausted && call !== undefined) {
+            await iterator?.return?.();
+            void call.status?.catch(() => undefined);
+        }
+    }
+}