@distrohelena/canton-typescript-sdk 0.1.4 → 0.1.6

package/dist/testing/runtime/canton-test-runtime.js

@@ -0,0 +1,138 @@
+import { TestingConfigurationError } from "../errors/testing-configuration-error.js";
+export function createCantonTestRuntime(init) {
+    for (const [name, actor] of Object.entries(init.actors)) {
+        if (init.participants[actor.participant] === undefined) {
+            throw new TestingConfigurationError(`Canton test actor '${name}' references unknown participant '${actor.participant}'.`);
+        }
+    }
+    const actors = Object.freeze({ ...init.actors });
+    const participants = Object.freeze({ ...init.participants });
+    const resolveRoute = (actorName) => {
+        const actor = actors[actorName];
+        if (actor === undefined) {
+            throw new TestingConfigurationError(`Canton test runtime has no actor '${actorName}'.`);
+        }
+        return Object.freeze({
+            actor: actorName,
+            participant: actor.participant,
+            party: actor.party,
+            actAs: Object.freeze([...(actor.actAs ?? [actor.party])]),
+            readAs: Object.freeze([...(actor.readAs ?? [])]),
+        });
+    };
+    return Object.freeze({
+        actors,
+        participants,
+        isolation: init.isolation,
+        async readLedgerEndAsync(participantName) {
+            const participant = participants[participantName];
+            const stateService = readObjectProperty(participant, "stateService");
+            const getLedgerEndAsync = readFunctionProperty(stateService, "getLedgerEndAsync");
+            if (getLedgerEndAsync === undefined) {
+                throw new TestingConfigurationError(`Canton test participant '${participantName}' has no stateService.getLedgerEndAsync method.`);
+            }
+            const response = await getLedgerEndAsync.call(stateService);
+            const offset = readStringProperty(response, "offset");
+            if (offset === undefined) {
+                throw new TestingConfigurationError(`Canton test participant '${participantName}' returned no ledger end offset.`);
+            }
+            return offset;
+        },
+        resolveRoute,
+        async submitAndWaitAsync(actorName, request) {
+            const route = resolveRoute(actorName);
+            const participant = participants[route.participant];
+            const commandService = readObjectProperty(participant, "commandService");
+            const submitAndWaitAsync = readFunctionProperty(commandService, "submitAndWaitAsync");
+            if (submitAndWaitAsync === undefined) {
+                throw new TestingConfigurationError(`Canton test participant '${route.participant}' has no commandService.submitAndWaitAsync method.`);
+            }
+            try {
+                return classifyCantonCommandOutcome({
+                    response: await submitAndWaitAsync.call(commandService, request),
+                });
+            }
+            catch (error) {
+                return classifyCantonCommandOutcome({ error });
+            }
+        },
+    });
+}
+export function classifyCantonCommandOutcome(input) {
+    if (input.error === undefined) {
+        const transactionId = readStringProperty(input.response, "transactionId");
+        const commandId = readStringProperty(input.response, "commandId");
+        return {
+            kind: "accepted",
+            ...(transactionId === undefined ? {} : { transactionId }),
+            ...(commandId === undefined ? {} : { commandId }),
+        };
+    }
+    const statusCode = readNumberProperty(input.error, "code");
+    const details = readStringProperty(input.error, "details") ?? "Unknown command failure.";
+    if ((statusCode === 9 && details.startsWith("DAML_INTERPRETATION_ERROR("))
+        || (statusCode === 3 && details.startsWith("DAML_AUTHORIZATION_ERROR("))) {
+        return { kind: "protocol-revert", statusCode, details };
+    }
+    else if (statusCode === 14 || statusCode === 13) {
+        return { kind: "transport-error", statusCode, details };
+    }
+    else if (statusCode === 4) {
+        return { kind: "timeout", statusCode, details };
+    }
+    return { kind: "unknown-commit-outcome", statusCode, details };
+}
+/** Converts the runtime's transport-safe outcome into the campaign metric union. */
+export function toCampaignMetricOutcome(outcome) {
+    if (outcome.kind !== "accepted") {
+        return {
+            kind: outcome.kind,
+            reason: outcome.details,
+        };
+    }
+    const updateId = outcome.transactionId ?? outcome.commandId;
+    return updateId === undefined
+        ? {
+            kind: "malformed-response",
+            reason: "Canton command response has no transaction or command ID.",
+        }
+        : { kind: "accepted", updateId };
+}
+export async function pollUntilAsync(init) {
+    const deadline = Date.now() + init.timeoutMs;
+    while (true) {
+        const value = await init.readAsync();
+        if (init.isReady(value)) {
+            return value;
+        }
+        else if (Date.now() >= deadline) {
+            throw new Error("Canton test runtime polling timed out.");
+        }
+        await new Promise((resolveDelay) => {
+            setTimeout(resolveDelay, init.intervalMs);
+        });
+    }
+}
+function readNumberProperty(value, key) {
+    const candidate = value;
+    const property = candidate?.[key];
+    return typeof property === "number" ? property : undefined;
+}
+function readObjectProperty(value, key) {
+    const candidate = value;
+    const property = candidate?.[key];
+    return property !== null && typeof property === "object"
+        ? property
+        : undefined;
+}
+function readFunctionProperty(value, key) {
+    const property = value?.[key];
+    return typeof property === "function"
+        ? property
+        : undefined;
+}
+function readStringProperty(value, key) {
+    const candidate = value;
+    const property = candidate?.[key];
+    return typeof property === "string" ? property : undefined;
+}

package/dist/testing/runtime/declarative-action-executor.d.ts

@@ -0,0 +1,16 @@
+import { DeclarativeAction } from "../daml/daml-action-arbitrary.js";
+import { DeclarativeChoiceAction } from "../daml/daml-choice-action-arbitrary.js";
+import { CantonTestRuntime } from "./canton-test-runtime.js";
+import { CampaignMetricOutcome } from "../campaign/campaign-metrics.js";
+/**
+ * Converts a generated declarative action into SDK command types and submits
+ * it over the actor's configured Canton route. Choice actions deliberately
+ * require an explicit contract resolver: the testing SDK never guesses an
+ * active contract ID from stale local state.
+ */
+export declare function executeDeclarativeActionAsync(init: {
+    readonly action: DeclarativeAction;
+    readonly applicationId: string;
+    readonly resolveContractIdAsync?: (action: DeclarativeChoiceAction) => Promise<string>;
+    readonly runtime: CantonTestRuntime;
+}): Promise<CampaignMetricOutcome>;

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

@@ -0,0 +1,41 @@
+import { CreateCommand } from "../../core/types/commands/create-command.js";
+import { ExerciseCommand } from "../../core/types/commands/exercise-command.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";
+/**
+ * Converts a generated declarative action into SDK command types and submits
+ * it over the actor's configured Canton route. Choice actions deliberately
+ * require an explicit contract resolver: the testing SDK never guesses an
+ * active contract ID from stale local state.
+ */
+export async function executeDeclarativeActionAsync(init) {
+    const route = init.runtime.resolveRoute(init.action.actor);
+    const command = "choice" in init.action
+        ? await createExerciseCommandAsync(init.action, init.resolveContractIdAsync)
+        : new CreateCommand({
+            templateId: init.action.templateId,
+            payload: { ...init.action.payload },
+        });
+    return toCampaignMetricOutcome(await init.runtime.submitAndWaitAsync(init.action.actor, new SubmitCommandRequest({
+        applicationId: init.applicationId,
+        actAs: route.actAs,
+        readAs: route.readAs,
+        command,
+    })));
+}
+async function createExerciseCommandAsync(action, resolveContractIdAsync) {
+    if (resolveContractIdAsync === undefined) {
+        throw new TestingConfigurationError(`Declarative choice target '${action.targetKey}' requires resolveContractIdAsync.`);
+    }
+    const contractId = await resolveContractIdAsync(action);
+    if (contractId.length === 0) {
+        throw new TestingConfigurationError(`Declarative choice target '${action.targetKey}' resolved an empty contract ID.`);
+    }
+    return new ExerciseCommand({
+        templateId: action.templateId,
+        contractId,
+        choice: action.choice,
+        argument: action.argument,
+    });
+}

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

@@ -0,0 +1,49 @@
+import { DamlTestingCatalog } from "../daml/daml-testing-catalog.js";
+export interface TemplateTarget {
+    readonly allChoices?: true;
+    readonly actors: readonly string[];
+    readonly choices: readonly string[];
+    readonly kind: "template";
+    readonly templateId: string;
+}
+export interface TemplateCreateTarget {
+    readonly actors: readonly string[];
+    readonly kind: "template-create";
+    readonly templateId: string;
+}
+export interface ExcludedChoiceTarget {
+    readonly choice: string;
+    readonly kind: "exclude-choice";
+    readonly templateId: string;
+}
+export interface ExcludedTemplateTarget {
+    readonly kind: "exclude-template";
+    readonly templateId: string;
+}
+export interface TemplateTargetBuilder {
+    allChoices(): TemplateTarget;
+    actors(actors: readonly string[]): TemplateTargetBuilder;
+    choice(choice: string): TemplateTarget;
+    create(): TemplateCreateTarget;
+}
+export interface ResolvedDeclarativeChoiceTarget {
+    readonly actors: readonly string[];
+    readonly choice: string;
+    readonly key: string;
+    readonly templateId: string;
+}
+export interface ResolvedDeclarativeCreateTarget {
+    readonly actors: readonly string[];
+    readonly key: string;
+    readonly kind: "create";
+    readonly templateId: string;
+}
+export type ResolvedDeclarativeTarget = ResolvedDeclarativeChoiceTarget | ResolvedDeclarativeCreateTarget;
+export declare function targetTemplate(templateId: string): TemplateTargetBuilder;
+/** Builds one immutable declarative template-choice target without a builder chain. */
+export declare function targetChoice(templateId: string, 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 resolveDeclarativeTargets(catalog: DamlTestingCatalog, descriptors: readonly (TemplateTarget | TemplateCreateTarget | ExcludedChoiceTarget | ExcludedTemplateTarget)[]): readonly ResolvedDeclarativeTarget[];

package/dist/testing/targets/target.js

@@ -0,0 +1,121 @@
+import { TestingConfigurationError } from "../errors/testing-configuration-error.js";
+export function targetTemplate(templateId) {
+    let actors = [];
+    return Object.freeze({
+        allChoices() {
+            return Object.freeze({
+                kind: "template",
+                templateId,
+                actors,
+                choices: Object.freeze([]),
+                allChoices: true,
+            });
+        },
+        actors(value) {
+            actors = Object.freeze([...value]);
+            return this;
+        },
+        choice(choice) {
+            return Object.freeze({
+                kind: "template",
+                templateId,
+                actors,
+                choices: Object.freeze([choice]),
+            });
+        },
+        create() {
+            return Object.freeze({
+                kind: "template-create",
+                templateId,
+                actors,
+            });
+        },
+    });
+}
+/** Builds one immutable declarative template-choice target without a builder chain. */
+export function targetChoice(templateId, choice, actors) {
+    return Object.freeze({
+        kind: "template",
+        templateId,
+        actors: Object.freeze([...actors]),
+        choices: Object.freeze([choice]),
+    });
+}
+/** Builds one immutable declarative contract-create target without a builder chain. */
+export function targetCreate(templateId, actors) {
+    return Object.freeze({
+        kind: "template-create",
+        templateId,
+        actors: Object.freeze([...actors]),
+    });
+}
+export function excludeChoice(templateId, choice) {
+    return Object.freeze({
+        kind: "exclude-choice",
+        templateId,
+        choice,
+    });
+}
+export function excludeTemplate(templateId) {
+    return Object.freeze({
+        kind: "exclude-template",
+        templateId,
+    });
+}
+export function resolveDeclarativeTargets(catalog, descriptors) {
+    for (const descriptor of descriptors) {
+        if (descriptor.kind === "template") {
+            continue;
+        }
+        const template = catalog.getTemplate(descriptor.templateId);
+        if (template === undefined) {
+            throw new TestingConfigurationError(`Declarative target '${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.`);
+        }
+    }
+    const excludedTemplates = new Set(descriptors
+        .filter((descriptor) => descriptor.kind === "exclude-template")
+        .map((descriptor) => descriptor.templateId));
+    const excluded = new Set(descriptors
+        .filter((descriptor) => descriptor.kind === "exclude-choice")
+        .map((descriptor) => `${descriptor.templateId}:${descriptor.choice}`));
+    return descriptors
+        .filter((descriptor) => descriptor.kind === "template" || descriptor.kind === "template-create")
+        .flatMap((descriptor) => {
+        const template = catalog.getTemplate(descriptor.templateId);
+        if (template === undefined) {
+            throw new TestingConfigurationError(`Declarative target '${descriptor.templateId}' is absent from the DAML catalog.`);
+        }
+        else if (descriptor.kind === "template-create") {
+            return [Object.freeze({
+                    key: `${descriptor.templateId}:create`,
+                    templateId: descriptor.templateId,
+                    actors: descriptor.actors,
+                    kind: "create",
+                })];
+        }
+        else {
+            if (descriptor.allChoices === true && excludedTemplates.has(descriptor.templateId)) {
+                return [];
+            }
+            const choices = (descriptor.allChoices === true
+                ? template.choices.filter((choice) => !excluded.has(`${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.`);
+            }
+            return choices
+                .map((choice) => Object.freeze({
+                key: `${descriptor.templateId}:${choice}`,
+                templateId: descriptor.templateId,
+                choice,
+                actors: descriptor.actors,
+            }));
+        }
+    })
+        .sort((left, right) => left.key.localeCompare(right.key));
+}

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

@@ -20,6 +20,7 @@ import { IPartyManagementServiceClient } from "./generated/canton/com/daml/ledge
 import { IUserManagementServiceClient } from "./generated/canton/com/daml/ledger/api/v2/admin/user_management_service.client.js";
 import { IVersionServiceClient } from "./generated/canton/com/daml/ledger/api/v2/version_service.client.js";
 import { ICommandServiceClient } from "./generated/canton/com/daml/ledger/api/v2/command_service.client.js";
+import { IInteractiveSubmissionServiceClient } from "./generated/canton/com/daml/ledger/api/v2/interactive/interactive_submission_service.client.js";
 import { ICommandCompletionServiceClient } from "./generated/canton/com/daml/ledger/api/v2/command_completion_service.client.js";
 import { IContractServiceClient } from "./generated/canton/com/daml/ledger/api/v2/contract_service.client.js";
 import { IEventQueryServiceClient } from "./generated/canton/com/daml/ledger/api/v2/event_query_service.client.js";
@@ -121,6 +122,8 @@ export interface GrpcOperations {
     getUpdateByHashAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     getUpdatesPageAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     getCompletionsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    prepareSubmissionAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    executeSubmissionAndWaitAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     submitCommandAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
 }
 export interface GrpcOperationDependencies {
@@ -150,6 +153,7 @@ export interface GrpcOperationDependencies {
     stateServiceClient?: Pick<IStateServiceClient, "getActiveContractsPage" | "getConnectedSynchronizers" | "getLedgerEnd" | "getLatestPrunedOffsets">;
     updateServiceClient?: Pick<IUpdateServiceClient, "getUpdates" | "getUpdateByOffset" | "getUpdateById" | "getUpdateByHash" | "getUpdatesPage">;
     commandCompletionServiceClient?: Pick<ICommandCompletionServiceClient, "getCompletions">;
+    interactiveSubmissionServiceClient?: Pick<IInteractiveSubmissionServiceClient, "prepareSubmission" | "executeSubmissionAndWait">;
     commandServiceClient?: Pick<ICommandServiceClient, "submitAndWait">;
 }
 export declare function createGrpcOperations(options: CantonClientOptions, endpoint: string, grpcChannelSecurity: GrpcChannelSecurity, dependencies?: GrpcOperationDependencies): GrpcOperations;

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

@@ -1,4 +1,5 @@
 import { GrpcTransport as ProtobufGrpcTransport } from "@protobuf-ts/grpc-transport";
+import { GrpcTransportError } from "../../core/errors/grpc-transport-error.js";
 import { PackageServiceClient as ParticipantPackageServiceClient, } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/package_service.client.js";
 import { PartyManagementServiceClient as ParticipantPartyManagementServiceClient, } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/party_management_service.client.js";
 import { ParticipantInspectionServiceClient, } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/participant_inspection_service.client.js";
@@ -20,6 +21,7 @@ import { PartyManagementServiceClient, } from "./generated/canton/com/daml/ledge
 import { UserManagementServiceClient, } from "./generated/canton/com/daml/ledger/api/v2/admin/user_management_service.client.js";
 import { VersionServiceClient, } from "./generated/canton/com/daml/ledger/api/v2/version_service.client.js";
 import { CommandServiceClient, } from "./generated/canton/com/daml/ledger/api/v2/command_service.client.js";
+import { InteractiveSubmissionServiceClient, } from "./generated/canton/com/daml/ledger/api/v2/interactive/interactive_submission_service.client.js";
 import { CommandCompletionServiceClient, } from "./generated/canton/com/daml/ledger/api/v2/command_completion_service.client.js";
 import { ContractServiceClient, } from "./generated/canton/com/daml/ledger/api/v2/contract_service.client.js";
 import { EventQueryServiceClient, } from "./generated/canton/com/daml/ledger/api/v2/event_query_service.client.js";
@@ -85,9 +87,11 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
     const updateServiceClient = dependencies.updateServiceClient ?? new UpdateServiceClient(rpcTransport);
     const commandCompletionServiceClient = dependencies.commandCompletionServiceClient
         ?? new CommandCompletionServiceClient(rpcTransport);
+    const interactiveSubmissionServiceClient = dependencies.interactiveSubmissionServiceClient
+        ?? new InteractiveSubmissionServiceClient(rpcTransport);
     const commandServiceClient = dependencies.commandServiceClient
         ?? new CommandServiceClient(rpcTransport);
-    return {
+    const operations = {
         async disposeAsync() {
             rpcTransport.close();
         },
@@ -459,7 +463,16 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
             const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(commandServiceClient.submitAndWait(request, callOptions));
         },
+        async prepareSubmissionAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(interactiveSubmissionServiceClient.prepareSubmission(request, callOptions));
+        },
+        async executeSubmissionAndWaitAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(interactiveSubmissionServiceClient.executeSubmissionAndWait(request, callOptions));
+        },
     };
+    return wrapGrpcOperations(operations, options.onGrpcError);
 }
 async function buildCallOptionsForLedgerSurfaceAsync(options, requestOptions) {
     return buildGrpcCallOptionsAsync(options.ledgerAuthProvider, options.defaultRequestTimeoutMs, requestOptions);
@@ -476,6 +489,34 @@ function normalizeGrpcHost(endpoint) {
     }
     return endpoint;
 }
+function wrapGrpcOperations(operations, onGrpcError) {
+    return new Proxy(operations, {
+        get(target, property, receiver) {
+            const operation = Reflect.get(target, property, receiver);
+            if (typeof operation !== "function") {
+                return operation;
+            }
+            return async (...args) => {
+                try {
+                    return await operation.apply(target, args);
+                }
+                catch (error) {
+                    const parsedError = GrpcTransportError.fromUnknown(error);
+                    if (parsedError === undefined) {
+                        throw error;
+                    }
+                    try {
+                        onGrpcError?.(parsedError);
+                    }
+                    catch {
+                        // Error observers must not replace the RPC failure.
+                    }
+                    throw parsedError;
+                }
+            };
+        },
+    });
+}
 async function unwrapUnaryResponse(call) {
     return await call.response;
 }

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

@@ -84,7 +84,7 @@ import { TopologyListPartiesRequest } from "../../core/types/requests/topology-l
 import { TopologyListVettedPackagesRequest } from "../../core/types/requests/topology-list-vetted-packages-request.js";
 import { TrafficControlStateRequest } from "../../core/types/requests/traffic-control-state-request.js";
 import { UploadDarFileRequest } from "../../core/types/requests/upload-dar-file-request.js";
-import { SignCommandResult } from "../../core/signing/sign-command-result.js";
+import { ICommandSigner } from "../../core/signing/command-signer.interface.js";
 import { AllocatePartyResponse as SdkAllocatePartyResponse } from "../../core/types/responses/allocate-party-response.js";
 import { AllocateExternalPartyResponse } from "../../core/types/responses/allocate-external-party-response.js";
 import { AddPartyAsyncResponse } from "../../core/types/responses/add-party-async-response.js";
@@ -275,7 +275,7 @@ export declare class GrpcTransport implements ITransport {
     getUpdateByHashAsync(request: GetUpdateByHashRequest, options?: RequestOptions): Promise<GetUpdateByHashResponse>;
     getUpdatesPageAsync(request: GetUpdatesPageRequest, options?: RequestOptions): Promise<GetUpdatesPageResponse>;
     getCompletionsAsync(request: GetCompletionsRequest, observer: CompletionObserver, options?: RequestOptions): Promise<void>;
-    submitCommandAsync(request: SubmitCommandRequest, signed?: SignCommandResult, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitCommandAsync(request: SubmitCommandRequest, signer?: ICommandSigner, options?: RequestOptions): Promise<SubmitCommandResponse>;
     private throwIfDisposed;
     private throwPartyTopologyReadCompatibilityError;
     private isProtobufDeserializationFailure;

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

@@ -1,3 +1,6 @@
+import { randomUUID } from "node:crypto";
+import { ValidationError } from "../../core/errors/validation-error.js";
+import { SignCommandRequest } from "../../core/signing/sign-command-request.js";
 import { AllocatePartyResponse as SdkAllocatePartyResponse } from "../../core/types/responses/allocate-party-response.js";
 import { GetActiveContractsPageResponse } from "../../core/types/responses/get-active-contracts-page-response.js";
 import { GetLedgerApiVersionResponse as SdkGetLedgerApiVersionResponse } from "../../core/types/responses/get-ledger-api-version-response.js";
@@ -8,6 +11,7 @@ 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 { 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";
 import { mapGrpcGetCommandStatus, mapGrpcGetCommandStatusRequest, } from "./mappers/command-inspection-mapper.js";
@@ -496,6 +500,8 @@ export class GrpcTransport {
         this.throwIfDisposed();
         const payload = await this.operations.queryContractsAsync(mapGrpcQueryContractsRequest({
             party: request.party,
+            parties: request.parties,
+            allParties: request.allParties,
             templateId: request.templateId,
             interfaceId: request.interfaceId,
             includeInterfaceView: request.includeInterfaceView,
@@ -571,10 +577,43 @@ export class GrpcTransport {
             await observer.nextAsync(mapGrpcCompletionStreamResponse(response));
         }
     }
-    async submitCommandAsync(request, signed, options) {
+    async submitCommandAsync(request, signer, options) {
         this.throwIfDisposed();
-        const payload = await this.operations.submitCommandAsync(mapGrpcSubmitCommandRequest(request, signed), options);
-        return mapGrpcSubmitCommand(payload);
+        if (!signer) {
+            const payload = await this.operations.submitCommandAsync(mapGrpcSubmitCommandRequest(request), options);
+            return mapGrpcSubmitCommand(payload);
+        }
+        else if (request.actAs.length !== 1) {
+            throw new ValidationError("interactive gRPC command signing currently requires exactly one actAs party");
+        }
+        else if (!this.operations.prepareSubmissionAsync) {
+            throw new NotSupportedError("interactive gRPC command signing is not available on this transport");
+        }
+        else if (!this.operations.executeSubmissionAndWaitAsync) {
+            throw new NotSupportedError("interactive gRPC command signing is not available on this transport");
+        }
+        const commandId = randomUUID();
+        const submissionId = randomUUID();
+        const prepared = await this.operations.prepareSubmissionAsync(mapGrpcPrepareSubmissionRequest(request, commandId), options);
+        if (!prepared.preparedTransaction) {
+            throw new ValidationError("interactive prepare submission did not return a preparedTransaction");
+        }
+        else if (prepared.preparedTransactionHash.length === 0) {
+            throw new ValidationError("interactive prepare submission did not return a preparedTransactionHash");
+        }
+        const signerResult = await signer.signAsync(new SignCommandRequest({
+            payload: prepared.preparedTransactionHash,
+            party: request.actAs[0],
+            algorithmHint: "ed25519",
+        }));
+        const executed = await this.operations.executeSubmissionAndWaitAsync(mapGrpcExecuteSubmissionAndWaitRequest({
+            request,
+            preparedTransaction: prepared.preparedTransaction,
+            hashingSchemeVersion: prepared.hashingSchemeVersion,
+            submissionId,
+            signerResult,
+        }), options);
+        return mapGrpcInteractiveSubmitCommand(executed);
     }
     throwIfDisposed() {
         if (this.disposed) {

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

@@ -1,10 +1,18 @@
-import { SignCommandResult } from "../../../core/signing/sign-command-result.js";
+import { CreateCommand } from "../../../core/types/commands/create-command.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 { 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";
-export declare function mapGrpcSubmitCommandRequest(request: SubmitCommandRequest, _signed?: SignCommandResult): SubmitAndWaitRequest;
+import { Identifier, Record as GrpcRecord, Value } from "../generated/canton/com/daml/ledger/api/v2/value.js";
+export declare function mapGrpcSubmitCommandRequest(request: SubmitCommandRequest): SubmitAndWaitRequest;
 export declare function mapGrpcSubmitCommand(payload: {
     commandId?: string;
     transactionId?: string;
     updateId?: string;
 } | 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 mapValue(value: unknown): Value;
+export declare function parseTemplateIdentifier(templateId: string): Identifier;