@distrohelena/canton-typescript-sdk 0.1.25 → 0.1.27

package/dist/daml-interface/analysis/analyzed-daml-type.d.ts

@@ -7,7 +7,6 @@ export type AnalyzedDamlPrimitiveType = {
 };
 export type AnalyzedDamlContractIdType = {
     readonly kind: "contractId";
-    readonly contract: AnalyzedDamlType;
 };
 export type AnalyzedDamlOptionalType = {
     readonly kind: "optional";

package/dist/daml-interface/analysis/daml-interface-analyzer.js

@@ -128,9 +128,9 @@ class AnalyzedDamlTypeBuilder {
                     numericScale: type.numericScale,
                 });
             case DamlLfBuiltinType.contractId:
+                this.assertArgumentCountOrThrow(type, 1, context);
                 return Object.freeze({
                     kind: "contractId",
-                    contract: this.buildUnaryArgumentOrThrow(type, context),
                 });
             case DamlLfBuiltinType.optional:
                 return Object.freeze({
@@ -189,8 +189,8 @@ class AnalyzedDamlTypeBuilder {
         try {
             dataType = this.semanticModel.getDataTypeOrThrow(reference);
         }
-        catch (error) {
-            throw this.unsupported(context, `could not resolve named type '${reference.name}'`);
+        catch {
+            throw this.unsupported(context, `could not resolve named type '${reference.packageId}:${reference.moduleName}:${reference.name}'`);
         }
         if (dataType.definition.kind === "record") {
             return Object.freeze({

package/dist/daml-interface/daml-interface-generator.js

@@ -29,14 +29,14 @@ export class DamlInterfaceGenerator {
     /** Generates an in-memory project from compiled DAML-LF archive bytes. */
     async generateFromDalfOrThrowAsync(archiveBytes) {
         const pkg = this.packageLoader.loadPackageOrThrow(archiveBytes);
-        const compilation = DamlLfCompilation.createOrThrow(new DamlLfWorkspace([pkg]));
+        const compilation = DamlLfCompilation.createForTemplateGeneration(new DamlLfWorkspace([pkg]));
         return this.projectEmitter.emitProject(this.analyzeOrThrow(compilation));
     }
     /** Generates an in-memory project from DAR bytes. */
     async generateFromDarOrThrowAsync(archiveBytes) {
         const archive = await this.darArchiveLoader.loadDarOrThrowAsync(archiveBytes);
         const packages = archive.packageEntries.map((entry) => this.packageLoader.loadPackageOrThrow(entry.bytes));
-        const compilation = DamlLfCompilation.createOrThrow(new DamlLfWorkspace(packages));
+        const compilation = DamlLfCompilation.createForTemplateGeneration(new DamlLfWorkspace(packages));
         return this.projectEmitter.emitProject(this.analyzeOrThrow(compilation));
     }
 }

package/dist/daml-interface/emission/named-type-emitter.js

@@ -139,9 +139,7 @@ export class NamedTypeEmitter {
             case "namedReference":
                 yield type;
                 return;
-            case "contractId":
-                yield* this.getNamedReferences(type.contract);
-                return;
+            case "contractId": return;
             case "optional":
             case "list":
                 yield* this.getNamedReferences(type.element);
@@ -405,9 +403,7 @@ export class NamedTypeEmitter {
                 }
                 return;
             }
-            case "contractId":
-                yield* this.getRuntimePrimitiveTypes(type.contract);
-                return;
+            case "contractId": return;
             case "optional":
             case "list":
                 yield* this.getRuntimePrimitiveTypes(type.element);

package/dist/daml-interface/emission/support-file-emitter.js

@@ -186,7 +186,7 @@ export class SupportFileEmitter {
             case "primitive":
                 return `{ kind: "primitive", primitive: ${JSON.stringify(type.builtinType)}${type.numericScale === undefined ? "" : `, numericScale: ${type.numericScale}`} }`;
             case "contractId":
-                return `{ kind: "contractId", contract: ${this.emitDescriptor(type.contract)} }`;
+                return '{ kind: "contractId" }';
             case "optional":
                 return `{ kind: "optional", element: ${this.emitDescriptor(type.element)} }`;
             case "list":

package/dist/daml-interface/emission/template-binding-emitter.js

@@ -195,7 +195,7 @@ export class TemplateBindingEmitter {
             case "primitive":
                 return `{ kind: "primitive", primitive: ${JSON.stringify(type.builtinType)}${type.numericScale === undefined ? "" : `, numericScale: ${type.numericScale}`} }`;
             case "contractId":
-                return `{ kind: "contractId", contract: ${this.emitDescriptor(type.contract)} }`;
+                return '{ kind: "contractId" }';
             case "optional":
                 return `{ kind: "optional", element: ${this.emitDescriptor(type.element)} }`;
             case "list":
@@ -255,13 +255,17 @@ export class TemplateBindingEmitter {
         if ("kind" in type) {
             return type;
         }
-        const arguments_ = type.typeArguments.map((argument) => this.normalizeType(argument));
-        if (type.typeConReference !== undefined) {
+        else if (type.builtinType === DamlLfBuiltinType.contractId) {
+            if (type.typeArguments.length !== 1) {
+                throw new Error("DAML ContractId requires exactly one type argument");
+            }
+            return { kind: "contractId" };
+        }
+        else if (type.typeConReference !== undefined) {
             return { kind: "namedReference", identity: type.typeConReference };
         }
+        const arguments_ = type.typeArguments.map((argument) => this.normalizeType(argument));
         switch (type.builtinType) {
-            case DamlLfBuiltinType.contractId:
-                return { kind: "contractId", contract: arguments_[0] ?? { kind: "primitive", builtinType: DamlLfBuiltinType.text } };
             case DamlLfBuiltinType.optional:
                 return { kind: "optional", element: arguments_[0] ?? { kind: "primitive", builtinType: DamlLfBuiltinType.text } };
             case DamlLfBuiltinType.list:
@@ -345,9 +349,7 @@ export class TemplateBindingEmitter {
             case "namedReference":
                 yield type;
                 return;
-            case "contractId":
-                yield* this.walkNamedReferences(type.contract);
-                return;
+            case "contractId": return;
             case "optional":
             case "list":
                 yield* this.walkNamedReferences(type.element);

package/dist/daml-interface/emission/type-script-name-resolver.js

@@ -2,13 +2,13 @@ import { DamlLfBuiltinType } from "../../daml-lf/model/daml-lf-builtin-type.js";
 const typeScriptKeywords = new Set([
     "as", "async", "await", "break", "case", "catch", "class", "const", "continue",
     "debugger", "default", "delete", "do", "else", "enum", "export", "extends", "false",
-    "finally", "for", "from", "function", "get", "if", "implements", "import", "in",
+    "finally", "for", "from", "function", "if", "implements", "import", "in",
     "instanceof", "interface", "let", "new", "null", "of", "package", "private", "protected",
     "public", "return", "set", "static", "super", "switch", "this", "throw", "true", "try",
     "type", "typeof", "undefined", "var", "void", "while", "with", "yield",
 ]);
 const damlTemplateMemberNames = new Set([
-    "constructor", "get", "contractId", "templateId", "create", "decodeCreatedEvent",
+    "constructor", "contractId", "templateId", "create", "decodeCreatedEvent",
     "decodeExercisedEvent",
 ]);
 const reservedTypeNames = new Set(["DamlTemplate"]);

package/dist/daml-interface/runtime/daml-template.d.ts

@@ -2,5 +2,5 @@
 export declare class DamlTemplate {
     #private;
     constructor(contractId: string);
-    get(): string;
+    get contractId(): string;
 }

package/dist/daml-interface/runtime/daml-template.js

@@ -4,7 +4,7 @@ export class DamlTemplate {
     constructor(contractId) {
         this.#contractId = contractId;
     }
-    get() {
+    get contractId() {
         return this.#contractId;
     }
 }

package/dist/daml-interface/runtime/daml-type-descriptor.d.ts

@@ -12,7 +12,7 @@ export type DamlPrimitiveDescriptor = {
 };
 export type DamlContractIdDescriptor = {
     readonly kind: "contractId";
-    readonly contract: DamlTypeDescriptor;
+    readonly contract?: DamlTypeDescriptor;
 };
 export type DamlOptionalDescriptor = {
     readonly kind: "optional";

package/dist/daml-lf/daml-lf-compilation.d.ts

@@ -18,6 +18,7 @@ export declare class DamlLfCompilation {
     private readonly valueDefinitionIdentities;
     private constructor();
     static createOrThrow(workspace: DamlLfWorkspace): DamlLfCompilation;
+    static createForTemplateGeneration(workspace: DamlLfWorkspace): DamlLfCompilation;
     getModuleSymbolOrThrow(reference: ModuleReference): ModuleSymbol;
     getTypeSymbolOrThrow(reference: TypeConReference): TypeSymbol;
     createSemanticModel(): DamlLfSemanticModel;

package/dist/daml-lf/daml-lf-compilation.js

@@ -1,5 +1,6 @@
 import { DamlLfResolutionException } from "./errors/daml-lf-resolution.exception.js";
 import { DamlLfSemanticException } from "./errors/daml-lf-semantic.exception.js";
+import { DamlLfBuiltinType } from "./model/daml-lf-builtin-type.js";
 import { DamlLfDataType } from "./model/daml-lf-data-type.js";
 import { DamlLfTemplate } from "./model/daml-lf-template.js";
 import { DamlLfValueDefinition } from "./model/daml-lf-value-definition.js";
@@ -24,6 +25,11 @@ export class DamlLfCompilation {
         compilation.validateReferencesOrThrow();
         return compilation;
     }
+    static createForTemplateGeneration(workspace) {
+        const compilation = new DamlLfCompilation(workspace);
+        compilation.buildIndexes();
+        return compilation;
+    }
     getModuleSymbolOrThrow(reference) {
         const symbol = this.moduleSymbols.get(DamlLfCompilation.createModuleKey(reference.packageId, reference.moduleName));
         if (symbol === undefined) {
@@ -122,6 +128,12 @@ export class DamlLfCompilation {
         }
     }
     validateTypeOrThrow(type) {
+        if (type.builtinType === DamlLfBuiltinType.contractId) {
+            if (type.typeArguments.length !== 1) {
+                throw new DamlLfSemanticException("builtin 'contractId' requires 1 type argument");
+            }
+            return;
+        }
         for (const typeArgument of type.typeArguments) {
             this.validateTypeOrThrow(typeArgument);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@distrohelena/canton-typescript-sdk",
-    "version": "0.1.25",
+    "version": "0.1.27",
     "license": "Apache-2.0",
     "type": "module",
     "main": "./dist/index.js",