@distrohelena/canton-typescript-sdk 0.1.35 → 0.1.37

package/dist/query/pqs/pqs-sql-syntax.d.ts

@@ -0,0 +1,2 @@
+export declare function quotePqsIdentifier(value: string): string;
+export declare function quotePqsString(value: string): string;

package/dist/query/pqs/pqs-sql-syntax.js

@@ -0,0 +1,6 @@
+export function quotePqsIdentifier(value) {
+    return `"${value.replaceAll('"', '""')}"`;
+}
+export function quotePqsString(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}

package/dist/query/query-client.d.ts

@@ -8,6 +8,19 @@ export interface FindManyArgs<TWhere, TSelect, TOrderBy, TInclude = never> {
     readonly take?: number;
     readonly include?: TInclude;
 }
+export interface ContractCacheArgs {
+    readonly parties?: readonly string[];
+}
+export type ContractCacheResult = {
+    readonly source: QuerySource.grpc;
+    readonly cached: true;
+    readonly activeAtOffset: string;
+    readonly contractCount: number;
+    readonly expiresAt: Date;
+} | {
+    readonly source: QuerySource.pqs;
+    readonly cached: false;
+};
 export interface QueryDelegate<TRow, TWhere, TSelect, TOrderBy, TUnique, TInclude = never, TGroupBy = never, TGroupRow = never> {
     findMany<TArgs extends FindManyArgs<TWhere, TSelect, TOrderBy, TInclude>>(args?: TArgs): Promise<readonly (TRow & JsonProjectionResult<TArgs>)[]>;
     findUnique<TArgs extends {
@@ -36,6 +49,8 @@ export type QueryCollectionDelegate<TRow, TWhere, TSelect, TOrderBy, TInclude =
 export interface QueryClient {
     readonly source: QuerySource;
     $queryRaw<TRow>(sql: string, values?: readonly unknown[]): Promise<readonly TRow[]>;
+    cacheContracts(args?: ContractCacheArgs): Promise<ContractCacheResult>;
+    invalidateContractsCache(args?: ContractCacheArgs): Promise<void>;
     readonly contracts: {
         findMany<TArgs extends ContractFindManyArgs>(args?: TArgs): Promise<readonly (ContractResult & JsonProjectionResult<TArgs>)[]>;
         findUnique<TArgs extends ContractFindUniqueArgs>(args: TArgs): Promise<(ContractResult & JsonProjectionResult<TArgs>) | undefined>;

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

@@ -1,7 +1,7 @@
 import { CommandSigners, ICommandSigner } from "../../core/signing/command-signer.interface.js";
 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 { SubmitCommandsRequest } from "../../core/types/requests/submit-commands-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";
@@ -9,9 +9,14 @@ 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>;
+    submitAndWaitForTransactionAsync(request: SubmitCommandsRequest, 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>;
+    submitAndWaitAsync(request: SubmitCommandsRequest, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    /**
+     * Submits through the connected participant without external command signing.
+     * A configured command signer is deliberately ignored for this call.
+     */
+    submitParticipantLocalAndWaitAsync(request: SubmitCommandsRequest, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    prepareAsync(request: SubmitCommandsRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;
     executeAndWaitAsync(prepared: PreparedCommandSubmission, signatures: Readonly<Record<string, SignCommandResult>>, options?: RequestOptions): Promise<SubmitCommandResponse>;
 }

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

@@ -7,11 +7,24 @@ export class CommandServiceClient {
             signer,
         });
     }
-    submitAndWaitForTransactionAsync(request, options) { return this.pipeline.submitForTransactionAsync(request, options); }
+    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);
     }
-    prepareAsync(request, options) { return this.pipeline.prepareAsync(request, options); }
-    executeAndWaitAsync(prepared, signatures, options) { return this.pipeline.executeAsync(prepared, signatures, options); }
+    /**
+     * Submits through the connected participant without external command signing.
+     * A configured command signer is deliberately ignored for this call.
+     */
+    submitParticipantLocalAndWaitAsync(request, options) {
+        return this.pipeline.submitParticipantLocalAsync(request, options);
+    }
+    prepareAsync(request, options) {
+        return this.pipeline.prepareAsync(request, options);
+    }
+    executeAndWaitAsync(prepared, signatures, options) {
+        return this.pipeline.executeAsync(prepared, signatures, options);
+    }
 }

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

@@ -1,9 +1,9 @@
 import { ITransport } from "../../core/transports/transport.interface.js";
-import { SubmitCommandRequest } from "../../core/types/requests/submit-command-request.js";
+import { SubmitCommandsRequest } from "../../core/types/requests/submit-commands-request.js";
 import { SubmitCommandResponse } from "../../core/types/responses/submit-command-response.js";
 export declare class CommandSubmissionServiceClient {
     private readonly transport;
     constructor(transport: ITransport);
     /** Submits a command without waiting. Placeholder until explicitly implemented. */
-    submitAsync(_request: SubmitCommandRequest): Promise<SubmitCommandResponse>;
+    submitAsync(_request: SubmitCommandsRequest): Promise<SubmitCommandResponse>;
 }

package/dist/services/commands/command-payload-builder.d.ts

@@ -1,2 +1,2 @@
-import { SubmitCommandRequest } from "../../core/types/requests/submit-command-request.js";
-export declare function buildCanonicalCommandPayload(request: SubmitCommandRequest): Uint8Array;
+import { SubmitCommandsRequest } from "../../core/types/requests/submit-commands-request.js";
+export declare function buildCanonicalCommandPayload(request: SubmitCommandsRequest): Uint8Array;

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

@@ -7,7 +7,7 @@ export function buildCanonicalCommandPayload(request) {
         applicationId: request.applicationId,
         actAs: request.actAs,
         readAs: request.readAs,
-        command: mapCanonicalCommand(request.command),
+        commands: request.commands.map(mapCanonicalCommand),
     }));
 }
 function mapCanonicalCommand(command) {

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

@@ -1,7 +1,7 @@
 import { CommandSigners, ICommandSigner } from "../../core/signing/command-signer.interface.js";
 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 { SubmitCommandsRequest } from "../../core/types/requests/submit-commands-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";
@@ -12,8 +12,9 @@ export declare class CommandSubmissionPipeline {
         transport: ITransport;
         signer?: ICommandSigner | CommandSigners;
     });
-    submitAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<SubmitCommandResponse>;
-    submitForTransactionAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<SubmitCommandTransactionResponse>;
-    prepareAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;
+    submitAsync(request: SubmitCommandsRequest, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitParticipantLocalAsync(request: SubmitCommandsRequest, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitForTransactionAsync(request: SubmitCommandsRequest, options?: RequestOptions): Promise<SubmitCommandTransactionResponse>;
+    prepareAsync(request: SubmitCommandsRequest, 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,10 +12,25 @@ 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)
-        throw new NotSupportedError("interactive command execution is not supported by the selected transport"); return this.dependencies.transport.executePreparedCommandAndWaitAsync(prepared, signatures, options); }
+    submitParticipantLocalAsync(request, options) {
+        return this.dependencies.transport.submitCommandAsync(request, undefined, 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) {
+            throw new NotSupportedError("interactive command execution is not supported by the selected transport");
+        }
+        return this.dependencies.transport.executePreparedCommandAndWaitAsync(prepared, signatures, options);
+    }
 }

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

@@ -1,4 +1,5 @@
 import { ITransport } from "../../core/transports/transport.interface.js";
+import { ActiveContractsTraversalOptions } from "../../core/types/active-contracts-traversal-options.js";
 import { RequestOptions } from "../../core/types/request-options.js";
 import { GetActiveContractsRequest } from "../../core/types/requests/get-active-contracts-request.js";
 import type { GetActiveContractsPageRequest, GetActiveContractsPageResponse, GetConnectedSynchronizersRequest, GetConnectedSynchronizersResponse, GetLedgerEndRequest, GetLedgerEndResponse, GetLatestPrunedOffsetsRequest, GetLatestPrunedOffsetsResponse } from "../../transports/grpc/generated/canton/com/daml/ledger/api/v2/state_service.js";
@@ -8,6 +9,8 @@ export declare class StateServiceClient {
     constructor(transport: ITransport);
     /** Reads a page of active contracts. Supported on gRPC; JSON rejects it. */
     getActiveContractsPageAsync(request: GetActiveContractsPageRequest, options?: RequestOptions): Promise<GetActiveContractsPageResponse>;
+    /** Reads active-contract pages lazily. Supported on gRPC; JSON rejects it. */
+    getActiveContractsPagesAsync(request: GetActiveContractsPageRequest, options: ActiveContractsTraversalOptions): AsyncIterable<GetActiveContractsPageResponse>;
     /** Reads active contracts as a stream. JSON-backed; gRPC currently rejects it. */
     getActiveContractsAsync(request: GetActiveContractsRequest, observer: ContractObserver, options?: RequestOptions): Promise<void>;
     /** Reads connected synchronizers. Supported on gRPC; JSON rejects it. */
@@ -16,4 +19,5 @@ export declare class StateServiceClient {
     getLedgerEndAsync(request: GetLedgerEndRequest, options?: RequestOptions): Promise<GetLedgerEndResponse>;
     /** Reads the latest participant pruning offsets. Supported on gRPC; JSON rejects it. */
     getLatestPrunedOffsetsAsync(request: GetLatestPrunedOffsetsRequest, options?: RequestOptions): Promise<GetLatestPrunedOffsetsResponse>;
+    private getActiveContractsPagesLazy;
 }

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

@@ -1,3 +1,5 @@
+import { ActiveContractsTraversalError } from "../../core/errors/active-contracts-traversal-error.js";
+import { ValidationError } from "../../core/errors/validation-error.js";
 export class StateServiceClient {
     transport;
     constructor(transport) {
@@ -8,6 +10,10 @@ export class StateServiceClient {
     getActiveContractsPageAsync(request, options) {
         return this.transport.getActiveContractsPageAsync(request, options);
     }
+    /** Reads active-contract pages lazily. Supported on gRPC; JSON rejects it. */
+    getActiveContractsPagesAsync(request, options) {
+        return this.getActiveContractsPagesLazy(request, options);
+    }
     /** Reads active contracts as a stream. JSON-backed; gRPC currently rejects it. */
     getActiveContractsAsync(request, observer, options) {
         return this.transport.getActiveContractsAsync(request, observer, options);
@@ -24,4 +30,54 @@ export class StateServiceClient {
     getLatestPrunedOffsetsAsync(request, options) {
         return this.transport.getLatestPrunedOffsetsAsync(request, options);
     }
+    async *getActiveContractsPagesLazy(request, options) {
+        if (request.pageToken && request.pageToken.length > 0) {
+            throw new ValidationError("active contracts traversal must not start with a page token");
+        }
+        let pageRequest = request;
+        let pagesRead = 0;
+        let contractsRead = 0;
+        let activeAtOffset;
+        const observedPageTokens = new Set();
+        while (true) {
+            if (pagesRead >= options.maxPages) {
+                throw new ActiveContractsTraversalError("max-pages-exceeded", "active contracts traversal exceeded maxPages");
+            }
+            const response = await this.transport.getActiveContractsPageAsync(pageRequest, options.deadline.createRequestOptions());
+            pagesRead += 1;
+            if (typeof response.activeAtOffset !== "string" ||
+                response.activeAtOffset.trim().length === 0) {
+                throw new ActiveContractsTraversalError("missing-active-at-offset", "active contracts response is missing activeAtOffset");
+            }
+            else if (activeAtOffset === undefined) {
+                if (request.activeAtOffset !== undefined &&
+                    request.activeAtOffset !== response.activeAtOffset) {
+                    throw new ActiveContractsTraversalError("active-at-offset-mismatch", "active contracts response activeAtOffset does not match the request");
+                }
+                activeAtOffset = response.activeAtOffset;
+            }
+            else if (activeAtOffset !== response.activeAtOffset) {
+                throw new ActiveContractsTraversalError("active-at-offset-mismatch", "active contracts response activeAtOffset changed during traversal");
+            }
+            contractsRead += response.activeContracts.length;
+            if (contractsRead > options.maxContracts) {
+                throw new ActiveContractsTraversalError("max-contracts-exceeded", "active contracts traversal exceeded maxContracts");
+            }
+            yield response;
+            if (!response.nextPageToken || response.nextPageToken.length === 0) {
+                return;
+            }
+            const pageTokenKey = Array.from(response.nextPageToken).join(",");
+            if (observedPageTokens.has(pageTokenKey)) {
+                throw new ActiveContractsTraversalError("repeated-page-token", "active contracts traversal received a repeated page token");
+            }
+            observedPageTokens.add(pageTokenKey);
+            pageRequest = {
+                activeAtOffset,
+                eventFormat: request.eventFormat,
+                maxPageSize: request.maxPageSize,
+                pageToken: response.nextPageToken,
+            };
+        }
+    }
 }

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

@@ -1,7 +1,7 @@
 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 { SubmitCommandsRequest } from "../../core/types/requests/submit-commands-request.js";
 import { TestingConfigurationError } from "../errors/testing-configuration-error.js";
 import { toCampaignMetricOutcome, } from "./canton-test-runtime.js";
 /**
@@ -18,11 +18,11 @@ export async function executeDeclarativeActionAsync(init) {
             templateId: init.action.templateId,
             createArguments: new DamlRecord({ ...init.action.payload }),
         });
-    return toCampaignMetricOutcome(await init.runtime.submitAndWaitAsync(init.action.actor, new SubmitCommandRequest({
+    return toCampaignMetricOutcome(await init.runtime.submitAndWaitAsync(init.action.actor, new SubmitCommandsRequest({
         applicationId: init.applicationId,
         actAs: route.actAs,
         readAs: route.readAs,
-        command,
+        commands: [command],
     })));
 }
 async function createExerciseCommandAsync(action, resolveContractIdAsync) {

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

@@ -6,7 +6,7 @@ import { ListKnownPartiesRequest } from "../../core/types/requests/list-known-pa
 import { ListPartyToParticipantRequest } from "../../core/types/requests/list-party-to-participant-request.js";
 import { ListUserRightsRequest } from "../../core/types/requests/list-user-rights-request.js";
 import { ListUsersRequest } from "../../core/types/requests/list-users-request.js";
-import { SubmitCommandRequest } from "../../core/types/requests/submit-command-request.js";
+import { SubmitCommandsRequest } from "../../core/types/requests/submit-commands-request.js";
 import { CommandSigners, ICommandSigner } from "../../core/signing/command-signer.interface.js";
 import { SignCommandResult } from "../../core/signing/sign-command-result.js";
 import { PreparedCommandSubmission } from "../../core/types/prepared-command-submission.js";
@@ -151,9 +151,9 @@ export declare class GrpcTransport implements ITransport {
     getUpdateByHashAsync(request: GetUpdateByHashRequest, options?: RequestOptions): Promise<ProtobufGetUpdateResponse>;
     getUpdatesPageAsync(request: GetUpdatesPageRequest, options?: RequestOptions): Promise<ProtobufGetUpdatesPageResponse>;
     getCompletionsAsync(request: GetCompletionsRequest, options?: RequestOptions): AsyncIterable<ProtobufCompletionStreamResponse>;
-    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>;
+    submitCommandAsync(request: SubmitCommandsRequest, signer?: ICommandSigner | CommandSigners, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitCommandForTransactionAsync(request: SubmitCommandsRequest, options?: RequestOptions): Promise<import("../../core/types/responses/submit-command-transaction-response.js").SubmitCommandTransactionResponse>;
+    prepareCommandAsync(request: SubmitCommandsRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;
     executePreparedCommandAndWaitAsync(prepared: PreparedCommandSubmission, signatures: Readonly<Record<string, SignCommandResult>>, options?: RequestOptions): Promise<SubmitCommandResponse>;
     private throwIfDisposed;
     private throwPartyTopologyReadCompatibilityError;

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

@@ -7,7 +7,7 @@ import { ListKnownPartiesResponse as SdkListKnownPartiesResponse } from "../../c
 import { NotSupportedError } from "../../core/errors/not-supported-error.js";
 import { TransportError } from "../../core/errors/transport-error.js";
 import { createGrpcOperations, } from "./grpc-channel-factory.js";
-import { mapGrpcSubmitCommand, mapGrpcSubmitCommandForTransactionRequest, mapGrpcSubmitCommandTransaction, mapGrpcSubmitCommandRequest, } from "./mappers/commands-mapper.js";
+import { mapGrpcSubmitCommand, mapGrpcSubmitCommandsForTransactionRequest, mapGrpcSubmitCommandTransaction, mapGrpcSubmitCommandsRequest, } from "./mappers/commands-mapper.js";
 import { mapGrpcExecuteSubmissionAndWaitRequest, mapGrpcInteractiveSubmitCommand, mapGrpcPrepareSubmissionRequest, } from "./mappers/interactive-command-mapper.js";
 import { mapGrpcCreateParty, mapGrpcCreatePartyRequest, mapGrpcListParties, mapGrpcListPartiesRequest } from "./mappers/parties-mapper.js";
 import { mapGrpcListPartyToParticipantRequest, mapGrpcListPartyToParticipantResponse, } from "./mappers/topology-manager-read-mapper.js";
@@ -487,7 +487,7 @@ export class GrpcTransport {
     async submitCommandAsync(request, signer, options) {
         this.throwIfDisposed();
         if (!signer) {
-            const payload = await this.operations.submitCommandAsync(mapGrpcSubmitCommandRequest(request), options);
+            const payload = await this.operations.submitCommandAsync(mapGrpcSubmitCommandsRequest(request), options);
             return mapGrpcSubmitCommand(payload);
         }
         else if (request.actAs.length !== 1 && !("signAsync" in signer)) {
@@ -529,7 +529,7 @@ export class GrpcTransport {
         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));
+        return mapGrpcSubmitCommandTransaction(await this.operations.submitCommandForTransactionAsync(mapGrpcSubmitCommandsForTransactionRequest(request), options));
     }
     async prepareCommandAsync(request, options) {
         if (!this.operations.prepareSubmissionAsync) {

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

@@ -1,14 +1,14 @@
 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 { SubmitCommandsRequest } from "../../../core/types/requests/submit-commands-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, 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 mapGrpcSubmitCommandsRequest(request: SubmitCommandsRequest): SubmitAndWaitRequest;
+export declare function mapGrpcSubmitCommandsForTransactionRequest(request: SubmitCommandsRequest): SubmitAndWaitForTransactionRequest;
 export declare function mapGrpcSubmitCommandTransaction(payload: SubmitAndWaitForTransactionResponse): SubmitCommandTransactionResponse;
 export declare function mapGrpcSubmitCommand(payload: {
     commandId?: string;

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

@@ -11,13 +11,13 @@ import { ExerciseCommand } from "../../../core/types/commands/exercise-command.j
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
 import { SubmitCommandTransactionResponse } from "../../../core/types/responses/submit-command-transaction-response.js";
 import { mapGrpcDeduplicationPeriod } from "./command-deduplication-mapper.js";
-export function mapGrpcSubmitCommandRequest(request) {
+export function mapGrpcSubmitCommandsRequest(request) {
     return {
         commands: {
             workflowId: "",
             userId: request.userId ?? "",
             commandId: request.commandId ?? randomUUID(),
-            commands: [mapGrpcLedgerCommand(request.command)],
+            commands: request.commands.map(mapGrpcLedgerCommand),
             deduplicationPeriod: mapGrpcDeduplicationPeriod(request.deduplicationPeriod, { allowParticipantBegin: true }),
             actAs: [...request.actAs],
             readAs: [...request.readAs],
@@ -29,8 +29,8 @@ export function mapGrpcSubmitCommandRequest(request) {
         },
     };
 }
-export function mapGrpcSubmitCommandForTransactionRequest(request) {
-    return { commands: mapGrpcSubmitCommandRequest(request).commands };
+export function mapGrpcSubmitCommandsForTransactionRequest(request) {
+    return { commands: mapGrpcSubmitCommandsRequest(request).commands };
 }
 export function mapGrpcSubmitCommandTransaction(payload) {
     const transaction = payload.transaction;

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

@@ -1,11 +1,11 @@
 import { SignCommandResult } from "../../../core/signing/sign-command-result.js";
-import { SubmitCommandRequest } from "../../../core/types/requests/submit-command-request.js";
+import { SubmitCommandsRequest } from "../../../core/types/requests/submit-commands-request.js";
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
 import { Signature } from "../generated/canton/com/daml/ledger/api/v2/crypto.js";
 import { ExecuteSubmissionAndWaitRequest, ExecuteSubmissionAndWaitResponse, HashingSchemeVersion, PrepareSubmissionRequest, PreparedTransaction } from "../generated/canton/com/daml/ledger/api/v2/interactive/interactive_submission_service.js";
-export declare function mapGrpcPrepareSubmissionRequest(request: SubmitCommandRequest, commandId: string): PrepareSubmissionRequest;
+export declare function mapGrpcPrepareSubmissionRequest(request: SubmitCommandsRequest, commandId: string): PrepareSubmissionRequest;
 export declare function mapGrpcExecuteSubmissionAndWaitRequest(init: {
-    request: SubmitCommandRequest;
+    request: SubmitCommandsRequest;
     preparedTransaction: PreparedTransaction;
     hashingSchemeVersion: HashingSchemeVersion;
     submissionId: string;

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

@@ -10,7 +10,7 @@ export function mapGrpcPrepareSubmissionRequest(request, commandId) {
     return {
         userId: request.userId ?? "",
         commandId,
-        commands: [mapGrpcLedgerCommand(request.command)],
+        commands: request.commands.map(mapGrpcLedgerCommand),
         actAs: [...request.actAs],
         readAs: [...request.readAs],
         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 } })),

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

@@ -5,7 +5,7 @@ import { ListKnownPartiesRequest } from "../../core/types/requests/list-known-pa
 import { ListPartyToParticipantRequest } from "../../core/types/requests/list-party-to-participant-request.js";
 import { ListUserRightsRequest } from "../../core/types/requests/list-user-rights-request.js";
 import { ListUsersRequest } from "../../core/types/requests/list-users-request.js";
-import { SubmitCommandRequest } from "../../core/types/requests/submit-command-request.js";
+import { SubmitCommandsRequest } from "../../core/types/requests/submit-commands-request.js";
 import { AllocatePartyResponse } from "../../core/types/responses/allocate-party-response.js";
 import { GetUserResponse } from "../../core/types/responses/get-user-response.js";
 import { ListPartyToParticipantResponse } from "../../core/types/responses/list-party-to-participant-response.js";
@@ -150,6 +150,6 @@ export declare class JsonTransport implements ITransport {
     getUpdateByHashAsync(_request: GetUpdateByHashRequest, _options?: RequestOptions): Promise<GetUpdateResponse>;
     getUpdatesPageAsync(_request: GetUpdatesPageRequest, _options?: RequestOptions): Promise<GetUpdatesPageResponse>;
     getCompletionsAsync(_request: GetCompletionsRequest, _options?: RequestOptions): AsyncIterable<CompletionStreamResponse>;
-    submitCommandAsync(request: SubmitCommandRequest, signer?: ICommandSigner, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitCommandAsync(request: SubmitCommandsRequest, signer?: ICommandSigner, options?: RequestOptions): Promise<SubmitCommandResponse>;
     private throwIfDisposed;
 }

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

@@ -3,7 +3,7 @@ import { ListKnownPartiesResponse } from "../../core/types/responses/list-known-
 import { NotSupportedError } from "../../core/errors/not-supported-error.js";
 import { GetLedgerApiVersionResponse } from "../grpc/generated/canton/com/daml/ledger/api/v2/version_service.js";
 import { ObjectDisposedError } from "../../core/errors/object-disposed-error.js";
-import { mapJsonSubmitCommand, mapJsonSubmitCommandRequest, } from "./mappers/commands-mapper.js";
+import { mapJsonSubmitCommand, mapJsonSubmitCommandsRequest, } from "./mappers/commands-mapper.js";
 import { UploadDarFileResponse } from "../grpc/generated/canton/com/daml/ledger/api/v2/admin/package_management_service.js";
 import { mapJsonAllocatePartyRequest, mapJsonCreateParty, mapJsonListParties, } from "./mappers/parties-mapper.js";
 import { mapJsonTransactionEvents } from "./mappers/events-mapper.js";
@@ -451,7 +451,7 @@ export class JsonTransport {
         if (signer) {
             throw new NotSupportedError("command signing is not supported by json transport");
         }
-        const payload = await this.httpClient.postAsync("/v2/commands/submit-and-wait", mapJsonSubmitCommandRequest(request), options);
+        const payload = await this.httpClient.postAsync("/v2/commands/submit-and-wait", mapJsonSubmitCommandsRequest(request), options);
         return mapJsonSubmitCommand(payload);
     }
     throwIfDisposed() {

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

@@ -1,6 +1,6 @@
-import { SubmitCommandRequest } from "../../../core/types/requests/submit-command-request.js";
+import { SubmitCommandsRequest } from "../../../core/types/requests/submit-commands-request.js";
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
-export declare function mapJsonSubmitCommandRequest(request: SubmitCommandRequest): {
+export declare function mapJsonSubmitCommandsRequest(request: SubmitCommandsRequest): {
     commandId: string;
     actAs: readonly string[];
     readAs: readonly string[];

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

@@ -9,7 +9,7 @@ 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";
-export function mapJsonSubmitCommandRequest(request) {
+export function mapJsonSubmitCommandsRequest(request) {
     if (request.deduplicationPeriod !== undefined) {
         throw new TransportError("command deduplication periods are not supported by the JSON transport");
     }
@@ -17,7 +17,7 @@ export function mapJsonSubmitCommandRequest(request) {
         commandId: request.commandId ?? randomUUID(),
         actAs: request.actAs,
         readAs: request.readAs,
-        commands: [mapJsonCommand(request.command)],
+        commands: request.commands.map(mapJsonCommand),
         applicationId: request.applicationId || undefined,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@distrohelena/canton-typescript-sdk",
-    "version": "0.1.35",
+    "version": "0.1.37",
     "license": "Apache-2.0",
     "type": "module",
     "main": "./dist/index.js",
@@ -98,6 +98,11 @@
         "example:workflow:retry": "npm run build && node --loader ts-node/esm examples/91-idempotent-command-retry.ts",
         "example:workflow:resume": "npm run build && node --loader ts-node/esm examples/92-resume-update-stream.ts",
         "example:workflow:stale-contract": "npm run build && node --loader ts-node/esm examples/93-archive-and-stale-contract.ts",
+        "example:workflow:command-completion": "npm run build && node --loader ts-node/esm examples/94-command-completion-correlation.ts",
+        "example:workflow:contract-lifecycle-audit": "npm run build && node --loader ts-node/esm examples/95-contract-lifecycle-audit.ts",
+        "example:workflow:update-lookup-reconciliation": "npm run build && node --loader ts-node/esm examples/96-update-lookup-reconciliation.ts",
+        "example:workflow:pruning-preflight": "npm run build && node --loader ts-node/esm examples/97-pruning-preflight.ts",
+        "example:workflow:participant-local": "npm run build && node --loader ts-node/esm examples/98-participant-local-command-submission.ts",
         "lint": "eslint . --max-warnings=0",
         "lint:fix": "eslint . --fix --max-warnings=0",
         "start:local-ledger": "bash node/start-local.sh",
@@ -108,9 +113,9 @@
         "test:stop-local-script": "bash node/test-stop-local.sh",
         "test:participant-358-sidecar-script": "bash node/test-participant-358-sidecar.sh",
         "test:participant-358-sidecar-smoke": "bash node/test-participant-358-sidecar-smoke.sh",
-        "test": "vitest run --maxWorkers=1 --testTimeout=15000",
+        "test": "vitest run --exclude 'tests/live/**' --maxWorkers=1 --testTimeout=15000",
         "test:property": "vitest run tests/property --maxWorkers=1 --testTimeout=15000",
-        "test:live": "vitest run tests/live --maxWorkers=1 --testTimeout=15000",
+        "test:live": "vitest run --dir tests/live --maxWorkers=1 --testTimeout=15000",
         "test:live:fuzz": "vitest run tests/live/specs/live-stateful-fuzzing.test.ts --maxWorkers=1 --testTimeout=300000",
         "test:unit": "vitest run tests/unit",
         "verify:pack": "node ./scripts/verify-npm-pack.mjs"