@distrohelena/canton-typescript-sdk 0.1.11 → 0.1.13

package/dist/core/transports/transport.interface.d.ts

@@ -188,6 +188,7 @@ import { TransactionObserver } from "../../services/events/transaction-observer.
 import { CommandSigners, ICommandSigner } from "../signing/command-signer.interface.js";
 import { SignCommandResult } from "../signing/sign-command-result.js";
 import { PreparedCommandSubmission } from "../types/prepared-command-submission.js";
+import { SubmitCommandTransactionResponse } from "../types/responses/submit-command-transaction-response.js";
 import { RequestOptions } from "../types/request-options.js";
 import { SubmitCommandRequest } from "../types/requests/submit-command-request.js";
 export interface ITransport {
@@ -383,6 +384,7 @@ export interface ITransport {
      * Supported on JSON and gRPC. External signing is gRPC-only.
      */
     submitCommandAsync(request: SubmitCommandRequest, signer?: ICommandSigner | CommandSigners, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitCommandForTransactionAsync?(request: SubmitCommandRequest, options?: RequestOptions): Promise<SubmitCommandTransactionResponse>;
     prepareCommandAsync?(request: SubmitCommandRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;
     executePreparedCommandAndWaitAsync?(prepared: PreparedCommandSubmission, signatures: Readonly<Record<string, SignCommandResult>>, options?: RequestOptions): Promise<SubmitCommandResponse>;
 }

package/dist/core/types/command-inspection-contract.d.ts

@@ -1,10 +1,11 @@
+import type { TemplateId } from "../../query/model-types.js";
 export declare class CommandInspectionContract {
-    readonly templateId?: string;
+    readonly templateId?: TemplateId;
     readonly contractId: string;
     readonly contractKey?: unknown;
     constructor(init: {
         contractId: string;
-        templateId?: string;
+        templateId?: TemplateId;
         contractKey?: unknown;
     });
 }

package/dist/core/types/commands/create-and-exercise-command.d.ts

@@ -1,12 +1,14 @@
+import { DamlRecord } from "../daml-values.js";
+import type { TemplateId } from "../../../query/model-types.js";
 export declare class CreateAndExerciseCommand {
-    readonly templateId: string;
-    readonly payload: Record<string, unknown>;
+    readonly templateId: TemplateId;
+    readonly createArguments: DamlRecord;
     readonly choice: string;
-    readonly argument: unknown;
+    readonly choiceArgument: unknown;
     constructor(init: {
-        templateId: string;
-        payload: Record<string, unknown>;
+        templateId: TemplateId;
+        createArguments: DamlRecord;
         choice: string;
-        argument: unknown;
+        choiceArgument: unknown;
     });
 }

package/dist/core/types/commands/create-and-exercise-command.js

@@ -1,19 +1,23 @@
 import { ValidationError } from "../../errors/validation-error.js";
+import { DamlRecord } from "../daml-values.js";
 export class CreateAndExerciseCommand {
     templateId;
-    payload;
+    createArguments;
     choice;
-    argument;
+    choiceArgument;
     constructor(init) {
-        if (!init.templateId) {
+        if (!init.templateId?.moduleName || !init.templateId.entityName) {
             throw new ValidationError("create-and-exercise commands require a templateId");
         }
+        else if (!(init.createArguments instanceof DamlRecord)) {
+            throw new ValidationError("create-and-exercise commands require DamlRecord createArguments");
+        }
         else if (!init.choice) {
             throw new ValidationError("create-and-exercise commands require a choice");
         }
         this.templateId = init.templateId;
-        this.payload = init.payload;
+        this.createArguments = init.createArguments;
         this.choice = init.choice;
-        this.argument = init.argument;
+        this.choiceArgument = init.choiceArgument;
     }
 }

package/dist/core/types/commands/create-command.d.ts

@@ -1,8 +1,10 @@
+import { DamlRecord } from "../daml-values.js";
+import type { TemplateId } from "../../../query/model-types.js";
 export declare class CreateCommand {
-    readonly templateId: string;
-    readonly payload: Record<string, unknown>;
+    readonly templateId: TemplateId;
+    readonly createArguments: DamlRecord;
     constructor(init: {
-        templateId: string;
-        payload: Record<string, unknown>;
+        templateId: TemplateId;
+        createArguments: DamlRecord;
     });
 }

package/dist/core/types/commands/create-command.js

@@ -1,12 +1,16 @@
 import { ValidationError } from "../../errors/validation-error.js";
+import { DamlRecord } from "../daml-values.js";
 export class CreateCommand {
     templateId;
-    payload;
+    createArguments;
     constructor(init) {
-        if (!init.templateId) {
+        if (!init.templateId?.moduleName || !init.templateId.entityName) {
             throw new ValidationError("create commands require a templateId");
         }
+        else if (!(init.createArguments instanceof DamlRecord)) {
+            throw new ValidationError("create commands require DamlRecord createArguments");
+        }
         this.templateId = init.templateId;
-        this.payload = init.payload;
+        this.createArguments = init.createArguments;
     }
 }

package/dist/core/types/commands/exercise-by-key-command.d.ts

@@ -1,12 +1,13 @@
+import type { TemplateId } from "../../../query/model-types.js";
 export declare class ExerciseByKeyCommand {
-    readonly templateId: string;
+    readonly templateId: TemplateId;
     readonly contractKey: unknown;
     readonly choice: string;
-    readonly argument: unknown;
+    readonly choiceArgument: unknown;
     constructor(init: {
-        templateId: string;
+        templateId: TemplateId;
         contractKey: unknown;
         choice: string;
-        argument: unknown;
+        choiceArgument: unknown;
     });
 }

package/dist/core/types/commands/exercise-by-key-command.js

@@ -3,9 +3,9 @@ export class ExerciseByKeyCommand {
     templateId;
     contractKey;
     choice;
-    argument;
+    choiceArgument;
     constructor(init) {
-        if (!init.templateId) {
+        if (!init.templateId?.moduleName || !init.templateId.entityName) {
             throw new ValidationError("exercise-by-key commands require a templateId");
         }
         else if (init.contractKey === undefined) {
@@ -17,6 +17,6 @@ export class ExerciseByKeyCommand {
         this.templateId = init.templateId;
         this.contractKey = init.contractKey;
         this.choice = init.choice;
-        this.argument = init.argument;
+        this.choiceArgument = init.choiceArgument;
     }
 }

package/dist/core/types/commands/exercise-command.d.ts

@@ -1,12 +1,13 @@
+import type { TemplateId } from "../../../query/model-types.js";
 export declare class ExerciseCommand {
-    readonly templateId: string;
+    readonly templateId: TemplateId;
     readonly contractId: string;
     readonly choice: string;
-    readonly argument: unknown;
+    readonly choiceArgument: unknown;
     constructor(init: {
-        templateId: string;
+        templateId: TemplateId;
         contractId: string;
         choice: string;
-        argument: unknown;
+        choiceArgument: unknown;
     });
 }

package/dist/core/types/commands/exercise-command.js

@@ -3,9 +3,9 @@ export class ExerciseCommand {
     templateId;
     contractId;
     choice;
-    argument;
+    choiceArgument;
     constructor(init) {
-        if (!init.templateId) {
+        if (!init.templateId?.moduleName || !init.templateId.entityName) {
             throw new ValidationError("exercise commands require a templateId");
         }
         else if (!init.contractId) {
@@ -17,6 +17,6 @@ export class ExerciseCommand {
         this.templateId = init.templateId;
         this.contractId = init.contractId;
         this.choice = init.choice;
-        this.argument = init.argument;
+        this.choiceArgument = init.choiceArgument;
     }
 }

package/dist/core/types/responses/submit-command-transaction-response.d.ts

@@ -0,0 +1,7 @@
+/** Result of a gRPC command submission that waited for its transaction. */
+export declare class SubmitCommandTransactionResponse {
+    readonly transactionId: string;
+    readonly events: readonly unknown[];
+    readonly transaction: unknown;
+    constructor(transactionId: string, events: readonly unknown[], transaction: unknown);
+}

package/dist/core/types/responses/submit-command-transaction-response.js

@@ -0,0 +1,11 @@
+/** Result of a gRPC command submission that waited for its transaction. */
+export class SubmitCommandTransactionResponse {
+    transactionId;
+    events;
+    transaction;
+    constructor(transactionId, events, transaction) {
+        this.transactionId = transactionId;
+        this.events = events;
+        this.transaction = transaction;
+    }
+}

package/dist/core/types/sdk-command.d.ts

@@ -1,18 +1,20 @@
+import type { DamlRecord } from "./daml-values.js";
+import type { TemplateId } from "../../query/model-types.js";
 export declare class SdkCommand {
     readonly type: string;
-    readonly templateId?: string;
+    readonly templateId?: TemplateId;
     readonly contractId?: string;
     readonly contractKey?: unknown;
     readonly choice?: string;
-    readonly createArguments?: Record<string, unknown>;
+    readonly createArguments?: DamlRecord;
     readonly choiceArgument?: unknown;
     constructor(init: {
         type: string;
-        templateId?: string;
+        templateId?: TemplateId;
         contractId?: string;
         contractKey?: unknown;
         choice?: string;
-        createArguments?: Record<string, unknown>;
+        createArguments?: DamlRecord;
         choiceArgument?: unknown;
     });
 }

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export { PqsQueryError } from "./query/errors/pqs-query-error.js";
 export { PqsSchemaProfileError } from "./query/errors/pqs-schema-profile-error.js";
 export type { CantonManagerOptions, PqsQueryOptions, QueryCacheOptions, } from "./query/canton-manager-options.js";
 export type { QueryCacheStore } from "./query/cache/query-cache-store.js";
-export type { ContractFindManyArgs, ContractFindUniqueArgs, ContractCountArgs, ContractRow, ContractTypeRow, EventRow, ExerciseRow, ExerciseTypeRow, PackageRow, TransactionRow, WatermarkRow, RowWhere, RowSelect, RowOrderBy, } from "./query/model-types.js";
+export type { ContractFindManyArgs, ContractFindUniqueArgs, ContractCountArgs, ContractRow, TemplateId, ContractTypeRow, EventRow, ExerciseRow, ExerciseTypeRow, PackageRow, TransactionRow, WatermarkRow, RowWhere, RowSelect, RowOrderBy, } from "./query/model-types.js";
 export type { QueryClient, QueryDelegate, QueryCollectionDelegate } from "./query/query-client.js";
 export { CantonHashingClient } from "./client/canton-hashing-client.js";
 export { CantonClientOptions } from "./client/canton-client-options.js";
@@ -210,6 +210,7 @@ export { DisclosedContract } from "./core/types/disclosed-contract.js";
 export { PreparedCommandSubmission } from "./core/types/prepared-command-submission.js";
 export { DamlContractId } from "./core/types/daml-contract-id.js";
 export { DamlUnit, DamlDate, DamlTimestamp, DamlTextMap, DamlGenMap, DamlVariant, DamlEnum, DamlRecord } from "./core/types/daml-values.js";
+export { SubmitCommandTransactionResponse } from "./core/types/responses/submit-command-transaction-response.js";
 export { AddPartyAsyncArguments } from "./core/types/requests/add-party-async-request.js";
 export { AddPartyAsyncRequest } from "./core/types/requests/add-party-async-request.js";
 export { AssembleSignedTopologyTransactionsRequest } from "./core/types/requests/assemble-signed-topology-transactions-request.js";

package/dist/index.js

@@ -197,6 +197,7 @@ export { DisclosedContract } from "./core/types/disclosed-contract.js";
 export { PreparedCommandSubmission } from "./core/types/prepared-command-submission.js";
 export { DamlContractId } from "./core/types/daml-contract-id.js";
 export { DamlUnit, DamlDate, DamlTimestamp, DamlTextMap, DamlGenMap, DamlVariant, DamlEnum, DamlRecord } from "./core/types/daml-values.js";
+export { SubmitCommandTransactionResponse } from "./core/types/responses/submit-command-transaction-response.js";
 export { AddPartyAsyncArguments } from "./core/types/requests/add-party-async-request.js";
 export { AddPartyAsyncRequest } from "./core/types/requests/add-party-async-request.js";
 export { AssembleSignedTopologyTransactionsRequest } from "./core/types/requests/assemble-signed-topology-transactions-request.js";

package/dist/services/command/command-service-client.d.ts

@@ -3,11 +3,13 @@ import { RequestOptions } from "../../core/types/request-options.js";
 import { ITransport } from "../../core/transports/transport.interface.js";
 import { SubmitCommandRequest } from "../../core/types/requests/submit-command-request.js";
 import { SubmitCommandResponse } from "../../core/types/responses/submit-command-response.js";
+import { SubmitCommandTransactionResponse } from "../../core/types/responses/submit-command-transaction-response.js";
 import { PreparedCommandSubmission } from "../../core/types/prepared-command-submission.js";
 import { SignCommandResult } from "../../core/signing/sign-command-result.js";
 export declare class CommandServiceClient {
     private readonly pipeline;
     constructor(transport: ITransport, signer?: ICommandSigner | CommandSigners);
+    submitAndWaitForTransactionAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<SubmitCommandTransactionResponse>;
     /** Submits a command and waits for the result. Supported on JSON and gRPC. */
     submitAndWaitAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<SubmitCommandResponse>;
     prepareAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;

package/dist/services/command/command-service-client.js

@@ -7,6 +7,7 @@ export class CommandServiceClient {
             signer,
         });
     }
+    submitAndWaitForTransactionAsync(request, options) { return this.pipeline.submitForTransactionAsync(request, options); }
     /** Submits a command and waits for the result. Supported on JSON and gRPC. */
     submitAndWaitAsync(request, options) {
         return this.pipeline.submitAsync(request, options);

package/dist/services/commands/command-payload-builder.js

@@ -15,7 +15,7 @@ function mapCanonicalCommand(command) {
         return {
             kind: "create",
             templateId: command.templateId,
-            payload: command.payload,
+            createArguments: mapCanonicalRecord(command.createArguments),
         };
     }
     else if (command instanceof ExerciseCommand) {
@@ -24,7 +24,7 @@ function mapCanonicalCommand(command) {
             templateId: command.templateId,
             contractId: command.contractId,
             choice: command.choice,
-            argument: command.argument,
+            choiceArgument: command.choiceArgument,
         };
     }
     else if (command instanceof ExerciseByKeyCommand) {
@@ -33,17 +33,23 @@ function mapCanonicalCommand(command) {
             templateId: command.templateId,
             contractKey: command.contractKey,
             choice: command.choice,
-            argument: command.argument,
+            choiceArgument: command.choiceArgument,
         };
     }
     else if (command instanceof CreateAndExerciseCommand) {
         return {
             kind: "createAndExercise",
             templateId: command.templateId,
-            payload: command.payload,
+            createArguments: mapCanonicalRecord(command.createArguments),
             choice: command.choice,
-            argument: command.argument,
+            choiceArgument: command.choiceArgument,
         };
     }
     return {};
 }
+function mapCanonicalRecord(record) {
+    return {
+        fields: record.fields,
+        recordId: record.recordId ?? null,
+    };
+}

package/dist/services/commands/command-submission-pipeline.d.ts

@@ -3,6 +3,7 @@ import { ITransport } from "../../core/transports/transport.interface.js";
 import { RequestOptions } from "../../core/types/request-options.js";
 import { SubmitCommandRequest } from "../../core/types/requests/submit-command-request.js";
 import { SubmitCommandResponse } from "../../core/types/responses/submit-command-response.js";
+import { SubmitCommandTransactionResponse } from "../../core/types/responses/submit-command-transaction-response.js";
 import { PreparedCommandSubmission } from "../../core/types/prepared-command-submission.js";
 import { SignCommandResult } from "../../core/signing/sign-command-result.js";
 export declare class CommandSubmissionPipeline {
@@ -12,6 +13,7 @@ export declare class CommandSubmissionPipeline {
         signer?: ICommandSigner | CommandSigners;
     });
     submitAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitForTransactionAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<SubmitCommandTransactionResponse>;
     prepareAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;
     executeAsync(prepared: PreparedCommandSubmission, signatures: Readonly<Record<string, SignCommandResult>>, options?: RequestOptions): Promise<SubmitCommandResponse>;
 }

package/dist/services/commands/command-submission-pipeline.js

@@ -12,6 +12,8 @@ export class CommandSubmissionPipeline {
         }
         return this.dependencies.transport.submitCommandAsync(request, this.dependencies.signer, options);
     }
+    submitForTransactionAsync(request, options) { if (!this.dependencies.transport.submitCommandForTransactionAsync)
+        throw new NotSupportedError("transaction-returning command submission is not supported by the selected transport"); return this.dependencies.transport.submitCommandForTransactionAsync(request, options); }
     prepareAsync(request, options) { if (!this.dependencies.transport.prepareCommandAsync)
         throw new NotSupportedError("interactive command preparation is not supported by the selected transport"); return this.dependencies.transport.prepareCommandAsync(request, options); }
     executeAsync(prepared, signatures, options) { if (!this.dependencies.transport.executePreparedCommandAndWaitAsync)

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

@@ -3,10 +3,11 @@ import { CampaignExecutableAction } from "../campaign/campaign-runner.js";
 import { ResolvedDeclarativeChoiceTarget } 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 DeclarativeChoiceAction extends CampaignExecutableAction {
     readonly argument: DamlTestingValue;
     readonly choice: string;
-    readonly templateId: string;
+    readonly templateId: TemplateId;
 }
 /**
  * Builds a well-typed, actor-routed automatic choice input from declarative

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

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

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

@@ -125,6 +125,7 @@ export interface GrpcOperations {
     prepareSubmissionAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     executeSubmissionAndWaitAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     submitCommandAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+    submitCommandForTransactionAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
 }
 export interface GrpcOperationDependencies {
     versionServiceClient?: Pick<IVersionServiceClient, "getLedgerApiVersion">;
@@ -154,6 +155,6 @@ export interface GrpcOperationDependencies {
     updateServiceClient?: Pick<IUpdateServiceClient, "getUpdates" | "getUpdateByOffset" | "getUpdateById" | "getUpdateByHash" | "getUpdatesPage">;
     commandCompletionServiceClient?: Pick<ICommandCompletionServiceClient, "getCompletions">;
     interactiveSubmissionServiceClient?: Pick<IInteractiveSubmissionServiceClient, "prepareSubmission" | "executeSubmissionAndWait">;
-    commandServiceClient?: Pick<ICommandServiceClient, "submitAndWait">;
+    commandServiceClient?: Pick<ICommandServiceClient, "submitAndWait" | "submitAndWaitForTransaction">;
 }
 export declare function createGrpcOperations(options: CantonClientOptions, endpoint: string, grpcChannelSecurity: GrpcChannelSecurity, dependencies?: GrpcOperationDependencies): GrpcOperations;

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

@@ -463,6 +463,10 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
             const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(commandServiceClient.submitAndWait(request, callOptions));
         },
+        async submitCommandForTransactionAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(commandServiceClient.submitAndWaitForTransaction(request, callOptions));
+        },
         async prepareSubmissionAsync(request, requestOptions) {
             const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(interactiveSubmissionServiceClient.prepareSubmission(request, callOptions));

package/dist/transports/grpc/grpc-transport.d.ts

@@ -278,6 +278,7 @@ export declare class GrpcTransport implements ITransport {
     getUpdatesPageAsync(request: GetUpdatesPageRequest, options?: RequestOptions): Promise<GetUpdatesPageResponse>;
     getCompletionsAsync(request: GetCompletionsRequest, observer: CompletionObserver, options?: RequestOptions): Promise<void>;
     submitCommandAsync(request: SubmitCommandRequest, signer?: ICommandSigner | CommandSigners, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitCommandForTransactionAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<import("../../core/types/responses/submit-command-transaction-response.js").SubmitCommandTransactionResponse>;
     prepareCommandAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;
     executePreparedCommandAndWaitAsync(prepared: PreparedCommandSubmission, signatures: Readonly<Record<string, SignCommandResult>>, options?: RequestOptions): Promise<SubmitCommandResponse>;
     private throwIfDisposed;

package/dist/transports/grpc/grpc-transport.js

@@ -11,7 +11,7 @@ import { NotSupportedError } from "../../core/errors/not-supported-error.js";
 import { TransportError } from "../../core/errors/transport-error.js";
 import { PackageFormat } from "../../core/types/package-format.js";
 import { createGrpcOperations, } from "./grpc-channel-factory.js";
-import { mapGrpcSubmitCommand, mapGrpcSubmitCommandRequest, } from "./mappers/commands-mapper.js";
+import { mapGrpcSubmitCommand, mapGrpcSubmitCommandForTransactionRequest, mapGrpcSubmitCommandTransaction, mapGrpcSubmitCommandRequest, } from "./mappers/commands-mapper.js";
 import { mapGrpcExecuteSubmissionAndWaitRequest, mapGrpcInteractiveSubmitCommand, mapGrpcPrepareSubmissionRequest, } from "./mappers/interactive-command-mapper.js";
 import { mapGrpcGetContract, mapGrpcGetContractRequest, mapGrpcQueryContracts, mapGrpcQueryContractsRequest, } from "./mappers/contracts-mapper.js";
 import { mapGrpcCompletionStreamResponse, mapGrpcGetCompletionsRequest, } from "./mappers/command-completion-mapper.js";
@@ -617,6 +617,12 @@ export class GrpcTransport {
         }), options);
         return mapGrpcInteractiveSubmitCommand(executed);
     }
+    async submitCommandForTransactionAsync(request, options) {
+        this.throwIfDisposed();
+        if (!this.operations.submitCommandForTransactionAsync)
+            throw new NotSupportedError("transaction-returning command submission is not available on this transport");
+        return mapGrpcSubmitCommandTransaction(await this.operations.submitCommandForTransactionAsync(mapGrpcSubmitCommandForTransactionRequest(request), options));
+    }
     async prepareCommandAsync(request, options) {
         if (!this.operations.prepareSubmissionAsync)
             throw new NotSupportedError("interactive gRPC command signing is not available on this transport");

package/dist/transports/grpc/mappers/command-inspection-mapper.js

@@ -5,6 +5,7 @@ import { CommandStatus } from "../../../core/types/command-status.js";
 import { CommandTiming } from "../../../core/types/command-timing.js";
 import { CommandUpdateSummary } from "../../../core/types/command-update-summary.js";
 import { SdkCommand } from "../../../core/types/sdk-command.js";
+import { DamlRecord } from "../../../core/types/daml-values.js";
 import { GetCommandStatusResponse } from "../../../core/types/responses/get-command-status-response.js";
 import { CommandState as GrpcCommandState, } from "../generated/canton/com/daml/ledger/api/v2/admin/command_inspection_service.js";
 import { mapGrpcCompletion } from "./command-completion-mapper.js";
@@ -118,21 +119,16 @@ function mapGrpcIdentifier(value) {
     if (value === undefined) {
         return undefined;
     }
-    else if (value.packageId) {
-        return `${value.packageId}:${value.moduleName}:${value.entityName}`;
-    }
-    else {
-        return `${value.moduleName}:${value.entityName}`;
-    }
+    return value;
 }
 function mapGrpcRecord(value) {
     if (value === undefined) {
         return undefined;
     }
-    return Object.fromEntries(value.fields.map((field, index) => [
+    return new DamlRecord(Object.fromEntries(value.fields.map((field, index) => [
         field.label || index.toString(),
         mapGrpcValue(field.value),
-    ]));
+    ])), mapGrpcIdentifier(value.recordId));
 }
 function mapGrpcValue(value) {
     switch (value?.sum.oneofKind) {

package/dist/transports/grpc/mappers/commands-mapper.d.ts

@@ -1,11 +1,15 @@
 import { CreateCommand } from "../../../core/types/commands/create-command.js";
+import { DamlRecord } from "../../../core/types/daml-values.js";
 import { LedgerCommand } from "../../../core/types/commands/ledger-command.js";
 import { SubmitCommandRequest } from "../../../core/types/requests/submit-command-request.js";
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
+import { SubmitCommandTransactionResponse } from "../../../core/types/responses/submit-command-transaction-response.js";
 import { Command } from "../generated/canton/com/daml/ledger/api/v2/commands.js";
-import { SubmitAndWaitRequest, SubmitAndWaitResponse } from "../generated/canton/com/daml/ledger/api/v2/command_service.js";
-import { Identifier, Record as GrpcRecord, Value } from "../generated/canton/com/daml/ledger/api/v2/value.js";
+import { SubmitAndWaitRequest, SubmitAndWaitResponse, SubmitAndWaitForTransactionRequest, SubmitAndWaitForTransactionResponse } from "../generated/canton/com/daml/ledger/api/v2/command_service.js";
+import { Record as GrpcRecord, Value } from "../generated/canton/com/daml/ledger/api/v2/value.js";
 export declare function mapGrpcSubmitCommandRequest(request: SubmitCommandRequest): SubmitAndWaitRequest;
+export declare function mapGrpcSubmitCommandForTransactionRequest(request: SubmitCommandRequest): SubmitAndWaitForTransactionRequest;
+export declare function mapGrpcSubmitCommandTransaction(payload: SubmitAndWaitForTransactionResponse): SubmitCommandTransactionResponse;
 export declare function mapGrpcSubmitCommand(payload: {
     commandId?: string;
     transactionId?: string;
@@ -13,6 +17,5 @@ export declare function mapGrpcSubmitCommand(payload: {
 } | SubmitAndWaitResponse): SubmitCommandResponse;
 export declare function mapGrpcLedgerCommand(command: LedgerCommand): Command;
 export declare function mapGrpcCreateCommand(command: CreateCommand): Command;
-export declare function mapRecord(payload: Record<string, unknown>): GrpcRecord;
+export declare function mapRecord(payload: DamlRecord | Record<string, unknown>): GrpcRecord;
 export declare function mapValue(value: unknown): Value;
-export declare function parseTemplateIdentifier(templateId: string): Identifier;

package/dist/transports/grpc/mappers/commands-mapper.js

@@ -9,6 +9,7 @@ import { DamlDate, DamlEnum, DamlGenMap, DamlRecord, DamlTextMap, DamlTimestamp,
 import { ExerciseByKeyCommand } from "../../../core/types/commands/exercise-by-key-command.js";
 import { ExerciseCommand } from "../../../core/types/commands/exercise-command.js";
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
+import { SubmitCommandTransactionResponse } from "../../../core/types/responses/submit-command-transaction-response.js";
 export function mapGrpcSubmitCommandRequest(request) {
     return {
         commands: {
@@ -29,6 +30,13 @@ export function mapGrpcSubmitCommandRequest(request) {
         },
     };
 }
+export function mapGrpcSubmitCommandForTransactionRequest(request) {
+    return { commands: mapGrpcSubmitCommandRequest(request).commands };
+}
+export function mapGrpcSubmitCommandTransaction(payload) {
+    const transaction = payload.transaction;
+    return new SubmitCommandTransactionResponse(transaction?.updateId ?? "", transaction?.events ?? [], transaction);
+}
 function mapGrpcDisclosedContract(value) {
     return { createdEventBlob: value.createdEventBlob, contractId: value.contractId ?? "", synchronizerId: value.synchronizerId ?? "", templateId: value.templateId === undefined ? undefined : { packageId: value.templateId.packageId, moduleName: value.templateId.moduleName, entityName: value.templateId.entityName } };
 }
@@ -49,10 +57,10 @@ export function mapGrpcLedgerCommand(command) {
             command: {
                 oneofKind: "exercise",
                 exercise: {
-                    templateId: parseTemplateIdentifier(command.templateId),
+                    templateId: command.templateId,
                     contractId: command.contractId,
                     choice: command.choice,
-                    choiceArgument: mapValue(command.argument),
+                    choiceArgument: mapValue(command.choiceArgument),
                 },
             },
         };
@@ -62,10 +70,10 @@ export function mapGrpcLedgerCommand(command) {
             command: {
                 oneofKind: "exerciseByKey",
                 exerciseByKey: {
-                    templateId: parseTemplateIdentifier(command.templateId),
+                    templateId: command.templateId,
                     contractKey: mapValue(command.contractKey),
                     choice: command.choice,
-                    choiceArgument: mapValue(command.argument),
+                    choiceArgument: mapValue(command.choiceArgument),
                 },
             },
         };
@@ -75,10 +83,10 @@ export function mapGrpcLedgerCommand(command) {
             command: {
                 oneofKind: "createAndExercise",
                 createAndExercise: {
-                    templateId: parseTemplateIdentifier(command.templateId),
-                    createArguments: mapRecord(command.payload),
+                    templateId: command.templateId,
+                    createArguments: mapRecord(command.createArguments),
                     choice: command.choice,
-                    choiceArgument: mapValue(command.argument),
+                    choiceArgument: mapValue(command.choiceArgument),
                 },
             },
         };
@@ -90,15 +98,19 @@ export function mapGrpcCreateCommand(command) {
         command: {
             oneofKind: "create",
             create: {
-                templateId: parseTemplateIdentifier(command.templateId),
-                createArguments: mapRecord(command.payload),
+                templateId: command.templateId,
+                createArguments: mapRecord(command.createArguments),
             },
         },
     };
 }
 export function mapRecord(payload) {
+    const fields = payload instanceof DamlRecord ? payload.fields : payload;
     return {
-        fields: Object.entries(payload).map(([label, value]) => ({
+        ...(payload instanceof DamlRecord && payload.recordId !== undefined
+            ? { recordId: payload.recordId }
+            : {}),
+        fields: Object.entries(fields).map(([label, value]) => ({
             label,
             value: mapValue(value),
         })),
@@ -106,23 +118,31 @@ export function mapRecord(payload) {
 }
 export function mapValue(value) {
     const identifier = (value) => ({ packageId: value.packageId, moduleName: value.moduleName, entityName: value.entityName });
-    if (value instanceof DamlUnit)
+    if (value instanceof DamlUnit) {
         return { sum: { oneofKind: "unit", unit: {} } };
-    if (value instanceof DamlDate)
+    }
+    else if (value instanceof DamlDate) {
         return { sum: { oneofKind: "date", date: value.daysSinceEpoch } };
-    if (value instanceof DamlTimestamp)
+    }
+    else if (value instanceof DamlTimestamp) {
         return { sum: { oneofKind: "timestamp", timestamp: value.microsecondsSinceEpoch } };
-    if (value instanceof DamlTextMap)
+    }
+    else if (value instanceof DamlTextMap) {
         return { sum: { oneofKind: "textMap", textMap: { entries: value.entries.map(([key, item]) => ({ key, value: mapValue(item) })) } } };
-    if (value instanceof DamlGenMap)
+    }
+    else if (value instanceof DamlGenMap) {
         return { sum: { oneofKind: "genMap", genMap: { entries: value.entries.map(([key, item]) => ({ key: mapValue(key), value: mapValue(item) })) } } };
-    if (value instanceof DamlVariant)
+    }
+    else if (value instanceof DamlVariant) {
         return { sum: { oneofKind: "variant", variant: { variantId: value.variantId && identifier(value.variantId), constructor: value.constructorName, value: mapValue(value.value) } } };
-    if (value instanceof DamlEnum)
+    }
+    else if (value instanceof DamlEnum) {
         return { sum: { oneofKind: "enum", enum: { enumId: value.enumId && identifier(value.enumId), constructor: value.constructorName } } };
-    if (value instanceof DamlRecord)
-        return { sum: { oneofKind: "record", record: { recordId: value.recordId && identifier(value.recordId), fields: mapRecord(value.fields).fields } } };
-    if (value === null || value === undefined) {
+    }
+    else if (value instanceof DamlRecord) {
+        return { sum: { oneofKind: "record", record: mapRecord(value) } };
+    }
+    else if (value === null || value === undefined) {
         return {
             sum: {
                 oneofKind: "optional",
@@ -197,21 +217,3 @@ export function mapValue(value) {
         },
     };
 }
-export function parseTemplateIdentifier(templateId) {
-    const parts = templateId.split(":");
-    if (parts.length === 2) {
-        return {
-            packageId: "",
-            moduleName: parts[0],
-            entityName: parts[1],
-        };
-    }
-    else if (parts.length === 3) {
-        return {
-            packageId: parts[0],
-            moduleName: parts[1],
-            entityName: parts[2],
-        };
-    }
-    throw new ValidationError(`templateId must be '<module>:<entity>' or '<package>:<module>:<entity>', but was '${templateId}'.`);
-}

package/dist/transports/json/mappers/commands-mapper.js

@@ -4,6 +4,7 @@ import { CreateAndExerciseCommand } from "../../../core/types/commands/create-an
 import { CreateCommand } from "../../../core/types/commands/create-command.js";
 import { DamlNumeric } from "../../../core/types/daml-numeric.js";
 import { DamlParty } from "../../../core/types/daml-party.js";
+import { DamlRecord } from "../../../core/types/daml-values.js";
 import { ExerciseByKeyCommand } from "../../../core/types/commands/exercise-by-key-command.js";
 import { ExerciseCommand } from "../../../core/types/commands/exercise-command.js";
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
@@ -29,38 +30,38 @@ function mapJsonCommand(command) {
     if (command instanceof CreateCommand) {
         return {
             CreateCommand: {
-                templateId: command.templateId,
-                createArguments: mapJsonValue(command.payload),
+                templateId: formatTemplateId(command.templateId),
+                createArguments: mapJsonValue(command.createArguments.fields),
             },
         };
     }
     else if (command instanceof ExerciseCommand) {
         return {
             ExerciseCommand: {
-                templateId: command.templateId,
+                templateId: formatTemplateId(command.templateId),
                 contractId: command.contractId,
                 choice: command.choice,
-                choiceArgument: mapJsonValue(command.argument),
+                choiceArgument: mapJsonValue(command.choiceArgument),
             },
         };
     }
     else if (command instanceof ExerciseByKeyCommand) {
         return {
             ExerciseByKeyCommand: {
-                templateId: command.templateId,
+                templateId: formatTemplateId(command.templateId),
                 contractKey: mapJsonValue(command.contractKey),
                 choice: command.choice,
-                choiceArgument: mapJsonValue(command.argument),
+                choiceArgument: mapJsonValue(command.choiceArgument),
             },
         };
     }
     else if (command instanceof CreateAndExerciseCommand) {
         return {
             CreateAndExerciseCommand: {
-                templateId: command.templateId,
-                createArguments: mapJsonValue(command.payload),
+                templateId: formatTemplateId(command.templateId),
+                createArguments: mapJsonValue(command.createArguments.fields),
                 choice: command.choice,
-                choiceArgument: mapJsonValue(command.argument),
+                choiceArgument: mapJsonValue(command.choiceArgument),
             },
         };
     }
@@ -70,6 +71,9 @@ function mapJsonValue(value) {
     if (value instanceof DamlParty || value instanceof DamlNumeric) {
         return value.value;
     }
+    else if (value instanceof DamlRecord) {
+        return mapJsonValue(value.fields);
+    }
     else if (Array.isArray(value)) {
         return value.map(mapJsonValue);
     }
@@ -78,3 +82,8 @@ function mapJsonValue(value) {
     }
     return value;
 }
+function formatTemplateId(templateId) {
+    return templateId.packageId.length === 0
+        ? `${templateId.moduleName}:${templateId.entityName}`
+        : `${templateId.packageId}:${templateId.moduleName}:${templateId.entityName}`;
+}

package/package.json

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