@c7-digital/ledger 0.0.8 → 0.0.9

package/lib/src/ledger.js

@@ -63,6 +63,7 @@ function createEvent_(cantonEvent, versionedRegistry) {
         }
     }
     else {
+        console.debug(`Using default lookupTemplate for ${cantonEvent.templateId}`);
         t = lookupTemplate(cantonEvent.templateId);
     }
     return {
@@ -171,16 +172,16 @@ function convertCommand(command) {
             return {
                 CreateCommand: {
                     templateId: command.template.templateId,
-                    createArguments: command.payload,
+                    createArguments: command.template.encode(command.payload),
                 }
             };
         case 'createAndExercise':
             return {
                 CreateAndExerciseCommand: {
                     templateId: command.template.templateId,
-                    createArguments: command.payload,
+                    createArguments: command.template.encode(command.payload),
                     choice: createNameString(command.choice.choiceName),
-                    choiceArgument: command.argument,
+                    choiceArgument: command.choice.argumentEncode(command.argument),
                 }
             };
         case 'exercise':
@@ -189,7 +190,7 @@ function convertCommand(command) {
                     templateId: command.choice.template().templateId,
                     contractId: createLedgerString(command.contractId),
                     choice: createNameString(command.choice.choiceName),
-                    choiceArgument: command.argument,
+                    choiceArgument: command.choice.argumentEncode(command.argument),
                 }
             };
         default:
@@ -679,7 +680,7 @@ export class Ledger {
     async create(template, payload, actAs) {
         const createCommand = {
             templateId: template.templateId,
-            createArguments: payload,
+            createArguments: template.encode(payload),
         };
         const actAs_ = actAs || (await this.getTokenActAsParties());
         const commands = {
@@ -735,7 +736,7 @@ export class Ledger {
             templateId: choice.template().templateId,
             contractId: createLedgerString(contractId.toString()),
             choice: createNameString(choice.choiceName),
-            choiceArgument: argument,
+            choiceArgument: choice.argumentEncode(argument),
         };
         const actAs_ = actAs || (await this.getTokenActAsParties());
         const commands = {

package/lib/src/sets.d.ts

@@ -0,0 +1,29 @@
+import { Map as DamlMap } from "@daml/types";
+/**
+ * Immutable Set mirroring Daml's DA.Set.Types.Set<T>.
+ *
+ * Structurally compatible with the codegen's `{ map: DamlMap<T, {}> }`,
+ * so instances can be passed directly to template payloads and choice arguments.
+ */
+export interface DamlSet<T> {
+    /** The underlying Map<T, Unit>. Exposed for codegen compatibility. */
+    readonly map: DamlMap<T, {}>;
+    /** Check if the set contains an item. */
+    has(item: T): boolean;
+    /** Add an item, returning a new set. */
+    add(item: T): DamlSet<T>;
+    /** Remove an item, returning a new set. */
+    delete(item: T): DamlSet<T>;
+    /** Return an iterator over the set's items. */
+    values(): Iterator<T, undefined, undefined>;
+    /** Return the set's items as an array. */
+    toArray(): T[];
+    /** Return the number of items in the set. */
+    readonly size: number;
+    /** Call a function for each item in the set. */
+    forEach(f: (item: T) => void): void;
+}
+/** Create a DamlSet from an array of items. */
+export declare function create<T>(items: T[]): DamlSet<T>;
+/** Create an empty DamlSet. */
+export declare function empty<T>(): DamlSet<T>;

package/lib/src/sets.js

@@ -0,0 +1,39 @@
+import { emptyMap } from "@daml/types";
+class DamlSetImpl {
+    constructor(map) {
+        this.map = map;
+    }
+    has(item) {
+        return this.map.has(item);
+    }
+    add(item) {
+        return new DamlSetImpl(this.map.set(item, {}));
+    }
+    delete(item) {
+        return new DamlSetImpl(this.map.delete(item));
+    }
+    values() {
+        return this.map.keys();
+    }
+    toArray() {
+        return this.map.entriesArray().map(([k]) => k);
+    }
+    get size() {
+        return this.map.entriesArray().length;
+    }
+    forEach(f) {
+        this.map.forEach((_v, k) => f(k));
+    }
+}
+/** Create a DamlSet from an array of items. */
+export function create(items) {
+    let map = emptyMap();
+    for (const item of items) {
+        map = map.set(item, {});
+    }
+    return new DamlSetImpl(map);
+}
+/** Create an empty DamlSet. */
+export function empty() {
+    return new DamlSetImpl(emptyMap());
+}