@distrohelena/canton-typescript-sdk 0.1.0

package/dist/daml-lf/model/daml-lf-template.d.ts

@@ -0,0 +1,17 @@
+import { DamlLfChoice } from "./daml-lf-choice.js";
+import { DamlLfDefinition } from "./daml-lf-definition.js";
+import { DamlLfField } from "./daml-lf-field.js";
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+import { DamlLfTemplateId } from "./daml-lf-template-id.js";
+export declare class DamlLfTemplate extends DamlLfDefinition {
+    readonly nodeKind = DamlLfNodeKind.template;
+    readonly templateId: DamlLfTemplateId;
+    readonly fields: readonly DamlLfField[];
+    readonly choices: readonly DamlLfChoice[];
+    constructor(init: {
+        templateId: DamlLfTemplateId;
+        name: string;
+        fields: readonly DamlLfField[];
+        choices: readonly DamlLfChoice[];
+    });
+}

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

@@ -0,0 +1,16 @@
+import { DamlLfDefinition } from "./daml-lf-definition.js";
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export class DamlLfTemplate extends DamlLfDefinition {
+    nodeKind = DamlLfNodeKind.template;
+    templateId;
+    fields;
+    choices;
+    constructor(init) {
+        super({
+            name: init.name,
+        });
+        this.templateId = init.templateId;
+        this.fields = init.fields;
+        this.choices = init.choices;
+    }
+}

package/dist/daml-lf/model/daml-lf-type.d.ts

@@ -0,0 +1,12 @@
+import { DamlLfBuiltinType } from "./daml-lf-builtin-type.js";
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+import { TypeConReference } from "./type-con-reference.js";
+export declare class DamlLfType {
+    readonly nodeKind = DamlLfNodeKind.type;
+    readonly builtinType: DamlLfBuiltinType;
+    readonly typeConReference?: TypeConReference;
+    constructor(init: {
+        builtinType?: DamlLfBuiltinType;
+        typeConReference?: TypeConReference;
+    });
+}

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

@@ -0,0 +1,11 @@
+import { DamlLfBuiltinType } from "./daml-lf-builtin-type.js";
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export class DamlLfType {
+    nodeKind = DamlLfNodeKind.type;
+    builtinType;
+    typeConReference;
+    constructor(init) {
+        this.builtinType = init.builtinType ?? DamlLfBuiltinType.unknown;
+        this.typeConReference = init.typeConReference;
+    }
+}

package/dist/daml-lf/model/daml-lf-value-definition.d.ts

@@ -0,0 +1,14 @@
+import { DamlLfDefinition } from "./daml-lf-definition.js";
+import { DamlLfExpression } from "./daml-lf-expression.js";
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+import { DamlLfType } from "./daml-lf-type.js";
+export declare class DamlLfValueDefinition extends DamlLfDefinition {
+    readonly nodeKind = DamlLfNodeKind.valueDefinition;
+    readonly type: DamlLfType;
+    readonly expression: DamlLfExpression;
+    constructor(init: {
+        name: string;
+        type: DamlLfType;
+        expression: DamlLfExpression;
+    });
+}

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

@@ -0,0 +1,14 @@
+import { DamlLfDefinition } from "./daml-lf-definition.js";
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export class DamlLfValueDefinition extends DamlLfDefinition {
+    nodeKind = DamlLfNodeKind.valueDefinition;
+    type;
+    expression;
+    constructor(init) {
+        super({
+            name: init.name,
+        });
+        this.type = init.type;
+        this.expression = init.expression;
+    }
+}

package/dist/daml-lf/model/lf-2-model-mapper.d.ts

@@ -0,0 +1,19 @@
+import { Package as LfArchivePackage } from "../../transports/grpc/generated/canton/com/digitalasset/daml/lf/archive/daml_lf2.js";
+import { DamlLfLanguageVersion } from "../decoding/daml-lf-language-version.js";
+import { DamlLfPackage } from "./daml-lf-package.js";
+export declare class Lf2ModelMapper {
+    static mapPackage(packageId: string, rawPackage: LfArchivePackage, languageVersion: DamlLfLanguageVersion): DamlLfPackage;
+    private static mapType;
+    private static mapModule;
+    private static mapDataType;
+    private static mapTemplateOrThrow;
+    private static mapChoice;
+    private static mapChoiceParameterOrThrow;
+    private static mapField;
+    private static mapTypeConReferenceOrThrow;
+    private static resolvePackageIdOrThrow;
+    private static resolveImportedPackageIdOrThrow;
+    private static mapExpression;
+    private static resolveInternedString;
+    private static resolveInternedDottedName;
+}

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

@@ -0,0 +1,166 @@
+import { 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";
+import { DamlLfChoiceParameter } from "./daml-lf-choice-parameter.js";
+import { DamlLfDataType } from "./daml-lf-data-type.js";
+import { DamlLfExpression } from "./daml-lf-expression.js";
+import { DamlLfField } from "./daml-lf-field.js";
+import { DamlLfModule } from "./daml-lf-module.js";
+import { DamlLfPackage } from "./daml-lf-package.js";
+import { DamlLfTemplate } from "./daml-lf-template.js";
+import { DamlLfTemplateId } from "./daml-lf-template-id.js";
+import { DamlLfType } from "./daml-lf-type.js";
+import { DamlLfValueDefinition } from "./daml-lf-value-definition.js";
+import { TypeConReference } from "./type-con-reference.js";
+export class Lf2ModelMapper {
+    static mapPackage(packageId, rawPackage, languageVersion) {
+        return new DamlLfPackage({
+            packageId,
+            packageName: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawPackage.metadata?.nameInternedStr),
+            packageVersion: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawPackage.metadata?.versionInternedStr),
+            languageVersion,
+            modules: rawPackage.modules.map((module) => Lf2ModelMapper.mapModule(packageId, module, rawPackage)),
+        });
+    }
+    static mapType(currentPackageId, rawPackage, rawType) {
+        if (rawType?.sum.oneofKind === "con") {
+            return new DamlLfType({
+                typeConReference: Lf2ModelMapper.mapTypeConReferenceOrThrow(currentPackageId, rawPackage, rawType.sum.con.tycon, rawType),
+            });
+        }
+        else if (rawType?.sum.oneofKind === "builtin") {
+            return new DamlLfType({
+                builtinType: rawType.sum.builtin.builtin === BuiltinType.TEXT
+                    ? DamlLfBuiltinType.text
+                    : DamlLfBuiltinType.unknown,
+            });
+        }
+        return new DamlLfType({
+            builtinType: DamlLfBuiltinType.unknown,
+        });
+    }
+    static mapModule(packageId, rawModule, rawPackage) {
+        const moduleName = Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawModule.nameInternedDname);
+        const dataTypes = rawModule.dataTypes
+            .map((item) => Lf2ModelMapper.mapDataType(packageId, item, rawPackage))
+            .filter((item) => item !== undefined);
+        const definitions = [
+            ...dataTypes,
+            ...rawModule.values.map((value) => new 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),
+            })),
+            ...rawModule.templates.map((item) => Lf2ModelMapper.mapTemplateOrThrow(packageId, moduleName, item, rawPackage, dataTypes)),
+        ];
+        return new DamlLfModule({
+            name: moduleName,
+            definitions,
+        });
+    }
+    static mapDataType(packageId, rawDataType, rawPackage) {
+        if (rawDataType.dataCons.oneofKind !== "record") {
+            return undefined;
+        }
+        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)),
+        });
+    }
+    static mapTemplateOrThrow(packageId, moduleName, rawTemplate, rawPackage, dataTypes) {
+        const templateName = Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawTemplate.tyconInternedDname);
+        const matchingDataType = dataTypes.find((item) => item.name === templateName);
+        if (matchingDataType === undefined) {
+            throw new DamlLfDecodeException(`daml lf template '${templateName}' is missing its backing data type`);
+        }
+        return new DamlLfTemplate({
+            templateId: new DamlLfTemplateId({
+                packageId,
+                moduleName,
+                templateName,
+            }),
+            name: templateName,
+            fields: matchingDataType.fields,
+            choices: rawTemplate.choices.map((item) => Lf2ModelMapper.mapChoice(packageId, item, rawPackage)),
+        });
+    }
+    static mapChoice(packageId, rawChoice, rawPackage) {
+        return new DamlLfChoice({
+            name: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawChoice.nameInternedStr),
+            consuming: rawChoice.consuming,
+            parameter: Lf2ModelMapper.mapChoiceParameterOrThrow(packageId, rawChoice.argBinder, rawPackage),
+            returnType: Lf2ModelMapper.mapType(packageId, rawPackage, rawChoice.retType),
+        });
+    }
+    static mapChoiceParameterOrThrow(packageId, rawParameter, rawPackage) {
+        if (rawParameter === undefined) {
+            throw new DamlLfDecodeException("daml lf template choice is missing its argument binder");
+        }
+        return new DamlLfChoiceParameter({
+            name: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, rawParameter.varInternedStr),
+            type: Lf2ModelMapper.mapType(packageId, rawPackage, rawParameter.type),
+        });
+    }
+    static mapField(packageId, nameInternedStr, rawType, rawPackage) {
+        return new DamlLfField({
+            name: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, nameInternedStr),
+            type: Lf2ModelMapper.mapType(packageId, rawPackage, rawType),
+        });
+    }
+    static mapTypeConReferenceOrThrow(currentPackageId, rawPackage, rawTypeConId, rawType) {
+        const module = rawTypeConId?.module;
+        if (module === undefined) {
+            throw new DamlLfDecodeException(`daml lf type constructor is missing its module (${rawType.sum.oneofKind})`);
+        }
+        return new TypeConReference({
+            packageId: Lf2ModelMapper.resolvePackageIdOrThrow(currentPackageId, module.packageId, rawPackage),
+            moduleName: Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, module.moduleNameInternedDname),
+            name: Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawTypeConId?.nameInternedDname),
+        });
+    }
+    static resolvePackageIdOrThrow(currentPackageId, rawPackageId, rawPackage) {
+        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);
+            default:
+                throw new DamlLfDecodeException("daml lf type constructor is missing its package id");
+        }
+    }
+    static resolveImportedPackageIdOrThrow(rawPackage, index) {
+        if (rawPackage.importsSum.oneofKind !== "packageImports" ||
+            rawPackage.importsSum.packageImports.importedPackages[index] === undefined) {
+            throw new DamlLfDecodeException("daml lf package references a missing imported package id");
+        }
+        return rawPackage.importsSum.packageImports.importedPackages[index];
+    }
+    static mapExpression(rawExpression, internedStrings) {
+        if (rawExpression?.sum.oneofKind === "builtinLit") {
+            const rawLiteral = rawExpression.sum.builtinLit;
+            if (rawLiteral.sum.oneofKind === "textInternedStr") {
+                return new DamlLfExpression({
+                    textLiteral: Lf2ModelMapper.resolveInternedString(internedStrings, rawLiteral.sum.textInternedStr),
+                });
+            }
+        }
+        return new DamlLfExpression({});
+    }
+    static resolveInternedString(internedStrings, index) {
+        if (index === undefined || internedStrings[index] === undefined) {
+            throw new DamlLfDecodeException("daml lf package references a missing interned string");
+        }
+        return internedStrings[index];
+    }
+    static resolveInternedDottedName(internedStrings, internedDottedNames, index) {
+        if (index === undefined || internedDottedNames[index] === undefined) {
+            throw new DamlLfDecodeException("daml lf package references a missing interned dotted name");
+        }
+        return internedDottedNames[index].segmentsInternedStr
+            .map((segmentIndex) => Lf2ModelMapper.resolveInternedString(internedStrings, segmentIndex))
+            .join(".");
+    }
+}

package/dist/daml-lf/model/module-reference.d.ts

@@ -0,0 +1,8 @@
+export declare class ModuleReference {
+    readonly packageId: string;
+    readonly moduleName: string;
+    constructor(init: {
+        packageId: string;
+        moduleName: string;
+    });
+}

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

@@ -0,0 +1,8 @@
+export class ModuleReference {
+    packageId;
+    moduleName;
+    constructor(init) {
+        this.packageId = init.packageId;
+        this.moduleName = init.moduleName;
+    }
+}

package/dist/daml-lf/model/type-con-reference.d.ts

@@ -0,0 +1,10 @@
+export declare class TypeConReference {
+    readonly packageId: string;
+    readonly moduleName: string;
+    readonly name: string;
+    constructor(init: {
+        packageId: string;
+        moduleName: string;
+        name: string;
+    });
+}

package/dist/daml-lf/model/type-con-reference.js

@@ -0,0 +1,10 @@
+export class TypeConReference {
+    packageId;
+    moduleName;
+    name;
+    constructor(init) {
+        this.packageId = init.packageId;
+        this.moduleName = init.moduleName;
+        this.name = init.name;
+    }
+}

package/dist/daml-lf/semantics/daml-lf-semantic-model.d.ts

@@ -0,0 +1,16 @@
+import { DamlLfChoice } from "../model/daml-lf-choice.js";
+import { DamlLfCompilation } from "../daml-lf-compilation.js";
+import { DamlLfField } from "../model/daml-lf-field.js";
+import { DamlLfTemplate } from "../model/daml-lf-template.js";
+import { DamlLfTemplateId } from "../model/daml-lf-template-id.js";
+import { TypeConReference } from "../model/type-con-reference.js";
+export declare class DamlLfSemanticModel {
+    private readonly compilation;
+    constructor(compilation: DamlLfCompilation);
+    /** Returns the templates exposed by the compiled workspace. */
+    getTemplates(): readonly DamlLfTemplate[];
+    /** Returns the choices declared on a template identity. */
+    getTemplateChoicesOrThrow(templateId: DamlLfTemplateId): readonly DamlLfChoice[];
+    /** Returns the record fields for a resolved type constructor reference. */
+    getRecordFieldsOrThrow(reference: TypeConReference): readonly DamlLfField[];
+}

package/dist/daml-lf/semantics/daml-lf-semantic-model.js

@@ -0,0 +1,19 @@
+export class DamlLfSemanticModel {
+    compilation;
+    constructor(compilation) {
+        this.compilation = compilation;
+        void this.compilation;
+    }
+    /** Returns the templates exposed by the compiled workspace. */
+    getTemplates() {
+        return this.compilation.getTemplates();
+    }
+    /** Returns the choices declared on a template identity. */
+    getTemplateChoicesOrThrow(templateId) {
+        return this.compilation.getTemplateChoicesOrThrow(templateId);
+    }
+    /** Returns the record fields for a resolved type constructor reference. */
+    getRecordFieldsOrThrow(reference) {
+        return this.compilation.getTypeSymbolOrThrow(reference).definition.fields;
+    }
+}

package/dist/daml-lf/symbols/daml-lf-symbol.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class DamlLfSymbol {
+    readonly name: string;
+    protected constructor(init: {
+        name: string;
+    });
+}

package/dist/daml-lf/symbols/daml-lf-symbol.js

@@ -0,0 +1,6 @@
+export class DamlLfSymbol {
+    name;
+    constructor(init) {
+        this.name = init.name;
+    }
+}

package/dist/daml-lf/symbols/module-symbol.d.ts

@@ -0,0 +1,9 @@
+import { DamlLfModule } from "../model/daml-lf-module.js";
+import { DamlLfSymbol } from "./daml-lf-symbol.js";
+export declare class ModuleSymbol extends DamlLfSymbol {
+    readonly module: DamlLfModule;
+    constructor(init: {
+        name: string;
+        module: DamlLfModule;
+    });
+}

package/dist/daml-lf/symbols/module-symbol.js

@@ -0,0 +1,10 @@
+import { DamlLfSymbol } from "./daml-lf-symbol.js";
+export class ModuleSymbol extends DamlLfSymbol {
+    module;
+    constructor(init) {
+        super({
+            name: init.name,
+        });
+        this.module = init.module;
+    }
+}

package/dist/daml-lf/symbols/type-symbol.d.ts

@@ -0,0 +1,9 @@
+import { DamlLfDataType } from "../model/daml-lf-data-type.js";
+import { DamlLfSymbol } from "./daml-lf-symbol.js";
+export declare class TypeSymbol extends DamlLfSymbol {
+    readonly definition: DamlLfDataType;
+    constructor(init: {
+        name: string;
+        definition: DamlLfDataType;
+    });
+}

package/dist/daml-lf/symbols/type-symbol.js

@@ -0,0 +1,10 @@
+import { DamlLfSymbol } from "./daml-lf-symbol.js";
+export class TypeSymbol extends DamlLfSymbol {
+    definition;
+    constructor(init) {
+        super({
+            name: init.name,
+        });
+        this.definition = init.definition;
+    }
+}

package/dist/grpc/index.d.ts

@@ -0,0 +1,2 @@
+export { GrpcLedgerClient } from "../transports/grpc/grpc-ledger-client.js";
+export { GrpcTransport } from "../transports/grpc/grpc-transport.js";

package/dist/grpc/index.js

@@ -0,0 +1,2 @@
+export { GrpcLedgerClient } from "../transports/grpc/grpc-ledger-client.js";
+export { GrpcTransport } from "../transports/grpc/grpc-transport.js";