@distrohelena/canton-typescript-sdk 0.1.5 → 0.1.7

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.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";
@@ -90,7 +91,7 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
         ?? new InteractiveSubmissionServiceClient(rpcTransport);
     const commandServiceClient = dependencies.commandServiceClient
         ?? new CommandServiceClient(rpcTransport);
-    return {
+    const operations = {
         async disposeAsync() {
             rpcTransport.close();
         },
@@ -471,6 +472,7 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
             return await unwrapUnaryResponse(interactiveSubmissionServiceClient.executeSubmissionAndWait(request, callOptions));
         },
     };
+    return wrapGrpcOperations(operations, options.onGrpcError);
 }
 async function buildCallOptionsForLedgerSurfaceAsync(options, requestOptions) {
     return buildGrpcCallOptionsAsync(options.ledgerAuthProvider, options.defaultRequestTimeoutMs, requestOptions);
@@ -487,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 { ICommandSigner } from "../../core/signing/command-signer.interface.js";
+import { CommandSigners, 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, signer?: ICommandSigner, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitCommandAsync(request: SubmitCommandRequest, signer?: ICommandSigner | CommandSigners, options?: RequestOptions): Promise<SubmitCommandResponse>;
     private throwIfDisposed;
     private throwPartyTopologyReadCompatibilityError;
     private isProtobufDeserializationFailure;

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

@@ -500,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,
@@ -581,13 +583,13 @@ export class GrpcTransport {
             const payload = await this.operations.submitCommandAsync(mapGrpcSubmitCommandRequest(request), options);
             return mapGrpcSubmitCommand(payload);
         }
-        if (request.actAs.length !== 1) {
+        else if (request.actAs.length !== 1 && !("signAsync" in signer)) {
             throw new ValidationError("interactive gRPC command signing currently requires exactly one actAs party");
         }
-        if (!this.operations.prepareSubmissionAsync) {
+        else if (!this.operations.prepareSubmissionAsync) {
             throw new NotSupportedError("interactive gRPC command signing is not available on this transport");
         }
-        if (!this.operations.executeSubmissionAndWaitAsync) {
+        else if (!this.operations.executeSubmissionAndWaitAsync) {
             throw new NotSupportedError("interactive gRPC command signing is not available on this transport");
         }
         const commandId = randomUUID();
@@ -599,17 +601,18 @@ export class GrpcTransport {
         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 signerResults = await Promise.all(request.actAs.map(async (party) => {
+            const partySigner = "signAsync" in signer ? signer : signer[party];
+            if (partySigner === undefined)
+                throw new ValidationError(`interactive command signing requires a signer for ${party}`);
+            return { party, result: await partySigner.signAsync(new SignCommandRequest({ payload: prepared.preparedTransactionHash, party, algorithmHint: "ed25519" })) };
         }));
         const executed = await this.operations.executeSubmissionAndWaitAsync(mapGrpcExecuteSubmissionAndWaitRequest({
             request,
             preparedTransaction: prepared.preparedTransaction,
             hashingSchemeVersion: prepared.hashingSchemeVersion,
             submissionId,
-            signerResult,
+            signerResults,
         }), options);
         return mapGrpcInteractiveSubmitCommand(executed);
     }

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

@@ -2,6 +2,8 @@ import { randomUUID } from "node:crypto";
 import { ValidationError } from "../../../core/errors/validation-error.js";
 import { CreateAndExerciseCommand } from "../../../core/types/commands/create-and-exercise-command.js";
 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 { 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";
@@ -18,13 +20,16 @@ export function mapGrpcSubmitCommandRequest(request) {
             actAs: [...request.actAs],
             readAs: [...request.readAs],
             submissionId: "",
-            disclosedContracts: [],
-            synchronizerId: "",
+            disclosedContracts: request.disclosedContracts.map(mapGrpcDisclosedContract),
+            synchronizerId: request.synchronizerId ?? "",
             packageIdSelectionPreference: [],
             prefetchContractKeys: [],
         },
     };
 }
+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 } };
+}
 export function mapGrpcSubmitCommand(payload) {
     return new SubmitCommandResponse({
         commandId: "commandId" in payload ? payload.commandId : undefined,
@@ -106,6 +111,22 @@ export function mapValue(value) {
             },
         };
     }
+    else if (value instanceof DamlParty) {
+        return {
+            sum: {
+                oneofKind: "party",
+                party: value.value,
+            },
+        };
+    }
+    else if (value instanceof DamlNumeric) {
+        return {
+            sum: {
+                oneofKind: "numeric",
+                numeric: value.value,
+            },
+        };
+    }
     else if (typeof value === "string") {
         return {
             sum: {

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

@@ -5,7 +5,9 @@ import { GetContractRequest as GrpcGetContractRequest } from "../generated/canto
 import { GetContractResponse as GrpcGetContractResponse } from "../generated/canton/com/daml/ledger/api/v2/contract_service.js";
 import { GetActiveContractsPageRequest } from "../generated/canton/com/daml/ledger/api/v2/state_service.js";
 export declare function mapGrpcQueryContractsRequest(request: {
-    party: string;
+    party?: string;
+    parties?: readonly string[];
+    allParties?: boolean;
     templateId?: string;
     interfaceId?: string;
     includeInterfaceView?: boolean;

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

@@ -30,10 +30,23 @@ export function mapGrpcGetContract(payload) {
     });
 }
 function createEventFormat(request) {
+    const filters = createFilters(request);
+    const parties = request.parties ?? (request.party === undefined ? [] : [request.party]);
+    if (request.allParties === true) {
+        if (parties.length > 0) {
+            throw new ValidationError("allParties cannot be combined with party filters");
+        }
+        return {
+            filtersByParty: {},
+            filtersForAnyParty: filters,
+            verbose: true,
+        };
+    }
+    else if (parties.length === 0) {
+        throw new ValidationError("A party filter or allParties is required");
+    }
     return {
-        filtersByParty: {
-            [request.party]: createFilters(request),
-        },
+        filtersByParty: Object.fromEntries(parties.map((party) => [party, filters])),
         verbose: true,
     };
 }

package/dist/transports/grpc/mappers/interactive-command-mapper.d.ts

@@ -9,7 +9,10 @@ export declare function mapGrpcExecuteSubmissionAndWaitRequest(init: {
     preparedTransaction: PreparedTransaction;
     hashingSchemeVersion: HashingSchemeVersion;
     submissionId: string;
-    signerResult: SignCommandResult;
+    signerResults: readonly {
+        readonly party: string;
+        readonly result: SignCommandResult;
+    }[];
 }): ExecuteSubmissionAndWaitRequest;
 export declare function mapGrpcInteractiveSubmitCommand(payload: ExecuteSubmissionAndWaitResponse): SubmitCommandResponse;
 export declare function mapGrpcSignature(result: SignCommandResult): Signature;

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

@@ -9,8 +9,8 @@ export function mapGrpcPrepareSubmissionRequest(request, commandId) {
         commands: [mapGrpcLedgerCommand(request.command)],
         actAs: [...request.actAs],
         readAs: [...request.readAs],
-        disclosedContracts: [],
-        synchronizerId: "",
+        disclosedContracts: request.disclosedContracts.map(value => ({ 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 } })),
+        synchronizerId: request.synchronizerId ?? "",
         packageIdSelectionPreference: [],
         prefetchContractKeys: [],
         verboseHashing: false,
@@ -20,12 +20,7 @@ export function mapGrpcExecuteSubmissionAndWaitRequest(init) {
     return {
         preparedTransaction: init.preparedTransaction,
         partySignatures: {
-            signatures: [
-                {
-                    party: init.request.actAs[0] ?? "",
-                    signatures: [mapGrpcSignature(init.signerResult)],
-                },
-            ],
+            signatures: init.signerResults.map(({ party, result }) => ({ party, signatures: [mapGrpcSignature(result)] })),
         },
         deduplicationPeriod: {
             oneofKind: undefined,