@c7-digital/ledger 0.0.8 → 0.0.10

package/lib-lite/src/ledger.d.ts

@@ -17,7 +17,7 @@
  * you need access to Canton-specific endpoints or full control over API calls.
  */
 import { ContractId, Party, Choice, InterfaceCompanion, Template } from "@daml/types";
-import { AllocatePartyRequest, AllocatePartyResponse, Command, CreateCommand, CreateAndExerciseCommand, CreateEvent, ExerciseCommand, Event, Interface, LedgerOffset, Stream, InterfaceStream, InterfaceMapping, InterfaceMultiStream, PartyDetails, User, MultiStream, TemplateMapping, VersionedRegistry } from "./types.js";
+import { AllocatePartyRequest, AllocatePartyResponse, AnyCommand, CreateCommand, CreateAndExerciseCommand, CreateEvent, ExerciseCommand, Event, Interface, LedgerOffset, Stream, InterfaceStream, InterfaceMapping, InterfaceMultiStream, PartyDetails, User, MultiStream, TemplateMapping, VersionedRegistry } from "./types.js";
 import { ValidationMode } from "./validation.js";
 import { PackageIdString } from "./valueTypes.js";
 export declare function createCmd<T extends object, K = unknown>(template: Template<T, K, string>, payload: T): CreateCommand<T, K>;
@@ -134,7 +134,7 @@ export declare class Ledger {
      * @param actAs Defaults to the actAs parties of the user in the token.
      * @returns Stream of events resulting from the submitted commands.
      */
-    submit(commands: Command<any, any>[], actAs?: Party[]): Promise<Event<object, unknown>[]>;
+    submit(commands: AnyCommand[], actAs?: Party[]): Promise<Event<object, unknown>[]>;
     private initClient;
     /**
      * Stream functionality using WebSockets

package/lib-lite/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-lite/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-lite/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());
+}

package/lib-lite/src/types.d.ts

@@ -226,6 +226,13 @@ export type ExerciseCommand<T extends object, C, R, K = unknown> = {
     argument: C;
 };
 export type Command<T extends object, C, R = unknown, K = unknown> = CreateCommand<T, K> | CreateAndExerciseCommand<T, C, R, K> | ExerciseCommand<T, C, R, K>;
+/**
+ * A command with erased type parameters, suitable for heterogeneous arrays
+ * passed to `Ledger.submit()`. Each variant is independently widened to `any`,
+ * so a `CreateCommand<A, KA>` and an `ExerciseCommand<B, CB, RB, KB>` can
+ * coexist in the same `AnyCommand[]` without a cast.
+ */
+export type AnyCommand = CreateCommand<any, any> | CreateAndExerciseCommand<any, any, any, any> | ExerciseCommand<any, any, any, any>;
 export interface AllocatePartyRequest {
     partyIdHint?: PartyIdString;
     displayName?: string;