@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/transports/grpc/mappers/admin-status-mapper.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapGrpcAdminNodeStatus = mapGrpcAdminNodeStatus;
+exports.mapGrpcAdminNotInitializedStatus = mapGrpcAdminNotInitializedStatus;
+exports.mapGrpcAdminTopologyQueueStatus = mapGrpcAdminTopologyQueueStatus;
+exports.mapGrpcAdminComponentStatus = mapGrpcAdminComponentStatus;
+const admin_component_health_kind_js_1 = require("../../../core/types/admin-component-health-kind.js");
+const admin_component_status_js_1 = require("../../../core/types/admin-component-status.js");
+const admin_node_status_js_1 = require("../../../core/types/admin-node-status.js");
+const admin_not_initialized_external_input_kind_js_1 = require("../../../core/types/admin-not-initialized-external-input-kind.js");
+const admin_not_initialized_status_js_1 = require("../../../core/types/admin-not-initialized-status.js");
+const admin_topology_queue_status_js_1 = require("../../../core/types/admin-topology-queue-status.js");
+const status_service_js_1 = require("../generated/canton/com/digitalasset/canton/admin/health/v30/status_service.js");
+function mapGrpcAdminNodeStatus(payload) {
+    return new admin_node_status_js_1.AdminNodeStatus({
+        uid: payload?.uid ?? "",
+        uptime: mapGrpcDuration(payload?.uptime),
+        ports: { ...(payload?.ports ?? {}) },
+        active: payload?.active ?? false,
+        topologyQueues: payload?.topologyQueues === undefined
+            ? undefined
+            : mapGrpcAdminTopologyQueueStatus(payload.topologyQueues),
+        components: (payload?.components ?? []).map((component) => mapGrpcAdminComponentStatus(component)),
+        version: payload?.version ?? "",
+    });
+}
+function mapGrpcAdminNotInitializedStatus(payload) {
+    return new admin_not_initialized_status_js_1.AdminNotInitializedStatus({
+        active: payload?.active ?? false,
+        waitingForExternalInput: mapGrpcAdminNotInitializedExternalInputKind(payload?.waitingForExternalInput),
+        version: payload?.version ?? "",
+    });
+}
+function mapGrpcAdminTopologyQueueStatus(payload) {
+    return new admin_topology_queue_status_js_1.AdminTopologyQueueStatus({
+        manager: payload.manager ?? 0,
+        dispatcher: payload.dispatcher ?? 0,
+        clients: payload.clients ?? 0,
+    });
+}
+function mapGrpcAdminComponentStatus(payload) {
+    const statusKind = payload.status?.oneofKind;
+    return new admin_component_status_js_1.AdminComponentStatus({
+        name: payload.name ?? "",
+        kind: mapGrpcAdminComponentHealthKind(statusKind),
+        description: mapGrpcAdminComponentDescription(payload),
+    });
+}
+function mapGrpcAdminComponentHealthKind(statusKind) {
+    switch (statusKind) {
+        case "ok":
+            return admin_component_health_kind_js_1.AdminComponentHealthKind.ok;
+        case "degraded":
+            return admin_component_health_kind_js_1.AdminComponentHealthKind.degraded;
+        case "failed":
+            return admin_component_health_kind_js_1.AdminComponentHealthKind.failed;
+        case "fatal":
+            return admin_component_health_kind_js_1.AdminComponentHealthKind.fatal;
+        default:
+            return admin_component_health_kind_js_1.AdminComponentHealthKind.unknown;
+    }
+}
+function mapGrpcAdminNotInitializedExternalInputKind(value) {
+    switch (value) {
+        case status_service_js_1.NotInitialized_WaitingForExternalInput.ID:
+            return admin_not_initialized_external_input_kind_js_1.AdminNotInitializedExternalInputKind.id;
+        case status_service_js_1.NotInitialized_WaitingForExternalInput.NODE_TOPOLOGY:
+            return admin_not_initialized_external_input_kind_js_1.AdminNotInitializedExternalInputKind.nodeTopology;
+        case status_service_js_1.NotInitialized_WaitingForExternalInput.INITIALIZATION:
+            return admin_not_initialized_external_input_kind_js_1.AdminNotInitializedExternalInputKind.initialization;
+        case status_service_js_1.NotInitialized_WaitingForExternalInput.UNSPECIFIED:
+        default:
+            return admin_not_initialized_external_input_kind_js_1.AdminNotInitializedExternalInputKind.unspecified;
+    }
+}
+function mapGrpcAdminComponentDescription(payload) {
+    switch (payload.status?.oneofKind) {
+        case "ok":
+            return payload.status.ok.description;
+        case "degraded":
+            return payload.status.degraded.description;
+        case "failed":
+            return payload.status.failed.description;
+        case "fatal":
+            return payload.status.fatal.description;
+        default:
+            return undefined;
+    }
+}
+function mapGrpcDuration(payload) {
+    if (payload === undefined || payload.seconds === undefined) {
+        return undefined;
+    }
+    return {
+        seconds: payload.seconds,
+        nanos: payload.nanos ?? 0,
+    };
+}

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

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapGrpcGetCommandStatusRequest = mapGrpcGetCommandStatusRequest;
+exports.mapGrpcGetCommandStatus = mapGrpcGetCommandStatus;
+const command_inspection_contract_js_1 = require("../../../core/types/command-inspection-contract.js");
+const command_request_statistics_js_1 = require("../../../core/types/command-request-statistics.js");
+const command_state_js_1 = require("../../../core/types/command-state.js");
+const command_status_js_1 = require("../../../core/types/command-status.js");
+const command_timing_js_1 = require("../../../core/types/command-timing.js");
+const command_update_summary_js_1 = require("../../../core/types/command-update-summary.js");
+const sdk_command_js_1 = require("../../../core/types/sdk-command.js");
+const daml_values_js_1 = require("../../../core/types/daml-values.js");
+const get_command_status_response_js_1 = require("../../../core/types/responses/get-command-status-response.js");
+const command_inspection_service_js_1 = require("../generated/canton/com/daml/ledger/api/v2/admin/command_inspection_service.js");
+const completion_mapper_js_1 = require("./completion-mapper.js");
+function mapGrpcGetCommandStatusRequest(request) {
+    return {
+        commandIdPrefix: request.commandIdPrefix ?? "",
+        state: mapSdkCommandState(request.state),
+        limit: request.limit ?? 0,
+    };
+}
+function mapGrpcGetCommandStatus(payload) {
+    return new get_command_status_response_js_1.GetCommandStatusResponse({
+        commandStatuses: (payload.commandStatus ?? []).map(mapGrpcCommandStatus),
+    });
+}
+function mapGrpcCommandStatus(payload) {
+    return new command_status_js_1.CommandStatus({
+        started: mapGrpcTimestamp(payload.started),
+        completed: mapGrpcTimestamp(payload.completed),
+        completion: payload.completion === undefined
+            ? undefined
+            : (0, completion_mapper_js_1.mapGrpcCompletion)(payload.completion),
+        state: mapGrpcCommandState(payload.state),
+        commands: payload.commands.map(mapGrpcCommand),
+        requestStatistics: payload.requestStatistics === undefined
+            ? undefined
+            : new command_request_statistics_js_1.CommandRequestStatistics(payload.requestStatistics),
+        updates: payload.updates === undefined
+            ? undefined
+            : new command_update_summary_js_1.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 command_timing_js_1.CommandTiming(item)),
+    });
+}
+function mapGrpcCommand(payload) {
+    switch (payload.command.oneofKind) {
+        case "create":
+            return new sdk_command_js_1.SdkCommand({
+                type: "create",
+                templateId: mapGrpcIdentifier(payload.command.create.templateId),
+                createArguments: mapGrpcRecord(payload.command.create.createArguments),
+            });
+        case "exercise":
+            return new sdk_command_js_1.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 sdk_command_js_1.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 sdk_command_js_1.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 sdk_command_js_1.SdkCommand({
+                type: "unspecified",
+            });
+    }
+}
+function mapGrpcCommandInspectionContract(payload) {
+    return new command_inspection_contract_js_1.CommandInspectionContract({
+        templateId: mapGrpcIdentifier(payload.templateId),
+        contractId: payload.contractId,
+        contractKey: mapGrpcValue(payload.contractKey),
+    });
+}
+function mapSdkCommandState(value) {
+    switch (value) {
+        case command_state_js_1.CommandState.pending:
+            return command_inspection_service_js_1.CommandState.PENDING;
+        case command_state_js_1.CommandState.succeeded:
+            return command_inspection_service_js_1.CommandState.SUCCEEDED;
+        case command_state_js_1.CommandState.failed:
+            return command_inspection_service_js_1.CommandState.FAILED;
+        default:
+            return command_inspection_service_js_1.CommandState.UNSPECIFIED;
+    }
+}
+function mapGrpcCommandState(value) {
+    switch (value) {
+        case command_inspection_service_js_1.CommandState.PENDING:
+            return command_state_js_1.CommandState.pending;
+        case command_inspection_service_js_1.CommandState.SUCCEEDED:
+            return command_state_js_1.CommandState.succeeded;
+        case command_inspection_service_js_1.CommandState.FAILED:
+            return command_state_js_1.CommandState.failed;
+        default:
+            return command_state_js_1.CommandState.unspecified;
+    }
+}
+function mapGrpcIdentifier(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return value;
+}
+function mapGrpcRecord(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return new daml_values_js_1.DamlRecord(Object.fromEntries(value.fields.map((field, index) => [
+        field.label || index.toString(),
+        mapGrpcValue(field.value),
+    ])), mapGrpcIdentifier(value.recordId));
+}
+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/cjs/transports/grpc/mappers/commands-mapper.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapGrpcSubmitCommandRequest = mapGrpcSubmitCommandRequest;
+exports.mapGrpcSubmitCommandForTransactionRequest = mapGrpcSubmitCommandForTransactionRequest;
+exports.mapGrpcSubmitCommandTransaction = mapGrpcSubmitCommandTransaction;
+exports.mapGrpcSubmitCommand = mapGrpcSubmitCommand;
+exports.mapGrpcLedgerCommand = mapGrpcLedgerCommand;
+exports.mapGrpcCreateCommand = mapGrpcCreateCommand;
+exports.mapRecord = mapRecord;
+exports.mapValue = mapValue;
+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_contract_id_js_1 = require("../../../core/types/daml-contract-id.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");
+const submit_command_transaction_response_js_1 = require("../../../core/types/responses/submit-command-transaction-response.js");
+function mapGrpcSubmitCommandRequest(request) {
+    return {
+        commands: {
+            workflowId: "",
+            userId: request.userId ?? "",
+            commandId: (0, node_crypto_1.randomUUID)(),
+            commands: [mapGrpcLedgerCommand(request.command)],
+            deduplicationPeriod: {
+                oneofKind: undefined,
+            },
+            actAs: [...request.actAs],
+            readAs: [...request.readAs],
+            submissionId: "",
+            disclosedContracts: request.disclosedContracts.map(mapGrpcDisclosedContract),
+            synchronizerId: request.synchronizerId ?? "",
+            packageIdSelectionPreference: [],
+            prefetchContractKeys: [],
+        },
+    };
+}
+function mapGrpcSubmitCommandForTransactionRequest(request) {
+    return { commands: mapGrpcSubmitCommandRequest(request).commands };
+}
+function mapGrpcSubmitCommandTransaction(payload) {
+    const transaction = payload.transaction;
+    return new submit_command_transaction_response_js_1.SubmitCommandTransactionResponse(transaction?.updateId ?? "", transaction?.events ?? [], transaction);
+}
+function mapGrpcDisclosedContract(value) {
+    return { createdEventBlob: value.createdEventBlob, contractId: value.contractId ?? "", synchronizerId: value.synchronizerId ?? "", templateId: value.templateId === undefined ? undefined : { packageId: value.templateId.packageId, moduleName: value.templateId.moduleName, entityName: value.templateId.entityName } };
+}
+function mapGrpcSubmitCommand(payload) {
+    return new submit_command_response_js_1.SubmitCommandResponse({
+        commandId: "commandId" in payload ? payload.commandId : undefined,
+        transactionId: "transactionId" in payload
+            ? payload.transactionId
+            : payload.updateId,
+    });
+}
+function mapGrpcLedgerCommand(command) {
+    if (command instanceof create_command_js_1.CreateCommand) {
+        return mapGrpcCreateCommand(command);
+    }
+    else if (command instanceof exercise_command_js_1.ExerciseCommand) {
+        return {
+            command: {
+                oneofKind: "exercise",
+                exercise: {
+                    templateId: command.templateId,
+                    contractId: command.contractId,
+                    choice: command.choice,
+                    choiceArgument: mapValue(command.choiceArgument),
+                },
+            },
+        };
+    }
+    else if (command instanceof exercise_by_key_command_js_1.ExerciseByKeyCommand) {
+        return {
+            command: {
+                oneofKind: "exerciseByKey",
+                exerciseByKey: {
+                    templateId: command.templateId,
+                    contractKey: mapValue(command.contractKey),
+                    choice: command.choice,
+                    choiceArgument: mapValue(command.choiceArgument),
+                },
+            },
+        };
+    }
+    else if (command instanceof create_and_exercise_command_js_1.CreateAndExerciseCommand) {
+        return {
+            command: {
+                oneofKind: "createAndExercise",
+                createAndExercise: {
+                    templateId: command.templateId,
+                    createArguments: mapRecord(command.createArguments),
+                    choice: command.choice,
+                    choiceArgument: mapValue(command.choiceArgument),
+                },
+            },
+        };
+    }
+    throw new validation_error_js_1.ValidationError("unsupported submit command type");
+}
+function mapGrpcCreateCommand(command) {
+    return {
+        command: {
+            oneofKind: "create",
+            create: {
+                templateId: command.templateId,
+                createArguments: mapRecord(command.createArguments),
+            },
+        },
+    };
+}
+function mapRecord(payload) {
+    const fields = payload instanceof daml_values_js_1.DamlRecord ? payload.fields : payload;
+    return {
+        ...(payload instanceof daml_values_js_1.DamlRecord && payload.recordId !== undefined
+            ? { recordId: payload.recordId }
+            : {}),
+        fields: Object.entries(fields).map(([label, value]) => ({
+            label,
+            value: mapValue(value),
+        })),
+    };
+}
+function mapValue(value) {
+    const identifier = (value) => ({ packageId: value.packageId, moduleName: value.moduleName, entityName: value.entityName });
+    if (value instanceof daml_values_js_1.DamlUnit) {
+        return { sum: { oneofKind: "unit", unit: {} } };
+    }
+    else if (value instanceof daml_values_js_1.DamlDate) {
+        return { sum: { oneofKind: "date", date: value.daysSinceEpoch } };
+    }
+    else if (value instanceof daml_values_js_1.DamlTimestamp) {
+        return { sum: { oneofKind: "timestamp", timestamp: value.microsecondsSinceEpoch } };
+    }
+    else if (value instanceof daml_values_js_1.DamlTextMap) {
+        return { sum: { oneofKind: "textMap", textMap: { entries: value.entries.map(([key, item]) => ({ key, value: mapValue(item) })) } } };
+    }
+    else if (value instanceof daml_values_js_1.DamlGenMap) {
+        return { sum: { oneofKind: "genMap", genMap: { entries: value.entries.map(([key, item]) => ({ key: mapValue(key), value: mapValue(item) })) } } };
+    }
+    else if (value instanceof daml_values_js_1.DamlVariant) {
+        return { sum: { oneofKind: "variant", variant: { variantId: value.variantId && identifier(value.variantId), constructor: value.constructorName, value: mapValue(value.value) } } };
+    }
+    else if (value instanceof daml_values_js_1.DamlEnum) {
+        return { sum: { oneofKind: "enum", enum: { enumId: value.enumId && identifier(value.enumId), constructor: value.constructorName } } };
+    }
+    else if (value instanceof daml_values_js_1.DamlRecord) {
+        return { sum: { oneofKind: "record", record: mapRecord(value) } };
+    }
+    else if (value === null || value === undefined) {
+        return {
+            sum: {
+                oneofKind: "optional",
+                optional: {},
+            },
+        };
+    }
+    else if (value instanceof daml_party_js_1.DamlParty) {
+        return {
+            sum: {
+                oneofKind: "party",
+                party: value.value,
+            },
+        };
+    }
+    else if (value instanceof daml_contract_id_js_1.DamlContractId) {
+        return { sum: { oneofKind: "contractId", contractId: value.value } };
+    }
+    else if (value instanceof daml_numeric_js_1.DamlNumeric) {
+        return {
+            sum: {
+                oneofKind: "numeric",
+                numeric: value.value,
+            },
+        };
+    }
+    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),
+        },
+    };
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapGrpcCompletion = mapGrpcCompletion;
+const completion_js_1 = require("../../../core/types/completion.js");
+const state_read_mapper_js_1 = require("./state-read-mapper.js");
+function mapGrpcCompletion(payload) {
+    return new completion_js_1.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
+            : (0, state_read_mapper_js_1.mapGrpcSynchronizerTime)(payload.synchronizerTime),
+        paidTrafficCost: payload.paidTrafficCost,
+        transactionHash: payload.transactionHash,
+    });
+}

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapGrpcQueryContractsRequest = mapGrpcQueryContractsRequest;
+exports.mapGrpcQueryContracts = mapGrpcQueryContracts;
+const validation_error_js_1 = require("../../../core/errors/validation-error.js");
+const query_contracts_response_js_1 = require("../../../core/types/responses/query-contracts-response.js");
+function mapGrpcQueryContractsRequest(request) {
+    return {
+        activeAtOffset: request.activeAtOffset,
+        eventFormat: createEventFormat(request),
+        maxPageSize: request.maxPageSize,
+        pageToken: request.pageToken,
+    };
+}
+function mapGrpcQueryContracts(payload) {
+    return new query_contracts_response_js_1.QueryContractsResponse({
+        contracts: payload.contracts
+            ?? payload.activeContracts?.map((contract) => contract.contractEntry?.oneofKind === "activeContract"
+                ? contract.contractEntry.activeContract
+                : contract)
+            ?? [],
+    });
+}
+function createEventFormat(request) {
+    const filters = createFilters(request);
+    const parties = request.parties ?? (request.party === undefined ? [] : [request.party]);
+    if (request.allParties === true) {
+        if (parties.length > 0) {
+            throw new validation_error_js_1.ValidationError("allParties cannot be combined with party filters");
+        }
+        return {
+            filtersByParty: {},
+            filtersForAnyParty: filters,
+            verbose: true,
+        };
+    }
+    else if (parties.length === 0) {
+        throw new validation_error_js_1.ValidationError("A party filter or allParties is required");
+    }
+    return {
+        filtersByParty: Object.fromEntries(parties.map((party) => [party, filters])),
+        verbose: true,
+    };
+}
+function createFilters(request) {
+    const cumulative = [];
+    const includeCreatedEventBlob = request.includeCreatedEventBlob ?? false;
+    if (request.templateId) {
+        cumulative.push({
+            identifierFilter: {
+                oneofKind: "templateFilter",
+                templateFilter: {
+                    templateId: parseIdentifier(request.templateId, "templateId"),
+                    includeCreatedEventBlob,
+                },
+            },
+        });
+    }
+    if (request.interfaceId) {
+        cumulative.push({
+            identifierFilter: {
+                oneofKind: "interfaceFilter",
+                interfaceFilter: {
+                    interfaceId: parseIdentifier(request.interfaceId, "interfaceId"),
+                    includeInterfaceView: request.includeInterfaceView ?? false,
+                    includeCreatedEventBlob,
+                },
+            },
+        });
+    }
+    if (cumulative.length === 0) {
+        cumulative.push(createWildcardFilter(includeCreatedEventBlob));
+    }
+    return { cumulative };
+}
+function createWildcardFilter(includeCreatedEventBlob) {
+    return {
+        identifierFilter: {
+            oneofKind: "wildcardFilter",
+            wildcardFilter: {
+                includeCreatedEventBlob,
+            },
+        },
+    };
+}
+function parseIdentifier(value, propertyName) {
+    const parts = value.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 validation_error_js_1.ValidationError(`${propertyName} must be '<module>:<entity>' or '<package>:<module>:<entity>', but was '${value}'.`);
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapGrpcHealthCheckResponse = mapGrpcHealthCheckResponse;
+const health_check_status_js_1 = require("../../../core/types/health-check-status.js");
+const health_check_response_js_1 = require("../../../core/types/responses/health-check-response.js");
+const health_js_1 = require("../generated/canton/google/grpc/health/v1/health.js");
+function mapGrpcHealthCheckResponse(payload) {
+    return new health_check_response_js_1.HealthCheckResponse({
+        status: mapGrpcHealthStatus(payload.status),
+    });
+}
+function mapGrpcHealthStatus(status) {
+    switch (status) {
+        case health_js_1.HealthCheckResponse_ServingStatus.SERVING:
+            return health_check_status_js_1.HealthCheckStatus.serving;
+        case health_js_1.HealthCheckResponse_ServingStatus.NOT_SERVING:
+            return health_check_status_js_1.HealthCheckStatus.notServing;
+        case health_js_1.HealthCheckResponse_ServingStatus.SERVICE_UNKNOWN:
+            return health_check_status_js_1.HealthCheckStatus.serviceUnknown;
+        case health_js_1.HealthCheckResponse_ServingStatus.UNKNOWN:
+        default:
+            return health_check_status_js_1.HealthCheckStatus.unknown;
+    }
+}