@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/daml-lf/model/lf-2-model-mapper.js

@@ -0,0 +1,731 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lf2ModelMapper = void 0;
+const daml_lf2_js_1 = require("../../transports/grpc/generated/canton/com/digitalasset/daml/lf/archive/daml_lf2.js");
+const daml_lf_decode_exception_js_1 = require("../errors/daml-lf-decode.exception.js");
+const daml_lf_builtin_type_js_1 = require("./daml-lf-builtin-type.js");
+const daml_lf_choice_js_1 = require("./daml-lf-choice.js");
+const daml_lf_choice_parameter_js_1 = require("./daml-lf-choice-parameter.js");
+const daml_lf_data_type_js_1 = require("./daml-lf-data-type.js");
+const daml_lf_expression_js_1 = require("./daml-lf-expression.js");
+const daml_lf_field_js_1 = require("./daml-lf-field.js");
+const daml_lf_module_js_1 = require("./daml-lf-module.js");
+const daml_lf_package_js_1 = require("./daml-lf-package.js");
+const daml_lf_template_js_1 = require("./daml-lf-template.js");
+const daml_lf_template_id_js_1 = require("./daml-lf-template-id.js");
+const daml_lf_type_js_1 = require("./daml-lf-type.js");
+const daml_lf_value_definition_js_1 = require("./daml-lf-value-definition.js");
+const type_con_reference_js_1 = require("./type-con-reference.js");
+class Lf2ModelMapper {
+    static mapPackage(packageId, rawPackage, languageVersion) {
+        return new daml_lf_package_js_1.DamlLfPackage({
+            packageId,
+            packageName: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawPackage.metadata?.nameInternedStr),
+            packageVersion: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawPackage.metadata?.versionInternedStr),
+            languageVersion,
+            modules: rawPackage.modules.map((module) => Lf2ModelMapper.mapModule(packageId, module, rawPackage)),
+        });
+    }
+    static mapType(currentPackageId, rawPackage, rawType) {
+        if (rawType?.sum.oneofKind === "internedType"
+            && rawType.sum.internedType >= 0) {
+            return Lf2ModelMapper.mapType(currentPackageId, rawPackage, rawPackage.internedTypes[rawType.sum.internedType]);
+        }
+        if (rawType?.sum.oneofKind === "tapp") {
+            const lhs = Lf2ModelMapper.mapType(currentPackageId, rawPackage, rawType.sum.tapp.lhs);
+            const numericScale = lhs.builtinType === daml_lf_builtin_type_js_1.DamlLfBuiltinType.numeric
+                ? Lf2ModelMapper.readNumericScale(rawPackage, rawType.sum.tapp.rhs)
+                : undefined;
+            return new daml_lf_type_js_1.DamlLfType({
+                builtinType: lhs.builtinType,
+                ...(numericScale === undefined
+                    ? lhs.numericScale === undefined
+                        ? {}
+                        : { numericScale: lhs.numericScale }
+                    : { numericScale }),
+                ...(lhs.typeConReference === undefined
+                    ? {}
+                    : { typeConReference: lhs.typeConReference }),
+                ...(lhs.typeVariable === undefined
+                    ? {}
+                    : { typeVariable: lhs.typeVariable }),
+                ...(lhs.diagnosticForall === undefined
+                    ? {}
+                    : { diagnosticForall: lhs.diagnosticForall }),
+                typeArguments: numericScale === undefined
+                    ? [
+                        ...lhs.typeArguments,
+                        Lf2ModelMapper.mapType(currentPackageId, rawPackage, rawType.sum.tapp.rhs),
+                    ]
+                    : lhs.typeArguments,
+            });
+        }
+        if (rawType?.sum.oneofKind === "forall") {
+            return new daml_lf_type_js_1.DamlLfType({
+                diagnosticForall: {
+                    typeParameters: rawType.sum.forall.vars.map((parameter) => Lf2ModelMapper.mapTypeParameter(rawPackage, parameter)),
+                    body: Lf2ModelMapper.mapType(currentPackageId, rawPackage, rawType.sum.forall.body),
+                },
+            });
+        }
+        else if (rawType?.sum.oneofKind === "var") {
+            return new daml_lf_type_js_1.DamlLfType({
+                typeVariable: Lf2ModelMapper.mapTypeVariableReference(rawPackage, rawType.sum.var.varInternedStr),
+                typeArguments: rawType.sum.var.args.map((item) => Lf2ModelMapper.mapType(currentPackageId, rawPackage, item)),
+            });
+        }
+        if (rawType?.sum.oneofKind === "con") {
+            return new daml_lf_type_js_1.DamlLfType({
+                typeConReference: Lf2ModelMapper.mapTypeConReferenceOrThrow(currentPackageId, rawPackage, rawType.sum.con.tycon, rawType),
+                typeArguments: rawType.sum.con.args.map((item) => Lf2ModelMapper.mapType(currentPackageId, rawPackage, item)),
+            });
+        }
+        else if (rawType?.sum.oneofKind === "builtin") {
+            const builtinType = Lf2ModelMapper.mapBuiltinType(rawType.sum.builtin.builtin);
+            const numericScale = builtinType === daml_lf_builtin_type_js_1.DamlLfBuiltinType.numeric
+                ? Lf2ModelMapper.readNumericScale(rawPackage, rawType.sum.builtin.args[0])
+                : undefined;
+            return new daml_lf_type_js_1.DamlLfType({
+                builtinType,
+                ...(numericScale === undefined
+                    ? {}
+                    : { numericScale }),
+                typeArguments: rawType.sum.builtin.args
+                    .slice(numericScale === undefined ? 0 : 1)
+                    .map((item) => Lf2ModelMapper.mapType(currentPackageId, rawPackage, item)),
+            });
+        }
+        return new daml_lf_type_js_1.DamlLfType({
+            builtinType: daml_lf_builtin_type_js_1.DamlLfBuiltinType.unknown,
+        });
+    }
+    static mapTypeParameter(rawPackage, rawParameter) {
+        const name = Lf2ModelMapper.resolveInternedStringOrUndefined(rawPackage.internedStrings, rawParameter.varInternedStr);
+        return {
+            ...(name === undefined ? {} : { name }),
+            internedStringIndex: rawParameter.varInternedStr,
+            kind: Lf2ModelMapper.mapTypeParameterKind(rawPackage, rawParameter.kind),
+        };
+    }
+    static mapTypeVariableReference(rawPackage, internedStringIndex) {
+        const name = Lf2ModelMapper.resolveInternedStringOrUndefined(rawPackage.internedStrings, internedStringIndex);
+        return {
+            ...(name === undefined ? {} : { name }),
+            internedStringIndex,
+        };
+    }
+    static mapTypeParameterKind(rawPackage, rawKind, visitedInternedKindIndices = new Set()) {
+        if (rawKind?.sum.oneofKind === "star") {
+            return { kind: "star" };
+        }
+        else if (rawKind?.sum.oneofKind === "nat") {
+            return { kind: "nat" };
+        }
+        else if (rawKind?.sum.oneofKind === "arrow") {
+            return {
+                kind: "arrow",
+                parameters: rawKind.sum.arrow.params.map((parameter) => Lf2ModelMapper.mapTypeParameterKind(rawPackage, parameter, visitedInternedKindIndices)),
+                result: Lf2ModelMapper.mapTypeParameterKind(rawPackage, rawKind.sum.arrow.result, visitedInternedKindIndices),
+            };
+        }
+        if (rawKind?.sum.oneofKind !== "internedKind") {
+            return { kind: "unknown" };
+        }
+        const internedKindIndex = rawKind.sum.internedKind;
+        if (visitedInternedKindIndices.has(internedKindIndex)) {
+            return {
+                kind: "unknown",
+                internedKindIndex,
+            };
+        }
+        const internedKind = rawPackage.internedKinds[internedKindIndex];
+        return internedKind === undefined
+            ? {
+                kind: "unknown",
+                internedKindIndex,
+            }
+            : Lf2ModelMapper.mapTypeParameterKind(rawPackage, internedKind, new Set([...visitedInternedKindIndices, internedKindIndex]));
+    }
+    static mapBuiltinType(builtinType) {
+        switch (builtinType) {
+            case daml_lf2_js_1.BuiltinType.UNIT:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.unit;
+            case daml_lf2_js_1.BuiltinType.BOOL:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.bool;
+            case daml_lf2_js_1.BuiltinType.INT64:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.int64;
+            case daml_lf2_js_1.BuiltinType.DATE:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.date;
+            case daml_lf2_js_1.BuiltinType.TIMESTAMP:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.timestamp;
+            case daml_lf2_js_1.BuiltinType.NUMERIC:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.numeric;
+            case daml_lf2_js_1.BuiltinType.PARTY:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.party;
+            case daml_lf2_js_1.BuiltinType.TEXT:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.text;
+            case daml_lf2_js_1.BuiltinType.CONTRACT_ID:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.contractId;
+            case daml_lf2_js_1.BuiltinType.OPTIONAL:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.optional;
+            case daml_lf2_js_1.BuiltinType.LIST:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.list;
+            case daml_lf2_js_1.BuiltinType.TEXTMAP:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.textMap;
+            case daml_lf2_js_1.BuiltinType.GENMAP:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.genMap;
+            default:
+                return daml_lf_builtin_type_js_1.DamlLfBuiltinType.unknown;
+        }
+    }
+    static readNumericScale(rawPackage, rawType) {
+        if (rawType?.sum.oneofKind === "internedType"
+            && rawType.sum.internedType >= 0) {
+            return Lf2ModelMapper.readNumericScale(rawPackage, rawPackage.internedTypes[rawType.sum.internedType]);
+        }
+        if (rawType?.sum.oneofKind !== "nat") {
+            return undefined;
+        }
+        const scale = Number(rawType.sum.nat);
+        return Number.isSafeInteger(scale) && scale >= 0 && scale <= 37
+            ? scale
+            : undefined;
+    }
+    static mapModule(packageId, rawModule, rawPackage) {
+        const moduleName = Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawModule.nameInternedDname);
+        const dataTypes = rawModule.dataTypes
+            .map((item) => Lf2ModelMapper.mapDataType(packageId, item, rawPackage))
+            .filter((item) => item !== undefined);
+        const definitions = [
+            ...dataTypes,
+            ...rawModule.values.map((value) => new daml_lf_value_definition_js_1.DamlLfValueDefinition({
+                name: Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, value.nameWithType?.nameInternedDname),
+                type: Lf2ModelMapper.mapType(packageId, rawPackage, value.nameWithType?.type),
+                expression: Lf2ModelMapper.mapExpression(value.expr, rawPackage.internedStrings, rawPackage.internedDottedNames, packageId, rawPackage),
+            })),
+            ...rawModule.templates.map((item) => Lf2ModelMapper.mapTemplateOrThrow(packageId, moduleName, item, rawPackage, dataTypes)),
+        ];
+        return new daml_lf_module_js_1.DamlLfModule({
+            name: moduleName,
+            definitions,
+        });
+    }
+    static mapDataType(packageId, rawDataType, rawPackage) {
+        const definition = rawDataType.dataCons.oneofKind === "record"
+            ? {
+                kind: "record",
+                fields: rawDataType.dataCons.record.fields.map((item) => Lf2ModelMapper.mapField(packageId, item.fieldInternedStr, item.type, rawPackage)),
+            }
+            : rawDataType.dataCons.oneofKind === "variant"
+                ? {
+                    kind: "variant",
+                    constructors: rawDataType.dataCons.variant.fields.map((item) => ({
+                        name: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, item.fieldInternedStr),
+                        type: Lf2ModelMapper.mapType(packageId, rawPackage, item.type),
+                    })),
+                }
+                : rawDataType.dataCons.oneofKind === "enum"
+                    ? {
+                        kind: "enum",
+                        constructors: rawDataType.dataCons.enum.constructorsInternedStr.map((item) => Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, item)),
+                    }
+                    : undefined;
+        if (definition === undefined) {
+            return undefined;
+        }
+        return new daml_lf_data_type_js_1.DamlLfDataType({
+            name: Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawDataType.nameInternedDname),
+            definition,
+            typeParameters: rawDataType.params.map((parameter) => Lf2ModelMapper.mapTypeParameter(rawPackage, parameter)),
+        });
+    }
+    static mapTemplateOrThrow(packageId, moduleName, rawTemplate, rawPackage, dataTypes) {
+        const templateName = Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawTemplate.tyconInternedDname);
+        const matchingDataType = dataTypes.find((item) => item.name === templateName);
+        if (matchingDataType === undefined) {
+            throw new daml_lf_decode_exception_js_1.DamlLfDecodeException(`daml lf template '${templateName}' is missing its backing data type`);
+        }
+        return new daml_lf_template_js_1.DamlLfTemplate({
+            templateId: new daml_lf_template_id_js_1.DamlLfTemplateId({
+                packageId,
+                moduleName,
+                templateName,
+            }),
+            name: templateName,
+            parameterName: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawTemplate.paramInternedStr),
+            fields: matchingDataType.fields,
+            choices: rawTemplate.choices.map((item) => Lf2ModelMapper.mapChoice(packageId, item, rawPackage)),
+        });
+    }
+    static mapChoice(packageId, rawChoice, rawPackage) {
+        return new daml_lf_choice_js_1.DamlLfChoice({
+            name: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawChoice.nameInternedStr),
+            consuming: rawChoice.consuming,
+            selfBinderName: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawChoice.selfBinderInternedStr),
+            parameter: Lf2ModelMapper.mapChoiceParameterOrThrow(packageId, rawChoice.argBinder, rawPackage),
+            returnType: Lf2ModelMapper.mapType(packageId, rawPackage, rawChoice.retType),
+            updateExpression: rawChoice.update === undefined
+                ? undefined
+                : Lf2ModelMapper.mapExpression(rawChoice.update, rawPackage.internedStrings, rawPackage.internedDottedNames, packageId, rawPackage),
+        });
+    }
+    static mapChoiceParameterOrThrow(packageId, rawParameter, rawPackage) {
+        if (rawParameter === undefined) {
+            throw new daml_lf_decode_exception_js_1.DamlLfDecodeException("daml lf template choice is missing its argument binder");
+        }
+        return new daml_lf_choice_parameter_js_1.DamlLfChoiceParameter({
+            name: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawParameter.varInternedStr),
+            type: Lf2ModelMapper.mapType(packageId, rawPackage, rawParameter.type),
+        });
+    }
+    static mapField(packageId, nameInternedStr, rawType, rawPackage) {
+        return new daml_lf_field_js_1.DamlLfField({
+            name: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, nameInternedStr),
+            type: Lf2ModelMapper.mapType(packageId, rawPackage, rawType),
+        });
+    }
+    static mapTypeConReferenceOrThrow(currentPackageId, rawPackage, rawTypeConId, rawType) {
+        const module = rawTypeConId?.module;
+        if (module === undefined) {
+            throw new daml_lf_decode_exception_js_1.DamlLfDecodeException(`daml lf type constructor is missing its module (${rawType.sum.oneofKind})`);
+        }
+        return new type_con_reference_js_1.TypeConReference({
+            packageId: Lf2ModelMapper.resolvePackageIdOrThrow(currentPackageId, module.packageId, rawPackage),
+            moduleName: Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, module.moduleNameInternedDname),
+            name: Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawTypeConId?.nameInternedDname),
+        });
+    }
+    static resolvePackageIdOrThrow(currentPackageId, rawPackageId, rawPackage) {
+        if (rawPackageId === undefined) {
+            return currentPackageId;
+        }
+        switch (rawPackageId.sum?.oneofKind) {
+            case "selfPackageId":
+                return currentPackageId;
+            case "importedPackageIdInternedStr":
+                return Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawPackageId.sum.importedPackageIdInternedStr);
+            case "packageImportId":
+                return Lf2ModelMapper.resolveImportedPackageIdOrThrow(rawPackage, rawPackageId.sum.packageImportId);
+            case undefined:
+                return currentPackageId;
+            default:
+                throw new daml_lf_decode_exception_js_1.DamlLfDecodeException("daml lf type constructor is missing its package id");
+        }
+    }
+    static resolveImportedPackageIdOrThrow(rawPackage, index) {
+        if (rawPackage.importsSum.oneofKind !== "packageImports" ||
+            rawPackage.importsSum.packageImports.importedPackages[index] === undefined) {
+            throw new daml_lf_decode_exception_js_1.DamlLfDecodeException("daml lf package references a missing imported package id");
+        }
+        return rawPackage.importsSum.packageImports.importedPackages[index];
+    }
+    static mapExpression(rawExpression, internedStrings, internedDottedNames, currentPackageId, rawPackage) {
+        return Lf2ModelMapper.mapExpressionWithoutSourceLocation(rawExpression, internedStrings, internedDottedNames, currentPackageId, rawPackage).withSourceLocation(Lf2ModelMapper.mapExpressionSourceLocation(rawExpression, internedStrings, internedDottedNames, currentPackageId, rawPackage));
+    }
+    static mapExpressionWithoutSourceLocation(rawExpression, internedStrings, internedDottedNames, currentPackageId, rawPackage) {
+        if (rawExpression?.sum.oneofKind === "varInternedStr") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                variableName: Lf2ModelMapper.resolveInternedString(internedStrings, rawExpression.sum.varInternedStr),
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "builtinLit") {
+            const rawLiteral = rawExpression.sum.builtinLit;
+            if (rawLiteral.sum.oneofKind === "textInternedStr") {
+                return new daml_lf_expression_js_1.DamlLfExpression({
+                    textLiteral: Lf2ModelMapper.resolveInternedString(internedStrings, rawLiteral.sum.textInternedStr),
+                });
+            }
+            if (rawLiteral.sum.oneofKind === "int64") {
+                return new daml_lf_expression_js_1.DamlLfExpression({
+                    int64Literal: rawLiteral.sum.int64,
+                });
+            }
+            if (rawLiteral.sum.oneofKind === "numericInternedStr") {
+                return new daml_lf_expression_js_1.DamlLfExpression({
+                    numericLiteral: Lf2ModelMapper.resolveInternedString(internedStrings, rawLiteral.sum.numericInternedStr),
+                });
+            }
+            if (rawLiteral.sum.oneofKind === "timestamp") {
+                return new daml_lf_expression_js_1.DamlLfExpression({
+                    textLiteral: rawLiteral.sum.timestamp,
+                });
+            }
+            if (rawLiteral.sum.oneofKind === "date") {
+                return new daml_lf_expression_js_1.DamlLfExpression({
+                    textLiteral: String(rawLiteral.sum.date),
+                });
+            }
+        }
+        if (rawExpression?.sum.oneofKind === "builtinCon") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                builtinConstructor: rawExpression.sum.builtinCon === daml_lf2_js_1.BuiltinCon.CON_TRUE
+                    ? "true"
+                    : rawExpression.sum.builtinCon === daml_lf2_js_1.BuiltinCon.CON_FALSE
+                        ? "false"
+                        : "unit",
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "builtin") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                builtinFunction: rawExpression.sum.builtin === daml_lf2_js_1.BuiltinFunction.EQUAL
+                    ? "equal"
+                    : rawExpression.sum.builtin === daml_lf2_js_1.BuiltinFunction.GREATER
+                        ? "greater"
+                        : rawExpression.sum.builtin
+                            === daml_lf2_js_1.BuiltinFunction.APPEND_TEXT
+                            ? "appendText"
+                            : (daml_lf2_js_1.BuiltinFunction[rawExpression.sum.builtin]
+                                ?? "unsupported"),
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "val") {
+            const valueReference = rawExpression.sum.val;
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                valueReference: {
+                    packageId: Lf2ModelMapper.resolvePackageIdOrThrow(currentPackageId, valueReference.module?.packageId, rawPackage),
+                    moduleName: Lf2ModelMapper.resolveInternedDottedName(internedStrings, internedDottedNames, valueReference.module?.moduleNameInternedDname),
+                    definitionName: Lf2ModelMapper.resolveInternedDottedName(internedStrings, internedDottedNames, valueReference.nameInternedDname),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "abs") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                lambda: {
+                    parameters: rawExpression.sum.abs.param.map((parameter) => Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, parameter.varInternedStr)),
+                    body: Lf2ModelMapper.mapExpression(rawExpression.sum.abs.body, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "app") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                application: {
+                    function: Lf2ModelMapper.mapExpression(rawExpression.sum.app.fun, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    arguments: rawExpression.sum.app.args.map((argument) => Lf2ModelMapper.mapExpression(argument, internedStrings, internedDottedNames, currentPackageId, rawPackage)),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "recCon") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                recordConstruction: {
+                    fields: rawExpression.sum.recCon.fields.map((field) => ({
+                        name: Lf2ModelMapper.resolveInternedString(internedStrings, field.fieldInternedStr),
+                        value: Lf2ModelMapper.mapExpression(field.expr, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    })),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "recProj") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                recordProjection: {
+                    fieldName: Lf2ModelMapper.resolveInternedString(internedStrings, rawExpression.sum.recProj.fieldInternedStr),
+                    record: Lf2ModelMapper.mapExpression(rawExpression.sum.recProj.record, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "recUpd") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                recordUpdate: {
+                    fieldName: Lf2ModelMapper.resolveInternedString(internedStrings, rawExpression.sum.recUpd.fieldInternedStr),
+                    record: Lf2ModelMapper.mapExpression(rawExpression.sum.recUpd.record, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    value: Lf2ModelMapper.mapExpression(rawExpression.sum.recUpd.update, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "variantCon") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                variantConstruction: {
+                    constructorName: Lf2ModelMapper.resolveInternedString(internedStrings, rawExpression.sum.variantCon.variantConInternedStr),
+                    argument: Lf2ModelMapper.mapExpression(rawExpression.sum.variantCon.variantArg, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "structCon") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                recordConstruction: {
+                    fields: rawExpression.sum.structCon.fields.map((field) => ({
+                        name: Lf2ModelMapper.resolveInternedString(internedStrings, field.fieldInternedStr),
+                        value: Lf2ModelMapper.mapExpression(field.expr, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    })),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "structProj") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                recordProjection: {
+                    fieldName: Lf2ModelMapper.resolveInternedString(internedStrings, rawExpression.sum.structProj.fieldInternedStr),
+                    record: Lf2ModelMapper.mapExpression(rawExpression.sum.structProj.struct, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "structUpd") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                recordUpdate: {
+                    fieldName: Lf2ModelMapper.resolveInternedString(internedStrings, rawExpression.sum.structUpd.fieldInternedStr),
+                    record: Lf2ModelMapper.mapExpression(rawExpression.sum.structUpd.struct, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    value: Lf2ModelMapper.mapExpression(rawExpression.sum.structUpd.update, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "optionalNone") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                optionalConstruction: {},
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "optionalSome") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                optionalConstruction: {
+                    value: Lf2ModelMapper.mapExpression(rawExpression.sum.optionalSome.value, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "update") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                updateExpression: Lf2ModelMapper.mapUpdateExpression(rawExpression.sum.update, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "tyApp") {
+            return Lf2ModelMapper.mapExpression(rawExpression.sum.tyApp.expr, internedStrings, internedDottedNames, currentPackageId, rawPackage);
+        }
+        if (rawExpression?.sum.oneofKind === "tyAbs") {
+            return Lf2ModelMapper.mapExpression(rawExpression.sum.tyAbs.body, internedStrings, internedDottedNames, currentPackageId, rawPackage);
+        }
+        if (rawExpression?.sum.oneofKind === "enumCon") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                enumConstruction: {
+                    constructorName: Lf2ModelMapper.resolveInternedString(internedStrings, rawExpression.sum.enumCon.enumConInternedStr),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "nil") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                listConstruction: {
+                    front: [],
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "cons") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                listConstruction: {
+                    front: rawExpression.sum.cons.front.map((item) => Lf2ModelMapper.mapExpression(item, internedStrings, internedDottedNames, currentPackageId, rawPackage)),
+                    tail: Lf2ModelMapper.mapExpression(rawExpression.sum.cons.tail, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "throw") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                throwExpression: {
+                    exception: Lf2ModelMapper.mapExpression(rawExpression.sum.throw.exceptionExpr, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "case") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                caseExpression: {
+                    scrutinee: Lf2ModelMapper.mapExpression(rawExpression.sum.case.scrut, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    alternatives: rawExpression.sum.case.alts.map((alternative) => ({
+                        patternKind: alternative.sum.oneofKind === "builtinCon"
+                            ? "builtinCon"
+                            : alternative.sum.oneofKind === "variant"
+                                ? "variant"
+                                : alternative.sum.oneofKind === "optionalNone"
+                                    ? "optionalNone"
+                                    : alternative.sum.oneofKind
+                                        === "optionalSome"
+                                        ? "optionalSome"
+                                        : alternative.sum.oneofKind === "enum"
+                                            ? "enum"
+                                            : alternative.sum.oneofKind === "nil"
+                                                ? "nil"
+                                                : alternative.sum.oneofKind === "cons"
+                                                    ? "cons"
+                                                    : "default",
+                        builtinConstructor: alternative.sum.oneofKind === "builtinCon"
+                            ? alternative.sum.builtinCon === daml_lf2_js_1.BuiltinCon.CON_TRUE
+                                ? "true"
+                                : alternative.sum.builtinCon
+                                    === daml_lf2_js_1.BuiltinCon.CON_FALSE
+                                    ? "false"
+                                    : "unit"
+                            : undefined,
+                        constructorName: alternative.sum.oneofKind === "variant"
+                            ? Lf2ModelMapper.resolveInternedString(internedStrings, alternative.sum.variant.variantInternedStr)
+                            : alternative.sum.oneofKind === "enum"
+                                ? Lf2ModelMapper.resolveInternedString(internedStrings, alternative.sum.enum.constructorInternedStr)
+                                : undefined,
+                        binderName: alternative.sum.oneofKind === "variant"
+                            ? Lf2ModelMapper.resolveInternedString(internedStrings, alternative.sum.variant.binderInternedStr)
+                            : alternative.sum.oneofKind === "optionalSome"
+                                ? Lf2ModelMapper.resolveInternedString(internedStrings, alternative.sum.optionalSome.varBodyInternedStr)
+                                : undefined,
+                        headBinderName: alternative.sum.oneofKind === "cons"
+                            ? Lf2ModelMapper.resolveInternedString(internedStrings, alternative.sum.cons.varHeadInternedStr)
+                            : undefined,
+                        tailBinderName: alternative.sum.oneofKind === "cons"
+                            ? Lf2ModelMapper.resolveInternedString(internedStrings, alternative.sum.cons.varTailInternedStr)
+                            : undefined,
+                        body: Lf2ModelMapper.mapExpression(alternative.body, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    })),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "internedExpr") {
+            return Lf2ModelMapper.mapExpression(rawPackage.internedExprs[rawExpression.sum.internedExpr], internedStrings, internedDottedNames, currentPackageId, rawPackage);
+        }
+        if (rawExpression?.sum.oneofKind === "let") {
+            return new daml_lf_expression_js_1.DamlLfExpression({
+                letExpression: {
+                    bindings: rawExpression.sum.let.bindings.map((binding) => ({
+                        name: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, binding.binder?.varInternedStr),
+                        value: Lf2ModelMapper.mapExpression(binding.bound, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    })),
+                    body: Lf2ModelMapper.mapExpression(rawExpression.sum.let.body, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        return new daml_lf_expression_js_1.DamlLfExpression({
+            unsupportedNodeKind: rawExpression?.sum.oneofKind,
+        });
+    }
+    static mapExpressionSourceLocation(rawExpression, internedStrings, internedDottedNames, currentPackageId, rawPackage) {
+        const rawLocation = rawExpression?.location;
+        const range = rawLocation?.range;
+        if (range === undefined) {
+            return undefined;
+        }
+        return {
+            packageId: rawLocation?.module === undefined
+                ? undefined
+                : Lf2ModelMapper.resolvePackageIdOrThrow(currentPackageId, rawLocation.module.packageId, rawPackage),
+            moduleName: rawLocation?.module === undefined
+                ? undefined
+                : Lf2ModelMapper.resolveInternedDottedName(internedStrings, internedDottedNames, rawLocation.module.moduleNameInternedDname),
+            startLine: range.startLine,
+            startColumn: range.startCol,
+            endLine: range.endLine,
+            endColumn: range.endCol,
+        };
+    }
+    static mapUpdateExpression(rawUpdate, internedStrings, internedDottedNames, currentPackageId, rawPackage) {
+        switch (rawUpdate.sum.oneofKind) {
+            case "pure":
+                return {
+                    kind: "pure",
+                    expression: Lf2ModelMapper.mapExpression(rawUpdate.sum.pure.expr, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                };
+            case "block":
+                return {
+                    kind: "block",
+                    bindings: rawUpdate.sum.block.bindings.map((binding) => ({
+                        name: Lf2ModelMapper.resolveInternedString(internedStrings, binding.binder?.varInternedStr),
+                        value: Lf2ModelMapper.mapExpression(binding.bound, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    })),
+                    body: Lf2ModelMapper.mapExpression(rawUpdate.sum.block.body, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                };
+            case "embedExpr":
+                return {
+                    kind: "embedExpr",
+                    expression: Lf2ModelMapper.mapExpression(rawUpdate.sum.embedExpr.body, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                };
+            case "tryCatch":
+                return {
+                    kind: "tryCatch",
+                    expression: Lf2ModelMapper.mapExpression(rawUpdate.sum.tryCatch.tryExpr, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    catchVariableName: Lf2ModelMapper.resolveInternedString(internedStrings, rawUpdate.sum.tryCatch.varInternedStr),
+                    catchExpression: Lf2ModelMapper.mapExpression(rawUpdate.sum.tryCatch.catchExpr, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                };
+            case "create":
+                return {
+                    kind: "create",
+                    templateId: Lf2ModelMapper.mapTemplateReferenceOrThrow(currentPackageId, rawPackage, rawUpdate.sum.create.template),
+                    argument: Lf2ModelMapper.mapExpression(rawUpdate.sum.create.expr, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                };
+            case "createInterface":
+                return {
+                    kind: "createInterface",
+                    interfaceId: Lf2ModelMapper.mapTemplateReferenceOrThrow(currentPackageId, rawPackage, rawUpdate.sum.createInterface.interface),
+                    argument: Lf2ModelMapper.mapExpression(rawUpdate.sum.createInterface.expr, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                };
+            case "fetch":
+                return {
+                    kind: "fetch",
+                    templateId: Lf2ModelMapper.mapTemplateReferenceOrThrow(currentPackageId, rawPackage, rawUpdate.sum.fetch.template),
+                    contractId: Lf2ModelMapper.mapExpression(rawUpdate.sum.fetch.cid, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                };
+            case "fetchInterface":
+                return {
+                    kind: "fetchInterface",
+                    interfaceId: Lf2ModelMapper.mapTemplateReferenceOrThrow(currentPackageId, rawPackage, rawUpdate.sum.fetchInterface.interface),
+                    contractId: Lf2ModelMapper.mapExpression(rawUpdate.sum.fetchInterface.cid, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                };
+            case "exercise":
+                return {
+                    kind: "exercise",
+                    templateId: Lf2ModelMapper.mapTemplateReferenceOrThrow(currentPackageId, rawPackage, rawUpdate.sum.exercise.template),
+                    choiceName: Lf2ModelMapper.resolveInternedString(internedStrings, rawUpdate.sum.exercise.choiceInternedStr),
+                    contractId: Lf2ModelMapper.mapExpression(rawUpdate.sum.exercise.cid, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    argument: Lf2ModelMapper.mapExpression(rawUpdate.sum.exercise.arg, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                };
+            case "exerciseInterface":
+                return {
+                    kind: "exerciseInterface",
+                    interfaceId: Lf2ModelMapper.mapTemplateReferenceOrThrow(currentPackageId, rawPackage, rawUpdate.sum.exerciseInterface.interface),
+                    choiceName: Lf2ModelMapper.resolveInternedString(internedStrings, rawUpdate.sum.exerciseInterface.choiceInternedStr),
+                    contractId: Lf2ModelMapper.mapExpression(rawUpdate.sum.exerciseInterface.cid, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    argument: Lf2ModelMapper.mapExpression(rawUpdate.sum.exerciseInterface.arg, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                    guardExpression: rawUpdate.sum.exerciseInterface.guard === undefined
+                        ? undefined
+                        : Lf2ModelMapper.mapExpression(rawUpdate.sum.exerciseInterface.guard, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                };
+            case "getTime":
+                return {
+                    kind: "getTime",
+                };
+            case "ledgerTimeLt":
+                return {
+                    kind: "ledgerTimeLt",
+                    expression: Lf2ModelMapper.mapExpression(rawUpdate.sum.ledgerTimeLt, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                };
+            default:
+                return {
+                    kind: "embedExpr",
+                    expression: new daml_lf_expression_js_1.DamlLfExpression({
+                        unsupportedNodeKind: `update.${rawUpdate.sum.oneofKind ?? "unknown"}`,
+                    }),
+                };
+        }
+    }
+    static mapTemplateReferenceOrThrow(currentPackageId, rawPackage, rawTypeConId) {
+        const reference = Lf2ModelMapper.mapTypeConReferenceOrThrow(currentPackageId, rawPackage, rawTypeConId, {
+            sum: {
+                oneofKind: "con",
+                con: {
+                    tycon: rawTypeConId,
+                    args: [],
+                },
+            },
+        });
+        return {
+            packageId: reference.packageId,
+            moduleName: reference.moduleName,
+            templateName: reference.name,
+        };
+    }
+    static resolveInternedString(internedStrings, index) {
+        if (index === undefined || internedStrings[index] === undefined) {
+            throw new daml_lf_decode_exception_js_1.DamlLfDecodeException("daml lf package references a missing interned string");
+        }
+        return internedStrings[index];
+    }
+    static resolveInternedStringOrUndefined(internedStrings, index) {
+        return index === undefined ? undefined : internedStrings[index];
+    }
+    static resolveInternedDottedName(internedStrings, internedDottedNames, index) {
+        if (index === undefined || internedDottedNames[index] === undefined) {
+            throw new daml_lf_decode_exception_js_1.DamlLfDecodeException("daml lf package references a missing interned dotted name");
+        }
+        return internedDottedNames[index].segmentsInternedStr
+            .map((segmentIndex) => Lf2ModelMapper.resolveInternedString(internedStrings, segmentIndex))
+            .join(".");
+    }
+}
+exports.Lf2ModelMapper = Lf2ModelMapper;