@distrohelena/canton-typescript-sdk 0.1.0

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

@@ -0,0 +1,422 @@
+import { AllocatePartyResponse } from "../../core/types/responses/allocate-party-response.js";
+import { GetActiveContractsPageResponse } from "../../core/types/responses/get-active-contracts-page-response.js";
+import { GetLedgerApiVersionResponse } from "../../core/types/responses/get-ledger-api-version-response.js";
+import { ListKnownPartiesResponse } from "../../core/types/responses/list-known-parties-response.js";
+import { UploadDarFileResponse } from "../../core/types/responses/upload-dar-file-response.js";
+import { NotSupportedError } from "../../core/errors/not-supported-error.js";
+import { ObjectDisposedError } from "../../core/errors/object-disposed-error.js";
+import { mapJsonSubmitCommand } from "./mappers/commands-mapper.js";
+import { mapJsonUploadPackage } from "./mappers/packages-mapper.js";
+import { mapJsonCreateParty, mapJsonListParties } from "./mappers/parties-mapper.js";
+import { mapJsonQueryContracts } from "./mappers/contracts-mapper.js";
+import { mapJsonTransactionEvents } from "./mappers/events-mapper.js";
+import { mapJsonGrantRights } from "./mappers/users-mapper.js";
+export 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("/livez", options);
+        return new GetLedgerApiVersionResponse({
+            version: payload.version
+                ?? "unknown",
+        });
+    }
+    async checkHealthAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("grpc.health.v1.Health.Check is not supported by json transport");
+    }
+    async allocatePartyAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.httpClient.postAsync("/v1/parties/allocate", {
+            identifierHint: request.partyIdHint,
+            displayName: request.displayName,
+        }, options);
+        const response = mapJsonCreateParty(payload);
+        return new 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 = mapJsonListParties(payload);
+        return new ListKnownPartiesResponse({
+            partyDetails: [...response.partyDetails],
+            nextPageToken: response.nextPageToken,
+        });
+    }
+    async getParticipantIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PartyManagementService.GetParticipantId is not supported by json transport");
+    }
+    async getPartiesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PartyManagementService.GetParties 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) => ({
+                type: right.type,
+                party: right.party,
+            })),
+        }, options);
+        return mapJsonGrantRights(payload);
+    }
+    async getCommandStatusAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("CommandInspectionService.GetCommandStatus is not supported by json transport");
+    }
+    async getUserAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("UserManagementService.GetUser is not supported by json transport");
+    }
+    async listUsersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("UserManagementService.ListUsers is not supported by json transport");
+    }
+    async listUserRightsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("UserManagementService.ListUserRights is not supported by json transport");
+    }
+    async uploadDarFileAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.httpClient.postAsync("/v1/packages", {
+            format: "dar",
+            bytes: Array.from(request.bytes),
+        }, options);
+        const response = mapJsonUploadPackage(payload);
+        return new UploadDarFileResponse({
+            packageId: response.packageId,
+        });
+    }
+    async listPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PackageService.ListPackages is not supported by json transport");
+    }
+    async listKnownPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PackageManagementService.ListKnownPackages is not supported by json transport");
+    }
+    async getIdentityProviderConfigAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("IdentityProviderConfigService.GetIdentityProviderConfig is not supported by json transport");
+    }
+    async listIdentityProviderConfigsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("IdentityProviderConfigService.ListIdentityProviderConfigs is not supported by json transport");
+    }
+    async getPackageAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PackageService.GetPackage is not supported by json transport");
+    }
+    async getPackageStatusAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PackageService.GetPackageStatus is not supported by json transport");
+    }
+    async listVettedPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PackageService.ListVettedPackages is not supported by json transport");
+    }
+    async listParticipantPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("Participant PackageService.ListPackages is not supported by json transport");
+    }
+    async getParticipantPackageContentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("Participant PackageService.GetPackageContents is not supported by json transport");
+    }
+    async getParticipantPackageReferencesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("Participant PackageService.GetPackageReferences is not supported by json transport");
+    }
+    async getParticipantDarAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantPackageService.GetDar is not supported by json transport");
+    }
+    async listParticipantDarsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantPackageService.ListDars is not supported by json transport");
+    }
+    async getParticipantDarContentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantPackageService.GetDarContents is not supported by json transport");
+    }
+    async getParticipantStatusAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantStatusService.ParticipantStatus is not supported by json transport");
+    }
+    async lookupOffsetByTimeAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantInspectionService.LookupOffsetByTime is not supported by json transport");
+    }
+    async openCommitmentAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantInspectionService.OpenCommitment is not supported by json transport");
+    }
+    async inspectCommitmentContractsAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantInspectionService.InspectCommitmentContracts is not supported by json transport");
+    }
+    async countInFlightAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantInspectionService.CountInFlight is not supported by json transport");
+    }
+    async getConfigForSlowCounterParticipantsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantInspectionService.GetConfigForSlowCounterParticipants is not supported by json transport");
+    }
+    async getIntervalsBehindForCounterParticipantsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantInspectionService.GetIntervalsBehindForCounterParticipants is not supported by json transport");
+    }
+    async lookupSentAcsCommitmentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantInspectionService.LookupSentAcsCommitments is not supported by json transport");
+    }
+    async lookupReceivedAcsCommitmentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantInspectionService.LookupReceivedAcsCommitments is not supported by json transport");
+    }
+    async getHighestOffsetByTimestampAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantPartyManagementService.GetHighestOffsetByTimestamp is not supported by json transport");
+    }
+    async getSafePruningOffsetAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PruningService.GetSafePruningOffset is not supported by json transport");
+    }
+    async getPruningScheduleAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PruningService.GetSchedule is not supported by json transport");
+    }
+    async getParticipantPruningScheduleAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PruningService.GetParticipantSchedule is not supported by json transport");
+    }
+    async getNoWaitCommitmentsFromAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("PruningService.GetNoWaitCommitmentsFrom is not supported by json transport");
+    }
+    async trafficControlStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TrafficControlService.TrafficControlState is not supported by json transport");
+    }
+    async listConnectedSynchronizersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("SynchronizerConnectivityService.ListConnectedSynchronizers is not supported by json transport");
+    }
+    async getSynchronizerIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("SynchronizerConnectivityService.GetSynchronizerId is not supported by json transport");
+    }
+    async listRegisteredSynchronizersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("SynchronizerConnectivityService.ListRegisteredSynchronizers is not supported by json transport");
+    }
+    async listPendingOperationsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ParticipantRepairService.ListPendingOperations is not supported by json transport");
+    }
+    async getResourceLimitsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ResourceManagementService.GetResourceLimits is not supported by json transport");
+    }
+    async getIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("IdentityInitializationService.GetId is not supported by json transport");
+    }
+    async currentTimeAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("IdentityInitializationService.CurrentTime is not supported by json transport");
+    }
+    async getContractAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("ContractService.GetContract is not supported by json transport");
+    }
+    async getEventsByContractIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("EventQueryService.GetEventsByContractId is not supported by json transport");
+    }
+    async listNamespaceDelegationAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListNamespaceDelegation is not supported by json transport");
+    }
+    async listDecentralizedNamespaceDefinitionAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListDecentralizedNamespaceDefinition is not supported by json transport");
+    }
+    async listOwnerToKeyMappingAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListOwnerToKeyMapping is not supported by json transport");
+    }
+    async listPartyToKeyMappingAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListPartyToKeyMapping is not supported by json transport");
+    }
+    async listSynchronizerTrustCertificateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListSynchronizerTrustCertificate is not supported by json transport");
+    }
+    async listParticipantSynchronizerPermissionAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListParticipantSynchronizerPermission is not supported by json transport");
+    }
+    async listPartyHostingLimitsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListPartyHostingLimits is not supported by json transport");
+    }
+    async topologyListVettedPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListVettedPackages is not supported by json transport");
+    }
+    async listPartyToParticipantAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListPartyToParticipant is not supported by json transport");
+    }
+    async listSynchronizerParametersStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListSynchronizerParametersState is not supported by json transport");
+    }
+    async listSequencingParametersStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListSequencingParametersState is not supported by json transport");
+    }
+    async listMediatorSynchronizerStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListMediatorSynchronizerState is not supported by json transport");
+    }
+    async listSequencerSynchronizerStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListSequencerSynchronizerState is not supported by json transport");
+    }
+    async listLsuAnnouncementAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListLsuAnnouncement is not supported by json transport");
+    }
+    async listLsuSequencerConnectionSuccessorAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListLsuSequencerConnectionSuccessor is not supported by json transport");
+    }
+    async listAvailableStoresAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListAvailableStores is not supported by json transport");
+    }
+    async listAllAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListAll is not supported by json transport");
+    }
+    async listAllV2Async(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyManagerReadService.ListAllV2 is not supported by json transport");
+    }
+    async topologyListPartiesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyAggregationService.ListParties is not supported by json transport");
+    }
+    async listKeyOwnersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("TopologyAggregationService.ListKeyOwners is not supported by json transport");
+    }
+    async getActiveContractsPageAsync(request, options) {
+        this.throwIfDisposed();
+        const payload = await this.httpClient.postAsync("/v1/query", {
+            templateIds: request.templateId ? [request.templateId] : [],
+        }, options);
+        const response = mapJsonQueryContracts(payload);
+        return new GetActiveContractsPageResponse({
+            contracts: response.contracts,
+        });
+    }
+    async getConnectedSynchronizersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("StateService.GetConnectedSynchronizers is not supported by json transport");
+    }
+    async getLedgerEndAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("StateService.GetLedgerEnd is not supported by json transport");
+    }
+    async getLatestPrunedOffsetsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new 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 = mapJsonTransactionEvents(payload);
+        for (const event of events) {
+            await observer.nextAsync(event);
+        }
+    }
+    async getUpdatesAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("UpdateService.GetUpdates is gRPC-only; JSON supports StateService.getActiveContractsAsync instead");
+    }
+    async getUpdateByOffsetAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("UpdateService.GetUpdateByOffset is not supported by json transport");
+    }
+    async getUpdateByIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("UpdateService.GetUpdateById is not supported by json transport");
+    }
+    async getUpdateByHashAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("UpdateService.GetUpdateByHash is not supported by json transport");
+    }
+    async getUpdatesPageAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("UpdateService.GetUpdatesPage is not supported by json transport");
+    }
+    async getCompletionsAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new NotSupportedError("CommandCompletionService.GetCompletions is not supported by json transport");
+    }
+    async submitCommandAsync(request, signed, options) {
+        this.throwIfDisposed();
+        if (signed) {
+            throw new NotSupportedError("command signing is not supported by json transport");
+        }
+        const payload = await this.httpClient.postAsync("/v1/create", {
+            templateId: request.command.templateId,
+            payload: request.command.payload,
+            applicationId: request.applicationId,
+            actAs: request.actAs,
+            readAs: request.readAs,
+        }, options);
+        return mapJsonSubmitCommand(payload);
+    }
+    throwIfDisposed() {
+        if (this.disposed) {
+            throw new ObjectDisposedError("The client or transport has been disposed.");
+        }
+    }
+}

package/dist/transports/json/mappers/commands-mapper.d.ts

@@ -0,0 +1,9 @@
+import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
+export declare function mapJsonSubmitCommand(payload: {
+    result?: {
+        commandId?: string;
+        transactionId?: string;
+    };
+    commandId?: string;
+    transactionId?: string;
+}): SubmitCommandResponse;

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

@@ -0,0 +1,7 @@
+import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
+export function mapJsonSubmitCommand(payload) {
+    return new SubmitCommandResponse({
+        commandId: payload.result?.commandId ?? payload.commandId,
+        transactionId: payload.result?.transactionId ?? payload.transactionId,
+    });
+}

package/dist/transports/json/mappers/contracts-mapper.d.ts

@@ -0,0 +1,4 @@
+import { QueryContractsResponse } from "../../../core/types/responses/query-contracts-response.js";
+export declare function mapJsonQueryContracts(payload: {
+    result?: unknown[];
+}): QueryContractsResponse;

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

@@ -0,0 +1,6 @@
+import { QueryContractsResponse } from "../../../core/types/responses/query-contracts-response.js";
+export function mapJsonQueryContracts(payload) {
+    return new QueryContractsResponse({
+        contracts: payload.result ?? [],
+    });
+}

package/dist/transports/json/mappers/events-mapper.d.ts

@@ -0,0 +1,3 @@
+export declare function mapJsonTransactionEvents(payload: {
+    events?: unknown[];
+}): readonly unknown[];

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

@@ -0,0 +1,3 @@
+export function mapJsonTransactionEvents(payload) {
+    return payload.events ?? [];
+}

package/dist/transports/json/mappers/packages-mapper.d.ts

@@ -0,0 +1,7 @@
+import { UploadPackageResponse } from "../../../core/types/responses/upload-package-response.js";
+export declare function mapJsonUploadPackage(payload: {
+    result?: {
+        packageId?: string;
+    };
+    packageId?: string;
+}): UploadPackageResponse;

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

@@ -0,0 +1,6 @@
+import { UploadPackageResponse } from "../../../core/types/responses/upload-package-response.js";
+export function mapJsonUploadPackage(payload) {
+    return new UploadPackageResponse({
+        packageId: payload.result?.packageId ?? payload.packageId,
+    });
+}

package/dist/transports/json/mappers/parties-mapper.d.ts

@@ -0,0 +1,19 @@
+import { CreatePartyResponse } from "../../../core/types/responses/create-party-response.js";
+import { ListPartiesResponse } from "../../../core/types/responses/list-parties-response.js";
+export declare function mapJsonCreateParty(payload: {
+    result?: {
+        identifier?: string;
+    };
+    identifier?: string;
+}): CreatePartyResponse;
+export declare function mapJsonListParties(payload: {
+    partyDetails?: Array<{
+        party?: string;
+        isLocal?: boolean;
+        localMetadata?: {
+            attributes?: Record<string, string>;
+        };
+        identityProviderId?: string;
+    }>;
+    nextPageToken?: string;
+}): ListPartiesResponse;

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

@@ -0,0 +1,19 @@
+import { CreatePartyResponse } from "../../../core/types/responses/create-party-response.js";
+import { ListPartiesResponse } from "../../../core/types/responses/list-parties-response.js";
+import { PartyDetails } from "../../../core/types/party-details.js";
+export function mapJsonCreateParty(payload) {
+    return new CreatePartyResponse({
+        party: payload.result?.identifier ?? payload.identifier ?? "",
+    });
+}
+export function mapJsonListParties(payload) {
+    return new ListPartiesResponse({
+        partyDetails: (payload.partyDetails ?? []).map(item => new PartyDetails({
+            party: item.party ?? "",
+            isLocal: item.isLocal ?? false,
+            localMetadata: item.localMetadata?.attributes,
+            identityProviderId: item.identityProviderId,
+        })),
+        nextPageToken: payload.nextPageToken,
+    });
+}

package/dist/transports/json/mappers/system-mapper.d.ts

@@ -0,0 +1,5 @@
+import { HealthStatusResponse } from "../../../core/types/responses/health-status-response.js";
+export declare function mapJsonHealth(payload: {
+    status?: string;
+    version?: string;
+}): HealthStatusResponse;

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

@@ -0,0 +1,7 @@
+import { HealthStatusResponse } from "../../../core/types/responses/health-status-response.js";
+export function mapJsonHealth(payload) {
+    return new HealthStatusResponse({
+        status: payload.status ?? "unknown",
+        version: payload.version,
+    });
+}

package/dist/transports/json/mappers/users-mapper.d.ts

@@ -0,0 +1,7 @@
+import { GrantUserRightsResponse } from "../../../core/types/responses/grant-user-rights-response.js";
+export declare function mapJsonGrantRights(payload: {
+    result?: Array<{
+        type: string;
+        party?: string;
+    }>;
+}): GrantUserRightsResponse;

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

@@ -0,0 +1,8 @@
+import { GrantUserRightsResponse } from "../../../core/types/responses/grant-user-rights-response.js";
+export function mapJsonGrantRights(payload) {
+    const rights = (payload.result ?? []).map((right) => ({
+        type: right.type,
+        party: right.party,
+    }));
+    return new GrantUserRightsResponse({ rights });
+}

package/package.json

@@ -0,0 +1,82 @@
+{
+    "name": "@distrohelena/canton-typescript-sdk",
+    "version": "0.1.0",
+    "license": "Apache-2.0",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "keywords": [
+        "canton",
+        "daml",
+        "grpc",
+        "json-rpc",
+        "typescript"
+    ],
+    "homepage": "https://github.com/distrohelena/canton-typescript-sdk#readme",
+    "bugs": {
+        "url": "https://github.com/distrohelena/canton-typescript-sdk/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/distrohelena/canton-typescript-sdk.git"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./daml-interface": {
+            "types": "./dist/daml-interface/index.d.ts",
+            "import": "./dist/daml-interface/index.js"
+        },
+        "./daml-lf": {
+            "types": "./dist/daml-lf/index.d.ts",
+            "import": "./dist/daml-lf/index.js"
+        },
+        "./grpc": {
+            "types": "./dist/grpc/index.d.ts",
+            "import": "./dist/grpc/index.js"
+        },
+        "./json": {
+            "types": "./dist/json/index.d.ts",
+            "import": "./dist/json/index.js"
+        }
+    },
+    "scripts": {
+        "build": "node ./scripts/clean-dist.mjs && tsc -p tsconfig.json",
+        "generate:daml-interface": "node ./dist/daml-interface/cli/daml-interface-cli-main.js",
+        "generate:grpc": "node ./scripts/generate-grpc-bindings.mjs",
+        "lint": "eslint . --max-warnings=0",
+        "lint:fix": "eslint . --fix --max-warnings=0",
+        "start:local-ledger": "bash node/start-local.sh",
+        "stop:local-ledger": "bash node/stop-local.sh",
+        "test": "vitest run",
+        "test:unit": "vitest run tests/unit",
+        "verify:pack": "node ./scripts/verify-npm-pack.mjs"
+    },
+    "dependencies": {
+        "@grpc/grpc-js": "^1.14.4",
+        "@protobuf-ts/grpc-transport": "^2.11.1",
+        "@protobuf-ts/runtime": "^2.11.1",
+        "@protobuf-ts/runtime-rpc": "^2.11.1",
+        "fflate": "^0.8.3"
+    },
+    "devDependencies": {
+        "@distrohelena/linter": "^0.5.0",
+        "@protobuf-ts/plugin": "^2.11.1",
+        "@typescript-eslint/parser": "^8.62.1",
+        "@typescript-eslint/utils": "^8.62.1",
+        "eslint": "^10.6.0",
+        "prettier": "^3.9.4",
+        "typescript": "^5.9.2",
+        "vitest": "^3.2.4"
+    }
+}