@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/transports/grpc/grpc-ledger-client.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcLedgerClient = void 0;
+const command_service_client_js_1 = require("../../services/command/command-service-client.js");
+const command_completion_service_client_js_1 = require("../../services/command-completion/command-completion-service-client.js");
+const command_submission_service_client_js_1 = require("../../services/command-submission/command-submission-service-client.js");
+const contract_service_client_js_1 = require("../../services/contract/contract-service-client.js");
+const event_query_service_client_js_1 = require("../../services/event-query/event-query-service-client.js");
+const health_service_client_js_1 = require("../../services/health/health-service-client.js");
+const package_management_service_client_js_1 = require("../../services/package-management/package-management-service-client.js");
+const package_service_client_js_1 = require("../../services/package/package-service-client.js");
+const participant_inspection_service_client_js_1 = require("../../services/participant-inspection/participant-inspection-service-client.js");
+const participant_party_management_service_client_js_1 = require("../../services/participant-party-management/participant-party-management-service-client.js");
+const participant_package_service_client_js_1 = require("../../services/participant-package/participant-package-service-client.js");
+const participant_repair_service_client_js_1 = require("../../services/participant-repair/participant-repair-service-client.js");
+const participant_status_service_client_js_1 = require("../../services/participant-status/participant-status-service-client.js");
+const party_management_service_client_js_1 = require("../../services/party-management/party-management-service-client.js");
+const pruning_service_client_js_1 = require("../../services/pruning/pruning-service-client.js");
+const state_service_client_js_1 = require("../../services/state/state-service-client.js");
+const synchronizer_connectivity_service_client_js_1 = require("../../services/synchronizer-connectivity/synchronizer-connectivity-service-client.js");
+const traffic_control_service_client_js_1 = require("../../services/traffic-control/traffic-control-service-client.js");
+const update_service_client_js_1 = require("../../services/update/update-service-client.js");
+const user_management_service_client_js_1 = require("../../services/user-management/user-management-service-client.js");
+const version_service_client_js_1 = require("../../services/version/version-service-client.js");
+const grpc_transport_js_1 = require("./grpc-transport.js");
+class GrpcLedgerClient {
+    versionService;
+    healthService;
+    partyManagementService;
+    userManagementService;
+    packageService;
+    packageManagementService;
+    participantPackageService;
+    participantInspectionService;
+    participantPartyManagementService;
+    participantRepairService;
+    participantStatusService;
+    pruningService;
+    synchronizerConnectivityService;
+    trafficControlService;
+    commandService;
+    commandSubmissionService;
+    commandCompletionService;
+    stateService;
+    updateService;
+    eventQueryService;
+    contractService;
+    constructor(operations, signer) {
+        const transport = new grpc_transport_js_1.GrpcTransport(operations);
+        this.versionService = new version_service_client_js_1.VersionServiceClient(transport);
+        this.healthService = new health_service_client_js_1.HealthServiceClient(transport);
+        this.partyManagementService = new party_management_service_client_js_1.PartyManagementServiceClient(transport);
+        this.userManagementService = new user_management_service_client_js_1.UserManagementServiceClient(transport);
+        this.packageService = new package_service_client_js_1.PackageServiceClient(transport);
+        this.packageManagementService = new package_management_service_client_js_1.PackageManagementServiceClient(transport);
+        this.participantPackageService = new participant_package_service_client_js_1.ParticipantPackageServiceClient(transport);
+        this.participantInspectionService =
+            new participant_inspection_service_client_js_1.ParticipantInspectionServiceClient(transport);
+        this.participantPartyManagementService =
+            new participant_party_management_service_client_js_1.ParticipantPartyManagementServiceClient(transport);
+        this.participantRepairService = new participant_repair_service_client_js_1.ParticipantRepairServiceClient(transport);
+        this.participantStatusService = new participant_status_service_client_js_1.ParticipantStatusServiceClient(transport);
+        this.pruningService = new pruning_service_client_js_1.PruningServiceClient(transport);
+        this.synchronizerConnectivityService =
+            new synchronizer_connectivity_service_client_js_1.SynchronizerConnectivityServiceClient(transport);
+        this.trafficControlService = new traffic_control_service_client_js_1.TrafficControlServiceClient(transport);
+        this.commandService = new command_service_client_js_1.CommandServiceClient(transport, signer);
+        this.commandSubmissionService = new command_submission_service_client_js_1.CommandSubmissionServiceClient(transport);
+        this.commandCompletionService = new command_completion_service_client_js_1.CommandCompletionServiceClient(transport);
+        this.stateService = new state_service_client_js_1.StateServiceClient(transport);
+        this.updateService = new update_service_client_js_1.UpdateServiceClient(transport);
+        this.eventQueryService = new event_query_service_client_js_1.EventQueryServiceClient(transport);
+        this.contractService = new contract_service_client_js_1.ContractServiceClient(transport);
+    }
+}
+exports.GrpcLedgerClient = GrpcLedgerClient;

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGrpcTransport = createGrpcTransport;
+const grpc_transport_js_1 = require("./grpc-transport.js");
+function createGrpcTransport(options, endpoint, grpcChannelSecurity) {
+    return (0, grpc_transport_js_1.createDefaultGrpcTransport)(options, endpoint, grpcChannelSecurity);
+}

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

@@ -0,0 +1,574 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcTransport = void 0;
+exports.createDefaultGrpcTransport = createDefaultGrpcTransport;
+const node_crypto_1 = require("node:crypto");
+const validation_error_js_1 = require("../../core/errors/validation-error.js");
+const sign_command_request_js_1 = require("../../core/signing/sign-command-request.js");
+const prepared_command_submission_js_1 = require("../../core/types/prepared-command-submission.js");
+const allocate_party_response_js_1 = require("../../core/types/responses/allocate-party-response.js");
+const list_known_parties_response_js_1 = require("../../core/types/responses/list-known-parties-response.js");
+const not_supported_error_js_1 = require("../../core/errors/not-supported-error.js");
+const transport_error_js_1 = require("../../core/errors/transport-error.js");
+const grpc_channel_factory_js_1 = require("./grpc-channel-factory.js");
+const commands_mapper_js_1 = require("./mappers/commands-mapper.js");
+const interactive_command_mapper_js_1 = require("./mappers/interactive-command-mapper.js");
+const parties_mapper_js_1 = require("./mappers/parties-mapper.js");
+const object_disposed_error_js_1 = require("../../core/errors/object-disposed-error.js");
+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 payload;
+    }
+    async checkHealthAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.checkHealthAsync(request, options);
+    }
+    async allocatePartyAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.createPartyAsync((0, parties_mapper_js_1.mapGrpcCreatePartyRequest)(request), options);
+        const response = (0, parties_mapper_js_1.mapGrpcCreateParty)(payload);
+        return new allocate_party_response_js_1.AllocatePartyResponse({
+            party: response.party,
+        });
+    }
+    async listKnownPartiesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listPartiesAsync((0, parties_mapper_js_1.mapGrpcListPartiesRequest)(request), options);
+        const response = (0, parties_mapper_js_1.mapGrpcListParties)(payload);
+        return new list_known_parties_response_js_1.ListKnownPartiesResponse({
+            partyDetails: [...response.partyDetails],
+            nextPageToken: response.nextPageToken,
+        });
+    }
+    async generateExternalPartyTopologyAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.generateExternalPartyTopologyAsync(request, options);
+        return payload;
+    }
+    async allocateExternalPartyAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.allocateExternalPartyAsync(request, options);
+        return payload;
+    }
+    async getParticipantIdAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantIdAsync(request, options);
+        return payload;
+    }
+    async getPartiesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getPartiesAsync(request, options);
+        return payload;
+    }
+    async grantUserRightsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.grantUserRightsAsync(request, options);
+        return payload;
+    }
+    async getCommandStatusAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.getCommandStatusAsync(request, options));
+    }
+    async getUserAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.getUserAsync(request, options));
+    }
+    async listUsersAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.listUsersAsync(request, options));
+    }
+    async listUserRightsAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.listUserRightsAsync(request, options));
+    }
+    async uploadDarFileAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.uploadPackageAsync(request, options));
+    }
+    async listPackagesAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.listPackagesAsync(request, options));
+    }
+    async listKnownPackagesAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.listKnownPackagesAsync(request, options));
+    }
+    async getIdentityProviderConfigAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getIdentityProviderConfigAsync(request, options);
+        return payload;
+    }
+    async listIdentityProviderConfigsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listIdentityProviderConfigsAsync(request, options);
+        return payload;
+    }
+    async getPackageAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.getPackageAsync(request, options));
+    }
+    async getPackageStatusAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.getPackageStatusAsync(request, options));
+    }
+    async listVettedPackagesAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.listVettedPackagesAsync(request, options));
+    }
+    async listParticipantPackagesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listParticipantPackagesAsync(request, options);
+        return payload;
+    }
+    async getParticipantPackageContentsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantPackageContentsAsync(request, options);
+        return payload;
+    }
+    async getParticipantPackageReferencesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantPackageReferencesAsync(request, options);
+        return payload;
+    }
+    async getParticipantDarAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantDarAsync(request, options);
+        return payload;
+    }
+    async listParticipantDarsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listParticipantDarsAsync(request, options);
+        return payload;
+    }
+    async getParticipantDarContentsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantDarContentsAsync(request, options);
+        return payload;
+    }
+    async getParticipantStatusAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantStatusAsync(request, options);
+        return payload;
+    }
+    async lookupOffsetByTimeAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.lookupOffsetByTimeAsync(request, options);
+        return payload;
+    }
+    async openCommitmentAsync(request, observer, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.openCommitmentAsync(request, options);
+        for (const item of payload) {
+            await observer.nextAsync(item);
+        }
+    }
+    async inspectCommitmentContractsAsync(request, observer, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.inspectCommitmentContractsAsync(request, options);
+        for (const item of payload) {
+            await observer.nextAsync(item);
+        }
+    }
+    async countInFlightAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.countInFlightAsync(request, options);
+        return payload;
+    }
+    async getConfigForSlowCounterParticipantsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getConfigForSlowCounterParticipantsAsync(request, options);
+        return payload;
+    }
+    async getIntervalsBehindForCounterParticipantsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getIntervalsBehindForCounterParticipantsAsync(request, options);
+        return payload;
+    }
+    async lookupSentAcsCommitmentsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.lookupSentAcsCommitmentsAsync(request, options);
+        return payload;
+    }
+    async lookupReceivedAcsCommitmentsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.lookupReceivedAcsCommitmentsAsync(request, options);
+        return payload;
+    }
+    async addPartyAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.addPartyAsync(request, options);
+        return payload;
+    }
+    async clearPartyOnboardingFlagAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.clearPartyOnboardingFlagAsync(request, options);
+        return payload;
+    }
+    async getHighestOffsetByTimestampAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getHighestOffsetByTimestampAsync(request, options);
+        return payload;
+    }
+    async getSafePruningOffsetAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getSafePruningOffsetAsync(request, options);
+        return payload;
+    }
+    async getPruningScheduleAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getPruningScheduleAsync(request, options);
+        return payload;
+    }
+    async getParticipantPruningScheduleAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getParticipantPruningScheduleAsync(request, options);
+        return payload;
+    }
+    async getNoWaitCommitmentsFromAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.getNoWaitCommitmentsFromAsync(request, options);
+        return payload;
+    }
+    async trafficControlStateAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.trafficControlStateAsync(request, options);
+    }
+    async listConnectedSynchronizersAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.listConnectedSynchronizersAsync(request, options);
+    }
+    async getSynchronizerIdAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.getSynchronizerIdAsync(request, options);
+    }
+    async listRegisteredSynchronizersAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.listRegisteredSynchronizersAsync(request, options);
+    }
+    async listPendingOperationsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listPendingOperationsAsync(request, options);
+        return payload;
+    }
+    async getResourceLimitsAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.getResourceLimitsAsync(request, options);
+    }
+    async getIdAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.getIdAsync(request, options);
+    }
+    async currentTimeAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.currentTimeAsync(request, options);
+    }
+    async getContractAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.getContractAsync(request, options);
+    }
+    async getEventsByContractIdAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.getEventsByContractIdAsync(request, options);
+    }
+    async listNamespaceDelegationAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listNamespaceDelegationAsync(request, options);
+        return payload;
+    }
+    async listDecentralizedNamespaceDefinitionAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listDecentralizedNamespaceDefinitionAsync(request, options);
+        return payload;
+    }
+    async listOwnerToKeyMappingAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listOwnerToKeyMappingAsync(request, options);
+        return payload;
+    }
+    async listPartyToKeyMappingAsync(request, options) {
+        this.throwIfDisposed();
+        let payload;
+        try {
+            payload = await this.operations.listPartyToKeyMappingAsync(request, options);
+        }
+        catch (error) {
+            this.throwPartyTopologyReadCompatibilityError(error, "topologyManagerReadService.listPartyToKeyMappingAsync");
+        }
+        return payload;
+    }
+    async listSynchronizerTrustCertificateAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listSynchronizerTrustCertificateAsync(request, options);
+        return payload;
+    }
+    async listParticipantSynchronizerPermissionAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listParticipantSynchronizerPermissionAsync(request, options);
+        return payload;
+    }
+    async authorizeTopologyTransactionsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.authorizeTopologyTransactionsAsync(request, options);
+        return payload;
+    }
+    async addTopologyTransactionsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.addTopologyTransactionsAsync(request, options);
+        return payload;
+    }
+    async importTopologySnapshotAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.importTopologySnapshotAsync(request, options);
+        return payload;
+    }
+    async importTopologySnapshotV2Async(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.importTopologySnapshotV2Async(request, options);
+        return payload;
+    }
+    async signTopologyTransactionsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.signTopologyTransactionsAsync(request, options);
+        return payload;
+    }
+    async generateTopologyTransactionsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.generateTopologyTransactionsAsync(request, options);
+        return payload;
+    }
+    async createTemporaryTopologyStoreAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.createTemporaryTopologyStoreAsync(request, options);
+        return payload;
+    }
+    async dropTemporaryTopologyStoreAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.dropTemporaryTopologyStoreAsync(request, options);
+        return payload;
+    }
+    async listPartyHostingLimitsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listPartyHostingLimitsAsync(request, options);
+        return payload;
+    }
+    async topologyListVettedPackagesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.topologyListVettedPackagesAsync(request, options);
+        return payload;
+    }
+    async listPartyToParticipantAsync(request, options) {
+        this.throwIfDisposed();
+        let payload;
+        try {
+            payload = await this.operations.listPartyToParticipantAsync(request, options);
+        }
+        catch (error) {
+            this.throwPartyTopologyReadCompatibilityError(error, "topologyManagerReadService.listPartyToParticipantAsync");
+        }
+        return payload;
+    }
+    async listSynchronizerParametersStateAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listSynchronizerParametersStateAsync(request, options);
+        return payload;
+    }
+    async listSequencingParametersStateAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listSequencingParametersStateAsync(request, options);
+        return payload;
+    }
+    async listMediatorSynchronizerStateAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listMediatorSynchronizerStateAsync(request, options);
+        return payload;
+    }
+    async listSequencerSynchronizerStateAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listSequencerSynchronizerStateAsync(request, options);
+        return payload;
+    }
+    async listLsuAnnouncementAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listLsuAnnouncementAsync(request, options);
+        return payload;
+    }
+    async listLsuSequencerConnectionSuccessorAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listLsuSequencerConnectionSuccessorAsync(request, options);
+        return payload;
+    }
+    async listAvailableStoresAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listAvailableStoresAsync(request, options);
+        return payload;
+    }
+    async listAllAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listAllAsync(request, options);
+        return payload;
+    }
+    async listAllV2Async(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listAllV2Async(request, options);
+        return payload;
+    }
+    async topologyListPartiesAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.topologyListPartiesAsync(request, options);
+        return payload;
+    }
+    async listKeyOwnersAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.operations.listKeyOwnersAsync(request, options);
+        return payload;
+    }
+    async getActiveContractsPageAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.getActiveContractsPageAsync(request, options));
+    }
+    async getConnectedSynchronizersAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.getConnectedSynchronizersAsync(request, options));
+    }
+    async getLedgerEndAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.getLedgerEndAsync(request, options));
+    }
+    async getLatestPrunedOffsetsAsync(request, options) {
+        this.throwIfDisposed();
+        return (await this.operations.getLatestPrunedOffsetsAsync(request, options));
+    }
+    async getActiveContractsAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("StateService.GetActiveContracts is not supported by gRPC transport yet");
+    }
+    getUpdatesAsync(request, options) {
+        this.throwIfDisposed();
+        return this.operations.getUpdatesAsync(request, options);
+    }
+    async getUpdateByOffsetAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.getUpdateByOffsetAsync(request, options);
+    }
+    async getUpdateByIdAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.getUpdateByIdAsync(request, options);
+    }
+    async getUpdateByHashAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.getUpdateByHashAsync(request, options);
+    }
+    async getUpdatesPageAsync(request, options) {
+        this.throwIfDisposed();
+        return await this.operations.getUpdatesPageAsync(request, options);
+    }
+    getCompletionsAsync(request, options) {
+        this.throwIfDisposed();
+        return this.operations.getCompletionsAsync(request, options);
+    }
+    async submitCommandAsync(request, signer, options) {
+        this.throwIfDisposed();
+        if (!signer) {
+            const payload = await this.operations.submitCommandAsync((0, commands_mapper_js_1.mapGrpcSubmitCommandRequest)(request), options);
+            return (0, commands_mapper_js_1.mapGrpcSubmitCommand)(payload);
+        }
+        else if (request.actAs.length !== 1 && !("signAsync" in signer)) {
+            throw new validation_error_js_1.ValidationError("interactive gRPC command signing currently requires exactly one actAs party");
+        }
+        else if (!this.operations.prepareSubmissionAsync) {
+            throw new not_supported_error_js_1.NotSupportedError("interactive gRPC command signing is not available on this transport");
+        }
+        else if (!this.operations.executeSubmissionAndWaitAsync) {
+            throw new not_supported_error_js_1.NotSupportedError("interactive gRPC command signing is not available on this transport");
+        }
+        const commandId = (0, node_crypto_1.randomUUID)();
+        const submissionId = (0, node_crypto_1.randomUUID)();
+        const prepared = await this.operations.prepareSubmissionAsync((0, interactive_command_mapper_js_1.mapGrpcPrepareSubmissionRequest)(request, commandId), options);
+        if (!prepared.preparedTransaction) {
+            throw new validation_error_js_1.ValidationError("interactive prepare submission did not return a preparedTransaction");
+        }
+        else if (prepared.preparedTransactionHash.length === 0) {
+            throw new validation_error_js_1.ValidationError("interactive prepare submission did not return a preparedTransactionHash");
+        }
+        const signerResults = await Promise.all(request.actAs.map(async (party) => {
+            const partySigner = "signAsync" in signer ? signer : signer[party];
+            if (partySigner === undefined)
+                throw new validation_error_js_1.ValidationError(`interactive command signing requires a signer for ${party}`);
+            return { party, result: await partySigner.signAsync(new sign_command_request_js_1.SignCommandRequest({ payload: prepared.preparedTransactionHash, party, algorithmHint: "ed25519" })) };
+        }));
+        const executed = await this.operations.executeSubmissionAndWaitAsync((0, interactive_command_mapper_js_1.mapGrpcExecuteSubmissionAndWaitRequest)({
+            request,
+            preparedTransaction: prepared.preparedTransaction,
+            hashingSchemeVersion: prepared.hashingSchemeVersion,
+            submissionId,
+            signerResults,
+        }), options);
+        return (0, interactive_command_mapper_js_1.mapGrpcInteractiveSubmitCommand)(executed);
+    }
+    async submitCommandForTransactionAsync(request, options) {
+        this.throwIfDisposed();
+        if (!this.operations.submitCommandForTransactionAsync)
+            throw new not_supported_error_js_1.NotSupportedError("transaction-returning command submission is not available on this transport");
+        return (0, commands_mapper_js_1.mapGrpcSubmitCommandTransaction)(await this.operations.submitCommandForTransactionAsync((0, commands_mapper_js_1.mapGrpcSubmitCommandForTransactionRequest)(request), options));
+    }
+    async prepareCommandAsync(request, options) {
+        if (!this.operations.prepareSubmissionAsync)
+            throw new not_supported_error_js_1.NotSupportedError("interactive gRPC command signing is not available on this transport");
+        const prepared = await this.operations.prepareSubmissionAsync((0, interactive_command_mapper_js_1.mapGrpcPrepareSubmissionRequest)(request, (0, node_crypto_1.randomUUID)()), options);
+        if (!prepared.preparedTransaction || prepared.preparedTransactionHash.length === 0)
+            throw new validation_error_js_1.ValidationError("interactive prepare submission returned an incomplete result");
+        return new prepared_command_submission_js_1.PreparedCommandSubmission(request, prepared.preparedTransaction, prepared.preparedTransactionHash, prepared.hashingSchemeVersion);
+    }
+    async executePreparedCommandAndWaitAsync(prepared, signatures, options) {
+        if (!this.operations.executeSubmissionAndWaitAsync)
+            throw new not_supported_error_js_1.NotSupportedError("interactive gRPC command signing is not available on this transport");
+        const signerResults = prepared.request.actAs.map((party) => { const result = signatures[party]; if (!result)
+            throw new validation_error_js_1.ValidationError(`interactive command signing requires a signature for ${party}`); return { party, result }; });
+        const result = await this.operations.executeSubmissionAndWaitAsync((0, interactive_command_mapper_js_1.mapGrpcExecuteSubmissionAndWaitRequest)({ request: prepared.request, preparedTransaction: prepared.transaction, hashingSchemeVersion: prepared.hashingSchemeVersion, submissionId: (0, node_crypto_1.randomUUID)(), signerResults }), options);
+        return (0, interactive_command_mapper_js_1.mapGrpcInteractiveSubmitCommand)(result);
+    }
+    throwIfDisposed() {
+        if (this.disposed) {
+            throw new object_disposed_error_js_1.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 transport_error_js_1.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");
+    }
+}
+exports.GrpcTransport = GrpcTransport;
+function createDefaultGrpcTransport(options, endpoint, grpcChannelSecurity) {
+    return new GrpcTransport((0, grpc_channel_factory_js_1.createGrpcOperations)(options, endpoint, grpcChannelSecurity));
+}