@distrohelena/canton-typescript-sdk 0.1.12 → 0.1.14

package/dist/testing/daml/daml-create-action-arbitrary.d.ts

@@ -3,9 +3,10 @@ import { CampaignExecutableAction } from "../campaign/campaign-runner.js";
 import { ResolvedDeclarativeCreateTarget } from "../targets/target.js";
 import { DamlTestingCatalog } from "./daml-testing-catalog.js";
 import { DamlTestingValue } from "./daml-value-arbitrary.js";
+import type { TemplateId } from "../../query/model-types.js";
 export interface DeclarativeCreateAction extends CampaignExecutableAction {
     readonly payload: Readonly<Record<string, DamlTestingValue>>;
-    readonly templateId: string;
+    readonly templateId: TemplateId;
 }
 export interface DeclarativeCreateActionGenerationOptions {
     readonly fieldArbitraries?: Readonly<Record<string, fc.Arbitrary<DamlTestingValue>>>;

package/dist/testing/daml/daml-create-action-arbitrary.js

@@ -7,7 +7,7 @@ import { createDamlValueArbitrary } from "./daml-value-arbitrary.js";
  * adapter.
  */
 export function createDeclarativeCreateActionArbitrary(catalog, target, options = {}) {
-    const template = catalog.getTemplate(target.templateId);
+    const template = catalog.getTemplate(formatTemplateId(target.templateId));
     if (template === undefined) {
         throw new TestingConfigurationError(`Declarative target '${target.key}' does not exist in the DAML catalog.`);
     }
@@ -32,3 +32,6 @@ export function createDeclarativeCreateActionArbitrary(catalog, target, options
         templateId: target.templateId,
     }));
 }
+function formatTemplateId(templateId) {
+    return `${templateId.packageId}:${templateId.moduleName}:${templateId.entityName}`;
+}

package/dist/testing/runtime/declarative-action-executor.js

@@ -1,5 +1,6 @@
 import { CreateCommand } from "../../core/types/commands/create-command.js";
 import { ExerciseCommand } from "../../core/types/commands/exercise-command.js";
+import { DamlRecord } from "../../core/types/daml-values.js";
 import { SubmitCommandRequest } from "../../core/types/requests/submit-command-request.js";
 import { TestingConfigurationError } from "../errors/testing-configuration-error.js";
 import { toCampaignMetricOutcome, } from "./canton-test-runtime.js";
@@ -15,7 +16,7 @@ export async function executeDeclarativeActionAsync(init) {
         ? await createExerciseCommandAsync(init.action, init.resolveContractIdAsync)
         : new CreateCommand({
             templateId: init.action.templateId,
-            payload: { ...init.action.payload },
+            createArguments: new DamlRecord({ ...init.action.payload }),
         });
     return toCampaignMetricOutcome(await init.runtime.submitAndWaitAsync(init.action.actor, new SubmitCommandRequest({
         applicationId: init.applicationId,
@@ -36,6 +37,6 @@ async function createExerciseCommandAsync(action, resolveContractIdAsync) {
         templateId: action.templateId,
         contractId,
         choice: action.choice,
-        argument: action.argument,
+        choiceArgument: action.argument,
     });
 }

package/dist/testing/targets/target.d.ts

@@ -1,24 +1,25 @@
 import { DamlTestingCatalog } from "../daml/daml-testing-catalog.js";
+import type { TemplateId } from "../../query/model-types.js";
 export interface TemplateTarget {
     readonly allChoices?: true;
     readonly actors: readonly string[];
     readonly choices: readonly string[];
     readonly kind: "template";
-    readonly templateId: string;
+    readonly templateId: TemplateId;
 }
 export interface TemplateCreateTarget {
     readonly actors: readonly string[];
     readonly kind: "template-create";
-    readonly templateId: string;
+    readonly templateId: TemplateId;
 }
 export interface ExcludedChoiceTarget {
     readonly choice: string;
     readonly kind: "exclude-choice";
-    readonly templateId: string;
+    readonly templateId: TemplateId;
 }
 export interface ExcludedTemplateTarget {
     readonly kind: "exclude-template";
-    readonly templateId: string;
+    readonly templateId: TemplateId;
 }
 export interface TemplateTargetBuilder {
     allChoices(): TemplateTarget;
@@ -30,20 +31,20 @@ export interface ResolvedDeclarativeChoiceTarget {
     readonly actors: readonly string[];
     readonly choice: string;
     readonly key: string;
-    readonly templateId: string;
+    readonly templateId: TemplateId;
 }
 export interface ResolvedDeclarativeCreateTarget {
     readonly actors: readonly string[];
     readonly key: string;
     readonly kind: "create";
-    readonly templateId: string;
+    readonly templateId: TemplateId;
 }
 export type ResolvedDeclarativeTarget = ResolvedDeclarativeChoiceTarget | ResolvedDeclarativeCreateTarget;
-export declare function targetTemplate(templateId: string): TemplateTargetBuilder;
+export declare function targetTemplate(templateId: TemplateId): TemplateTargetBuilder;
 /** Builds one immutable declarative template-choice target without a builder chain. */
-export declare function targetChoice(templateId: string, choice: string, actors: readonly string[]): TemplateTarget;
+export declare function targetChoice(templateId: TemplateId, choice: string, actors: readonly string[]): TemplateTarget;
 /** Builds one immutable declarative contract-create target without a builder chain. */
-export declare function targetCreate(templateId: string, actors: readonly string[]): TemplateCreateTarget;
-export declare function excludeChoice(templateId: string, choice: string): ExcludedChoiceTarget;
-export declare function excludeTemplate(templateId: string): ExcludedTemplateTarget;
+export declare function targetCreate(templateId: TemplateId, actors: readonly string[]): TemplateCreateTarget;
+export declare function excludeChoice(templateId: TemplateId, choice: string): ExcludedChoiceTarget;
+export declare function excludeTemplate(templateId: TemplateId): ExcludedTemplateTarget;
 export declare function resolveDeclarativeTargets(catalog: DamlTestingCatalog, descriptors: readonly (TemplateTarget | TemplateCreateTarget | ExcludedChoiceTarget | ExcludedTemplateTarget)[]): readonly ResolvedDeclarativeTarget[];

package/dist/testing/targets/target.js

@@ -67,50 +67,50 @@ export function resolveDeclarativeTargets(catalog, descriptors) {
         if (descriptor.kind === "template") {
             continue;
         }
-        const template = catalog.getTemplate(descriptor.templateId);
+        const template = catalog.getTemplate(formatTemplateId(descriptor.templateId));
         if (template === undefined) {
-            throw new TestingConfigurationError(`Declarative target '${descriptor.templateId}' is absent from the DAML catalog.`);
+            throw new TestingConfigurationError(`Declarative target '${formatTemplateId(descriptor.templateId)}' is absent from the DAML catalog.`);
         }
         else if (descriptor.kind === "exclude-choice"
             && !template.choices.includes(descriptor.choice)) {
-            throw new TestingConfigurationError(`Declarative target '${descriptor.templateId}:${descriptor.choice}' is absent from the DAML catalog.`);
+            throw new TestingConfigurationError(`Declarative target '${formatTemplateId(descriptor.templateId)}:${descriptor.choice}' is absent from the DAML catalog.`);
         }
     }
     const excludedTemplates = new Set(descriptors
         .filter((descriptor) => descriptor.kind === "exclude-template")
-        .map((descriptor) => descriptor.templateId));
+        .map((descriptor) => formatTemplateId(descriptor.templateId)));
     const excluded = new Set(descriptors
         .filter((descriptor) => descriptor.kind === "exclude-choice")
-        .map((descriptor) => `${descriptor.templateId}:${descriptor.choice}`));
+        .map((descriptor) => `${formatTemplateId(descriptor.templateId)}:${descriptor.choice}`));
     return descriptors
         .filter((descriptor) => descriptor.kind === "template" || descriptor.kind === "template-create")
         .flatMap((descriptor) => {
-        const template = catalog.getTemplate(descriptor.templateId);
+        const template = catalog.getTemplate(formatTemplateId(descriptor.templateId));
         if (template === undefined) {
-            throw new TestingConfigurationError(`Declarative target '${descriptor.templateId}' is absent from the DAML catalog.`);
+            throw new TestingConfigurationError(`Declarative target '${formatTemplateId(descriptor.templateId)}' is absent from the DAML catalog.`);
         }
         else if (descriptor.kind === "template-create") {
             return [Object.freeze({
-                    key: `${descriptor.templateId}:create`,
+                    key: `${formatTemplateId(descriptor.templateId)}:create`,
                     templateId: descriptor.templateId,
                     actors: descriptor.actors,
                     kind: "create",
                 })];
         }
         else {
-            if (descriptor.allChoices === true && excludedTemplates.has(descriptor.templateId)) {
+            if (descriptor.allChoices === true && excludedTemplates.has(formatTemplateId(descriptor.templateId))) {
                 return [];
             }
             const choices = (descriptor.allChoices === true
-                ? template.choices.filter((choice) => !excluded.has(`${descriptor.templateId}:${choice}`))
+                ? template.choices.filter((choice) => !excluded.has(`${formatTemplateId(descriptor.templateId)}:${choice}`))
                 : descriptor.choices);
             const missingChoice = choices.find((choice) => !template.choices.includes(choice));
             if (missingChoice !== undefined) {
-                throw new TestingConfigurationError(`Declarative target '${descriptor.templateId}:${missingChoice}' is absent from the DAML catalog.`);
+                throw new TestingConfigurationError(`Declarative target '${formatTemplateId(descriptor.templateId)}:${missingChoice}' is absent from the DAML catalog.`);
             }
             return choices
                 .map((choice) => Object.freeze({
-                key: `${descriptor.templateId}:${choice}`,
+                key: `${formatTemplateId(descriptor.templateId)}:${choice}`,
                 templateId: descriptor.templateId,
                 choice,
                 actors: descriptor.actors,
@@ -119,3 +119,6 @@ export function resolveDeclarativeTargets(catalog, descriptors) {
     })
         .sort((left, right) => left.key.localeCompare(right.key));
 }
+function formatTemplateId(templateId) {
+    return `${templateId.packageId}:${templateId.moduleName}:${templateId.entityName}`;
+}

package/dist/transports/grpc/grpc-channel-factory.d.ts

@@ -27,6 +27,10 @@ import { IEventQueryServiceClient } from "./generated/canton/com/daml/ledger/api
 import { IStateServiceClient } from "./generated/canton/com/daml/ledger/api/v2/state_service.client.js";
 import { IUpdateServiceClient } from "./generated/canton/com/daml/ledger/api/v2/update_service.client.js";
 import { IHealthClient } from "./generated/canton/google/grpc/health/v1/health.client.js";
+import { GetCompletionsRequest as GrpcGetCompletionsRequest, CompletionStreamResponse as GrpcCompletionStreamResponse } from "./generated/canton/com/daml/ledger/api/v2/command_completion_service.js";
+import { GetContractRequest as GrpcGetContractRequest, GetContractResponse as GrpcGetContractResponse } from "./generated/canton/com/daml/ledger/api/v2/contract_service.js";
+import { GetEventsByContractIdRequest as GrpcGetEventsByContractIdRequest, GetEventsByContractIdResponse as GrpcGetEventsByContractIdResponse } from "./generated/canton/com/daml/ledger/api/v2/event_query_service.js";
+import { GetUpdatesRequest, GetUpdateByHashRequest as GrpcGetUpdateByHashRequest, GetUpdateByIdRequest as GrpcGetUpdateByIdRequest, GetUpdateByOffsetRequest as GrpcGetUpdateByOffsetRequest, GetUpdateResponse as GrpcGetUpdateResponse, GetUpdatesResponse, GetUpdatesPageRequest as GrpcGetUpdatesPageRequest, GetUpdatesPageResponse as GrpcGetUpdatesPageResponse } from "./generated/canton/com/daml/ledger/api/v2/update_service.js";
 import { RequestOptions } from "../../core/types/request-options.js";
 import { GrpcChannelSecurity } from "../../core/types/grpc-channel-security.js";
 export interface GrpcOperations {
@@ -110,18 +114,19 @@ export interface GrpcOperations {
     listAllV2Async?(request: unknown, options?: RequestOptions): Promise<unknown>;
     topologyListPartiesAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     listKeyOwnersAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
-    getContractAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
-    getEventsByContractIdAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getContractAsync?(request: GrpcGetContractRequest, options?: RequestOptions): Promise<GrpcGetContractResponse>;
+    getEventsByContractIdAsync?(request: GrpcGetEventsByContractIdRequest, options?: RequestOptions): Promise<GrpcGetEventsByContractIdResponse>;
     queryContractsAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getActiveContractsPageAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     getConnectedSynchronizersAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     getLedgerEndAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     getLatestPrunedOffsetsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
-    streamTransactionsAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
-    getUpdateByOffsetAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
-    getUpdateByIdAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
-    getUpdateByHashAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
-    getUpdatesPageAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
-    getCompletionsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getUpdatesAsync(request: GetUpdatesRequest, options?: RequestOptions): AsyncIterable<GetUpdatesResponse>;
+    getUpdateByOffsetAsync?(request: GrpcGetUpdateByOffsetRequest, options?: RequestOptions): Promise<GrpcGetUpdateResponse>;
+    getUpdateByIdAsync?(request: GrpcGetUpdateByIdRequest, options?: RequestOptions): Promise<GrpcGetUpdateResponse>;
+    getUpdateByHashAsync?(request: GrpcGetUpdateByHashRequest, options?: RequestOptions): Promise<GrpcGetUpdateResponse>;
+    getUpdatesPageAsync?(request: GrpcGetUpdatesPageRequest, options?: RequestOptions): Promise<GrpcGetUpdatesPageResponse>;
+    getCompletionsAsync?(request: GrpcGetCompletionsRequest, options?: RequestOptions): AsyncIterable<GrpcCompletionStreamResponse>;
     prepareSubmissionAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     executeSubmissionAndWaitAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     submitCommandAsync(request: unknown, options?: RequestOptions): Promise<unknown>;

package/dist/transports/grpc/grpc-channel-factory.js

@@ -423,6 +423,10 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
             const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(stateServiceClient.getActiveContractsPage(request, callOptions));
         },
+        async getActiveContractsPageAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(stateServiceClient.getActiveContractsPage(request, callOptions));
+        },
         async getConnectedSynchronizersAsync(request, requestOptions) {
             const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(stateServiceClient.getConnectedSynchronizers(request, callOptions));
@@ -435,9 +439,8 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
             const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(stateServiceClient.getLatestPrunedOffsets(request, callOptions));
         },
-        async streamTransactionsAsync(request, requestOptions) {
-            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
-            return await collectServerResponsesAsync(updateServiceClient.getUpdates(request, callOptions));
+        getUpdatesAsync(request, requestOptions) {
+            return streamServerResponsesAsync(async () => updateServiceClient.getUpdates(request, await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions)));
         },
         async getUpdateByOffsetAsync(request, requestOptions) {
             const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
@@ -455,9 +458,8 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
             const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(updateServiceClient.getUpdatesPage(request, callOptions));
         },
-        async getCompletionsAsync(request, requestOptions) {
-            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
-            return await collectServerResponsesAsync(commandCompletionServiceClient.getCompletions(request, callOptions));
+        getCompletionsAsync(request, requestOptions) {
+            return streamServerResponsesAsync(async () => commandCompletionServiceClient.getCompletions(request, await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions)));
         },
         async submitCommandAsync(request, requestOptions) {
             const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
@@ -500,6 +502,9 @@ function wrapGrpcOperations(operations, onGrpcError) {
             if (typeof operation !== "function") {
                 return operation;
             }
+            if (property === "getUpdatesAsync" || property === "getCompletionsAsync") {
+                return (...args) => wrapGrpcStream(() => operation.apply(target, args), onGrpcError);
+            }
             return async (...args) => {
                 try {
                     return await operation.apply(target, args);
@@ -521,6 +526,26 @@ function wrapGrpcOperations(operations, onGrpcError) {
         },
     });
 }
+async function* wrapGrpcStream(createStream, onGrpcError) {
+    try {
+        for await (const response of createStream()) {
+            yield response;
+        }
+    }
+    catch (error) {
+        throw notifyGrpcError(error, onGrpcError);
+    }
+}
+function notifyGrpcError(error, onGrpcError) {
+    const parsedError = GrpcTransportError.fromUnknown(error);
+    if (parsedError === undefined)
+        return error;
+    try {
+        onGrpcError?.(parsedError);
+    }
+    catch { /* observers do not replace failures */ }
+    return parsedError;
+}
 async function unwrapUnaryResponse(call) {
     return await call.response;
 }
@@ -537,3 +562,26 @@ async function collectServerResponsesAsync(call) {
     await call.status;
     return responses;
 }
+async function* streamServerResponsesAsync(createCall) {
+    let call;
+    let exhausted = false;
+    let iterator;
+    try {
+        call = await createCall();
+        iterator = call.responses[Symbol.asyncIterator]();
+        while (true) {
+            const next = await iterator.next();
+            if (next.done)
+                break;
+            yield next.value;
+        }
+        exhausted = true;
+        await call.status;
+    }
+    finally {
+        if (!exhausted && call !== undefined) {
+            await iterator.return?.();
+            void call.status.catch(() => undefined);
+        }
+    }
+}