@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

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

@@ -0,0 +1,466 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonTransport = void 0;
+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 version_service_js_1 = require("../grpc/generated/canton/com/daml/ledger/api/v2/version_service.js");
+const object_disposed_error_js_1 = require("../../core/errors/object-disposed-error.js");
+const commands_mapper_js_1 = require("./mappers/commands-mapper.js");
+const package_management_service_js_1 = require("../grpc/generated/canton/com/daml/ledger/api/v2/admin/package_management_service.js");
+const parties_mapper_js_1 = require("./mappers/parties-mapper.js");
+const events_mapper_js_1 = require("./mappers/events-mapper.js");
+const users_mapper_js_1 = require("./mappers/users-mapper.js");
+class JsonTransport {
+    httpClient;
+    disposed = false;
+    features = {
+        supportsCommandSigning: false,
+    };
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async disposeAsync() {
+        this.disposed = true;
+    }
+    async getLedgerApiVersionAsync(_request, options) {
+        this.throwIfDisposed();
+        const payload = await this.httpClient.getAsync("/v2/version", options);
+        return version_service_js_1.GetLedgerApiVersionResponse.create({
+            version: payload.version
+                ?? "unknown",
+        });
+    }
+    async checkHealthAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("grpc.health.v1.Health.Check is not supported by json transport");
+    }
+    async allocatePartyAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.httpClient.postAsync("/v2/parties", (0, parties_mapper_js_1.mapJsonAllocatePartyRequest)(request), options);
+        const response = (0, parties_mapper_js_1.mapJsonCreateParty)(payload);
+        return new allocate_party_response_js_1.AllocatePartyResponse({
+            party: response.party,
+        });
+    }
+    async listKnownPartiesAsync(request, options) {
+        this.throwIfDisposed();
+        const query = new URLSearchParams();
+        if (request.identityProviderId) {
+            query.set("identity-provider-id", request.identityProviderId);
+        }
+        if (request.filterParty) {
+            query.set("filter-party", request.filterParty);
+        }
+        if (request.pageSize !== undefined) {
+            query.set("pageSize", request.pageSize.toString());
+        }
+        if (request.pageToken) {
+            query.set("pageToken", request.pageToken);
+        }
+        const path = query.size === 0 ? "/v2/parties" : `/v2/parties?${query.toString()}`;
+        const payload = await this.httpClient.getAsync(path, options);
+        const response = (0, parties_mapper_js_1.mapJsonListParties)(payload);
+        return new list_known_parties_response_js_1.ListKnownPartiesResponse({
+            partyDetails: [...response.partyDetails],
+            nextPageToken: response.nextPageToken,
+        });
+    }
+    async getParticipantIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PartyManagementService.GetParticipantId is not supported by json transport");
+    }
+    async getPartiesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PartyManagementService.GetParties is not supported by json transport");
+    }
+    async generateExternalPartyTopologyAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PartyManagementService.GenerateExternalPartyTopology is not supported by json transport");
+    }
+    async allocateExternalPartyAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PartyManagementService.AllocateExternalParty is not supported by json transport");
+    }
+    async grantUserRightsAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.httpClient.postAsync("/v1/user/rights/grant", {
+            userId: request.userId,
+            rights: request.rights.map((right) => {
+                switch (right.kind.oneofKind) {
+                    case "participantAdmin": return { type: "participantAdmin" };
+                    case "canActAs": return { type: "canActAs", party: right.kind.canActAs.party };
+                    case "canReadAs": return { type: "canReadAs", party: right.kind.canReadAs.party };
+                    case "identityProviderAdmin": return { type: "identityProviderAdmin" };
+                    case "canActAsAnyParty": return { type: "canActAsAnyParty" };
+                    case "canReadAsAnyParty": return { type: "canReadAsAnyParty" };
+                    case "canExecuteAs": return { type: "canExecuteAs", party: right.kind.canExecuteAs.party };
+                    case "canExecuteAsAnyParty": return { type: "canExecuteAsAnyParty" };
+                    default: throw new Error("unsupported protobuf user right");
+                }
+            }),
+        }, options);
+        return (0, users_mapper_js_1.mapJsonGrantRights)(payload);
+    }
+    async getCommandStatusAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("CommandInspectionService.GetCommandStatus is not supported by json transport");
+    }
+    async getUserAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("UserManagementService.GetUser is not supported by json transport");
+    }
+    async listUsersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("UserManagementService.ListUsers is not supported by json transport");
+    }
+    async listUserRightsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("UserManagementService.ListUserRights is not supported by json transport");
+    }
+    async uploadDarFileAsync(request, options) {
+        this.throwIfDisposed();
+        await this.httpClient.postAsync("/v1/packages", {
+            darFile: Array.from(request.darFile),
+            submissionId: request.submissionId,
+            vettingChange: request.vettingChange,
+            synchronizerId: request.synchronizerId,
+        }, options);
+        return package_management_service_js_1.UploadDarFileResponse.create();
+    }
+    async listPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PackageService.ListPackages is not supported by json transport");
+    }
+    async listKnownPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PackageManagementService.ListKnownPackages is not supported by json transport");
+    }
+    async getIdentityProviderConfigAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("IdentityProviderConfigService.GetIdentityProviderConfig is not supported by json transport");
+    }
+    async listIdentityProviderConfigsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("IdentityProviderConfigService.ListIdentityProviderConfigs is not supported by json transport");
+    }
+    async getPackageAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PackageService.GetPackage is not supported by json transport");
+    }
+    async getPackageStatusAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PackageService.GetPackageStatus is not supported by json transport");
+    }
+    async listVettedPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PackageService.ListVettedPackages is not supported by json transport");
+    }
+    async listParticipantPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("Participant PackageService.ListPackages is not supported by json transport");
+    }
+    async getParticipantPackageContentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("Participant PackageService.GetPackageContents is not supported by json transport");
+    }
+    async getParticipantPackageReferencesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("Participant PackageService.GetPackageReferences is not supported by json transport");
+    }
+    async getParticipantDarAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantPackageService.GetDar is not supported by json transport");
+    }
+    async listParticipantDarsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantPackageService.ListDars is not supported by json transport");
+    }
+    async getParticipantDarContentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantPackageService.GetDarContents is not supported by json transport");
+    }
+    async getParticipantStatusAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantStatusService.ParticipantStatus is not supported by json transport");
+    }
+    async lookupOffsetByTimeAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantInspectionService.LookupOffsetByTime is not supported by json transport");
+    }
+    async openCommitmentAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantInspectionService.OpenCommitment is not supported by json transport");
+    }
+    async inspectCommitmentContractsAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantInspectionService.InspectCommitmentContracts is not supported by json transport");
+    }
+    async countInFlightAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantInspectionService.CountInFlight is not supported by json transport");
+    }
+    async getConfigForSlowCounterParticipantsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantInspectionService.GetConfigForSlowCounterParticipants is not supported by json transport");
+    }
+    async getIntervalsBehindForCounterParticipantsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantInspectionService.GetIntervalsBehindForCounterParticipants is not supported by json transport");
+    }
+    async lookupSentAcsCommitmentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantInspectionService.LookupSentAcsCommitments is not supported by json transport");
+    }
+    async lookupReceivedAcsCommitmentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantInspectionService.LookupReceivedAcsCommitments is not supported by json transport");
+    }
+    async addPartyAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantPartyManagementService.AddPartyAsync is not supported by json transport");
+    }
+    async clearPartyOnboardingFlagAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantPartyManagementService.ClearPartyOnboardingFlag is not supported by json transport");
+    }
+    async getHighestOffsetByTimestampAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantPartyManagementService.GetHighestOffsetByTimestamp is not supported by json transport");
+    }
+    async getSafePruningOffsetAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PruningService.GetSafePruningOffset is not supported by json transport");
+    }
+    async getPruningScheduleAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PruningService.GetSchedule is not supported by json transport");
+    }
+    async getParticipantPruningScheduleAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PruningService.GetParticipantSchedule is not supported by json transport");
+    }
+    async getNoWaitCommitmentsFromAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("PruningService.GetNoWaitCommitmentsFrom is not supported by json transport");
+    }
+    async trafficControlStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TrafficControlService.TrafficControlState is not supported by json transport");
+    }
+    async listConnectedSynchronizersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("SynchronizerConnectivityService.ListConnectedSynchronizers is not supported by json transport");
+    }
+    async getSynchronizerIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("SynchronizerConnectivityService.GetSynchronizerId is not supported by json transport");
+    }
+    async listRegisteredSynchronizersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("SynchronizerConnectivityService.ListRegisteredSynchronizers is not supported by json transport");
+    }
+    async listPendingOperationsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ParticipantRepairService.ListPendingOperations is not supported by json transport");
+    }
+    async getResourceLimitsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ResourceManagementService.GetResourceLimits is not supported by json transport");
+    }
+    async getIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("IdentityInitializationService.GetId is not supported by json transport");
+    }
+    async currentTimeAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("IdentityInitializationService.CurrentTime is not supported by json transport");
+    }
+    async getContractAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("ContractService.GetContract is not supported by json transport");
+    }
+    async getEventsByContractIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("EventQueryService.GetEventsByContractId is not supported by json transport");
+    }
+    async listNamespaceDelegationAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListNamespaceDelegation is not supported by json transport");
+    }
+    async listDecentralizedNamespaceDefinitionAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListDecentralizedNamespaceDefinition is not supported by json transport");
+    }
+    async listOwnerToKeyMappingAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListOwnerToKeyMapping is not supported by json transport");
+    }
+    async listPartyToKeyMappingAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListPartyToKeyMapping is not supported by json transport");
+    }
+    async listSynchronizerTrustCertificateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListSynchronizerTrustCertificate is not supported by json transport");
+    }
+    async listParticipantSynchronizerPermissionAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListParticipantSynchronizerPermission is not supported by json transport");
+    }
+    async authorizeTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerWriteService.Authorize is not supported by json transport");
+    }
+    async addTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerWriteService.AddTransactions is not supported by json transport");
+    }
+    async importTopologySnapshotAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerWriteService.ImportTopologySnapshot is not supported by json transport");
+    }
+    async importTopologySnapshotV2Async(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerWriteService.ImportTopologySnapshotV2 is not supported by json transport");
+    }
+    async signTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerWriteService.SignTransactions is not supported by json transport");
+    }
+    async generateTopologyTransactionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerWriteService.GenerateTransactions is not supported by json transport");
+    }
+    async createTemporaryTopologyStoreAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerWriteService.CreateTemporaryTopologyStore is not supported by json transport");
+    }
+    async dropTemporaryTopologyStoreAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerWriteService.DropTemporaryTopologyStore is not supported by json transport");
+    }
+    async listPartyHostingLimitsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListPartyHostingLimits is not supported by json transport");
+    }
+    async topologyListVettedPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListVettedPackages is not supported by json transport");
+    }
+    async listPartyToParticipantAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListPartyToParticipant is not supported by json transport");
+    }
+    async listSynchronizerParametersStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListSynchronizerParametersState is not supported by json transport");
+    }
+    async listSequencingParametersStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListSequencingParametersState is not supported by json transport");
+    }
+    async listMediatorSynchronizerStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListMediatorSynchronizerState is not supported by json transport");
+    }
+    async listSequencerSynchronizerStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListSequencerSynchronizerState is not supported by json transport");
+    }
+    async listLsuAnnouncementAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListLsuAnnouncement is not supported by json transport");
+    }
+    async listLsuSequencerConnectionSuccessorAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListLsuSequencerConnectionSuccessor is not supported by json transport");
+    }
+    async listAvailableStoresAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListAvailableStores is not supported by json transport");
+    }
+    async listAllAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListAll is not supported by json transport");
+    }
+    async listAllV2Async(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyManagerReadService.ListAllV2 is not supported by json transport");
+    }
+    async topologyListPartiesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyAggregationService.ListParties is not supported by json transport");
+    }
+    async listKeyOwnersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("TopologyAggregationService.ListKeyOwners is not supported by json transport");
+    }
+    async getActiveContractsPageAsync(request, options) {
+        this.throwIfDisposed();
+        void request;
+        void options;
+        throw new not_supported_error_js_1.NotSupportedError("StateService.GetActiveContractsPage is not supported by json transport");
+    }
+    async getConnectedSynchronizersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("StateService.GetConnectedSynchronizers is not supported by json transport");
+    }
+    async getLedgerEndAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("StateService.GetLedgerEnd is not supported by json transport");
+    }
+    async getLatestPrunedOffsetsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("StateService.GetLatestPrunedOffsets is not supported by json transport");
+    }
+    async getActiveContractsAsync(request, observer, options) {
+        this.throwIfDisposed();
+        const payload = await this.httpClient.postAsync("/v1/stream/query", {
+            party: request.party,
+            templateIds: request.templateId ? [request.templateId] : [],
+        }, options);
+        const events = (0, events_mapper_js_1.mapJsonTransactionEvents)(payload);
+        for (const event of events) {
+            await observer.nextAsync(event);
+        }
+    }
+    getUpdatesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("UpdateService.GetUpdates is gRPC-only; JSON supports StateService.getActiveContractsAsync instead");
+    }
+    async getUpdateByOffsetAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("UpdateService.GetUpdateByOffset is not supported by json transport");
+    }
+    async getUpdateByIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("UpdateService.GetUpdateById is not supported by json transport");
+    }
+    async getUpdateByHashAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("UpdateService.GetUpdateByHash is not supported by json transport");
+    }
+    async getUpdatesPageAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("UpdateService.GetUpdatesPage is not supported by json transport");
+    }
+    getCompletionsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new not_supported_error_js_1.NotSupportedError("CommandCompletionService.GetCompletions is not supported by json transport");
+    }
+    async submitCommandAsync(request, signer, options) {
+        this.throwIfDisposed();
+        if (signer) {
+            throw new not_supported_error_js_1.NotSupportedError("command signing is not supported by json transport");
+        }
+        const payload = await this.httpClient.postAsync("/v2/commands/submit-and-wait", (0, commands_mapper_js_1.mapJsonSubmitCommandRequest)(request), options);
+        return (0, commands_mapper_js_1.mapJsonSubmitCommand)(payload);
+    }
+    throwIfDisposed() {
+        if (this.disposed) {
+            throw new object_disposed_error_js_1.ObjectDisposedError("The client or transport has been disposed.");
+        }
+    }
+}
+exports.JsonTransport = JsonTransport;

package/dist/cjs/transports/json/mappers/commands-mapper.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapJsonSubmitCommandRequest = mapJsonSubmitCommandRequest;
+exports.mapJsonSubmitCommand = mapJsonSubmitCommand;
+const node_crypto_1 = require("node:crypto");
+const validation_error_js_1 = require("../../../core/errors/validation-error.js");
+const create_and_exercise_command_js_1 = require("../../../core/types/commands/create-and-exercise-command.js");
+const create_command_js_1 = require("../../../core/types/commands/create-command.js");
+const daml_numeric_js_1 = require("../../../core/types/daml-numeric.js");
+const daml_party_js_1 = require("../../../core/types/daml-party.js");
+const daml_values_js_1 = require("../../../core/types/daml-values.js");
+const exercise_by_key_command_js_1 = require("../../../core/types/commands/exercise-by-key-command.js");
+const exercise_command_js_1 = require("../../../core/types/commands/exercise-command.js");
+const submit_command_response_js_1 = require("../../../core/types/responses/submit-command-response.js");
+function mapJsonSubmitCommandRequest(request) {
+    return {
+        commandId: (0, node_crypto_1.randomUUID)(),
+        actAs: request.actAs,
+        readAs: request.readAs,
+        commands: [mapJsonCommand(request.command)],
+        applicationId: request.applicationId || undefined,
+    };
+}
+function mapJsonSubmitCommand(payload) {
+    return new submit_command_response_js_1.SubmitCommandResponse({
+        commandId: payload.result?.commandId ?? payload.commandId,
+        transactionId: payload.result?.transactionId
+            ?? payload.result?.updateId
+            ?? payload.transactionId
+            ?? payload.updateId,
+    });
+}
+function mapJsonCommand(command) {
+    if (command instanceof create_command_js_1.CreateCommand) {
+        return {
+            CreateCommand: {
+                templateId: formatTemplateId(command.templateId),
+                createArguments: mapJsonValue(command.createArguments.fields),
+            },
+        };
+    }
+    else if (command instanceof exercise_command_js_1.ExerciseCommand) {
+        return {
+            ExerciseCommand: {
+                templateId: formatTemplateId(command.templateId),
+                contractId: command.contractId,
+                choice: command.choice,
+                choiceArgument: mapJsonValue(command.choiceArgument),
+            },
+        };
+    }
+    else if (command instanceof exercise_by_key_command_js_1.ExerciseByKeyCommand) {
+        return {
+            ExerciseByKeyCommand: {
+                templateId: formatTemplateId(command.templateId),
+                contractKey: mapJsonValue(command.contractKey),
+                choice: command.choice,
+                choiceArgument: mapJsonValue(command.choiceArgument),
+            },
+        };
+    }
+    else if (command instanceof create_and_exercise_command_js_1.CreateAndExerciseCommand) {
+        return {
+            CreateAndExerciseCommand: {
+                templateId: formatTemplateId(command.templateId),
+                createArguments: mapJsonValue(command.createArguments.fields),
+                choice: command.choice,
+                choiceArgument: mapJsonValue(command.choiceArgument),
+            },
+        };
+    }
+    throw new validation_error_js_1.ValidationError("unsupported submit command type");
+}
+function mapJsonValue(value) {
+    if (value instanceof daml_party_js_1.DamlParty || value instanceof daml_numeric_js_1.DamlNumeric) {
+        return value.value;
+    }
+    else if (value instanceof daml_values_js_1.DamlRecord) {
+        return mapJsonValue(value.fields);
+    }
+    else if (Array.isArray(value)) {
+        return value.map(mapJsonValue);
+    }
+    else if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, mapJsonValue(item)]));
+    }
+    return value;
+}
+function formatTemplateId(templateId) {
+    return templateId.packageId.length === 0
+        ? `${templateId.moduleName}:${templateId.entityName}`
+        : `${templateId.packageId}:${templateId.moduleName}:${templateId.entityName}`;
+}

package/dist/cjs/transports/json/mappers/contracts-mapper.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapJsonQueryContracts = mapJsonQueryContracts;
+const query_contracts_response_js_1 = require("../../../core/types/responses/query-contracts-response.js");
+function mapJsonQueryContracts(payload) {
+    return new query_contracts_response_js_1.QueryContractsResponse({
+        contracts: payload.result ?? [],
+    });
+}

package/dist/cjs/transports/json/mappers/events-mapper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapJsonTransactionEvents = mapJsonTransactionEvents;
+function mapJsonTransactionEvents(payload) {
+    return payload.events ?? [];
+}

package/dist/cjs/transports/json/mappers/packages-mapper.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapJsonUploadPackage = mapJsonUploadPackage;
+const upload_package_response_js_1 = require("../../../core/types/responses/upload-package-response.js");
+function mapJsonUploadPackage(payload) {
+    return new upload_package_response_js_1.UploadPackageResponse({
+        packageId: payload.result?.packageId ?? payload.packageId,
+    });
+}

package/dist/cjs/transports/json/mappers/parties-mapper.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapJsonCreateParty = mapJsonCreateParty;
+exports.mapJsonAllocatePartyRequest = mapJsonAllocatePartyRequest;
+exports.mapJsonListParties = mapJsonListParties;
+const create_party_response_js_1 = require("../../../core/types/responses/create-party-response.js");
+const list_parties_response_js_1 = require("../../../core/types/responses/list-parties-response.js");
+const party_details_js_1 = require("../../../core/types/party-details.js");
+function mapJsonCreateParty(payload) {
+    return new create_party_response_js_1.CreatePartyResponse({
+        party: payload.result?.partyDetails?.party
+            ?? payload.partyDetails?.party
+            ?? "",
+    });
+}
+function mapJsonAllocatePartyRequest(request) {
+    return {
+        partyIdHint: request.partyIdHint,
+        localMetadata: request.displayName === undefined
+            ? undefined
+            : {
+                attributes: {
+                    displayName: request.displayName,
+                },
+            },
+    };
+}
+function mapJsonListParties(payload) {
+    return new list_parties_response_js_1.ListPartiesResponse({
+        partyDetails: (payload.partyDetails ?? []).map(item => new party_details_js_1.PartyDetails({
+            party: item.party ?? "",
+            isLocal: item.isLocal ?? false,
+            localMetadata: item.localMetadata?.attributes,
+            identityProviderId: item.identityProviderId,
+        })),
+        nextPageToken: payload.nextPageToken,
+    });
+}

package/dist/cjs/transports/json/mappers/system-mapper.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapJsonHealth = mapJsonHealth;
+const health_status_response_js_1 = require("../../../core/types/responses/health-status-response.js");
+function mapJsonHealth(payload) {
+    return new health_status_response_js_1.HealthStatusResponse({
+        status: payload.status ?? "unknown",
+        version: payload.version,
+    });
+}

package/dist/cjs/transports/json/mappers/users-mapper.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapJsonGrantRights = mapJsonGrantRights;
+exports.mapJsonRight = mapJsonRight;
+const user_management_service_js_1 = require("../../grpc/generated/canton/com/daml/ledger/api/v2/admin/user_management_service.js");
+function mapJsonGrantRights(payload) {
+    return user_management_service_js_1.GrantUserRightsResponse.create({
+        newlyGrantedRights: (payload.result ?? []).map(mapJsonRight),
+    });
+}
+function mapJsonRight(right) {
+    switch (right.type) {
+        case "participantAdmin": return { kind: { oneofKind: "participantAdmin", participantAdmin: {} } };
+        case "canActAs": return { kind: { oneofKind: "canActAs", canActAs: { party: right.party ?? "" } } };
+        case "canReadAs": return { kind: { oneofKind: "canReadAs", canReadAs: { party: right.party ?? "" } } };
+        case "identityProviderAdmin": return { kind: { oneofKind: "identityProviderAdmin", identityProviderAdmin: {} } };
+        case "canActAsAnyParty": return { kind: { oneofKind: "canActAsAnyParty", canActAsAnyParty: {} } };
+        case "canReadAsAnyParty": return { kind: { oneofKind: "canReadAsAnyParty", canReadAsAnyParty: {} } };
+        case "canExecuteAs": return { kind: { oneofKind: "canExecuteAs", canExecuteAs: { party: right.party ?? "" } } };
+        case "canExecuteAsAnyParty": return { kind: { oneofKind: "canExecuteAsAnyParty", canExecuteAsAnyParty: {} } };
+        default: throw new Error(`unsupported JSON user right '${right.type}'`);
+    }
+}