@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/daml-interface/errors/daml-interface-unsupported-shape.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlInterfaceUnsupportedShapeException = void 0;
+class DamlInterfaceUnsupportedShapeException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DamlInterfaceUnsupportedShapeException";
+    }
+}
+exports.DamlInterfaceUnsupportedShapeException = DamlInterfaceUnsupportedShapeException;

package/dist/cjs/daml-interface/errors/daml-interface-write.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlInterfaceWriteException = void 0;
+class DamlInterfaceWriteException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DamlInterfaceWriteException";
+    }
+}
+exports.DamlInterfaceWriteException = DamlInterfaceWriteException;

package/dist/cjs/daml-interface/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlVariant = exports.DamlUnit = exports.DamlTimestamp = exports.DamlTextMap = exports.DamlRecord = exports.DamlGenMap = exports.DamlEnum = exports.DamlDate = exports.DamlParty = exports.DamlNumeric = exports.DamlEventSourceNormalizer = exports.DamlValueMaterializer = exports.DamlValueConverter = exports.DamlMaterializationError = exports.DamlTemplate = exports.DamlInterfaceWriter = exports.DamlInterfaceWriteException = exports.DamlInterfaceUnsupportedShapeException = exports.DamlInterfaceGenerationException = exports.GeneratedNamedTypeFile = exports.GeneratedTemplateBindingFile = exports.GeneratedDamlInterfaceProject = exports.DamlModuleImportStyles = exports.DamlInterfaceGeneratorOptions = exports.DamlInterfaceGenerator = exports.AnalyzedTemplateField = exports.AnalyzedTemplate = exports.AnalyzedChoice = exports.DamlInterfaceAnalyzer = exports.DamlInterfaceCliOptions = exports.DamlInterfaceCli = void 0;
+var daml_interface_cli_js_1 = require("./cli/daml-interface-cli.js");
+Object.defineProperty(exports, "DamlInterfaceCli", { enumerable: true, get: function () { return daml_interface_cli_js_1.DamlInterfaceCli; } });
+var daml_interface_cli_options_js_1 = require("./cli/daml-interface-cli-options.js");
+Object.defineProperty(exports, "DamlInterfaceCliOptions", { enumerable: true, get: function () { return daml_interface_cli_options_js_1.DamlInterfaceCliOptions; } });
+var daml_interface_analyzer_js_1 = require("./analysis/daml-interface-analyzer.js");
+Object.defineProperty(exports, "DamlInterfaceAnalyzer", { enumerable: true, get: function () { return daml_interface_analyzer_js_1.DamlInterfaceAnalyzer; } });
+var analyzed_choice_js_1 = require("./analysis/analyzed-choice.js");
+Object.defineProperty(exports, "AnalyzedChoice", { enumerable: true, get: function () { return analyzed_choice_js_1.AnalyzedChoice; } });
+var analyzed_template_js_1 = require("./analysis/analyzed-template.js");
+Object.defineProperty(exports, "AnalyzedTemplate", { enumerable: true, get: function () { return analyzed_template_js_1.AnalyzedTemplate; } });
+Object.defineProperty(exports, "AnalyzedTemplateField", { enumerable: true, get: function () { return analyzed_template_js_1.AnalyzedTemplateField; } });
+var daml_interface_generator_js_1 = require("./daml-interface-generator.js");
+Object.defineProperty(exports, "DamlInterfaceGenerator", { enumerable: true, get: function () { return daml_interface_generator_js_1.DamlInterfaceGenerator; } });
+var daml_interface_generator_options_js_1 = require("./daml-interface-generator-options.js");
+Object.defineProperty(exports, "DamlInterfaceGeneratorOptions", { enumerable: true, get: function () { return daml_interface_generator_options_js_1.DamlInterfaceGeneratorOptions; } });
+var daml_module_import_style_js_1 = require("./emission/daml-module-import-style.js");
+Object.defineProperty(exports, "DamlModuleImportStyles", { enumerable: true, get: function () { return daml_module_import_style_js_1.DamlModuleImportStyles; } });
+var generated_daml_interface_project_js_1 = require("./emission-model/generated-daml-interface-project.js");
+Object.defineProperty(exports, "GeneratedDamlInterfaceProject", { enumerable: true, get: function () { return generated_daml_interface_project_js_1.GeneratedDamlInterfaceProject; } });
+var generated_template_binding_file_js_1 = require("./emission-model/generated-template-binding-file.js");
+Object.defineProperty(exports, "GeneratedTemplateBindingFile", { enumerable: true, get: function () { return generated_template_binding_file_js_1.GeneratedTemplateBindingFile; } });
+var generated_named_type_file_js_1 = require("./emission-model/generated-named-type-file.js");
+Object.defineProperty(exports, "GeneratedNamedTypeFile", { enumerable: true, get: function () { return generated_named_type_file_js_1.GeneratedNamedTypeFile; } });
+var daml_interface_generation_exception_js_1 = require("./errors/daml-interface-generation.exception.js");
+Object.defineProperty(exports, "DamlInterfaceGenerationException", { enumerable: true, get: function () { return daml_interface_generation_exception_js_1.DamlInterfaceGenerationException; } });
+var daml_interface_unsupported_shape_exception_js_1 = require("./errors/daml-interface-unsupported-shape.exception.js");
+Object.defineProperty(exports, "DamlInterfaceUnsupportedShapeException", { enumerable: true, get: function () { return daml_interface_unsupported_shape_exception_js_1.DamlInterfaceUnsupportedShapeException; } });
+var daml_interface_write_exception_js_1 = require("./errors/daml-interface-write.exception.js");
+Object.defineProperty(exports, "DamlInterfaceWriteException", { enumerable: true, get: function () { return daml_interface_write_exception_js_1.DamlInterfaceWriteException; } });
+var daml_interface_writer_js_1 = require("./writing/daml-interface-writer.js");
+Object.defineProperty(exports, "DamlInterfaceWriter", { enumerable: true, get: function () { return daml_interface_writer_js_1.DamlInterfaceWriter; } });
+var daml_template_js_1 = require("./runtime/daml-template.js");
+Object.defineProperty(exports, "DamlTemplate", { enumerable: true, get: function () { return daml_template_js_1.DamlTemplate; } });
+var daml_materialization_error_js_1 = require("./runtime/daml-materialization-error.js");
+Object.defineProperty(exports, "DamlMaterializationError", { enumerable: true, get: function () { return daml_materialization_error_js_1.DamlMaterializationError; } });
+var daml_value_converter_js_1 = require("./runtime/daml-value-converter.js");
+Object.defineProperty(exports, "DamlValueConverter", { enumerable: true, get: function () { return daml_value_converter_js_1.DamlValueConverter; } });
+var daml_value_materializer_js_1 = require("./runtime/daml-value-materializer.js");
+Object.defineProperty(exports, "DamlValueMaterializer", { enumerable: true, get: function () { return daml_value_materializer_js_1.DamlValueMaterializer; } });
+var daml_event_source_normalizer_js_1 = require("./runtime/daml-event-source-normalizer.js");
+Object.defineProperty(exports, "DamlEventSourceNormalizer", { enumerable: true, get: function () { return daml_event_source_normalizer_js_1.DamlEventSourceNormalizer; } });
+var daml_numeric_js_1 = require("../core/types/daml-numeric.js");
+Object.defineProperty(exports, "DamlNumeric", { enumerable: true, get: function () { return daml_numeric_js_1.DamlNumeric; } });
+var daml_party_js_1 = require("../core/types/daml-party.js");
+Object.defineProperty(exports, "DamlParty", { enumerable: true, get: function () { return daml_party_js_1.DamlParty; } });
+var daml_values_js_1 = require("../core/types/daml-values.js");
+Object.defineProperty(exports, "DamlDate", { enumerable: true, get: function () { return daml_values_js_1.DamlDate; } });
+Object.defineProperty(exports, "DamlEnum", { enumerable: true, get: function () { return daml_values_js_1.DamlEnum; } });
+Object.defineProperty(exports, "DamlGenMap", { enumerable: true, get: function () { return daml_values_js_1.DamlGenMap; } });
+Object.defineProperty(exports, "DamlRecord", { enumerable: true, get: function () { return daml_values_js_1.DamlRecord; } });
+Object.defineProperty(exports, "DamlTextMap", { enumerable: true, get: function () { return daml_values_js_1.DamlTextMap; } });
+Object.defineProperty(exports, "DamlTimestamp", { enumerable: true, get: function () { return daml_values_js_1.DamlTimestamp; } });
+Object.defineProperty(exports, "DamlUnit", { enumerable: true, get: function () { return daml_values_js_1.DamlUnit; } });
+Object.defineProperty(exports, "DamlVariant", { enumerable: true, get: function () { return daml_values_js_1.DamlVariant; } });

package/dist/cjs/daml-interface/runtime/daml-event-source-normalizer.js

@@ -0,0 +1,532 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlEventSourceNormalizer = void 0;
+const runtime_1 = require("@protobuf-ts/runtime");
+const contract_service_js_1 = require("../../transports/grpc/generated/canton/com/daml/ledger/api/v2/contract_service.js");
+const event_js_1 = require("../../transports/grpc/generated/canton/com/daml/ledger/api/v2/event.js");
+const state_service_js_1 = require("../../transports/grpc/generated/canton/com/daml/ledger/api/v2/state_service.js");
+const value_js_1 = require("../../transports/grpc/generated/canton/com/daml/ledger/api/v2/value.js");
+const daml_materialization_error_js_1 = require("./daml-materialization-error.js");
+const DAML_MIN_TIMESTAMP_SECONDS = -62135596800n;
+const DAML_MAX_TIMESTAMP_SECONDS = 253402300799n;
+/** Recognizes Ledger API and PQS event sources as immutable DAML event shapes. */
+class DamlEventSourceNormalizer {
+    constructor() { }
+    /** Recognizes a Ledger API create event, contract response/wrapper, or PQS/JSON contract record. */
+    static normalizeCreated(source) {
+        return normalizeDamlCreatedEventSource(source);
+    }
+    /** Recognizes a Ledger API exercise event or a PQS/JSON exercise record. */
+    static normalizeExercised(source) {
+        return normalizeDamlExercisedEventSource(source);
+    }
+}
+exports.DamlEventSourceNormalizer = DamlEventSourceNormalizer;
+function normalizeDamlCreatedEventSource(source) {
+    const recognized = findNestedEvent(source, "created");
+    const { event } = recognized;
+    const contractId = requiredString(event, ["contractId", "contract_id"], "contract ID", "created event source");
+    const templateId = requiredIdentity(event, source, "created event source");
+    const payload = requiredProperty(event, ["createArguments", "create_arguments", "payload"], "created payload", "created event source");
+    const metadata = freezeCreatedMetadata(event, templateId);
+    return Object.freeze({
+        kind: "created",
+        contractId,
+        payload: freezeCreatedValueSource(payload, recognized.encoding),
+        metadata,
+    });
+}
+function normalizeDamlExercisedEventSource(source) {
+    const recognized = findNestedEvent(source, "exercised");
+    const { event } = recognized;
+    const contractId = requiredString(event, ["contractId", "contract_id"], "contract ID", "exercised event source");
+    const templateId = requiredIdentity(event, source, "exercised event source");
+    const choice = requiredStringFrom(event, source, ["choice"], "choice", "exercised event source");
+    const consuming = requiredBooleanFrom(event, source, ["consuming"], "consuming", "exercised event source");
+    const argument = requiredProperty(event, ["choiceArgument", "choice_argument", "argument"], "exercise argument", "exercised event source");
+    const result = requiredProperty(event, ["exerciseResult", "exercise_result", "result"], "exercise result", "exercised event source");
+    const metadata = freezeExercisedMetadata(event, source, templateId);
+    return Object.freeze({
+        kind: "exercised",
+        contractId,
+        choice,
+        argument: freezeValueSource(argument, recognized.encoding),
+        result: freezeValueSource(result, recognized.encoding),
+        consuming,
+        metadata,
+    });
+}
+function findNestedEvent(source, kind) {
+    const root = objectOrThrow(source, `${kind} event source`, "source must be an object");
+    const candidates = [];
+    const aliases = kind === "created" ? ["createdEvent", "created_event"] : ["exercisedEvent", "exercised_event"];
+    if (looksLikeEvent(root, kind)) {
+        candidates.push({ event: root, encoding: protobufEncoding(root, kind) });
+    }
+    for (const alias of aliases) {
+        if (hasValue(root, alias)) {
+            candidates.push({ event: objectOrThrow(root[alias], `${kind} event source`, "event must be an object"), encoding: protobufEncoding(root, kind) });
+        }
+    }
+    const nested = asObject(root.event);
+    if (nested !== undefined) {
+        const nestedAliases = kind === "created" ? ["created", "createdEvent", "created_event"] : ["exercised", "exercisedEvent", "exercised_event"];
+        for (const alias of nestedAliases) {
+            if (hasValue(nested, alias)) {
+                candidates.push({ event: objectOrThrow(nested[alias], `${kind} event source`, "event must be an object"), encoding: protobufEncoding(nested[alias], kind) });
+            }
+        }
+    }
+    if (candidates.length === 0) {
+        throw sourceError(`${kind} event source`, "no event or payload was found");
+    }
+    else if (candidates.length !== 1) {
+        throw sourceError(`${kind} event source`, "ambiguous nested event");
+    }
+    return candidates[0];
+}
+function protobufEncoding(value, kind) {
+    if (isGeneratedMessage(value, kind === "created" ? event_js_1.CreatedEvent : event_js_1.ExercisedEvent)) {
+        return "protobuf";
+    }
+    else if (kind === "created" && (isGeneratedMessage(value, contract_service_js_1.GetContractResponse) || isGeneratedMessage(value, state_service_js_1.ActiveContract))) {
+        return "protobuf";
+    }
+    return "json";
+}
+function isGeneratedMessage(value, type) {
+    return value !== null
+        && typeof value === "object"
+        && value[runtime_1.MESSAGE_TYPE] === type;
+}
+function looksLikeEvent(value, kind) {
+    const fields = kind === "created"
+        ? ["contractId", "contract_id", "templateId", "template_id", "createArguments", "create_arguments", "payload"]
+        : ["contractId", "contract_id", "templateId", "template_id", "choiceArgument", "choice_argument", "argument", "exerciseResult", "exercise_result", "result"];
+    return fields.some((field) => Object.prototype.hasOwnProperty.call(value, field));
+}
+function requiredIdentity(event, source, path) {
+    const direct = readProperty(event, ["templateId", "template_id"]);
+    if (direct.found) {
+        return identityFrom(direct.value, path);
+    }
+    const root = asObject(source);
+    const contract = asObject(readProperty(event, ["contract"]).value) ?? asObject(root?.contract);
+    const contractIdentity = contract === undefined ? { found: false } : readProperty(contract, ["templateId", "template_id"]);
+    if (contractIdentity.found) {
+        return identityFrom(contractIdentity.value, path);
+    }
+    const type = asObject(readProperty(event, ["exerciseType", "exercise_type", "contractType", "contract_type"]).value)
+        ?? asObject(root?.exerciseType)
+        ?? asObject(root?.exercise_type)
+        ?? asObject(root?.contractType)
+        ?? asObject(root?.contract_type);
+    const packageRecord = asObject(readProperty(event, ["package"]).value) ?? asObject(root?.package);
+    if (type !== undefined) {
+        return identityFrom({
+            packageId: readProperty(type, ["packageId", "package_id"]).value ?? readProperty(packageRecord ?? {}, ["id", "packageId", "package_id"]).value,
+            moduleName: readProperty(type, ["moduleName", "module_name"]).value,
+            entityName: readProperty(type, ["entityName", "entity_name"]).value,
+        }, path);
+    }
+    throw sourceError(path, "template identity is absent");
+}
+function identityFrom(value, path) {
+    const identifier = asObject(value);
+    if (identifier === undefined) {
+        throw sourceError(path, "template identity is absent");
+    }
+    const packageId = stringValue(readProperty(identifier, ["packageId", "package_id"]).value);
+    const moduleName = stringValue(readProperty(identifier, ["moduleName", "module_name"]).value);
+    const entityName = stringValue(readProperty(identifier, ["entityName", "entity_name"]).value);
+    if (packageId === undefined || moduleName === undefined || entityName === undefined) {
+        throw sourceError(path, "template identity is incomplete");
+    }
+    return Object.freeze({ packageId, moduleName, entityName });
+}
+function freezeCreatedMetadata(event, templateId) {
+    return Object.freeze(removeUndefined({
+        templateId,
+        offset: optionalString(event, ["offset", "createdEventOffset", "created_event_offset"], "offset", "created event source"),
+        nodeId: optionalNodeId(event, ["nodeId", "node_id"], "node ID", "created event source"),
+        witnessParties: optionalStringArray(event, ["witnessParties", "witness_parties", "witnesses"], "witness parties", "created event source"),
+        signatories: optionalStringArray(event, ["signatories"], "signatories", "created event source"),
+        observers: optionalStringArray(event, ["observers"], "observers", "created event source"),
+        createdAt: optionalCreatedAt(event, ["createdAt", "created_at"], "created event source"),
+    }));
+}
+function freezeExercisedMetadata(event, source, templateId) {
+    const root = asObject(source);
+    const transaction = asObject(readProperty(event, ["transaction"]).value) ?? asObject(root?.transaction);
+    return Object.freeze(removeUndefined({
+        templateId,
+        offset: optionalString(event, ["offset"], "offset", "exercised event source")
+            ?? optionalString(transaction ?? {}, ["offset"], "offset", "exercised event source"),
+        nodeId: optionalNodeId(event, ["nodeId", "node_id"], "node ID", "exercised event source"),
+        actingParties: optionalStringArray(event, ["actingParties", "acting_parties", "controllers"], "acting parties", "exercised event source"),
+        witnessParties: optionalStringArray(event, ["witnessParties", "witness_parties", "witnesses"], "witness parties", "exercised event source"),
+        lastDescendantNodeId: optionalNodeId(event, ["lastDescendantNodeId", "last_descendant_node_id"], "last descendant node ID", "exercised event source"),
+    }));
+}
+function requiredStringFrom(event, source, names, label, path) {
+    const direct = readProperty(event, names);
+    if (direct.found) {
+        return requiredStringValue(direct.value, label, path);
+    }
+    const root = asObject(source);
+    const type = asObject(readProperty(event, ["exerciseType", "exercise_type"]).value)
+        ?? asObject(root?.exerciseType)
+        ?? asObject(root?.exercise_type);
+    const nested = type === undefined ? { found: false } : readProperty(type, names);
+    return requiredStringValue(nested.value, label, path);
+}
+function requiredBooleanFrom(event, source, names, label, path) {
+    const direct = readProperty(event, names);
+    if (direct.found) {
+        return requiredBooleanValue(direct.value, label, path);
+    }
+    const root = asObject(source);
+    const type = asObject(readProperty(event, ["exerciseType", "exercise_type"]).value)
+        ?? asObject(root?.exerciseType)
+        ?? asObject(root?.exercise_type);
+    const nested = type === undefined ? { found: false } : readProperty(type, names);
+    return requiredBooleanValue(nested.value, label, path);
+}
+function requiredString(event, names, label, path) {
+    return requiredStringValue(readProperty(event, names).value, label, path);
+}
+function requiredStringValue(value, label, path) {
+    const string = stringValue(value);
+    if (string === undefined) {
+        throw sourceError(path, `${label} is absent`);
+    }
+    return string;
+}
+function requiredBooleanValue(value, label, path) {
+    if (typeof value !== "boolean") {
+        throw sourceError(path, `${label} is absent`);
+    }
+    return value;
+}
+function requiredProperty(event, names, label, path) {
+    const property = readProperty(event, names);
+    if (!property.found) {
+        throw sourceError(path, `${label} is absent`);
+    }
+    return property.value;
+}
+function freezeValueSource(value, encoding) {
+    if (encoding === "protobuf") {
+        return Object.freeze({ kind: "protobuf", value: cloneAndFreeze(value) });
+    }
+    else if (encoding === "protobuf-record") {
+        return Object.freeze({
+            kind: "protobuf",
+            value: cloneAndFreeze({ sum: { oneofKind: "record", record: value } }),
+        });
+    }
+    return Object.freeze({ kind: "json", value: cloneAndFreeze(value) });
+}
+function freezeCreatedValueSource(value, encoding) {
+    if (encoding === "protobuf") {
+        return freezeValueSource(value, "protobuf-record");
+    }
+    else if (isRecordWireJson(value)) {
+        return freezeValueSource(value_js_1.Value.fromJson({ record: value }), "protobuf");
+    }
+    return freezeValueSource(value, "json");
+}
+const VALUE_JSON_VARIANTS = new Set([
+    "unit",
+    "bool",
+    "int64",
+    "date",
+    "timestamp",
+    "numeric",
+    "party",
+    "text",
+    "contractId",
+    "optional",
+    "list",
+    "textMap",
+    "genMap",
+    "record",
+    "variant",
+    "enum",
+]);
+function isRecordWireJson(value) {
+    const record = asObject(value);
+    return record !== undefined
+        && hasOnlyKeys(record, ["recordId", "fields"])
+        && Array.isArray(record.fields)
+        && isAbsentOr(record, "recordId", isIdentifierJson)
+        && record.fields.every(isRecordFieldJson);
+}
+function isRecordFieldJson(value) {
+    const field = asObject(value);
+    return field !== undefined
+        && hasOnlyKeys(field, ["label", "value"])
+        && isAbsentOr(field, "label", (label) => typeof label === "string")
+        && isValueJson(field.value);
+}
+function isValueJson(value) {
+    const json = asObject(value);
+    if (json === undefined) {
+        return false;
+    }
+    const variants = Object.keys(json).filter((key) => VALUE_JSON_VARIANTS.has(key));
+    if (variants.length !== 1 || Object.keys(json).length !== 1) {
+        return false;
+    }
+    const variant = variants[0];
+    switch (variant) {
+        case "unit":
+            return isEmptyJsonObject(json.unit);
+        case "bool":
+            return typeof json.bool === "boolean";
+        case "int64":
+        case "timestamp":
+        case "numeric":
+        case "party":
+        case "text":
+        case "contractId":
+            return typeof json[variant] === "string";
+        case "date":
+            return typeof json.date === "number" && Number.isSafeInteger(json.date);
+        case "optional":
+            return isOptionalJson(json.optional);
+        case "list":
+            return isListJson(json.list);
+        case "textMap":
+            return isTextMapJson(json.textMap);
+        case "genMap":
+            return isGenMapJson(json.genMap);
+        case "record":
+            return isNestedRecordJson(json.record);
+        case "variant":
+            return isVariantJson(json.variant);
+        case "enum":
+            return isEnumJson(json.enum);
+        default:
+            return false;
+    }
+}
+function isEmptyJsonObject(value) {
+    const json = asObject(value);
+    return json !== undefined && Object.keys(json).length === 0;
+}
+function isOptionalJson(value) {
+    const json = asObject(value);
+    return json !== undefined
+        && hasOnlyKeys(json, ["value"])
+        && isAbsentOr(json, "value", isValueJson);
+}
+function isListJson(value) {
+    const json = asObject(value);
+    return json !== undefined
+        && hasOnlyKeys(json, ["elements"])
+        && isAbsentOr(json, "elements", (elements) => Array.isArray(elements) && elements.every(isValueJson));
+}
+function isTextMapJson(value) {
+    const json = asObject(value);
+    return json !== undefined
+        && hasOnlyKeys(json, ["entries"])
+        && isAbsentOr(json, "entries", (entries) => Array.isArray(entries) && entries.every((entry) => {
+            const item = asObject(entry);
+            return item !== undefined
+                && hasOnlyKeys(item, ["key", "value"])
+                && typeof item.key === "string"
+                && isValueJson(item.value);
+        }));
+}
+function isGenMapJson(value) {
+    const json = asObject(value);
+    return json !== undefined
+        && hasOnlyKeys(json, ["entries"])
+        && isAbsentOr(json, "entries", (entries) => Array.isArray(entries) && entries.every((entry) => {
+            const item = asObject(entry);
+            return item !== undefined
+                && hasOnlyKeys(item, ["key", "value"])
+                && isValueJson(item.key)
+                && isValueJson(item.value);
+        }));
+}
+function isNestedRecordJson(value) {
+    const record = asObject(value);
+    return record !== undefined
+        && hasOnlyKeys(record, ["recordId", "fields"])
+        && isAbsentOr(record, "recordId", isIdentifierJson)
+        && isAbsentOr(record, "fields", (fields) => Array.isArray(fields) && fields.every(isRecordFieldJson));
+}
+function isVariantJson(value) {
+    const variant = asObject(value);
+    return variant !== undefined
+        && hasOnlyKeys(variant, ["variantId", "constructor", "value"])
+        && isAbsentOr(variant, "variantId", isIdentifierJson)
+        && typeof variant.constructor === "string"
+        && isValueJson(variant.value);
+}
+function isEnumJson(value) {
+    const enumValue = asObject(value);
+    return enumValue !== undefined
+        && hasOnlyKeys(enumValue, ["enumId", "constructor"])
+        && isAbsentOr(enumValue, "enumId", isIdentifierJson)
+        && typeof enumValue.constructor === "string";
+}
+function isIdentifierJson(value) {
+    const identifier = asObject(value);
+    return identifier !== undefined
+        && hasOnlyKeys(identifier, ["packageId", "moduleName", "entityName"])
+        && typeof identifier.packageId === "string"
+        && typeof identifier.moduleName === "string"
+        && typeof identifier.entityName === "string";
+}
+function hasOnlyKeys(value, keys) {
+    return Object.keys(value).every((key) => keys.includes(key));
+}
+function isAbsentOr(value, key, predicate) {
+    return !Object.prototype.hasOwnProperty.call(value, key) || predicate(value[key]);
+}
+function optionalString(event, names, label, path) {
+    const property = readProperty(event, names);
+    if (!property.found) {
+        return undefined;
+    }
+    const value = stringValue(property.value);
+    if (value === undefined) {
+        throw sourceError(path, `${label} must be a non-empty string`);
+    }
+    return value;
+}
+function optionalNodeId(event, names, label, path) {
+    const property = readProperty(event, names);
+    if (!property.found) {
+        return undefined;
+    }
+    const value = property.value;
+    const number = typeof value === "number" ? value : typeof value === "string" && /^\d+$/.test(value) ? Number(value) : undefined;
+    if (number === undefined || !Number.isSafeInteger(number) || number < 0) {
+        throw sourceError(path, `${label} must be a non-negative safe integer`);
+    }
+    return number;
+}
+function optionalStringArray(event, names, label, path) {
+    const property = readProperty(event, names);
+    if (!property.found) {
+        return undefined;
+    }
+    else if (!Array.isArray(property.value) || !property.value.every((item) => typeof item === "string")) {
+        throw sourceError(path, `${label} must be an array of strings`);
+    }
+    return cloneAndFreeze(property.value);
+}
+function optionalCreatedAt(event, names, path) {
+    const property = readProperty(event, names);
+    if (!property.found || property.value === null) {
+        return undefined;
+    }
+    else if (property.value instanceof Date) {
+        return canonicalDateTimestamp(property.value, path);
+    }
+    else if (typeof property.value === "string") {
+        return canonicalIsoTimestamp(property.value, path);
+    }
+    return canonicalProtobufTimestamp(property.value, path);
+}
+function canonicalIsoTimestamp(value, path) {
+    const match = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?Z$/.exec(value);
+    if (match === null) {
+        throw sourceError(path, "created at must be a UTC ISO-8601 timestamp");
+    }
+    const milliseconds = (match[2] ?? "").padEnd(3, "0").slice(0, 3);
+    const date = new Date(`${match[1]}.${milliseconds}Z`);
+    if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 19) !== match[1]) {
+        throw sourceError(path, "created at must be a valid timestamp");
+    }
+    requireLedgerTimestampSeconds(BigInt(Math.floor(date.getTime() / 1000)), path);
+    return `${match[1]}.${(match[2] ?? "").padEnd(9, "0")}Z`;
+}
+function canonicalProtobufTimestamp(value, path) {
+    const timestamp = asObject(value);
+    const seconds = timestamp === undefined ? undefined : readProperty(timestamp, ["seconds"]).value;
+    const nanos = timestamp === undefined ? undefined : readProperty(timestamp, ["nanos"]).value;
+    if (typeof seconds !== "string" || !/^-?\d+$/.test(seconds) || typeof nanos !== "number" || !Number.isSafeInteger(nanos) || nanos < 0 || nanos > 999999999) {
+        throw sourceError(path, "created at must be a valid timestamp");
+    }
+    const secondsValue = BigInt(seconds);
+    requireLedgerTimestampSeconds(secondsValue, path);
+    const date = new Date(Number(secondsValue * 1000n));
+    if (Number.isNaN(date.getTime())) {
+        throw sourceError(path, "created at must be a valid timestamp");
+    }
+    const base = date.toISOString().replace(".000Z", "");
+    return `${base}.${nanos.toString().padStart(9, "0")}Z`;
+}
+function canonicalDateTimestamp(value, path) {
+    const milliseconds = value.getTime();
+    if (Number.isNaN(milliseconds)) {
+        throw sourceError(path, "created at must be a valid timestamp");
+    }
+    requireLedgerTimestampSeconds(BigInt(Math.floor(milliseconds / 1000)), path);
+    return value.toISOString().replace(/\.(\d{3})Z$/, (_match, milliseconds) => `.${milliseconds}000000Z`);
+}
+function requireLedgerTimestampSeconds(seconds, path) {
+    if (seconds < DAML_MIN_TIMESTAMP_SECONDS || seconds > DAML_MAX_TIMESTAMP_SECONDS) {
+        throw sourceError(path, "created at must be within DAML timestamp bounds");
+    }
+}
+function readProperty(object, names) {
+    for (const name of names) {
+        if (Object.prototype.hasOwnProperty.call(object, name) && object[name] !== undefined) {
+            return { found: true, value: object[name] };
+        }
+    }
+    return { found: false };
+}
+function hasValue(object, name) {
+    return Object.prototype.hasOwnProperty.call(object, name) && object[name] !== undefined;
+}
+function objectOrThrow(value, path, detail) {
+    const object = asObject(value);
+    if (object === undefined) {
+        throw sourceError(path, detail);
+    }
+    return object;
+}
+function asObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function cloneAndFreeze(value, seen = new WeakMap()) {
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    else if (value instanceof Date) {
+        return Object.freeze(new Date(value.getTime()));
+    }
+    const existing = seen.get(value);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const output = Array.isArray(value)
+        ? []
+        : Object.create(Object.getPrototypeOf(value));
+    seen.set(value, output);
+    for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor !== undefined && "value" in descriptor) {
+            Object.defineProperty(output, key, { ...descriptor, value: cloneAndFreeze(descriptor.value, seen) });
+        }
+    }
+    return Object.freeze(output);
+}
+function removeUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== undefined));
+}
+function sourceError(path, detail) {
+    return new daml_materialization_error_js_1.DamlMaterializationError(path, detail);
+}

package/dist/cjs/daml-interface/runtime/daml-materialization-error.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlMaterializationError = void 0;
+/** Raised when a transport value cannot be materialized as its DAML descriptor. */
+class DamlMaterializationError extends Error {
+    path;
+    constructor(path, detail) {
+        super(`${path}: ${detail}`);
+        this.name = "DamlMaterializationError";
+        this.path = path;
+    }
+}
+exports.DamlMaterializationError = DamlMaterializationError;

package/dist/cjs/daml-interface/runtime/daml-template.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlTemplate = void 0;
+/** Base class for generated DAML template bindings. */
+class DamlTemplate {
+    #contractId;
+    constructor(contractId) {
+        this.#contractId = contractId;
+    }
+    get contractId() {
+        return this.#contractId;
+    }
+}
+exports.DamlTemplate = DamlTemplate;

package/dist/cjs/daml-interface/runtime/daml-type-descriptor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });