@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/daml-lf/interpreter/daml-lf-interpreter-scaffold.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfInterpreterScaffold = void 0;
+const daml_lf_builtin_dispatch_js_1 = require("./daml-lf-builtin-dispatch.js");
+const daml_lf_evaluator_js_1 = require("./daml-lf-evaluator.js");
+class DamlLfInterpreterScaffold {
+    compilation;
+    builtinDispatch = new daml_lf_builtin_dispatch_js_1.DamlLfBuiltinDispatch();
+    evaluator;
+    constructor(compilation) {
+        this.compilation = compilation;
+        this.evaluator = new daml_lf_evaluator_js_1.DamlLfEvaluator(this.compilation, this.builtinDispatch);
+    }
+    getCompilation() {
+        return this.compilation;
+    }
+    getBuiltinDispatch() {
+        return this.builtinDispatch;
+    }
+    getEvaluator() {
+        return this.evaluator;
+    }
+}
+exports.DamlLfInterpreterScaffold = DamlLfInterpreterScaffold;

package/dist/cjs/daml-lf/interpreter/daml-lf-lexical-scope.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfLexicalScope = void 0;
+class DamlLfLexicalScope {
+    parent;
+    bindings = new Map();
+    constructor(parent) {
+        this.parent = parent;
+    }
+    getBinding(name) {
+        const visited = new Set();
+        let current = this;
+        while (current !== undefined && !visited.has(current)) {
+            visited.add(current);
+            const binding = current.bindings.get(name);
+            if (binding !== undefined) {
+                return binding;
+            }
+            current = current.parent;
+        }
+        return undefined;
+    }
+    setBinding(name, value) {
+        this.bindings.set(name, value);
+    }
+    createChild() {
+        return new DamlLfLexicalScope(this);
+    }
+    snapshotBindings() {
+        const scopes = [];
+        const resolved = new Map();
+        const visited = new Set();
+        let current = this;
+        while (current !== undefined && !visited.has(current)) {
+            visited.add(current);
+            scopes.push(current);
+            current = current.parent;
+        }
+        for (let index = scopes.length - 1; index >= 0; index -= 1) {
+            for (const [name, value] of scopes[index].bindings.entries()) {
+                resolved.set(name, value);
+            }
+        }
+        return [...resolved.entries()].map(([name, value]) => ({
+            name,
+            value,
+        }));
+    }
+}
+exports.DamlLfLexicalScope = DamlLfLexicalScope;

package/dist/cjs/daml-lf/interpreter/daml-lf-runtime-frame.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfRuntimeFrame = void 0;
+const daml_lf_lexical_scope_js_1 = require("./daml-lf-lexical-scope.js");
+class DamlLfRuntimeFrame {
+    frameId;
+    packageId;
+    moduleName;
+    definition;
+    scope;
+    constructor(init) {
+        this.frameId = init.frameId;
+        this.packageId = init.packageId;
+        this.moduleName = init.moduleName;
+        this.definition = init.definition;
+        this.scope = init.scope ?? new daml_lf_lexical_scope_js_1.DamlLfLexicalScope();
+    }
+}
+exports.DamlLfRuntimeFrame = DamlLfRuntimeFrame;

package/dist/cjs/daml-lf/interpreter/daml-lf-runtime-value.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAML_LF_RECORD_ID_MARKER_KEY = exports.DAML_LF_PARTY_MARKER_KEY = exports.DAML_LF_NUMERIC_MARKER_KEY = exports.DAML_LF_CONTRACT_ID_MARKER_KEY = void 0;
+exports.DAML_LF_CONTRACT_ID_MARKER_KEY = "__damlLfContractId";
+exports.DAML_LF_NUMERIC_MARKER_KEY = "__damlLfNumeric";
+exports.DAML_LF_PARTY_MARKER_KEY = "__damlLfParty";
+exports.DAML_LF_RECORD_ID_MARKER_KEY = "__damlLfRecordId";

package/dist/cjs/daml-lf/interpreter/daml-lf-step-kind.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfStepKind = void 0;
+var DamlLfStepKind;
+(function (DamlLfStepKind) {
+    DamlLfStepKind["stateEffect"] = "stateEffect";
+    DamlLfStepKind["call"] = "call";
+    DamlLfStepKind["return"] = "return";
+    DamlLfStepKind["enterExpression"] = "enterExpression";
+    DamlLfStepKind["exitExpression"] = "exitExpression";
+})(DamlLfStepKind || (exports.DamlLfStepKind = DamlLfStepKind = {}));

package/dist/cjs/daml-lf/interpreter/daml-lf-trace-sink.interface.js

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

package/dist/cjs/daml-lf/model/daml-lf-builtin-type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfBuiltinType = void 0;
+var DamlLfBuiltinType;
+(function (DamlLfBuiltinType) {
+    DamlLfBuiltinType["unit"] = "unit";
+    DamlLfBuiltinType["bool"] = "bool";
+    DamlLfBuiltinType["int64"] = "int64";
+    DamlLfBuiltinType["date"] = "date";
+    DamlLfBuiltinType["timestamp"] = "timestamp";
+    DamlLfBuiltinType["numeric"] = "numeric";
+    DamlLfBuiltinType["party"] = "party";
+    DamlLfBuiltinType["text"] = "text";
+    DamlLfBuiltinType["contractId"] = "contractId";
+    DamlLfBuiltinType["optional"] = "optional";
+    DamlLfBuiltinType["list"] = "list";
+    DamlLfBuiltinType["textMap"] = "textMap";
+    DamlLfBuiltinType["genMap"] = "genMap";
+    DamlLfBuiltinType["unknown"] = "unknown";
+})(DamlLfBuiltinType || (exports.DamlLfBuiltinType = DamlLfBuiltinType = {}));

package/dist/cjs/daml-lf/model/daml-lf-choice-parameter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfChoiceParameter = void 0;
+const daml_lf_node_kind_js_1 = require("./daml-lf-node-kind.js");
+class DamlLfChoiceParameter {
+    nodeKind = daml_lf_node_kind_js_1.DamlLfNodeKind.choiceParameter;
+    name;
+    type;
+    constructor(init) {
+        this.name = init.name;
+        this.type = init.type;
+    }
+}
+exports.DamlLfChoiceParameter = DamlLfChoiceParameter;

package/dist/cjs/daml-lf/model/daml-lf-choice.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfChoice = void 0;
+const daml_lf_node_kind_js_1 = require("./daml-lf-node-kind.js");
+class DamlLfChoice {
+    nodeKind = daml_lf_node_kind_js_1.DamlLfNodeKind.choice;
+    name;
+    consuming;
+    selfBinderName;
+    parameter;
+    returnType;
+    updateExpression;
+    constructor(init) {
+        this.name = init.name;
+        this.parameter = init.parameter;
+        this.consuming = init.consuming ?? true;
+        this.selfBinderName = init.selfBinderName;
+        this.returnType = init.returnType ?? init.parameter.type;
+        this.updateExpression = init.updateExpression;
+    }
+}
+exports.DamlLfChoice = DamlLfChoice;

package/dist/cjs/daml-lf/model/daml-lf-data-type.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfDataType = void 0;
+const daml_lf_definition_js_1 = require("./daml-lf-definition.js");
+const daml_lf_node_kind_js_1 = require("./daml-lf-node-kind.js");
+class DamlLfDataType extends daml_lf_definition_js_1.DamlLfDefinition {
+    nodeKind = daml_lf_node_kind_js_1.DamlLfNodeKind.dataType;
+    definition;
+    fields;
+    typeParameters;
+    constructor(init) {
+        super({
+            name: init.name,
+        });
+        this.definition = init.definition ?? {
+            kind: "record",
+            fields: init.fields ?? [],
+        };
+        this.fields = this.definition.kind === "record"
+            ? this.definition.fields
+            : [];
+        this.typeParameters = Object.freeze((init.typeParameters ?? []).map((parameter) => Object.freeze({
+            ...parameter,
+            kind: freezeTypeParameterKind(parameter.kind),
+        })));
+    }
+}
+exports.DamlLfDataType = DamlLfDataType;
+function freezeTypeParameterKind(kind) {
+    if (kind.kind !== "arrow") {
+        return Object.freeze({ ...kind });
+    }
+    return Object.freeze({
+        kind: "arrow",
+        parameters: Object.freeze(kind.parameters.map((parameter) => freezeTypeParameterKind(parameter))),
+        result: freezeTypeParameterKind(kind.result),
+    });
+}

package/dist/cjs/daml-lf/model/daml-lf-definition.js

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

package/dist/cjs/daml-lf/model/daml-lf-expression-path.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDamlLfExpressionAtPath = getDamlLfExpressionAtPath;
+// This child ordering is the compiler/SDK sidecar wire contract.
+function getDamlLfExpressionAtPath(root, path) {
+    let expression = root;
+    for (const childIndex of path) {
+        if (!Number.isSafeInteger(childIndex) || childIndex < 0) {
+            return undefined;
+        }
+        expression = getDamlLfExpressionChildren(expression)[childIndex];
+        if (expression === undefined) {
+            return undefined;
+        }
+    }
+    return expression;
+}
+function getDamlLfExpressionChildren(expression) {
+    if (expression.lambda !== undefined) {
+        return [expression.lambda.body];
+    }
+    if (expression.application !== undefined) {
+        return [
+            expression.application.function,
+            ...expression.application.arguments,
+        ];
+    }
+    if (expression.letExpression !== undefined) {
+        return [
+            ...expression.letExpression.bindings.map((binding) => binding.value),
+            expression.letExpression.body,
+        ];
+    }
+    if (expression.recordConstruction !== undefined) {
+        return expression.recordConstruction.fields.map((field) => field.value);
+    }
+    if (expression.recordProjection !== undefined) {
+        return [expression.recordProjection.record];
+    }
+    if (expression.recordUpdate !== undefined) {
+        return [
+            expression.recordUpdate.record,
+            expression.recordUpdate.value,
+        ];
+    }
+    if (expression.caseExpression !== undefined) {
+        return [
+            expression.caseExpression.scrutinee,
+            ...expression.caseExpression.alternatives.map((alternative) => alternative.body),
+        ];
+    }
+    if (expression.variantConstruction !== undefined) {
+        return [expression.variantConstruction.argument];
+    }
+    if (expression.optionalConstruction?.value !== undefined) {
+        return [expression.optionalConstruction.value];
+    }
+    if (expression.listConstruction !== undefined) {
+        return [
+            ...expression.listConstruction.front,
+            ...(expression.listConstruction.tail === undefined
+                ? []
+                : [expression.listConstruction.tail]),
+        ];
+    }
+    if (expression.updateExpression !== undefined) {
+        return [
+            ...(expression.updateExpression.expression === undefined
+                ? []
+                : [expression.updateExpression.expression]),
+            ...(expression.updateExpression.bindings?.map((binding) => binding.value) ?? []),
+            ...(expression.updateExpression.body === undefined
+                ? []
+                : [expression.updateExpression.body]),
+            ...(expression.updateExpression.contractId === undefined
+                ? []
+                : [expression.updateExpression.contractId]),
+            ...(expression.updateExpression.argument === undefined
+                ? []
+                : [expression.updateExpression.argument]),
+        ];
+    }
+    return [];
+}

package/dist/cjs/daml-lf/model/daml-lf-expression.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfExpression = void 0;
+const daml_lf_node_kind_js_1 = require("./daml-lf-node-kind.js");
+class DamlLfExpression {
+    nodeKind = daml_lf_node_kind_js_1.DamlLfNodeKind.expression;
+    textLiteral;
+    numericLiteral;
+    int64Literal;
+    valueReference;
+    variableName;
+    lambda;
+    application;
+    letExpression;
+    recordConstruction;
+    recordProjection;
+    recordUpdate;
+    throwExpression;
+    builtinConstructor;
+    builtinFunction;
+    caseExpression;
+    variantConstruction;
+    optionalConstruction;
+    enumConstruction;
+    listConstruction;
+    updateExpression;
+    unsupportedNodeKind;
+    sourceLocation;
+    constructor(init) {
+        this.textLiteral = init.textLiteral;
+        this.numericLiteral = init.numericLiteral;
+        this.int64Literal = init.int64Literal;
+        this.valueReference = init.valueReference;
+        this.variableName = init.variableName;
+        this.lambda = init.lambda;
+        this.application = init.application;
+        this.letExpression = init.letExpression;
+        this.recordConstruction = init.recordConstruction;
+        this.recordProjection = init.recordProjection;
+        this.recordUpdate = init.recordUpdate;
+        this.throwExpression = init.throwExpression;
+        this.builtinConstructor = init.builtinConstructor;
+        this.builtinFunction = init.builtinFunction;
+        this.caseExpression = init.caseExpression;
+        this.variantConstruction = init.variantConstruction;
+        this.optionalConstruction = init.optionalConstruction;
+        this.enumConstruction = init.enumConstruction;
+        this.listConstruction = init.listConstruction;
+        this.updateExpression = init.updateExpression;
+        this.unsupportedNodeKind = init.unsupportedNodeKind;
+        this.sourceLocation = init.sourceLocation;
+    }
+    withSourceLocation(sourceLocation) {
+        if (sourceLocation === undefined) {
+            return this;
+        }
+        return new DamlLfExpression({
+            textLiteral: this.textLiteral,
+            numericLiteral: this.numericLiteral,
+            int64Literal: this.int64Literal,
+            valueReference: this.valueReference,
+            variableName: this.variableName,
+            lambda: this.lambda,
+            application: this.application,
+            letExpression: this.letExpression,
+            recordConstruction: this.recordConstruction,
+            recordProjection: this.recordProjection,
+            recordUpdate: this.recordUpdate,
+            throwExpression: this.throwExpression,
+            builtinConstructor: this.builtinConstructor,
+            builtinFunction: this.builtinFunction,
+            caseExpression: this.caseExpression,
+            variantConstruction: this.variantConstruction,
+            optionalConstruction: this.optionalConstruction,
+            enumConstruction: this.enumConstruction,
+            listConstruction: this.listConstruction,
+            updateExpression: this.updateExpression,
+            unsupportedNodeKind: this.unsupportedNodeKind,
+            sourceLocation,
+        });
+    }
+}
+exports.DamlLfExpression = DamlLfExpression;

package/dist/cjs/daml-lf/model/daml-lf-field.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfField = void 0;
+class DamlLfField {
+    name;
+    type;
+    constructor(init) {
+        this.name = init.name;
+        this.type = init.type;
+    }
+}
+exports.DamlLfField = DamlLfField;

package/dist/cjs/daml-lf/model/daml-lf-module.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfModule = void 0;
+const daml_lf_node_kind_js_1 = require("./daml-lf-node-kind.js");
+class DamlLfModule {
+    nodeKind = daml_lf_node_kind_js_1.DamlLfNodeKind.module;
+    name;
+    definitions;
+    constructor(init) {
+        this.name = init.name;
+        this.definitions = init.definitions;
+    }
+}
+exports.DamlLfModule = DamlLfModule;

package/dist/cjs/daml-lf/model/daml-lf-node-kind.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfNodeKind = void 0;
+var DamlLfNodeKind;
+(function (DamlLfNodeKind) {
+    DamlLfNodeKind["package"] = "package";
+    DamlLfNodeKind["module"] = "module";
+    DamlLfNodeKind["dataType"] = "dataType";
+    DamlLfNodeKind["template"] = "template";
+    DamlLfNodeKind["choice"] = "choice";
+    DamlLfNodeKind["choiceParameter"] = "choiceParameter";
+    DamlLfNodeKind["valueDefinition"] = "valueDefinition";
+    DamlLfNodeKind["type"] = "type";
+    DamlLfNodeKind["expression"] = "expression";
+})(DamlLfNodeKind || (exports.DamlLfNodeKind = DamlLfNodeKind = {}));

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfPackage = void 0;
+const daml_lf_node_kind_js_1 = require("./daml-lf-node-kind.js");
+class DamlLfPackage {
+    nodeKind = daml_lf_node_kind_js_1.DamlLfNodeKind.package;
+    packageId;
+    packageName;
+    packageVersion;
+    languageVersion;
+    modules;
+    constructor(init) {
+        this.packageId = init.packageId ?? "";
+        this.packageName = init.packageName;
+        this.packageVersion = init.packageVersion;
+        this.languageVersion = init.languageVersion;
+        this.modules = init.modules;
+    }
+}
+exports.DamlLfPackage = DamlLfPackage;

package/dist/cjs/daml-lf/model/daml-lf-template-id.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfTemplateId = void 0;
+const type_con_reference_js_1 = require("./type-con-reference.js");
+class DamlLfTemplateId {
+    packageId;
+    moduleName;
+    templateName;
+    constructor(init) {
+        this.packageId = init.packageId;
+        this.moduleName = init.moduleName;
+        this.templateName = init.templateName;
+    }
+    toTypeConReference() {
+        return new type_con_reference_js_1.TypeConReference({
+            packageId: this.packageId,
+            moduleName: this.moduleName,
+            name: this.templateName,
+        });
+    }
+}
+exports.DamlLfTemplateId = DamlLfTemplateId;

package/dist/cjs/daml-lf/model/daml-lf-template.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfTemplate = void 0;
+const daml_lf_definition_js_1 = require("./daml-lf-definition.js");
+const daml_lf_node_kind_js_1 = require("./daml-lf-node-kind.js");
+class DamlLfTemplate extends daml_lf_definition_js_1.DamlLfDefinition {
+    nodeKind = daml_lf_node_kind_js_1.DamlLfNodeKind.template;
+    templateId;
+    parameterName;
+    fields;
+    choices;
+    constructor(init) {
+        super({
+            name: init.name,
+        });
+        this.templateId = init.templateId;
+        this.parameterName = init.parameterName;
+        this.fields = init.fields;
+        this.choices = init.choices;
+    }
+}
+exports.DamlLfTemplate = DamlLfTemplate;

package/dist/cjs/daml-lf/model/daml-lf-type.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfType = void 0;
+const daml_lf_builtin_type_js_1 = require("./daml-lf-builtin-type.js");
+const daml_lf_node_kind_js_1 = require("./daml-lf-node-kind.js");
+class DamlLfType {
+    nodeKind = daml_lf_node_kind_js_1.DamlLfNodeKind.type;
+    builtinType;
+    numericScale;
+    typeConReference;
+    typeVariable;
+    diagnosticForall;
+    typeArguments;
+    constructor(init) {
+        this.builtinType = init.builtinType ?? daml_lf_builtin_type_js_1.DamlLfBuiltinType.unknown;
+        if (init.numericScale !== undefined) {
+            this.numericScale = init.numericScale;
+        }
+        this.typeConReference = init.typeConReference;
+        this.typeVariable = init.typeVariable === undefined
+            ? undefined
+            : Object.freeze({ ...init.typeVariable });
+        this.diagnosticForall = init.diagnosticForall === undefined
+            ? undefined
+            : Object.freeze({
+                typeParameters: Object.freeze(init.diagnosticForall.typeParameters.map((parameter) => Object.freeze({
+                    ...parameter,
+                    kind: freezeTypeParameterKind(parameter.kind),
+                }))),
+                body: init.diagnosticForall.body,
+            });
+        this.typeArguments = Object.freeze([...(init.typeArguments ?? [])]);
+    }
+}
+exports.DamlLfType = DamlLfType;
+function freezeTypeParameterKind(kind) {
+    if (kind.kind !== "arrow") {
+        return Object.freeze({ ...kind });
+    }
+    return Object.freeze({
+        kind: "arrow",
+        parameters: Object.freeze(kind.parameters.map((parameter) => freezeTypeParameterKind(parameter))),
+        result: freezeTypeParameterKind(kind.result),
+    });
+}

package/dist/cjs/daml-lf/model/daml-lf-value-definition.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfValueDefinition = void 0;
+const daml_lf_definition_js_1 = require("./daml-lf-definition.js");
+const daml_lf_node_kind_js_1 = require("./daml-lf-node-kind.js");
+class DamlLfValueDefinition extends daml_lf_definition_js_1.DamlLfDefinition {
+    nodeKind = daml_lf_node_kind_js_1.DamlLfNodeKind.valueDefinition;
+    type;
+    expression;
+    constructor(init) {
+        super({
+            name: init.name,
+        });
+        this.type = init.type;
+        this.expression = init.expression;
+    }
+}
+exports.DamlLfValueDefinition = DamlLfValueDefinition;