@distrohelena/canton-typescript-sdk 0.1.0

package/dist/transports/grpc/mappers/command-completion-mapper.d.ts

@@ -0,0 +1,36 @@
+import { Completion } from "../../../core/types/completion.js";
+import { CompletionStreamResponse } from "../../../core/types/completion-stream-response.js";
+import { GetCompletionsRequest } from "../../../core/types/requests/get-completions-request.js";
+import { CompletionStreamResponse as GrpcCompletionStreamResponse } from "../generated/canton/com/daml/ledger/api/v2/command_completion_service.js";
+export declare function mapGrpcGetCompletionsRequest(request: GetCompletionsRequest): {
+    parties: string[];
+    beginExclusive: string;
+};
+export declare function mapGrpcCompletionStreamResponse(payload: Partial<GrpcCompletionStreamResponse>): CompletionStreamResponse;
+export declare function mapGrpcCompletion(payload: {
+    commandId: string;
+    status?: unknown;
+    updateId: string;
+    userId: string;
+    actAs: string[];
+    submissionId: string;
+    deduplicationPeriod?: {
+        oneofKind?: string;
+        deduplicationOffset?: string;
+        deduplicationDuration?: {
+            seconds: string;
+            nanos: number;
+        };
+    };
+    traceContext?: unknown;
+    offset: string;
+    synchronizerTime?: {
+        synchronizerId?: string;
+        recordTime?: {
+            seconds: string;
+            nanos: number;
+        };
+    };
+    paidTrafficCost: string;
+    transactionHash?: Uint8Array;
+}): Completion;

package/dist/transports/grpc/mappers/command-completion-mapper.js

@@ -0,0 +1,50 @@
+import { Completion } from "../../../core/types/completion.js";
+import { CompletionStreamResponse } from "../../../core/types/completion-stream-response.js";
+import { OffsetCheckpoint } from "../../../core/types/offset-checkpoint.js";
+import { mapGrpcSynchronizerTime } from "./state-read-mapper.js";
+export function mapGrpcGetCompletionsRequest(request) {
+    return {
+        parties: [...request.parties],
+        beginExclusive: request.beginExclusive,
+    };
+}
+export function mapGrpcCompletionStreamResponse(payload) {
+    switch (payload.completionResponse?.oneofKind) {
+        case "completion":
+            return new CompletionStreamResponse({
+                completion: mapGrpcCompletion(payload.completionResponse.completion),
+            });
+        case "offsetCheckpoint":
+            return new CompletionStreamResponse({
+                offsetCheckpoint: new OffsetCheckpoint({
+                    offset: payload.completionResponse.offsetCheckpoint.offset,
+                    synchronizerTimes: payload.completionResponse.offsetCheckpoint.synchronizerTimes.map(mapGrpcSynchronizerTime),
+                }),
+            });
+        default:
+            return new CompletionStreamResponse({});
+    }
+}
+export function mapGrpcCompletion(payload) {
+    return new Completion({
+        commandId: payload.commandId,
+        status: payload.status,
+        updateId: payload.updateId || undefined,
+        userId: payload.userId,
+        actAs: payload.actAs,
+        submissionId: payload.submissionId || undefined,
+        deduplicationOffset: payload.deduplicationPeriod?.oneofKind === "deduplicationOffset"
+            ? payload.deduplicationPeriod.deduplicationOffset
+            : undefined,
+        deduplicationDuration: payload.deduplicationPeriod?.oneofKind === "deduplicationDuration"
+            ? payload.deduplicationPeriod.deduplicationDuration
+            : undefined,
+        traceContext: payload.traceContext,
+        offset: payload.offset,
+        synchronizerTime: payload.synchronizerTime === undefined
+            ? undefined
+            : mapGrpcSynchronizerTime(payload.synchronizerTime),
+        paidTrafficCost: payload.paidTrafficCost,
+        transactionHash: payload.transactionHash,
+    });
+}

package/dist/transports/grpc/mappers/command-inspection-mapper.d.ts

@@ -0,0 +1,10 @@
+import { GetCommandStatusRequest } from "../../../core/types/requests/get-command-status-request.js";
+import { GetCommandStatusResponse } from "../../../core/types/responses/get-command-status-response.js";
+import { CommandState as GrpcCommandState } from "../generated/canton/com/daml/ledger/api/v2/admin/command_inspection_service.js";
+import { GetCommandStatusResponse as GrpcGetCommandStatusResponse } from "../generated/canton/com/daml/ledger/api/v2/admin/command_inspection_service.js";
+export declare function mapGrpcGetCommandStatusRequest(request: GetCommandStatusRequest): {
+    commandIdPrefix: string;
+    state: GrpcCommandState;
+    limit: number;
+};
+export declare function mapGrpcGetCommandStatus(payload: Partial<GrpcGetCommandStatusResponse>): GetCommandStatusResponse;

package/dist/transports/grpc/mappers/command-inspection-mapper.js

@@ -0,0 +1,191 @@
+import { CommandInspectionContract } from "../../../core/types/command-inspection-contract.js";
+import { CommandRequestStatistics } from "../../../core/types/command-request-statistics.js";
+import { CommandState } from "../../../core/types/command-state.js";
+import { CommandStatus } from "../../../core/types/command-status.js";
+import { CommandTiming } from "../../../core/types/command-timing.js";
+import { CommandUpdateSummary } from "../../../core/types/command-update-summary.js";
+import { SdkCommand } from "../../../core/types/sdk-command.js";
+import { GetCommandStatusResponse } from "../../../core/types/responses/get-command-status-response.js";
+import { CommandState as GrpcCommandState, } from "../generated/canton/com/daml/ledger/api/v2/admin/command_inspection_service.js";
+import { mapGrpcCompletion } from "./command-completion-mapper.js";
+export function mapGrpcGetCommandStatusRequest(request) {
+    return {
+        commandIdPrefix: request.commandIdPrefix ?? "",
+        state: mapSdkCommandState(request.state),
+        limit: request.limit ?? 0,
+    };
+}
+export function mapGrpcGetCommandStatus(payload) {
+    return new GetCommandStatusResponse({
+        commandStatuses: (payload.commandStatus ?? []).map(mapGrpcCommandStatus),
+    });
+}
+function mapGrpcCommandStatus(payload) {
+    return new CommandStatus({
+        started: mapGrpcTimestamp(payload.started),
+        completed: mapGrpcTimestamp(payload.completed),
+        completion: payload.completion === undefined
+            ? undefined
+            : mapGrpcCompletion(payload.completion),
+        state: mapGrpcCommandState(payload.state),
+        commands: payload.commands.map(mapGrpcCommand),
+        requestStatistics: payload.requestStatistics === undefined
+            ? undefined
+            : new CommandRequestStatistics(payload.requestStatistics),
+        updates: payload.updates === undefined
+            ? undefined
+            : new CommandUpdateSummary({
+                created: payload.updates.created.map(mapGrpcCommandInspectionContract),
+                archived: payload.updates.archived.map(mapGrpcCommandInspectionContract),
+                exercised: payload.updates.exercised,
+                fetched: payload.updates.fetched,
+                lookedUpByKey: payload.updates.lookedUpByKey,
+            }),
+        synchronizerId: payload.synchronizerId || undefined,
+        timings: payload.timings.map((item) => new CommandTiming(item)),
+    });
+}
+function mapGrpcCommand(payload) {
+    switch (payload.command.oneofKind) {
+        case "create":
+            return new SdkCommand({
+                type: "create",
+                templateId: mapGrpcIdentifier(payload.command.create.templateId),
+                createArguments: mapGrpcRecord(payload.command.create.createArguments),
+            });
+        case "exercise":
+            return new SdkCommand({
+                type: "exercise",
+                templateId: mapGrpcIdentifier(payload.command.exercise.templateId),
+                contractId: payload.command.exercise.contractId,
+                choice: payload.command.exercise.choice,
+                choiceArgument: mapGrpcValue(payload.command.exercise.choiceArgument),
+            });
+        case "exerciseByKey":
+            return new SdkCommand({
+                type: "exerciseByKey",
+                templateId: mapGrpcIdentifier(payload.command.exerciseByKey.templateId),
+                contractKey: mapGrpcValue(payload.command.exerciseByKey.contractKey),
+                choice: payload.command.exerciseByKey.choice,
+                choiceArgument: mapGrpcValue(payload.command.exerciseByKey.choiceArgument),
+            });
+        case "createAndExercise":
+            return new SdkCommand({
+                type: "createAndExercise",
+                templateId: mapGrpcIdentifier(payload.command.createAndExercise.templateId),
+                createArguments: mapGrpcRecord(payload.command.createAndExercise.createArguments),
+                choice: payload.command.createAndExercise.choice,
+                choiceArgument: mapGrpcValue(payload.command.createAndExercise.choiceArgument),
+            });
+        default:
+            return new SdkCommand({
+                type: "unspecified",
+            });
+    }
+}
+function mapGrpcCommandInspectionContract(payload) {
+    return new CommandInspectionContract({
+        templateId: mapGrpcIdentifier(payload.templateId),
+        contractId: payload.contractId,
+        contractKey: mapGrpcValue(payload.contractKey),
+    });
+}
+function mapSdkCommandState(value) {
+    switch (value) {
+        case CommandState.pending:
+            return GrpcCommandState.PENDING;
+        case CommandState.succeeded:
+            return GrpcCommandState.SUCCEEDED;
+        case CommandState.failed:
+            return GrpcCommandState.FAILED;
+        default:
+            return GrpcCommandState.UNSPECIFIED;
+    }
+}
+function mapGrpcCommandState(value) {
+    switch (value) {
+        case GrpcCommandState.PENDING:
+            return CommandState.pending;
+        case GrpcCommandState.SUCCEEDED:
+            return CommandState.succeeded;
+        case GrpcCommandState.FAILED:
+            return CommandState.failed;
+        default:
+            return CommandState.unspecified;
+    }
+}
+function mapGrpcIdentifier(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    else if (value.packageId) {
+        return `${value.packageId}:${value.moduleName}:${value.entityName}`;
+    }
+    else {
+        return `${value.moduleName}:${value.entityName}`;
+    }
+}
+function mapGrpcRecord(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return Object.fromEntries(value.fields.map((field, index) => [
+        field.label || index.toString(),
+        mapGrpcValue(field.value),
+    ]));
+}
+function mapGrpcValue(value) {
+    switch (value?.sum.oneofKind) {
+        case "unit":
+            return null;
+        case "bool":
+            return value.sum.bool;
+        case "int64":
+            return value.sum.int64;
+        case "date":
+            return value.sum.date;
+        case "timestamp":
+            return value.sum.timestamp;
+        case "numeric":
+            return value.sum.numeric;
+        case "party":
+            return value.sum.party;
+        case "text":
+            return value.sum.text;
+        case "contractId":
+            return value.sum.contractId;
+        case "optional":
+            return mapGrpcValue(value.sum.optional.value);
+        case "list":
+            return value.sum.list.elements.map(mapGrpcValue);
+        case "textMap":
+            return Object.fromEntries(value.sum.textMap.entries.map((entry) => [
+                entry.key,
+                mapGrpcValue(entry.value),
+            ]));
+        case "genMap":
+            return value.sum.genMap.entries.map((entry) => ({
+                key: mapGrpcValue(entry.key),
+                value: mapGrpcValue(entry.value),
+            }));
+        case "record":
+            return mapGrpcRecord(value.sum.record);
+        case "variant":
+            return {
+                constructor: value.sum.variant.constructor,
+                value: mapGrpcValue(value.sum.variant.value),
+            };
+        case "enum":
+            return value.sum.enum.constructor;
+        default:
+            return undefined;
+    }
+}
+function mapGrpcTimestamp(timestamp) {
+    if (timestamp === undefined) {
+        return undefined;
+    }
+    const milliseconds = Number(timestamp.seconds) * 1_000
+        + Math.trunc(timestamp.nanos / 1_000_000);
+    return new Date(milliseconds);
+}

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

@@ -0,0 +1,10 @@
+import { SignCommandResult } from "../../../core/signing/sign-command-result.js";
+import { SubmitCommandRequest } from "../../../core/types/requests/submit-command-request.js";
+import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
+import { SubmitAndWaitRequest, SubmitAndWaitResponse } from "../generated/canton/com/daml/ledger/api/v2/command_service.js";
+export declare function mapGrpcSubmitCommandRequest(request: SubmitCommandRequest, _signed?: SignCommandResult): SubmitAndWaitRequest;
+export declare function mapGrpcSubmitCommand(payload: {
+    commandId?: string;
+    transactionId?: string;
+    updateId?: string;
+} | SubmitAndWaitResponse): SubmitCommandResponse;

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

@@ -0,0 +1,125 @@
+import { randomUUID } from "node:crypto";
+import { ValidationError } from "../../../core/errors/validation-error.js";
+import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
+export function mapGrpcSubmitCommandRequest(request, _signed) {
+    return {
+        commands: {
+            workflowId: "",
+            userId: "",
+            commandId: randomUUID(),
+            commands: [mapCreateCommand(request)],
+            deduplicationPeriod: {
+                oneofKind: undefined,
+            },
+            actAs: [...request.actAs],
+            readAs: [...request.readAs],
+            submissionId: "",
+            disclosedContracts: [],
+            synchronizerId: "",
+            packageIdSelectionPreference: [],
+            prefetchContractKeys: [],
+        },
+    };
+}
+export function mapGrpcSubmitCommand(payload) {
+    return new SubmitCommandResponse({
+        commandId: "commandId" in payload ? payload.commandId : undefined,
+        transactionId: "transactionId" in payload
+            ? payload.transactionId
+            : payload.updateId,
+    });
+}
+function mapCreateCommand(request) {
+    return {
+        command: {
+            oneofKind: "create",
+            create: {
+                templateId: parseTemplateIdentifier(request.command.templateId),
+                createArguments: mapRecord(request.command.payload),
+            },
+        },
+    };
+}
+function mapRecord(payload) {
+    return {
+        fields: Object.entries(payload).map(([label, value]) => ({
+            label,
+            value: mapValue(value),
+        })),
+    };
+}
+function mapValue(value) {
+    if (value === null || value === undefined) {
+        return {
+            sum: {
+                oneofKind: "optional",
+                optional: {},
+            },
+        };
+    }
+    else if (typeof value === "string") {
+        return {
+            sum: {
+                oneofKind: "text",
+                text: value,
+            },
+        };
+    }
+    else if (typeof value === "boolean") {
+        return {
+            sum: {
+                oneofKind: "bool",
+                bool: value,
+            },
+        };
+    }
+    else if (typeof value === "number") {
+        return Number.isInteger(value)
+            ? {
+                sum: {
+                    oneofKind: "int64",
+                    int64: value.toString(),
+                },
+            }
+            : {
+                sum: {
+                    oneofKind: "numeric",
+                    numeric: value.toString(),
+                },
+            };
+    }
+    else if (Array.isArray(value)) {
+        return {
+            sum: {
+                oneofKind: "list",
+                list: {
+                    elements: value.map(mapValue),
+                },
+            },
+        };
+    }
+    return {
+        sum: {
+            oneofKind: "record",
+            record: mapRecord(value),
+        },
+    };
+}
+function parseTemplateIdentifier(templateId) {
+    const parts = templateId.split(":");
+    if (parts.length === 2) {
+        return {
+            packageId: "",
+            moduleName: parts[0],
+            entityName: parts[1],
+        };
+    }
+    else if (parts.length === 3) {
+        return {
+            packageId: parts[0],
+            moduleName: parts[1],
+            entityName: parts[2],
+        };
+    }
+    throw new ValidationError(`templateId must be '<module>:<entity>' or '<package>:<module>:<entity>', but was '${templateId}'.`);
+}

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

@@ -0,0 +1,21 @@
+import { GetContractRequest } from "../../../core/types/requests/get-contract-request.js";
+import { GetContractResponse } from "../../../core/types/responses/get-contract-response.js";
+import { QueryContractsResponse } from "../../../core/types/responses/query-contracts-response.js";
+import { GetContractRequest as GrpcGetContractRequest } from "../generated/canton/com/daml/ledger/api/v2/contract_service.js";
+import { GetContractResponse as GrpcGetContractResponse } from "../generated/canton/com/daml/ledger/api/v2/contract_service.js";
+import { GetActiveContractsPageRequest } from "../generated/canton/com/daml/ledger/api/v2/state_service.js";
+export declare function mapGrpcQueryContractsRequest(request: {
+    party: string;
+    templateId?: string;
+}): GetActiveContractsPageRequest;
+export declare function mapGrpcQueryContracts(payload: {
+    contracts?: unknown[];
+    activeContracts?: Array<{
+        contractEntry?: {
+            oneofKind?: string;
+            activeContract?: unknown;
+        };
+    }>;
+}): QueryContractsResponse;
+export declare function mapGrpcGetContractRequest(request: GetContractRequest): GrpcGetContractRequest;
+export declare function mapGrpcGetContract(payload: Partial<GrpcGetContractResponse>): GetContractResponse;

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

@@ -0,0 +1,77 @@
+import { ValidationError } from "../../../core/errors/validation-error.js";
+import { GetContractResponse } from "../../../core/types/responses/get-contract-response.js";
+import { QueryContractsResponse } from "../../../core/types/responses/query-contracts-response.js";
+export function mapGrpcQueryContractsRequest(request) {
+    return {
+        eventFormat: createEventFormat(request.party, request.templateId),
+    };
+}
+export function mapGrpcQueryContracts(payload) {
+    return new QueryContractsResponse({
+        contracts: payload.contracts
+            ?? payload.activeContracts?.map((contract) => contract.contractEntry?.oneofKind === "activeContract"
+                ? contract.contractEntry.activeContract
+                : contract)
+            ?? [],
+    });
+}
+export function mapGrpcGetContractRequest(request) {
+    return {
+        contractId: request.contractId,
+        queryingParties: [...request.queryingParties],
+    };
+}
+export function mapGrpcGetContract(payload) {
+    return new GetContractResponse({
+        createdEvent: payload.createdEvent,
+    });
+}
+function createEventFormat(party, templateId) {
+    return {
+        filtersByParty: {
+            [party]: {
+                cumulative: [createTemplateFilter(templateId)],
+            },
+        },
+        verbose: true,
+    };
+}
+function createTemplateFilter(templateId) {
+    if (!templateId) {
+        return {
+            identifierFilter: {
+                oneofKind: "wildcardFilter",
+                wildcardFilter: {
+                    includeCreatedEventBlob: false,
+                },
+            },
+        };
+    }
+    return {
+        identifierFilter: {
+            oneofKind: "templateFilter",
+            templateFilter: {
+                templateId: parseTemplateIdentifier(templateId),
+                includeCreatedEventBlob: false,
+            },
+        },
+    };
+}
+function parseTemplateIdentifier(templateId) {
+    const parts = templateId.split(":");
+    if (parts.length === 2) {
+        return {
+            packageId: "",
+            moduleName: parts[0],
+            entityName: parts[1],
+        };
+    }
+    else if (parts.length === 3) {
+        return {
+            packageId: parts[0],
+            moduleName: parts[1],
+            entityName: parts[2],
+        };
+    }
+    throw new ValidationError(`templateId must be '<module>:<entity>' or '<package>:<module>:<entity>', but was '${templateId}'.`);
+}

package/dist/transports/grpc/mappers/event-query-mapper.d.ts

@@ -0,0 +1,5 @@
+import { GetEventsByContractIdRequest } from "../../../core/types/requests/get-events-by-contract-id-request.js";
+import { GetEventsByContractIdResponse } from "../../../core/types/responses/get-events-by-contract-id-response.js";
+import { GetEventsByContractIdRequest as GrpcGetEventsByContractIdRequest, GetEventsByContractIdResponse as GrpcGetEventsByContractIdResponse } from "../generated/canton/com/daml/ledger/api/v2/event_query_service.js";
+export declare function mapGrpcGetEventsByContractIdRequest(request: GetEventsByContractIdRequest): GrpcGetEventsByContractIdRequest;
+export declare function mapGrpcGetEventsByContractId(payload: Partial<GrpcGetEventsByContractIdResponse>): GetEventsByContractIdResponse;

package/dist/transports/grpc/mappers/event-query-mapper.js

@@ -0,0 +1,25 @@
+import { GetEventsByContractIdResponse } from "../../../core/types/responses/get-events-by-contract-id-response.js";
+import { ContractArchived } from "../../../core/types/contract-archived.js";
+import { ContractCreated } from "../../../core/types/contract-created.js";
+export function mapGrpcGetEventsByContractIdRequest(request) {
+    return {
+        contractId: request.contractId,
+        eventFormat: request.eventFormat,
+    };
+}
+export function mapGrpcGetEventsByContractId(payload) {
+    return new GetEventsByContractIdResponse({
+        created: payload.created === undefined
+            ? undefined
+            : new ContractCreated({
+                createdEvent: payload.created.createdEvent,
+                synchronizerId: payload.created.synchronizerId,
+            }),
+        archived: payload.archived === undefined
+            ? undefined
+            : new ContractArchived({
+                archivedEvent: payload.archived.archivedEvent,
+                synchronizerId: payload.archived.synchronizerId,
+            }),
+    });
+}

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

@@ -0,0 +1,10 @@
+import { GetUpdatesRequest } from "../generated/canton/com/daml/ledger/api/v2/update_service.js";
+export declare function mapGrpcStreamTransactionsRequest(request: {
+    party: string;
+    beginOffset?: string;
+    endOffset?: string;
+    templateId?: string;
+}): GetUpdatesRequest;
+export declare function mapGrpcTransactionEvents(payload: {
+    events?: unknown[];
+} | readonly unknown[]): readonly unknown[];

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

@@ -0,0 +1,48 @@
+import { TransactionShape } from "../generated/canton/com/daml/ledger/api/v2/transaction_filter.js";
+import { mapGrpcQueryContractsRequest } from "./contracts-mapper.js";
+export function mapGrpcStreamTransactionsRequest(request) {
+    const queryRequest = mapGrpcQueryContractsRequest({
+        party: request.party,
+        templateId: request.templateId ?? "",
+    });
+    return {
+        beginExclusive: request.beginOffset ?? "0",
+        endInclusive: request.endOffset,
+        updateFormat: {
+            includeTransactions: {
+                eventFormat: queryRequest.eventFormat,
+                transactionShape: TransactionShape.ACS_DELTA,
+            },
+        },
+        descendingOrder: false,
+    };
+}
+export function mapGrpcTransactionEvents(payload) {
+    if (Array.isArray(payload)) {
+        return payload.map((item) => {
+            if (isGrpcUpdateEnvelope(item)) {
+                switch (item.update.oneofKind) {
+                    case "transaction":
+                        return item.update.transaction;
+                    case "reassignment":
+                        return item.update.reassignment;
+                    case "offsetCheckpoint":
+                        return item.update.offsetCheckpoint;
+                    case "topologyTransaction":
+                        return item.update.topologyTransaction;
+                }
+            }
+            return item;
+        });
+    }
+    const envelope = payload;
+    return envelope.events ?? [];
+}
+function isGrpcUpdateEnvelope(value) {
+    return (typeof value === "object"
+        && value !== null
+        && "update" in value
+        && typeof value.update === "object"
+        && value.update !== null
+        && "oneofKind" in value.update);
+}

package/dist/transports/grpc/mappers/health-mapper.d.ts

@@ -0,0 +1,5 @@
+import { HealthCheckResponse } from "../../../core/types/responses/health-check-response.js";
+import { HealthCheckResponse_ServingStatus } from "../generated/canton/google/grpc/health/v1/health.js";
+export declare function mapGrpcHealthCheckResponse(payload: {
+    status: HealthCheckResponse_ServingStatus;
+}): HealthCheckResponse;

package/dist/transports/grpc/mappers/health-mapper.js

@@ -0,0 +1,21 @@
+import { HealthCheckStatus } from "../../../core/types/health-check-status.js";
+import { HealthCheckResponse } from "../../../core/types/responses/health-check-response.js";
+import { HealthCheckResponse_ServingStatus } from "../generated/canton/google/grpc/health/v1/health.js";
+export function mapGrpcHealthCheckResponse(payload) {
+    return new HealthCheckResponse({
+        status: mapGrpcHealthStatus(payload.status),
+    });
+}
+function mapGrpcHealthStatus(status) {
+    switch (status) {
+        case HealthCheckResponse_ServingStatus.SERVING:
+            return HealthCheckStatus.serving;
+        case HealthCheckResponse_ServingStatus.NOT_SERVING:
+            return HealthCheckStatus.notServing;
+        case HealthCheckResponse_ServingStatus.SERVICE_UNKNOWN:
+            return HealthCheckStatus.serviceUnknown;
+        case HealthCheckResponse_ServingStatus.UNKNOWN:
+        default:
+            return HealthCheckStatus.unknown;
+    }
+}

package/dist/transports/grpc/mappers/identity-initialization-mapper.d.ts

@@ -0,0 +1,10 @@
+import { CurrentTimeRequest } from "../../../core/types/requests/current-time-request.js";
+import { GetIdRequest } from "../../../core/types/requests/get-id-request.js";
+import { CurrentTimeResponse } from "../../../core/types/responses/current-time-response.js";
+import { GetIdResponse } from "../../../core/types/responses/get-id-response.js";
+import { CurrentTimeResponse as GrpcCurrentTimeResponse } from "../generated/canton/com/digitalasset/canton/topology/admin/v30/initialization_service.js";
+import { GetIdResponse as GrpcGetIdResponse } from "../generated/canton/com/digitalasset/canton/topology/admin/v30/initialization_service.js";
+export declare function mapGrpcGetIdRequest(_request: GetIdRequest): Record<string, never>;
+export declare function mapGrpcGetId(payload: Partial<GrpcGetIdResponse>): GetIdResponse;
+export declare function mapGrpcCurrentTimeRequest(_request: CurrentTimeRequest): Record<string, never>;
+export declare function mapGrpcCurrentTime(payload: Partial<GrpcCurrentTimeResponse>): CurrentTimeResponse;