@distrohelena/canton-typescript-sdk 0.1.5 → 0.1.7

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

@@ -1,4 +1,4 @@
-import { BuiltinType, } from "../../transports/grpc/generated/canton/com/digitalasset/daml/lf/archive/daml_lf2.js";
+import { BuiltinCon, BuiltinFunction, BuiltinType, } from "../../transports/grpc/generated/canton/com/digitalasset/daml/lf/archive/daml_lf2.js";
 import { DamlLfDecodeException } from "../errors/daml-lf-decode.exception.js";
 import { DamlLfBuiltinType } from "./daml-lf-builtin-type.js";
 import { DamlLfChoice } from "./daml-lf-choice.js";
@@ -24,22 +24,65 @@ export class Lf2ModelMapper {
         });
     }
     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 === DamlLfBuiltinType.numeric
+                ? Lf2ModelMapper.readNumericScale(rawType.sum.tapp.rhs)
+                : undefined;
+            return numericScale === undefined
+                ? lhs
+                : new DamlLfType({
+                    builtinType: lhs.builtinType,
+                    numericScale,
+                    ...(lhs.typeConReference === undefined
+                        ? {}
+                        : { typeConReference: lhs.typeConReference }),
+                });
+        }
+        if (rawType?.sum.oneofKind === "forall") {
+            return Lf2ModelMapper.mapType(currentPackageId, rawPackage, rawType.sum.forall.body);
+        }
         if (rawType?.sum.oneofKind === "con") {
             return new DamlLfType({
                 typeConReference: Lf2ModelMapper.mapTypeConReferenceOrThrow(currentPackageId, rawPackage, rawType.sum.con.tycon, rawType),
             });
         }
         else if (rawType?.sum.oneofKind === "builtin") {
+            const builtinType = rawType.sum.builtin.builtin === BuiltinType.INT64
+                ? DamlLfBuiltinType.int64
+                : rawType.sum.builtin.builtin === BuiltinType.NUMERIC
+                    ? DamlLfBuiltinType.numeric
+                    : rawType.sum.builtin.builtin === BuiltinType.PARTY
+                        ? DamlLfBuiltinType.party
+                        : rawType.sum.builtin.builtin === BuiltinType.TEXT
+                            ? DamlLfBuiltinType.text
+                            : DamlLfBuiltinType.unknown;
             return new DamlLfType({
-                builtinType: rawType.sum.builtin.builtin === BuiltinType.TEXT
-                    ? DamlLfBuiltinType.text
-                    : DamlLfBuiltinType.unknown,
+                builtinType,
+                ...(builtinType !== DamlLfBuiltinType.numeric
+                    ? {}
+                    : {
+                        numericScale: Lf2ModelMapper.readNumericScale(rawType.sum.builtin.args[0]),
+                    }),
             });
         }
         return new DamlLfType({
             builtinType: DamlLfBuiltinType.unknown,
         });
     }
+    static readNumericScale(rawType) {
+        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
@@ -50,7 +93,7 @@ export class Lf2ModelMapper {
             ...rawModule.values.map((value) => new 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),
+                expression: Lf2ModelMapper.mapExpression(value.expr, rawPackage.internedStrings, rawPackage.internedDottedNames, packageId, rawPackage),
             })),
             ...rawModule.templates.map((item) => Lf2ModelMapper.mapTemplateOrThrow(packageId, moduleName, item, rawPackage, dataTypes)),
         ];
@@ -60,12 +103,12 @@ export class Lf2ModelMapper {
         });
     }
     static mapDataType(packageId, rawDataType, rawPackage) {
-        if (rawDataType.dataCons.oneofKind !== "record") {
-            return undefined;
-        }
+        const fields = rawDataType.dataCons.oneofKind === "record"
+            ? rawDataType.dataCons.record.fields.map((item) => Lf2ModelMapper.mapField(packageId, item.fieldInternedStr, item.type, rawPackage))
+            : [];
         return new DamlLfDataType({
             name: Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawDataType.nameInternedDname),
-            fields: rawDataType.dataCons.record.fields.map((item) => Lf2ModelMapper.mapField(packageId, item.fieldInternedStr, item.type, rawPackage)),
+            fields,
         });
     }
     static mapTemplateOrThrow(packageId, moduleName, rawTemplate, rawPackage, dataTypes) {
@@ -81,6 +124,7 @@ export class Lf2ModelMapper {
                 templateName,
             }),
             name: templateName,
+            parameterName: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawTemplate.paramInternedStr),
             fields: matchingDataType.fields,
             choices: rawTemplate.choices.map((item) => Lf2ModelMapper.mapChoice(packageId, item, rawPackage)),
         });
@@ -89,8 +133,12 @@ export class Lf2ModelMapper {
         return new 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) {
@@ -120,13 +168,18 @@ export class Lf2ModelMapper {
         });
     }
     static resolvePackageIdOrThrow(currentPackageId, rawPackageId, rawPackage) {
-        switch (rawPackageId?.sum.oneofKind) {
+        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 DamlLfDecodeException("daml lf type constructor is missing its package id");
         }
@@ -138,7 +191,15 @@ export class Lf2ModelMapper {
         }
         return rawPackage.importsSum.packageImports.importedPackages[index];
     }
-    static mapExpression(rawExpression, internedStrings) {
+    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 DamlLfExpression({
+                variableName: Lf2ModelMapper.resolveInternedString(internedStrings, rawExpression.sum.varInternedStr),
+            });
+        }
         if (rawExpression?.sum.oneofKind === "builtinLit") {
             const rawLiteral = rawExpression.sum.builtinLit;
             if (rawLiteral.sum.oneofKind === "textInternedStr") {
@@ -146,8 +207,380 @@ export class Lf2ModelMapper {
                     textLiteral: Lf2ModelMapper.resolveInternedString(internedStrings, rawLiteral.sum.textInternedStr),
                 });
             }
+            if (rawLiteral.sum.oneofKind === "int64") {
+                return new DamlLfExpression({
+                    int64Literal: rawLiteral.sum.int64,
+                });
+            }
+            if (rawLiteral.sum.oneofKind === "numericInternedStr") {
+                return new DamlLfExpression({
+                    numericLiteral: Lf2ModelMapper.resolveInternedString(internedStrings, rawLiteral.sum.numericInternedStr),
+                });
+            }
+            if (rawLiteral.sum.oneofKind === "timestamp") {
+                return new DamlLfExpression({
+                    textLiteral: rawLiteral.sum.timestamp,
+                });
+            }
+            if (rawLiteral.sum.oneofKind === "date") {
+                return new DamlLfExpression({
+                    textLiteral: String(rawLiteral.sum.date),
+                });
+            }
+        }
+        if (rawExpression?.sum.oneofKind === "builtinCon") {
+            return new DamlLfExpression({
+                builtinConstructor: rawExpression.sum.builtinCon === BuiltinCon.CON_TRUE
+                    ? "true"
+                    : rawExpression.sum.builtinCon === BuiltinCon.CON_FALSE
+                        ? "false"
+                        : "unit",
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "builtin") {
+            return new DamlLfExpression({
+                builtinFunction: rawExpression.sum.builtin === BuiltinFunction.EQUAL
+                    ? "equal"
+                    : rawExpression.sum.builtin === BuiltinFunction.GREATER
+                        ? "greater"
+                        : rawExpression.sum.builtin
+                            === BuiltinFunction.APPEND_TEXT
+                            ? "appendText"
+                            : (BuiltinFunction[rawExpression.sum.builtin]
+                                ?? "unsupported"),
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "val") {
+            const valueReference = rawExpression.sum.val;
+            return new 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 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 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 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 DamlLfExpression({
+                recordProjection: {
+                    fieldName: Lf2ModelMapper.resolveInternedString(internedStrings, rawExpression.sum.recProj.fieldInternedStr),
+                    record: Lf2ModelMapper.mapExpression(rawExpression.sum.recProj.record, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
         }
-        return new DamlLfExpression({});
+        if (rawExpression?.sum.oneofKind === "recUpd") {
+            return new 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 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 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 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 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 DamlLfExpression({
+                optionalConstruction: {},
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "optionalSome") {
+            return new DamlLfExpression({
+                optionalConstruction: {
+                    value: Lf2ModelMapper.mapExpression(rawExpression.sum.optionalSome.value, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "update") {
+            return new 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 DamlLfExpression({
+                enumConstruction: {
+                    constructorName: Lf2ModelMapper.resolveInternedString(internedStrings, rawExpression.sum.enumCon.enumConInternedStr),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "nil") {
+            return new DamlLfExpression({
+                listConstruction: {
+                    front: [],
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "cons") {
+            return new 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 DamlLfExpression({
+                throwExpression: {
+                    exception: Lf2ModelMapper.mapExpression(rawExpression.sum.throw.exceptionExpr, internedStrings, internedDottedNames, currentPackageId, rawPackage),
+                },
+            });
+        }
+        if (rawExpression?.sum.oneofKind === "case") {
+            return new 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 === BuiltinCon.CON_TRUE
+                                ? "true"
+                                : alternative.sum.builtinCon
+                                    === 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 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 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 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) {

package/dist/debugger/errors/replay-determinism.exception.d.ts

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export declare class ReplayDeterminismException extends CantonError {
+}

package/dist/debugger/errors/replay-determinism.exception.js

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export class ReplayDeterminismException extends CantonError {
+}

package/dist/debugger/errors/replay-missing-package.exception.d.ts

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export declare class ReplayMissingPackageException extends CantonError {
+}

package/dist/debugger/errors/replay-missing-package.exception.js

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export class ReplayMissingPackageException extends CantonError {
+}

package/dist/debugger/errors/replay-missing-source.exception.d.ts

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export declare class ReplayMissingSourceException extends CantonError {
+}

package/dist/debugger/errors/replay-missing-source.exception.js

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export class ReplayMissingSourceException extends CantonError {
+}

package/dist/debugger/errors/replay-source-map.exception.d.ts

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export declare class ReplaySourceMapException extends CantonError {
+}

package/dist/debugger/errors/replay-source-map.exception.js

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export class ReplaySourceMapException extends CantonError {
+}

package/dist/debugger/errors/replay-state-hydration.exception.d.ts

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export declare class ReplayStateHydrationException extends CantonError {
+}

package/dist/debugger/errors/replay-state-hydration.exception.js

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export class ReplayStateHydrationException extends CantonError {
+}

package/dist/debugger/errors/replay-unsupported-lf-construct.exception.d.ts

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export declare class ReplayUnsupportedLfConstructException extends CantonError {
+}

package/dist/debugger/errors/replay-unsupported-lf-construct.exception.js

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export class ReplayUnsupportedLfConstructException extends CantonError {
+}

package/dist/debugger/errors/replay-unsupported-update.exception.d.ts

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export declare class ReplayUnsupportedUpdateException extends CantonError {
+}

package/dist/debugger/errors/replay-unsupported-update.exception.js

@@ -0,0 +1,3 @@
+import { CantonError } from "../../core/errors/canton-error.js";
+export class ReplayUnsupportedUpdateException extends CantonError {
+}

package/dist/debugger/index.d.ts

@@ -0,0 +1,31 @@
+export { LedgerReplayDebuggerClient } from "./ledger-replay-debugger-client.js";
+export { ReplayDeterminismException } from "./errors/replay-determinism.exception.js";
+export { ReplayMissingPackageException } from "./errors/replay-missing-package.exception.js";
+export { ReplayMissingSourceException } from "./errors/replay-missing-source.exception.js";
+export { ReplaySourceMapException } from "./errors/replay-source-map.exception.js";
+export { ReplayStateHydrationException } from "./errors/replay-state-hydration.exception.js";
+export { ReplayUnsupportedLfConstructException } from "./errors/replay-unsupported-lf-construct.exception.js";
+export { ReplayUnsupportedUpdateException } from "./errors/replay-unsupported-update.exception.js";
+export { LedgerReplaySessionLoader } from "./replay/ledger-replay-session-loader.js";
+export { LedgerReplayEnvironmentBuilder } from "./replay/ledger-replay-environment-builder.js";
+export { ReplayArtifactResolver } from "./replay/replay-artifact-resolver.js";
+export { ReplayDeterminismValidator } from "./replay/replay-determinism-validator.js";
+export { ReplayEntrypointDefinitionResolver } from "./replay/replay-entrypoint-definition-resolver.js";
+export { ReplayEntrypoint } from "./replay/replay-entrypoint.js";
+export { ReplayUpdateLoader } from "./replay/replay-update-loader.js";
+export { ReplayPhase } from "./session/replay-phase.js";
+export { InMemoryReplaySessionStore } from "./session/in-memory-replay-session-store.js";
+export { ReplaySession } from "./session/replay-session.js";
+export { ReplaySessionMetadata } from "./session/replay-session-metadata.js";
+export { ReplaySessionRequest } from "./session/replay-session-request.js";
+export { ReplaySourceLocation } from "./session/replay-source-location.js";
+export { ReplayScope } from "./session/replay-scope.js";
+export { ReplayStackFrame } from "./session/replay-stack-frame.js";
+export { ReplayStateDelta } from "./session/replay-state-delta.js";
+export { ReplayStep } from "./session/replay-step.js";
+export { ReplayStepAdvanceResult } from "./session/replay-step-advance-result.js";
+export { ReplayValuePreview } from "./session/replay-value-preview.js";
+export { DamlSourceMapper } from "./source/daml-source-mapper.js";
+export { DarSourceMapMetadata } from "./source/dar-source-map-metadata.js";
+export { SourceMappingPrecision, } from "./source/source-mapping-precision.js";
+export { IndexedDefinitionSource, IndexedExecutableSource, SourceIndexedCompilation, } from "./source/source-indexed-compilation.js";