@distrohelena/canton-typescript-sdk 0.1.4 → 0.1.6

package/dist/daml-lf/interpreter/daml-lf-evaluator.js

@@ -0,0 +1,1131 @@
+import { ValidationError } from "../../core/errors/validation-error.js";
+import { ReplaySourceMapException } from "../../debugger/errors/replay-source-map.exception.js";
+import { DamlLfBuiltinType } from "../model/daml-lf-builtin-type.js";
+import { DamlLfExpression } from "../model/daml-lf-expression.js";
+import { DamlLfTemplateId } from "../model/daml-lf-template-id.js";
+import { DamlLfType } from "../model/daml-lf-type.js";
+import { TypeConReference } from "../model/type-con-reference.js";
+import { DamlLfBuiltinDispatch } from "./daml-lf-builtin-dispatch.js";
+import { DamlLfLexicalScope } from "./daml-lf-lexical-scope.js";
+import { DAML_LF_CONTRACT_ID_MARKER_KEY, DAML_LF_PARTY_MARKER_KEY, DAML_LF_RECORD_ID_MARKER_KEY, } from "./daml-lf-runtime-value.js";
+import { DamlLfRuntimeFrame } from "./daml-lf-runtime-frame.js";
+import { DamlLfStepKind } from "./daml-lf-step-kind.js";
+class DamlLfThrownException extends Error {
+    value;
+    constructor(value) {
+        super("daml lf threw an exception");
+        this.value = value;
+    }
+}
+export class DamlLfEvaluator {
+    compilation;
+    builtinDispatch;
+    nextFrameNumber = 1;
+    activeReplayContext;
+    semanticModel;
+    constructor(compilation, builtinDispatch = new DamlLfBuiltinDispatch()) {
+        this.compilation = compilation;
+        this.builtinDispatch = builtinDispatch;
+        this.semanticModel = this.compilation.createSemanticModel();
+        void this.compilation;
+    }
+    getCompilation() {
+        return this.compilation;
+    }
+    getBuiltinDispatch() {
+        return this.builtinDispatch;
+    }
+    evaluateValueDefinitionOrThrow(definition, traceSink) {
+        const frame = this.createFrame(definition);
+        return this.evaluateExpressionOrThrow(definition.expression, frame, traceSink);
+    }
+    evaluateReplayEntrypointOrThrow(definition, environment, traceSink) {
+        const frame = this.createFrame(definition);
+        const replayExpression = environment.entrypointExpression ?? definition.expression;
+        const replayContext = {
+            environment,
+            effects: [],
+            createdContracts: new Map(),
+            observedCreateContractIds: [
+                ...(environment.observedCreateContractIds ?? []),
+            ],
+            nextSyntheticContractIdNumber: 1,
+            nextObservedCreateIndex: 0,
+        };
+        this.activeReplayContext = replayContext;
+        try {
+            const shouldEmitEntrypointEffects = !this.isUpdateDrivenEntrypointExpression(replayExpression);
+            const shouldEmitTopLevelExerciseEffect = !shouldEmitEntrypointEffects
+                && environment.entrypoint.kind === "exercise"
+                && environment.entrypointBindingMode === "templateChoice";
+            if (shouldEmitEntrypointEffects || shouldEmitTopLevelExerciseEffect) {
+                for (const effect of this.createReplayEffects(environment)) {
+                    replayContext.effects.push(effect);
+                    traceSink?.onStep({
+                        kind: DamlLfStepKind.stateEffect,
+                        expression: replayExpression,
+                        frame,
+                        locals: frame.scope.snapshotBindings(),
+                        stateEffect: effect,
+                    });
+                }
+            }
+            return {
+                value: this.evaluateReplayExpressionOrThrow(replayExpression, frame, environment, traceSink),
+                effects: [...replayContext.effects],
+            };
+        }
+        finally {
+            this.activeReplayContext = undefined;
+        }
+    }
+    evaluateExpressionOrThrow(expression, frame, traceSink) {
+        traceSink?.onStep({
+            kind: DamlLfStepKind.enterExpression,
+            expression,
+            frame,
+            locals: frame.scope.snapshotBindings(),
+        });
+        const value = this.resolveExpressionValue(expression, frame, traceSink);
+        traceSink?.onStep({
+            kind: DamlLfStepKind.exitExpression,
+            expression,
+            frame,
+            locals: frame.scope.snapshotBindings(),
+            value,
+        });
+        return value;
+    }
+    createReplayEffects(environment) {
+        if (environment.entrypoint.kind === "exercise") {
+            return [
+                {
+                    kind: "exercise",
+                    contractId: environment.entrypoint.contractId,
+                    templateId: environment.entrypoint.templateId,
+                    choice: environment.entrypoint.choice,
+                    argument: environment.entrypoint.argument,
+                },
+            ];
+        }
+        return [
+            {
+                kind: "create",
+                templateId: environment.entrypoint.templateId,
+                payload: environment.entrypoint.argument,
+            },
+        ];
+    }
+    createFrame(definition, identityOverride) {
+        const identity = identityOverride
+            ?? this.compilation.getValueDefinitionIdentityOrThrow(definition);
+        return new DamlLfRuntimeFrame({
+            frameId: `frame-${this.nextFrameNumber++}`,
+            packageId: identity.packageId,
+            moduleName: identity.moduleName,
+            definition,
+            scope: new DamlLfLexicalScope(),
+        });
+    }
+    resolveExpressionValue(expression, frame, traceSink) {
+        if (expression.textLiteral !== undefined) {
+            return {
+                kind: "text",
+                value: expression.textLiteral,
+            };
+        }
+        if (expression.numericLiteral !== undefined) {
+            return {
+                kind: "numeric",
+                value: expression.numericLiteral,
+            };
+        }
+        if (expression.int64Literal !== undefined) {
+            return {
+                kind: "int64",
+                value: expression.int64Literal,
+            };
+        }
+        if (expression.variableName !== undefined) {
+            const value = frame.scope.getBinding(expression.variableName);
+            if (value === undefined) {
+                throw new ValidationError(`daml lf variable '${expression.variableName}' is not bound`);
+            }
+            return value;
+        }
+        if (expression.builtinConstructor !== undefined) {
+            switch (expression.builtinConstructor) {
+                case "true":
+                    return {
+                        kind: "boolean",
+                        value: true,
+                    };
+                case "false":
+                    return {
+                        kind: "boolean",
+                        value: false,
+                    };
+                default:
+                    return {
+                        kind: "unit",
+                    };
+            }
+        }
+        if (expression.builtinFunction !== undefined) {
+            return {
+                kind: "builtin",
+                builtinFunction: expression.builtinFunction,
+                appliedArguments: [],
+            };
+        }
+        if (expression.lambda !== undefined) {
+            return {
+                kind: "closure",
+                parameters: expression.lambda.parameters,
+                body: expression.lambda.body,
+                frame,
+            };
+        }
+        if (expression.application !== undefined) {
+            const functionValue = this.evaluateExpressionOrThrow(expression.application.function, frame, traceSink);
+            const argumentValues = expression.application.arguments.map((argument) => this.evaluateExpressionOrThrow(argument, frame, traceSink));
+            return this.applyFunctionOrThrow(functionValue, argumentValues, traceSink);
+        }
+        if (expression.letExpression !== undefined) {
+            const scopedFrame = this.deriveFrame(frame, frame.scope.createChild());
+            for (const binding of expression.letExpression.bindings) {
+                const boundValue = this.evaluateExpressionOrThrow(binding.value, scopedFrame, traceSink);
+                scopedFrame.scope.setBinding(binding.name, boundValue);
+            }
+            return this.evaluateExpressionOrThrow(expression.letExpression.body, scopedFrame, traceSink);
+        }
+        if (expression.recordConstruction !== undefined) {
+            return this.createRecordRuntimeValue(Object.fromEntries(expression.recordConstruction.fields.map((field) => [
+                field.name,
+                this.evaluateExpressionOrThrow(field.value, frame, traceSink),
+            ])));
+        }
+        if (expression.recordProjection !== undefined) {
+            const recordValue = this.evaluateExpressionOrThrow(expression.recordProjection.record, frame, traceSink);
+            if (recordValue.kind === "record") {
+                const recordFields = recordValue.fields;
+                const fieldValue = recordFields[expression.recordProjection.fieldName];
+                if (fieldValue === undefined) {
+                    throw new ValidationError(`daml lf record projection could not find field '${expression.recordProjection.fieldName}'`);
+                }
+                return fieldValue;
+            }
+            const rawValue = this.unwrapRuntimeValue(recordValue);
+            if (rawValue === null
+                || typeof rawValue !== "object"
+                || Array.isArray(rawValue)) {
+                throw new ValidationError(`daml lf record projection requires an object value for field '${expression.recordProjection.fieldName}'`);
+            }
+            return this.hydrateRuntimeValue(this.readLedgerRecordField(rawValue, expression.recordProjection.fieldName));
+        }
+        if (expression.recordUpdate !== undefined) {
+            const recordValue = this.evaluateExpressionOrThrow(expression.recordUpdate.record, frame, traceSink);
+            if (recordValue.kind === "record") {
+                const recordFields = recordValue.fields;
+                return this.createRecordRuntimeValue({
+                    ...recordFields,
+                    [expression.recordUpdate.fieldName]: this.evaluateExpressionOrThrow(expression.recordUpdate.value, frame, traceSink),
+                });
+            }
+            const rawValue = this.unwrapRuntimeValue(recordValue);
+            if (rawValue === null
+                || typeof rawValue !== "object"
+                || Array.isArray(rawValue)) {
+                throw new ValidationError(`daml lf record update requires an object value for field '${expression.recordUpdate.fieldName}'`);
+            }
+            return this.hydrateRuntimeValue({
+                ...rawValue,
+                ...this.createLedgerRecordFieldUpdate(rawValue, expression.recordUpdate.fieldName, this.unwrapRuntimeValue(this.evaluateExpressionOrThrow(expression.recordUpdate.value, frame, traceSink))),
+            });
+        }
+        if (expression.throwExpression !== undefined) {
+            throw new DamlLfThrownException(this.evaluateExpressionOrThrow(expression.throwExpression.exception, frame, traceSink));
+        }
+        if (expression.variantConstruction !== undefined) {
+            return this.hydrateRuntimeValue({
+                constructor: expression.variantConstruction.constructorName,
+                value: this.unwrapRuntimeValue(this.evaluateExpressionOrThrow(expression.variantConstruction.argument, frame, traceSink)),
+            });
+        }
+        if (expression.optionalConstruction !== undefined) {
+            return expression.optionalConstruction.value === undefined
+                ? {
+                    kind: "unit",
+                }
+                : this.evaluateExpressionOrThrow(expression.optionalConstruction.value, frame, traceSink);
+        }
+        if (expression.enumConstruction !== undefined) {
+            return this.hydrateRuntimeValue(expression.enumConstruction.constructorName);
+        }
+        if (expression.listConstruction !== undefined) {
+            const front = expression.listConstruction.front.map((item) => this.unwrapRuntimeValue(this.evaluateExpressionOrThrow(item, frame, traceSink)));
+            const tail = expression.listConstruction.tail === undefined
+                ? []
+                : this.unwrapRuntimeValue(this.evaluateExpressionOrThrow(expression.listConstruction.tail, frame, traceSink));
+            if (!Array.isArray(tail)) {
+                throw new ValidationError("daml lf list construction requires an array tail");
+            }
+            return this.hydrateRuntimeValue([...front, ...tail]);
+        }
+        if (expression.updateExpression !== undefined) {
+            return this.evaluateUpdateExpressionOrThrow(expression, frame, traceSink);
+        }
+        if (expression.caseExpression !== undefined) {
+            const scrutinee = this.evaluateExpressionOrThrow(expression.caseExpression.scrutinee, frame, traceSink);
+            const matchingAlternative = expression.caseExpression.alternatives.find((alternative) => this.matchesCaseAlternative(alternative, scrutinee));
+            if (matchingAlternative === undefined) {
+                const scrutineeDescription = scrutinee.kind === "builtin"
+                    ? `${String(scrutinee.builtinFunction)}(${scrutinee.appliedArguments
+                        .map((argument) => argument.kind)
+                        .join(", ")})`
+                    : scrutinee.kind;
+                throw new ValidationError(`daml lf case expression in '${frame.definition.name}' did not match any alternative for '${scrutineeDescription}' across [${expression.caseExpression.alternatives
+                    .map((alternative) => alternative.patternKind)
+                    .join(", ")}]`);
+            }
+            if ((matchingAlternative.patternKind === "variant"
+                || matchingAlternative.patternKind === "optionalSome"
+                || matchingAlternative.patternKind === "cons")) {
+                const rawValue = this.unwrapRuntimeValue(scrutinee);
+                if (matchingAlternative.patternKind === "optionalSome"
+                    || matchingAlternative.patternKind === "cons"
+                    || (rawValue !== null
+                        && typeof rawValue === "object"
+                        && "value" in rawValue)) {
+                    const scopedFrame = this.deriveFrame(frame, frame.scope.createChild());
+                    if (matchingAlternative.patternKind === "cons"
+                        && Array.isArray(rawValue)) {
+                        if (matchingAlternative.headBinderName !== undefined) {
+                            scopedFrame.scope.setBinding(matchingAlternative.headBinderName, this.hydrateRuntimeValue(rawValue[0]));
+                        }
+                        if (matchingAlternative.tailBinderName !== undefined) {
+                            scopedFrame.scope.setBinding(matchingAlternative.tailBinderName, this.hydrateRuntimeValue(rawValue.slice(1)));
+                        }
+                    }
+                    else if (matchingAlternative.binderName !== undefined) {
+                        scopedFrame.scope.setBinding(matchingAlternative.binderName, this.hydrateRuntimeValue(matchingAlternative.patternKind === "optionalSome"
+                            ? rawValue
+                            : rawValue.value));
+                    }
+                    return this.evaluateExpressionOrThrow(matchingAlternative.body, scopedFrame, traceSink);
+                }
+            }
+            return this.evaluateExpressionOrThrow(matchingAlternative.body, frame, traceSink);
+        }
+        if (expression.valueReference !== undefined) {
+            const definition = this.compilation.getValueDefinitionOrThrow(expression.valueReference.packageId, expression.valueReference.moduleName, expression.valueReference.definitionName);
+            const frame = this.createFrame(definition);
+            traceSink?.onStep({
+                kind: DamlLfStepKind.call,
+                expression,
+                frame,
+                locals: frame.scope.snapshotBindings(),
+            });
+            const value = this.evaluateExpressionOrThrow(definition.expression, frame, traceSink);
+            traceSink?.onStep({
+                kind: DamlLfStepKind.return,
+                expression,
+                frame,
+                locals: frame.scope.snapshotBindings(),
+                value,
+            });
+            return value;
+        }
+        throw new ValidationError(expression.unsupportedNodeKind === undefined
+            ? "daml lf expression is not supported yet"
+            : `daml lf expression '${expression.unsupportedNodeKind}' is not supported yet`);
+    }
+    evaluateReplayExpressionOrThrow(expression, frame, environment, traceSink) {
+        return this.evaluateReplayLambdaOrExpressionOrThrow(expression, frame, this.resolveEntrypointBindingValues(environment), traceSink, environment.entrypointBindingMode ?? "standard");
+    }
+    evaluateUpdateExpressionOrThrow(expression, frame, traceSink) {
+        const updateExpression = expression.updateExpression;
+        if (updateExpression === undefined) {
+            throw new ValidationError("daml lf update expression is missing");
+        }
+        switch (updateExpression.kind) {
+            case "pure":
+            case "embedExpr":
+                return this.evaluateExpressionOrThrow(updateExpression.expression ?? new DamlLfExpression({}), frame, traceSink);
+            case "block": {
+                const scopedFrame = this.deriveFrame(frame, frame.scope.createChild());
+                for (const binding of updateExpression.bindings ?? []) {
+                    const boundValue = this.evaluateExpressionOrThrow(binding.value, scopedFrame, traceSink);
+                    scopedFrame.scope.setBinding(binding.name, boundValue);
+                }
+                return this.evaluateExpressionOrThrow(updateExpression.body ?? new DamlLfExpression({}), scopedFrame, traceSink);
+            }
+            case "tryCatch": {
+                try {
+                    return this.evaluateExpressionOrThrow(updateExpression.expression ?? new DamlLfExpression({}), frame, traceSink);
+                }
+                catch (error) {
+                    if (!(error instanceof DamlLfThrownException)) {
+                        throw error;
+                    }
+                    const scopedFrame = this.deriveFrame(frame, frame.scope.createChild());
+                    if (updateExpression.catchVariableName !== undefined) {
+                        scopedFrame.scope.setBinding(updateExpression.catchVariableName, error.value);
+                    }
+                    return this.evaluateExpressionOrThrow(updateExpression.catchExpression ?? new DamlLfExpression({}), scopedFrame, traceSink);
+                }
+            }
+            case "create": {
+                const payload = this.normalizeSemanticRecordValue(this.unwrapRuntimeValue(this.evaluateExpressionOrThrow(updateExpression.argument ?? new DamlLfExpression({}), frame, traceSink)), updateExpression.templateId === undefined
+                    ? undefined
+                    : new TypeConReference({
+                        packageId: updateExpression.templateId.packageId,
+                        moduleName: updateExpression.templateId.moduleName,
+                        name: updateExpression.templateId.templateName,
+                    }));
+                const nextSyntheticContractIdNumber = this.activeReplayContext?.nextSyntheticContractIdNumber ?? 1;
+                const observedContractId = this.activeReplayContext?.observedCreateContractIds[this.activeReplayContext.nextObservedCreateIndex];
+                const contractId = observedContractId
+                    ?? `created-${nextSyntheticContractIdNumber}`;
+                if (this.activeReplayContext !== undefined) {
+                    this.activeReplayContext.nextSyntheticContractIdNumber =
+                        nextSyntheticContractIdNumber + 1;
+                    this.activeReplayContext.nextObservedCreateIndex += 1;
+                }
+                this.activeReplayContext?.createdContracts.set(contractId, {
+                    payload,
+                    templateId: updateExpression.templateId === undefined
+                        ? undefined
+                        : {
+                            packageId: updateExpression.templateId.packageId,
+                            moduleName: updateExpression.templateId.moduleName,
+                            entityName: updateExpression.templateId.templateName,
+                        },
+                });
+                this.emitReplayEffect({
+                    kind: "create",
+                    contractId,
+                    templateId: updateExpression.templateId === undefined
+                        ? undefined
+                        : {
+                            packageId: updateExpression.templateId.packageId,
+                            moduleName: updateExpression.templateId.moduleName,
+                            entityName: updateExpression.templateId.templateName,
+                        },
+                    payload,
+                }, expression, frame, traceSink);
+                return {
+                    kind: "contractId",
+                    value: contractId,
+                };
+            }
+            case "fetch": {
+                const contractId = this.readContractId(this.evaluateExpressionOrThrow(updateExpression.contractId ?? new DamlLfExpression({}), frame, traceSink));
+                const payload = this.activeReplayContext?.createdContracts.get(contractId)?.payload
+                    ?? this.activeReplayContext?.environment.contracts?.get(contractId)
+                        ?.payload;
+                this.emitReplayEffect({
+                    kind: "fetch",
+                    contractId,
+                    templateId: updateExpression.templateId === undefined
+                        ? undefined
+                        : {
+                            packageId: updateExpression.templateId.packageId,
+                            moduleName: updateExpression.templateId.moduleName,
+                            entityName: updateExpression.templateId.templateName,
+                        },
+                }, expression, frame, traceSink);
+                return this.hydrateRuntimeValue(payload);
+            }
+            case "fetchInterface": {
+                const contractId = this.readContractId(this.evaluateExpressionOrThrow(updateExpression.contractId ?? new DamlLfExpression({}), frame, traceSink));
+                const createdContract = this.activeReplayContext?.createdContracts.get(contractId);
+                const hydratedContract = this.activeReplayContext?.environment.contracts?.get(contractId);
+                const payload = createdContract?.payload
+                    ?? hydratedContract?.payload;
+                const resolvedTemplateId = createdContract?.templateId
+                    ?? hydratedContract?.templateId;
+                if (payload === undefined) {
+                    throw new ValidationError(`daml lf fetch-interface update could not hydrate contract '${contractId}'`);
+                }
+                this.emitReplayEffect({
+                    kind: "fetch",
+                    contractId,
+                    templateId: resolvedTemplateId,
+                }, expression, frame, traceSink);
+                return this.hydrateRuntimeValue(payload);
+            }
+            case "exercise": {
+                if (updateExpression.templateId === undefined
+                    || updateExpression.choiceName === undefined) {
+                    throw new ValidationError("daml lf exercise update is missing its template or choice");
+                }
+                const contractId = this.readContractId(this.evaluateExpressionOrThrow(updateExpression.contractId ?? new DamlLfExpression({}), frame, traceSink));
+                const argument = this.unwrapRuntimeValue(this.evaluateExpressionOrThrow(updateExpression.argument ?? new DamlLfExpression({}), frame, traceSink));
+                const payload = this.activeReplayContext?.createdContracts.get(contractId)?.payload
+                    ?? this.activeReplayContext?.environment.contracts?.get(contractId)
+                        ?.payload;
+                if (payload === undefined) {
+                    throw new ValidationError(`daml lf exercise update could not hydrate contract '${contractId}'`);
+                }
+                this.emitReplayEffect({
+                    kind: "exercise",
+                    contractId,
+                    templateId: this.toReplayTemplateId(updateExpression.templateId),
+                    choice: updateExpression.choiceName,
+                    argument,
+                }, expression, frame, traceSink);
+                const resolvedDefinition = this.activeReplayContext
+                    ?.environment.definitionResolver
+                    ?.resolveChoiceDefinitionOrThrow?.(new DamlLfTemplateId(updateExpression.templateId), updateExpression.choiceName);
+                if (resolvedDefinition === undefined) {
+                    throw new ValidationError("daml lf exercise update requires a replay definition resolver");
+                }
+                return this.evaluateReplayLambdaOrExpressionOrThrow(resolvedDefinition.replayExpression, this.createFrame(resolvedDefinition.definition, resolvedDefinition.frameIdentity), [
+                    {
+                        value: payload,
+                        contractId,
+                    },
+                    {
+                        value: argument,
+                    },
+                ], traceSink, resolvedDefinition.replayBindingMode);
+            }
+            case "exerciseInterface": {
+                if (updateExpression.choiceName === undefined) {
+                    throw new ValidationError("daml lf exercise-interface update is missing its choice");
+                }
+                const contractId = this.readContractId(this.evaluateExpressionOrThrow(updateExpression.contractId ?? new DamlLfExpression({}), frame, traceSink));
+                const argument = this.unwrapRuntimeValue(this.evaluateExpressionOrThrow(updateExpression.argument ?? new DamlLfExpression({}), frame, traceSink));
+                const createdContract = this.activeReplayContext?.createdContracts.get(contractId);
+                const hydratedContract = this.activeReplayContext?.environment.contracts?.get(contractId);
+                const payload = createdContract?.payload
+                    ?? hydratedContract?.payload;
+                const resolvedTemplateId = createdContract?.templateId
+                    ?? hydratedContract?.templateId;
+                if (payload === undefined || resolvedTemplateId === undefined) {
+                    throw new ValidationError(`daml lf exercise-interface update could not hydrate contract '${contractId}'`);
+                }
+                this.emitReplayEffect({
+                    kind: "exercise",
+                    contractId,
+                    templateId: resolvedTemplateId,
+                    choice: updateExpression.choiceName,
+                    argument,
+                }, expression, frame, traceSink);
+                let resolvedDefinition;
+                try {
+                    resolvedDefinition = this.activeReplayContext
+                        ?.environment.definitionResolver
+                        ?.resolveChoiceDefinitionOrThrow?.(new DamlLfTemplateId({
+                        packageId: resolvedTemplateId.packageId ?? "",
+                        moduleName: resolvedTemplateId.moduleName ?? "",
+                        templateName: resolvedTemplateId.entityName ?? "",
+                    }), updateExpression.choiceName);
+                }
+                catch (error) {
+                    if (error instanceof ReplaySourceMapException
+                        && error.message.includes("missing executable metadata for choice")) {
+                        return this.hydrateRuntimeValue({});
+                    }
+                    throw error;
+                }
+                if (resolvedDefinition === undefined) {
+                    return this.hydrateRuntimeValue({});
+                }
+                return this.evaluateReplayLambdaOrExpressionOrThrow(resolvedDefinition.replayExpression, this.createFrame(resolvedDefinition.definition, resolvedDefinition.frameIdentity), [
+                    {
+                        value: payload,
+                        contractId,
+                    },
+                    {
+                        value: argument,
+                    },
+                ], traceSink, resolvedDefinition.replayBindingMode);
+            }
+            case "getTime":
+                return {
+                    kind: "text",
+                    value: this.activeReplayContext?.environment.offset ?? "",
+                };
+            case "ledgerTimeLt":
+                if (updateExpression.expression !== undefined) {
+                    void this.evaluateExpressionOrThrow(updateExpression.expression, frame, traceSink);
+                }
+                return {
+                    kind: "unit",
+                };
+            default:
+                throw new ValidationError(`daml lf update expression '${updateExpression.kind}' is not supported yet`);
+        }
+    }
+    resolveEntrypointBindingValues(environment) {
+        if (environment.entrypoint.kind === "create") {
+            return environment.entrypoint.argument === undefined
+                ? []
+                : [{ value: environment.entrypoint.argument }];
+        }
+        const contractPayload = environment.entrypoint.contractId === undefined
+            ? undefined
+            : environment.contracts?.get(environment.entrypoint.contractId)?.payload;
+        const bindingValues = [];
+        if (contractPayload !== undefined) {
+            bindingValues.push({
+                value: contractPayload,
+                contractId: environment.entrypoint.contractId,
+            });
+        }
+        if (environment.entrypoint.argument !== undefined) {
+            bindingValues.push({
+                value: environment.entrypoint.argument,
+            });
+        }
+        return bindingValues;
+    }
+    evaluateReplayLambdaOrExpressionOrThrow(expression, frame, bindingValues, traceSink, bindingMode = "standard") {
+        if (expression.lambda === undefined) {
+            return this.evaluateExpressionOrThrow(expression, frame, traceSink);
+        }
+        const scopedFrame = this.deriveFrame(frame, frame.scope.createChild());
+        if (bindingMode === "templateChoice") {
+            const selfParameterName = expression.lambda.parameters[0];
+            const thisParameterName = expression.lambda.parameters[1];
+            const argumentParameterName = expression.lambda.parameters[2];
+            const contractId = bindingValues[0]?.contractId;
+            const payload = bindingValues[0];
+            const argument = bindingValues[1];
+            if (selfParameterName !== undefined && contractId !== undefined) {
+                scopedFrame.scope.setBinding(selfParameterName, {
+                    kind: "contractId",
+                    value: contractId,
+                });
+            }
+            if (thisParameterName !== undefined && payload !== undefined) {
+                scopedFrame.scope.setBinding(thisParameterName, this.hydrateRuntimeValue(payload.value, payload.contractId));
+            }
+            if (argumentParameterName !== undefined && argument !== undefined) {
+                scopedFrame.scope.setBinding(argumentParameterName, this.hydrateRuntimeValue(argument.value, argument.contractId));
+            }
+        }
+        else if (bindingMode === "exerciseWrapper") {
+            const thisParameterName = expression.lambda.parameters.at(-2);
+            const argumentParameterName = expression.lambda.parameters.at(-1);
+            const contractId = bindingValues[0]?.contractId;
+            if (thisParameterName !== undefined && contractId !== undefined) {
+                scopedFrame.scope.setBinding(thisParameterName, {
+                    kind: "contractId",
+                    value: contractId,
+                });
+            }
+            if (argumentParameterName !== undefined && bindingValues[1] !== undefined) {
+                scopedFrame.scope.setBinding(argumentParameterName, this.hydrateRuntimeValue(bindingValues[1].value, bindingValues[1].contractId));
+            }
+        }
+        else if (bindingMode === "createWrapper") {
+            const argumentParameterName = expression.lambda.parameters.at(-1);
+            const bindingValue = bindingValues[0];
+            if (argumentParameterName !== undefined && bindingValue !== undefined) {
+                scopedFrame.scope.setBinding(argumentParameterName, this.hydrateRuntimeValue(bindingValue.value, bindingValue.contractId));
+            }
+        }
+        else {
+            for (let index = 0; index < expression.lambda.parameters.length; index += 1) {
+                const bindingValue = bindingValues[index];
+                if (bindingValue === undefined) {
+                    break;
+                }
+                scopedFrame.scope.setBinding(expression.lambda.parameters[index], this.hydrateRuntimeValue(bindingValue.value, bindingValue.contractId));
+            }
+        }
+        return this.evaluateExpressionOrThrow(expression.lambda.body, scopedFrame, traceSink);
+    }
+    hydrateRuntimeValue(value, contractId) {
+        if (value === undefined || value === null) {
+            return {
+                kind: "unit",
+            };
+        }
+        const embeddedContractId = this.readEmbeddedContractId(value);
+        if (embeddedContractId !== undefined) {
+            return {
+                kind: "contractId",
+                value: embeddedContractId,
+            };
+        }
+        const embeddedContractIdArray = this.readEmbeddedContractIdArray(value);
+        if (embeddedContractIdArray !== undefined) {
+            return {
+                kind: "contractId[]",
+                value: embeddedContractIdArray,
+            };
+        }
+        const embeddedParty = this.readEmbeddedParty(value);
+        if (embeddedParty !== undefined) {
+            return {
+                kind: "party",
+                value: embeddedParty,
+            };
+        }
+        if (value !== null
+            && typeof value === "object"
+            && "__damlLfInt64" in value
+            && typeof value.__damlLfInt64 === "string") {
+            return {
+                kind: "int64",
+                value: value.__damlLfInt64,
+            };
+        }
+        if (value !== null
+            && typeof value === "object"
+            && "__damlLfNumeric" in value
+            && typeof value.__damlLfNumeric === "string") {
+            return {
+                kind: "numeric",
+                value: value.__damlLfNumeric,
+            };
+        }
+        if (typeof value === "string") {
+            return {
+                kind: "text",
+                value,
+            };
+        }
+        if (typeof value === "boolean") {
+            return {
+                kind: "boolean",
+                value,
+            };
+        }
+        return {
+            kind: "ledgerValue",
+            value,
+            contractId,
+        };
+    }
+    createRecordRuntimeValue(fields) {
+        return this.canProjectRecordAsLedgerValue(fields)
+            ? this.hydrateRuntimeValue(Object.fromEntries(Object.entries(fields).map(([name, value]) => [
+                name,
+                this.unwrapRuntimeValue(value),
+            ])))
+            : {
+                kind: "record",
+                fields,
+            };
+    }
+    canProjectRecordAsLedgerValue(fields) {
+        return Object.values(fields).every((value) => {
+            if (value.kind === "record") {
+                return this.canProjectRecordAsLedgerValue(value.fields);
+            }
+            return value.kind !== "closure" && value.kind !== "builtin";
+        });
+    }
+    readEmbeddedContractId(value) {
+        if (value !== null
+            && typeof value === "object"
+            && DAML_LF_CONTRACT_ID_MARKER_KEY in value
+            && typeof value[DAML_LF_CONTRACT_ID_MARKER_KEY] === "string") {
+            return value[DAML_LF_CONTRACT_ID_MARKER_KEY];
+        }
+        if (value !== null
+            && typeof value === "object"
+            && "sum" in value
+            && value.sum !== null
+            && typeof value.sum === "object"
+            && "oneofKind" in value.sum
+            && value.sum.oneofKind === "contractId"
+            && "contractId" in value.sum
+            && typeof value.sum.contractId === "string") {
+            return value.sum.contractId;
+        }
+        return undefined;
+    }
+    readEmbeddedContractIdArray(value) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return undefined;
+        }
+        const contractIds = value.map((item) => this.readEmbeddedContractId(item));
+        if (contractIds.some((contractId) => contractId === undefined)) {
+            return undefined;
+        }
+        return contractIds;
+    }
+    readEmbeddedParty(value) {
+        if (value !== null
+            && typeof value === "object"
+            && DAML_LF_PARTY_MARKER_KEY in value
+            && typeof value[DAML_LF_PARTY_MARKER_KEY] === "string") {
+            return value[DAML_LF_PARTY_MARKER_KEY];
+        }
+        if (value !== null
+            && typeof value === "object"
+            && "sum" in value
+            && value.sum !== null
+            && typeof value.sum === "object"
+            && "oneofKind" in value.sum
+            && value.sum.oneofKind === "party"
+            && "party" in value.sum
+            && typeof value.sum.party === "string") {
+            return value.sum.party;
+        }
+        return undefined;
+    }
+    readLedgerRecordField(rawValue, fieldName) {
+        const semanticField = this.resolveSemanticRecordField(rawValue, fieldName);
+        if (fieldName in rawValue) {
+            return this.coerceSemanticFieldValue(this.attachSemanticRecordId(rawValue[fieldName], semanticField?.type.typeConReference), semanticField?.type);
+        }
+        if (semanticField === undefined) {
+            return undefined;
+        }
+        return this.coerceSemanticFieldValue(this.attachSemanticRecordId(rawValue[String(semanticField.index)], semanticField.type.typeConReference), semanticField.type);
+    }
+    createLedgerRecordFieldUpdate(rawValue, fieldName, nextValue) {
+        if (fieldName in rawValue) {
+            return {
+                [fieldName]: nextValue,
+            };
+        }
+        const semanticField = this.resolveSemanticRecordField(rawValue, fieldName);
+        return semanticField === undefined
+            ? {
+                [fieldName]: nextValue,
+            }
+            : {
+                [String(semanticField.index)]: nextValue,
+            };
+    }
+    resolveSemanticRecordField(rawValue, fieldName) {
+        const recordId = rawValue[DAML_LF_RECORD_ID_MARKER_KEY];
+        if (recordId === undefined
+            || recordId === null
+            || typeof recordId !== "object") {
+            return undefined;
+        }
+        const typedRecordId = recordId;
+        const reference = new TypeConReference({
+            packageId: typeof typedRecordId.packageId === "string"
+                ? typedRecordId.packageId
+                : "",
+            moduleName: typeof typedRecordId.moduleName === "string"
+                ? typedRecordId.moduleName
+                : "",
+            name: typeof typedRecordId.entityName === "string"
+                ? typedRecordId.entityName
+                : "",
+        });
+        try {
+            const fields = this.semanticModel.getRecordFieldsOrThrow(reference);
+            const semanticIndex = fields.findIndex((field) => field.name === fieldName);
+            if (semanticIndex < 0) {
+                return undefined;
+            }
+            return {
+                index: semanticIndex,
+                type: fields[semanticIndex]?.type ?? new DamlLfType({}),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    coerceSemanticFieldValue(value, type) {
+        if (type?.builtinType === DamlLfBuiltinType.int64) {
+            return typeof value === "string" ? { __damlLfInt64: value } : value;
+        }
+        if (type?.builtinType === DamlLfBuiltinType.party) {
+            return typeof value === "string"
+                ? { [DAML_LF_PARTY_MARKER_KEY]: value }
+                : value;
+        }
+        return value;
+    }
+    attachSemanticRecordId(value, typeConReference) {
+        if (typeConReference === undefined
+            || value === null
+            || value === undefined
+            || typeof value !== "object"
+            || Array.isArray(value)
+            || DAML_LF_RECORD_ID_MARKER_KEY in value) {
+            return value;
+        }
+        return {
+            ...value,
+            [DAML_LF_RECORD_ID_MARKER_KEY]: {
+                packageId: typeConReference.packageId,
+                moduleName: typeConReference.moduleName,
+                entityName: typeConReference.name,
+            },
+        };
+    }
+    normalizeSemanticRecordValue(value, typeConReference) {
+        if (typeConReference === undefined
+            || value === null
+            || value === undefined
+            || typeof value !== "object"
+            || Array.isArray(value)) {
+            return value;
+        }
+        try {
+            const fields = this.semanticModel.getRecordFieldsOrThrow(typeConReference);
+            const rawValue = value;
+            const normalizedValue = {};
+            const consumedKeys = new Set();
+            for (const [index, field] of fields.entries()) {
+                const directValue = rawValue[field.name];
+                const positionalKey = String(index);
+                const positionalValue = rawValue[positionalKey];
+                const nextValue = directValue !== undefined ? directValue : positionalValue;
+                if (nextValue === undefined) {
+                    continue;
+                }
+                normalizedValue[field.name] = this.normalizeSemanticRecordValue(nextValue, field.type.typeConReference);
+                consumedKeys.add(field.name);
+                consumedKeys.add(positionalKey);
+            }
+            for (const [key, item] of Object.entries(rawValue)) {
+                if (!consumedKeys.has(key)) {
+                    normalizedValue[key] = item;
+                }
+            }
+            return normalizedValue;
+        }
+        catch {
+            return value;
+        }
+    }
+    toReplayTemplateId(templateId) {
+        return templateId === undefined
+            ? undefined
+            : {
+                packageId: templateId.packageId,
+                moduleName: templateId.moduleName,
+                entityName: templateId.templateName,
+            };
+    }
+    readContractId(value) {
+        if ((value.kind === "contractId" || value.kind === "text")
+            && "value" in value
+            && typeof value.value === "string") {
+            return value.value;
+        }
+        if (value.kind === "ledgerValue"
+            && "contractId" in value
+            && typeof value.contractId === "string") {
+            return value.contractId;
+        }
+        throw new ValidationError(`daml lf expected a contract id-compatible value, got '${value.kind}'`);
+    }
+    unwrapRuntimeValue(value) {
+        if (value.kind === "record") {
+            const recordFields = value.fields;
+            return Object.fromEntries(Object.entries(recordFields).map(([name, fieldValue]) => [
+                name,
+                this.unwrapRuntimeValue(fieldValue),
+            ]));
+        }
+        if (value.kind === "contractId[]") {
+            return value.value.map((contractId) => ({
+                [DAML_LF_CONTRACT_ID_MARKER_KEY]: contractId,
+            }));
+        }
+        if (value.kind === "contractId") {
+            return {
+                [DAML_LF_CONTRACT_ID_MARKER_KEY]: value.value,
+            };
+        }
+        if (value.kind === "party") {
+            return {
+                [DAML_LF_PARTY_MARKER_KEY]: value.value,
+            };
+        }
+        if (value.kind === "builtin"
+            && "builtinFunction" in value
+            && value.builtinFunction === "TEXTMAP_EMPTY") {
+            return {};
+        }
+        if (value.kind === "builtin"
+            && "builtinFunction" in value
+            && value.builtinFunction === "GENMAP_EMPTY") {
+            return [];
+        }
+        if ("value" in value) {
+            return value.value;
+        }
+        if (value.kind === "unit") {
+            return null;
+        }
+        return value.kind;
+    }
+    readRuntimeListOrThrow(value) {
+        if (value.kind === "contractId[]") {
+            return value.value.map((contractId) => ({
+                kind: "contractId",
+                value: contractId,
+            }));
+        }
+        if (value.kind === "ledgerValue"
+            && "value" in value
+            && Array.isArray(value.value)) {
+            return value.value.map((item) => this.hydrateRuntimeValue(item));
+        }
+        throw new ValidationError(`daml lf expected a list-compatible value, got '${value.kind}'`);
+    }
+    matchesBuiltinConstructor(builtinConstructor, runtimeValue) {
+        switch (builtinConstructor) {
+            case "true":
+                return runtimeValue.kind === "boolean" && runtimeValue.value === true;
+            case "false":
+                return runtimeValue.kind === "boolean" && runtimeValue.value === false;
+            case "unit":
+                return runtimeValue.kind === "unit";
+            default:
+                return false;
+        }
+    }
+    matchesCaseAlternative(alternative, runtimeValue) {
+        if (alternative.patternKind === "default") {
+            return true;
+        }
+        if (alternative.patternKind === "builtinCon") {
+            return this.matchesBuiltinConstructor(alternative.builtinConstructor, runtimeValue);
+        }
+        if (alternative.patternKind === "optionalNone") {
+            return runtimeValue.kind === "unit";
+        }
+        if (alternative.patternKind === "optionalSome") {
+            return runtimeValue.kind !== "unit";
+        }
+        if (alternative.patternKind === "enum") {
+            return (runtimeValue.kind === "text"
+                && runtimeValue.value === alternative.constructorName);
+        }
+        if (alternative.patternKind === "nil") {
+            const unwrapped = this.unwrapRuntimeValue(runtimeValue);
+            return Array.isArray(unwrapped) && unwrapped.length === 0;
+        }
+        if (alternative.patternKind === "cons") {
+            const unwrapped = this.unwrapRuntimeValue(runtimeValue);
+            return Array.isArray(unwrapped) && unwrapped.length > 0;
+        }
+        const rawValue = this.unwrapRuntimeValue(runtimeValue);
+        return (rawValue !== null
+            && typeof rawValue === "object"
+            && "constructor" in rawValue
+            && rawValue.constructor
+                === alternative.constructorName);
+    }
+    emitReplayEffect(effect, expression, frame, traceSink) {
+        this.activeReplayContext?.effects.push(effect);
+        traceSink?.onStep({
+            kind: DamlLfStepKind.stateEffect,
+            expression,
+            frame,
+            locals: frame.scope.snapshotBindings(),
+            stateEffect: effect,
+        });
+    }
+    isUpdateDrivenEntrypointExpression(expression) {
+        if (expression.updateExpression !== undefined) {
+            return true;
+        }
+        if (expression.lambda !== undefined) {
+            return this.isUpdateDrivenEntrypointExpression(expression.lambda.body);
+        }
+        if (expression.letExpression !== undefined) {
+            return this.isUpdateDrivenEntrypointExpression(expression.letExpression.body);
+        }
+        return false;
+    }
+    applyFunctionOrThrow(functionValue, argumentValues, traceSink) {
+        if (functionValue.kind !== "closure") {
+            if (functionValue.kind === "builtin") {
+                const builtinValue = functionValue;
+                if (builtinValue.builtinFunction === "FOLDL") {
+                    return this.applyFoldlBuiltinOrThrow(builtinValue, argumentValues, traceSink);
+                }
+                if (builtinValue.builtinFunction === "FOLDR") {
+                    return this.applyFoldrBuiltinOrThrow(builtinValue, argumentValues, traceSink);
+                }
+                return this.builtinDispatch.applyOrThrow(builtinValue, argumentValues);
+            }
+            throw new ValidationError(`daml lf expression is not callable (${functionValue.kind})`);
+        }
+        const closure = functionValue;
+        const boundParameterCount = Math.min(closure.parameters.length, argumentValues.length);
+        const remainingParameters = closure.parameters.slice(boundParameterCount);
+        const remainingArguments = argumentValues.slice(boundParameterCount);
+        const scope = closure.frame.scope.createChild();
+        for (let index = 0; index < boundParameterCount; index += 1) {
+            scope.setBinding(closure.parameters[index], argumentValues[index]);
+        }
+        const appliedFrame = this.deriveFrame(closure.frame, scope);
+        const intermediateValue = remainingParameters.length === 0
+            ? this.evaluateExpressionOrThrow(closure.body, appliedFrame, traceSink)
+            : {
+                kind: "closure",
+                parameters: remainingParameters,
+                body: closure.body,
+                frame: appliedFrame,
+            };
+        return remainingArguments.length === 0
+            ? intermediateValue
+            : this.applyFunctionOrThrow(intermediateValue, remainingArguments, traceSink);
+    }
+    applyFoldlBuiltinOrThrow(builtinValue, argumentValues, traceSink) {
+        const appliedArguments = [
+            ...builtinValue.appliedArguments,
+            ...argumentValues,
+        ];
+        if (appliedArguments.length < 3) {
+            return {
+                kind: "builtin",
+                builtinFunction: builtinValue.builtinFunction,
+                appliedArguments,
+            };
+        }
+        const foldFunction = appliedArguments[0];
+        let accumulator = appliedArguments[1];
+        const listItems = this.readRuntimeListOrThrow(appliedArguments[2]);
+        const remainingArguments = appliedArguments.slice(3);
+        for (const item of listItems) {
+            accumulator = this.applyFunctionOrThrow(this.applyFunctionOrThrow(foldFunction, [accumulator], traceSink), [item], traceSink);
+        }
+        return remainingArguments.length === 0
+            ? accumulator
+            : this.applyFunctionOrThrow(accumulator, remainingArguments, traceSink);
+    }
+    applyFoldrBuiltinOrThrow(builtinValue, argumentValues, traceSink) {
+        const appliedArguments = [
+            ...builtinValue.appliedArguments,
+            ...argumentValues,
+        ];
+        if (appliedArguments.length < 3) {
+            return {
+                kind: "builtin",
+                builtinFunction: builtinValue.builtinFunction,
+                appliedArguments,
+            };
+        }
+        const foldFunction = appliedArguments[0];
+        let accumulator = appliedArguments[1];
+        const listItems = this.readRuntimeListOrThrow(appliedArguments[2]);
+        const remainingArguments = appliedArguments.slice(3);
+        for (const item of [...listItems].reverse()) {
+            accumulator = this.applyFunctionOrThrow(this.applyFunctionOrThrow(foldFunction, [item], traceSink), [accumulator], traceSink);
+        }
+        return remainingArguments.length === 0
+            ? accumulator
+            : this.applyFunctionOrThrow(accumulator, remainingArguments, traceSink);
+    }
+    deriveFrame(frame, scope) {
+        return new DamlLfRuntimeFrame({
+            frameId: frame.frameId,
+            packageId: frame.packageId,
+            moduleName: frame.moduleName,
+            definition: frame.definition,
+            scope,
+        });
+    }
+}