@distrohelena/canton-typescript-sdk 0.1.36 → 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/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.36",
+    "version": "0.1.37",
     "license": "Apache-2.0",
     "type": "module",
     "main": "./dist/index.js",
@@ -102,6 +102,7 @@
         "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",
@@ -112,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"

package/dist/cjs/query/grpc/grpc-contract-query-client.js

@@ -1,178 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GrpcContractQueryClient = void 0;
-const contracts_mapper_js_1 = require("../../transports/grpc/mappers/contracts-mapper.js");
-const query_capability_error_js_1 = require("../errors/query-capability-error.js");
-const query_source_js_1 = require("../query-source.js");
-class GrpcContractQueryClient {
-    stateService;
-    cache;
-    cacheTtlMs;
-    cacheScope;
-    source = query_source_js_1.QuerySource.grpc;
-    contracts = {
-        findMany: (args = {}) => this.findManyAsync(args).then((rows) => rows),
-        findUnique: (args) => {
-            if (args.select !== undefined || args.include !== undefined) {
-                return Promise.reject(new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "contracts.findUnique"));
-            }
-            return this.findManyAsync({ where: { contractId: { equals: args.where.contractId } } }).then((rows) => rows[0]);
-        },
-        count: async (args = {}) => (await this.findManyAsync(args)).length,
-        aggregate: async () => {
-            throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "contracts.aggregate");
-        },
-        groupBy: async () => {
-            throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "contracts.groupBy");
-        },
-    };
-    contractTypes = this.unsupported("contractTypes");
-    events = this.unsupported("events");
-    exercises = this.unsupported("exercises");
-    exerciseTypes = this.unsupported("exerciseTypes");
-    packages = this.unsupported("packages");
-    transactions = this.unsupported("transactions");
-    watermark = this.unsupported("watermark");
-    constructor(stateService, cache, cacheTtlMs, cacheScope) {
-        this.stateService = stateService;
-        this.cache = cache;
-        this.cacheTtlMs = cacheTtlMs;
-        this.cacheScope = cacheScope;
-    }
-    async $queryRaw(_sql, _values = []) {
-        throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "query.$queryRaw");
-    }
-    async findManyAsync(args) {
-        if (hasUnsupportedFilter(args.where) ||
-            args.where?.active === false ||
-            args.where?.packageId !== undefined ||
-            args.where?.witnesses !== undefined ||
-            args.where?.contractId?.in !== undefined ||
-            args.where?.contractId?.is !== undefined ||
-            args.where?.contractId?.isNot !== undefined ||
-            args.where?.templateId !== undefined) {
-            throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "contracts.findMany");
-        }
-        const findArgs = args;
-        if (findArgs.select !== undefined || findArgs.include !== undefined || findArgs.orderBy !== undefined || findArgs.skip !== undefined || findArgs.take !== undefined) {
-            throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "contracts.findMany");
-        }
-        const snapshot = await this.readSnapshotAsync(args.parties);
-        let rows = snapshot.filter((row) => args.where?.contractId?.equals === undefined
-            ? true
-            : row.contractId === args.where.contractId.equals);
-        if (args.where?.payload !== undefined) {
-            rows = rows.filter((row) => matchesPayload(row.payload, args.where.payload));
-        }
-        return rows;
-    }
-    unsupported(operation) {
-        return {
-            findMany: async () => {
-                throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, `${operation}.findMany`);
-            },
-            findUnique: async () => {
-                throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, `${operation}.findUnique`);
-            },
-            count: async () => {
-                throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, `${operation}.count`);
-            },
-            aggregate: async () => {
-                throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, `${operation}.aggregate`);
-            },
-            groupBy: async () => {
-                throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, `${operation}.groupBy`);
-            },
-        };
-    }
-    async readSnapshotAsync(parties) {
-        const key = `${this.cacheScope}:${parties?.join(",") ?? "*"}`;
-        const cached = this.cache === undefined ? undefined : await this.cache.getAsync(key);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const rows = [];
-        let pageToken;
-        let activeAtOffset;
-        do {
-            const response = await this.stateService.getActiveContractsPageAsync((0, contracts_mapper_js_1.mapGrpcQueryContractsRequest)(parties === undefined
-                ? { allParties: true, activeAtOffset, pageToken }
-                : { parties, activeAtOffset, pageToken }));
-            activeAtOffset ??= response.activeAtOffset;
-            pageToken = response.nextPageToken;
-            rows.push(...response.activeContracts.map((response) => mapGrpcContract(response.contractEntry.oneofKind === "activeContract"
-                ? response.contractEntry.activeContract
-                : response)));
-        } while (pageToken !== undefined && pageToken.length > 0);
-        if (this.cache !== undefined && this.cacheTtlMs !== undefined) {
-            await this.cache.setAsync(key, rows, this.cacheTtlMs);
-        }
-        return rows;
-    }
-}
-exports.GrpcContractQueryClient = GrpcContractQueryClient;
-function hasUnsupportedFilter(where) {
-    if (where === undefined) {
-        return false;
-    }
-    else if ("and" in where || "or" in where || "not" in where || "createdEventOffset" in where || "createdAt" in where || "archivedEventOffset" in where || "archivedAt" in where) {
-        return true;
-    }
-    for (const field of ["contractId", "templateId"]) {
-        const filter = where[field];
-        if (filter !== undefined && Object.keys(filter).some((key) => key !== "equals")) {
-            return true;
-        }
-    }
-    return false;
-}
-function mapGrpcContract(value) {
-    const row = value;
-    const template = row.templateId;
-    return {
-        contractId: row.contractId ?? "",
-        templateId: { packageId: template?.packageId ?? "", moduleName: template?.moduleName ?? "", entityName: template?.entityName ?? "" },
-        packageId: null,
-        payload: row.payload,
-        witnesses: [],
-        createdEventOffset: "",
-        createdAt: null,
-        archivedEventOffset: null,
-        archivedAt: null,
-        active: true,
-    };
-}
-function matchesPayload(value, filter) {
-    const match = filter.match;
-    if (match === undefined) {
-        return false;
-    }
-    const visit = (current, node) => Object.entries(node).every(([key, child]) => {
-        const next = current !== null && typeof current === "object" ? current[key] : undefined;
-        const predicate = child;
-        if (Object.keys(predicate).some((name) => ["equals", "lt", "lte", "gt", "gte", "like", "ilike"].includes(name))) {
-            return compare(String(next ?? ""), predicate);
-        }
-        return visit(next, predicate);
-    });
-    return visit(value, match);
-}
-function compare(value, filter) {
-    if (filter.equals !== undefined) {
-        return value === filter.equals;
-    }
-    else if (filter.like !== undefined || filter.ilike !== undefined) {
-        const pattern = String(filter.like ?? filter.ilike).replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replaceAll("%", ".*").replaceAll("_", ".");
-        return new RegExp(`^${pattern}$`, filter.ilike === undefined ? "" : "i").test(value);
-    }
-    else if (filter.lt !== undefined) {
-        return value < String(filter.lt);
-    }
-    else if (filter.lte !== undefined) {
-        return value <= String(filter.lte);
-    }
-    else if (filter.gt !== undefined) {
-        return value > String(filter.gt);
-    }
-    return value >= String(filter.gte);
-}